docs: def parse_arguments(argv):
    """Parse the command line arguments."""
    parser = argparse.ArgumentParser(
        description=('Train a regression or classification model. Note that if '
                     'using a DNN model, --layer-size1=NUM, --layer-size2=NUM, '
                     'should be used. '))
  
    # I/O file parameters
    parser.add_argument('--train-data-paths', type=str, action='append',
                        required=True)
    parser.add_argument('--eval-data-paths', type=str, action='append',
                        required=True)
    parser.add_argument('--job-dir', type=str, required=True)
    parser.add_argument('--preprocess-output-dir',
                        type=str,
                        required=True,
                        help=('Output folder of preprocessing. Should contain the'
                              ' schema file, and numerical stats and vocab files.'
                              ' Path must be on GCS if running'
                              ' cloud training.'))
    parser.add_argument('--transforms-file',
                        type=str,
                        required=True,
                        help=('File describing the the transforms to apply on '
                              'each column'))
  
    # HP parameters
    parser.add_argument('--learning-rate', type=float, default=0.01,
                        help='tf.train.AdamOptimizer learning rate')
    parser.add_argument('--epsilon', type=float, default=0.0005,
                        help='tf.train.AdamOptimizer epsilon')
    # --layer_size See below
  
    # Model problems
    parser.add_argument('--model-type',
                        choices=['linear_classification', 'linear_regression',
                                 'dnn_classification', 'dnn_regression'],
                        required=True)
    parser.add_argument('--top-n',
                        type=int,
                        default=1,
                        help=('For classification problems, the output graph '
                              'will contain the labels and scores for the top '
                              'n classes.'))
    # Training input parameters
    parser.add_argument('--max-steps', type=int, default=5000,
                        help='Maximum number of training steps to perform.')
    parser.add_argument('--num-epochs',
                        type=int,
                        help=('Maximum number of training data epochs on which '
                              'to train. If both --max-steps and --num-epochs '
                              'are specified, the training job will run for '
                              '--max-steps or --num-epochs, whichever occurs '
                              'first. If unspecified will run for --max-steps.'))
    parser.add_argument('--train-batch-size', type=int, default=1000)
    parser.add_argument('--eval-batch-size', type=int, default=1000)
    parser.add_argument('--min-eval-frequency', type=int, default=100,
                        help=('Minimum number of training steps between '
                              'evaluations'))
  
    # other parameters
    parser.add_argument('--save-checkpoints-secs', type=int, default=600,
                        help=('How often the model should be checkpointed/saved '
                              'in seconds'))
  
    args, remaining_args = parser.parse_known_args(args=argv[1:])
  
    # All HP parambeters must be unique, so we need to support an unknown number
    # of --layer_size1=10 --layer_size2=10 ...
    # Look at remaining_args for layer_size\d+ to get the layer info.
  
    # Get number of layers
    pattern = re.compile('layer-size(\d+)')
    num_layers = 0
    for other_arg in remaining_args:
      match = re.search(pattern, other_arg)
      if match:
        num_layers = max(num_layers, int(match.group(1)))
  
    # Build a new parser so we catch unknown args and missing layer_sizes.
    parser = argparse.ArgumentParser()
    for i in range(num_layers):
      parser.add_argument('--layer-size%s' % str(i + 1), type=int, required=True)
  
    layer_args = vars(parser.parse_args(args=remaining_args))
    layer_sizes = []
    for i in range(num_layers):
      key = 'layer_size%s' % str(i + 1)
      layer_sizes.append(layer_args[key])
  
    assert len(layer_sizes) == num_layers
    args.layer_sizes = layer_sizes
  
    return args