<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:

def create_target_group(name,
                        protocol,
                        port,
                        vpc_id,
                        region=None,
                        key=None,
                        keyid=None,
                        profile=None,
                        health_check_protocol='HTTP',
                        health_check_port='traffic-port',
                        health_check_path='/',
                        health_check_interval_seconds=30,
                        health_check_timeout_seconds=5,
                        healthy_threshold_count=5,
                        unhealthy_threshold_count=2):
    '''
    Create target group if not present.

    name
        (string) - The name of the target group.
    protocol
        (string) - The protocol to use for routing traffic to the targets
    port
        (int) - The port on which the targets receive traffic. This port is used unless
        you specify a port override when registering the traffic.
    vpc_id
        (string) - The identifier of the virtual private cloud (VPC).
    health_check_protocol
        (string) - The protocol the load balancer uses when performing health check on
        targets. The default is the HTTP protocol.
    health_check_port
        (string) - The port the load balancer uses when performing health checks on
        targets. The default is 'traffic-port', which indicates the port on which each
        target receives traffic from the load balancer.
    health_check_path
        (string) - The ping path that is the destination on the targets for health
        checks. The default is /.
    health_check_interval_seconds
        (integer) - The approximate amount of time, in seconds, between health checks
        of an individual target. The default is 30 seconds.
    health_check_timeout_seconds
        (integer) - The amount of time, in seconds, during which no response from a
        target means a failed health check. The default is 5 seconds.
    healthy_threshold_count
        (integer) - The number of consecutive health checks successes required before
        considering an unhealthy target healthy. The default is 5.
    unhealthy_threshold_count
        (integer) - The number of consecutive health check failures required before
        considering a target unhealthy. The default is 2.

    returns
        (bool) - True on success, False on failure.

    CLI example:
    .. code-block:: bash

        salt myminion boto_elbv2.create_target_group learn1give1 protocol=HTTP port=54006 vpc_id=vpc-deadbeef
    '''

    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
    if target_group_exists(name, region, key, keyid, profile):
        return True

    try:
        alb = conn.create_target_group(Name=name, Protocol=protocol, Port=port,
                                       VpcId=vpc_id, HealthCheckProtocol=health_check_protocol,
                                       HealthCheckPort=health_check_port,
                                       HealthCheckPath=health_check_path,
                                       HealthCheckIntervalSeconds=health_check_interval_seconds,
                                       HealthCheckTimeoutSeconds=health_check_timeout_seconds,
                                       HealthyThresholdCount=healthy_threshold_count,
                                       UnhealthyThresholdCount=unhealthy_threshold_count)
        if alb:
            log.info('Created ALB %s: %s', name, alb['TargetGroups'][0]['TargetGroupArn'])
            return True
        else:
            log.error('Failed to create ALB %s', name)
            return False
    except ClientError as error:
        log.error(
            'Failed to create ALB %s: %s: %s',
            name, error.response['Error']['Code'],
            error.response['Error']['Message'],
            exc_info_on_loglevel=logging.DEBUG
        )