docs: def train(self, input_mode, input_config, role, job_name, output_config,  # noqa: C901
                resource_config, vpc_config, hyperparameters, stop_condition, tags, metric_definitions,
                enable_network_isolation=False, image=None, algorithm_arn=None,
                encrypt_inter_container_traffic=False):
          """Create an Amazon SageMaker training job.
  
          Args:
              input_mode (str): The input mode that the algorithm supports. Valid modes:
  
                  * 'File' - Amazon SageMaker copies the training dataset from the S3 location to
                      a directory in the Docker container.
                  * 'Pipe' - Amazon SageMaker streams data directly from S3 to the container via a Unix-named pipe.
  
              input_config (list): A list of Channel objects. Each channel is a named input source. Please refer to
                   the format details described:
                   https://botocore.readthedocs.io/en/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job
              role (str): An AWS IAM role (either name or full ARN). The Amazon SageMaker training jobs and APIs
                  that create Amazon SageMaker endpoints use this role to access training data and model artifacts.
                  You must grant sufficient permissions to this role.
              job_name (str): Name of the training job being created.
              output_config (dict): The S3 URI where you want to store the training results and optional KMS key ID.
              resource_config (dict): Contains values for ResourceConfig:
  
                  * instance_count (int): Number of EC2 instances to use for training.
                      The key in resource_config is 'InstanceCount'.
                  * instance_type (str): Type of EC2 instance to use for training, for example, 'ml.c4.xlarge'.
                      The key in resource_config is 'InstanceType'.
  
              vpc_config (dict): Contains values for VpcConfig:
  
                  * subnets (list[str]): List of subnet ids.
                      The key in vpc_config is 'Subnets'.
                  * security_group_ids (list[str]): List of security group ids.
                      The key in vpc_config is 'SecurityGroupIds'.
  
              hyperparameters (dict): Hyperparameters for model training. The hyperparameters are made accessible as
                  a dict[str, str] to the training code on SageMaker. For convenience, this accepts other types for
                  keys and values, but ``str()`` will be called to convert them before training.
              stop_condition (dict): Defines when training shall finish. Contains entries that can be understood by the
                  service like ``MaxRuntimeInSeconds``.
              tags (list[dict]): List of tags for labeling a training job. For more, see
                  https://docs.aws.amazon.com/sagemaker/latest/dg/API_Tag.html.
              metric_definitions (list[dict]): A list of dictionaries that defines the metric(s) used to evaluate the
                  training jobs. Each dictionary contains two keys: 'Name' for the name of the metric, and 'Regex' for
                  the regular expression used to extract the metric from the logs.
              enable_network_isolation (bool): Whether to request for the training job to run with
                  network isolation or not.
              image (str): Docker image containing training code.
              algorithm_arn (str): Algorithm Arn from Marketplace.
              encrypt_inter_container_traffic (bool): Specifies whether traffic between training containers is
                  encrypted for the training job (default: ``False``).
  
          Returns:
              str: ARN of the training job, if it is created.
          """
  
          train_request = {
              'AlgorithmSpecification': {
                  'TrainingInputMode': input_mode
              },
              'OutputDataConfig': output_config,
              'TrainingJobName': job_name,
              'StoppingCondition': stop_condition,
              'ResourceConfig': resource_config,
              'RoleArn': role,
          }
  
          if image and algorithm_arn:
              raise ValueError('image and algorithm_arn are mutually exclusive.'
                               'Both were provided: image: %s algorithm_arn: %s' % (image, algorithm_arn))
  
          if image is None and algorithm_arn is None:
              raise ValueError('either image or algorithm_arn is required. None was provided.')
  
          if image is not None:
              train_request['AlgorithmSpecification']['TrainingImage'] = image
  
          if algorithm_arn is not None:
              train_request['AlgorithmSpecification']['AlgorithmName'] = algorithm_arn
  
          if input_config is not None:
              train_request['InputDataConfig'] = input_config
  
          if metric_definitions is not None:
              train_request['AlgorithmSpecification']['MetricDefinitions'] = metric_definitions
  
          if hyperparameters and len(hyperparameters) > 0:
              train_request['HyperParameters'] = hyperparameters
  
          if tags is not None:
              train_request['Tags'] = tags
  
          if vpc_config is not None:
              train_request['VpcConfig'] = vpc_config
  
          if enable_network_isolation:
              train_request['EnableNetworkIsolation'] = enable_network_isolation
  
          if encrypt_inter_container_traffic:
              train_request['EnableInterContainerTrafficEncryption'] = \
                  encrypt_inter_container_traffic
  
          LOGGER.info('Creating training-job with name: {}'.format(job_name))
          LOGGER.debug('train request: {}'.format(json.dumps(train_request, indent=4)))
          self.sagemaker_client.create_training_job(**train_request)