class_docstr: Class to set up the input, train and eval processes for a TF Ranking model.
  
  An example use case is provided below:
  
  ```python
  import tensorflow as tf
  import tensorflow_ranking as tfr
  
  context_feature_columns = {
    "c1": tf.feature_column.numeric_column("c1", shape=(1,))
  }
  example_feature_columns = {
    "e1": tf.feature_column.numeric_column("e1", shape=(1,))
  }
  
  hparams = dict(
        train_input_pattern="/path/to/train/files",
        eval_input_pattern="/path/to/eval/files",
        train_batch_size=8,
        eval_batch_size=8,
        checkpoint_secs=120,
        num_checkpoints=1000,
        num_train_steps=10000,
        num_eval_steps=100,
        loss="softmax_loss",
        list_size=10,
        listwise_inference=False,
        convert_labels_to_binary=False,
        model_dir="/path/to/your/model/directory")
  
  # See `tensorflow_ranking.estimator` for details about creating an estimator.
  estimator = <create your own estimator>
  
  ranking_pipeline = tfr.ext.pipeline.RankingPipeline(
        context_feature_columns,
        example_feature_columns,
        hparams,
        estimator=estimator,
        label_feature_name="relevance",
        label_feature_type=tf.int64)
  ranking_pipeline.train_and_eval()
  ```
  
  Note that you may:
    * pass `best_exporter_metric` and `best_exporter_metric_higher_better` for
      different model export strategies.
    * pass `dataset_reader` for reading different `tf.Dataset`s. We recommend
      using TFRecord files and storing your data in `tfr.data.ELWC` format.
  
  If you want to further customize certain `RankingPipeline` behaviors, please
  create a subclass of `RankingPipeline`, and overwrite related functions. We
  recommend only overwriting the following functions:
    * `_make_dataset` which builds the tf.dataset for a tf-ranking model.
    * `_make_serving_input_fn` that defines the input function for serving.
    * `_export_strategies` if you have more advanced needs for model exporting.
  
  For example, if you want to remove the best exporters, you may overwrite:
  
  ```python
  class NoBestExporterRankingPipeline(tfr.ext.pipeline.RankingPipeline):
    def _export_strategies(self, event_file_pattern):
      del event_file_pattern
      latest_exporter = tf.estimator.LatestExporter(
          "latest_model",
          serving_input_receiver_fn=self._make_serving_input_fn())
      return [latest_exporter]
  
  ranking_pipeline = NoBestExporterRankingPipeline(
        context_feature_columns,
        example_feature_columns,
        hparams
        estimator=estimator)
  ranking_pipeline.train_and_eval()
  ```
  
  if you want to customize your dataset reading behaviors, you may overwrite:
  
  ```python
  class CustomizedDatasetRankingPipeline(tfr.ext.pipeline.RankingPipeline):
    def _make_dataset(self,
                      batch_size,
                      list_size,
                      input_pattern,
                      randomize_input=True,
                      num_epochs=None):
      # Creates your own dataset, plese follow `tfr.data.build_ranking_dataset`.
      dataset = build_my_own_ranking_dataset(...)
      ...
      return dataset.map(self._features_and_labels)
  
  ranking_pipeline = CustomizedDatasetRankingPipeline(
        context_feature_columns,
        example_feature_columns,
        hparams
        estimator=estimator)
  ranking_pipeline.train_and_eval()
  ```
docstr: Returns the input function for the ranking model.
  
  Args:
    input_pattern: (str) File pattern for the input data.
    batch_size: (int) The number of input examples to process per batch.
    list_size: (int) The list size for an ELWC example.
    randomize_input: (bool) If true, randomize input example order. It should
      almost always be true except for unittest/debug purposes.
    num_epochs: (int) The number of times the input dataset must be repeated.
      None to repeat the data indefinitely.
  
  Returns:
    An `input_fn` for `tf.estimator.Estimator`.
docstr_tok: ["Returns","the","input","function","for","the","ranking","model",".","Args",":","input_pattern",":","(","str",")","File","pattern","for","the","input","data",".","batch_size",":","(","int",")","The","number","of","input","examples","to","process","per","batch",".","list_size",":","(","int",")","The","list","size","for","an","ELWC","example",".","randomize_input",":","(","bool",")","If","true",",","randomize","input","example","order",".","It","should","almost","always","be","true","except","for","unittest\/debug","purposes",".","num_epochs",":","(","int",")","The","number","of","times","the","input","dataset","must","be","repeated",".","None","to","repeat","the","data","indefinitely",".","Returns",":","An","`","input_fn","`","for","`","tf.estimator.Estimator","`","."]
code: def _make_input_fn(
      self,
      input_pattern,
      batch_size,
      list_size,
      randomize_input=True,
      num_epochs=None,
  ):
      """Returns the input function for the ranking model.
  
      Args:
        input_pattern: (str) File pattern for the input data.
        batch_size: (int) The number of input examples to process per batch.
        list_size: (int) The list size for an ELWC example.
        randomize_input: (bool) If true, randomize input example order. It should
          almost always be true except for unittest/debug purposes.
        num_epochs: (int) The number of times the input dataset must be repeated.
          None to repeat the data indefinitely.
  
      Returns:
        An `input_fn` for `tf.estimator.Estimator`.
      """
  
      def _input_fn():
          """`input_fn` for the `Estimator`."""
          return self._make_dataset(
              batch_size=batch_size,
              list_size=list_size,
              input_pattern=input_pattern,
              randomize_input=randomize_input,
              num_epochs=num_epochs,
          )
  
      return _input_fn
  
file_path: ranking/tensorflow_ranking/extension/pipeline.py
imports: import tensorflow
  from tensorflow import estimator
  from tensorflow.compat.v1 import estimator
  from tensorflow_ranking.python import data
label_desc: Use image node_id 6 for calling the RankingPipeline obj's underlying member method code with example usage: obj._make_input_fn(input_pattern, batch_size, list_size, randomize_input, num_epochs) and returns: _input_fn, self