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 `Estimator` `input_fn` for serving the model.
  
  Returns:
    `input_fn` that can be used in serving. The returned input_fn takes no
    arguments and returns `InputFnOps'.
docstr_tok: ["Returns","`","Estimator","`","`","input_fn","`","for","serving","the","model",".","Returns",":","`","input_fn","`","that","can","be","used","in","serving",".","The","returned","input_fn","takes","no","arguments","and","returns","`","InputFnOps","'","."]
code: def _make_serving_input_fn(self):
      """Returns `Estimator` `input_fn` for serving the model.
  
      Returns:
        `input_fn` that can be used in serving. The returned input_fn takes no
        arguments and returns `InputFnOps'.
      """
      context_feature_spec = tf.feature_column.make_parse_example_spec(  # pylint: disable=g-deprecated-tf-checker
          self._context_feature_columns.values()
      )
      example_feature_spec = tf.feature_column.make_parse_example_spec(  # pylint: disable=g-deprecated-tf-checker
          self._example_feature_columns.values()
      )
  
      if self._hparams.get("listwise_inference"):
          # Exports accept the `ExampleListWithContext` format during serving.
          return tfr_data.build_ranking_serving_input_receiver_fn(
              data_format=tfr_data.ELWC,
              context_feature_spec=context_feature_spec,
              example_feature_spec=example_feature_spec,
              size_feature_name=self._size_feature_name,
          )
      else:
          # Exports accept `tf.Example` format during serving.
          feature_spec = {}
          feature_spec.update(example_feature_spec)
          feature_spec.update(context_feature_spec)
          return tf_estimator.export.build_parsing_serving_input_receiver_fn(  # pylint: disable=g-deprecated-tf-checker
              feature_spec
          )
  
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 7 for calling the RankingPipeline obj's underlying member method code with example usage: obj._make_serving_input_fn() and returns: tfr_data, tf_estimator