Documentation update.

PiperOrigin-RevId: 311614763

Author: w-hat

docs/new_model.md

@@ -15,43 +15,42 @@ Here we show how to create your own model in T2T.
 
   `T2TModel` has three typical usages:
 
-  1. Estimator: The method `make_estimator_model_fn` builds a `model_fn` for
-     the tf.Estimator workflow of training, evaluation, and prediction.
-     It performs the method `call`, which performs the core computation,
-     followed by `estimator_spec_train`, `estimator_spec_eval`, or
-     `estimator_spec_predict` depending on the tf.Estimator mode.
-  2. Layer: The method `call` enables `T2TModel` to be used a callable by
-     itself. It calls the following methods:
-
-     * `bottom`, which transforms features according to `problem_hparams`' input
-       and target `Modality`s;
-     * `body`, which takes features and performs the core model computation to
+1.  Estimator: The method `make_estimator_model_fn` builds a `model_fn` for the
+    tf.Estimator workflow of training, evaluation, and prediction. It performs
+    the method `call`, which performs the core computation, followed by
+    `estimator_spec_train`, `estimator_spec_eval`, or `estimator_spec_predict`
+    depending on the tf.Estimator mode.
+2.  Layer: The method `call` enables `T2TModel` to be used a callable by itself.
+    It calls the following methods:
+
+    *   `bottom`, which transforms features according to `problem_hparams`'
+        input and target `Modality`s;
+    *   `body`, which takes features and performs the core model computation to
         return output and any auxiliary loss terms;
-     * `top`, which takes features and the body output, and transforms them
-       according to `problem_hparams`' input and target `Modality`s to return
-       the final logits;
-     * `loss`, which takes the logits, forms any missing training loss, and sums
-       all loss terms.
-  3. Inference: The method `infer` enables `T2TModel` to make sequence
-     predictions by itself.
+    *   `top`, which takes features and the body output, and transforms them
+        according to `problem_hparams`' input and target `Modality`s to return
+        the final logits;
+    *   `loss`, which takes the logits, forms any missing training loss, and
+        sums all loss terms.
 
+3.  Inference: The method `infer` enables `T2TModel` to make sequence
+    predictions by itself.
 
 ## Creating your own model
 
-1. Create class that extends T2TModel
-    in this example it will be a copy of existing basic fully connected network:
+1.  Create a class that extends `T2TModel`. This example creates a copy of an
+    existing basic fully-connected network:
 
-```python
+    ```python
     from tensor2tensor.utils import t2t_model
 
     class MyFC(t2t_model.T2TModel):
         pass
-```
+    ```
 
+2.  Implement the `body` method:
 
-2. Implement body method:
-
-```python
+    ```python
     class MyFC(t2t_model.T2TModel):
       def body(self, features):
         hparams = self.hparams
@@ -63,43 +62,46 @@ Here we show how to create your own model in T2T.
           x = tf.nn.dropout(x, keep_prob=1.0 - hparams.dropout)
           x = tf.nn.relu(x)
         return tf.expand_dims(tf.expand_dims(x, axis=1), axis=1)  # 4D For T2T.
-```
+    ```
+
+    Method Signature:
 
+    *   Args:
 
-Method Signature:
+        *   features: dict of str to Tensor, where each Tensor has shape
+            [batch_size, ..., hidden_size]. It typically contains keys `inputs`
+            and `targets`.
 
-  * Args:
-      * features: dict of str to Tensor, where each Tensor has shape [batch_size,
-     ..., hidden_size]. It typically contains keys `inputs` and `targets`.
+    *   Returns one of:
 
-  * Returns one of:
-    * output: Tensor of pre-logit activations with shape [batch_size, ...,
-           hidden_size].
-    * losses: Either single loss as a scalar, a list, a Tensor (to be averaged),
-           or a dictionary of losses. If losses is a dictionary with the key
-           "training", losses["training"] is considered the final training
-           loss and output is considered logits; self.top and self.loss will
-           be skipped.
+        *   output: Tensor of pre-logit activations with shape [batch_size, ...,
+            hidden_size].
+        *   losses: Either single loss as a scalar, a list, a Tensor (to be
+            averaged), or a dictionary of losses. If losses is a dictionary with
+            the key "training", losses["training"] is considered the final
+            training loss and output is considered logits; self.top and
+            self.loss will be skipped.
 
-3. Register your model
+3.  Register your model:
 
-```python
+    ```python
     from tensor2tensor.utils import registry
 
     @registry.register_model
     class MyFC(t2t_model.T2TModel):
        # ...
-```
-
+    ```
 
-3. Use it with t2t tools as any other model
+4.  Use it with t2t tools as any other model:
 
-    Have in mind that names are translated from camel case to snake_case `MyFC` -> `my_fc`
-    and that you need to point t2t to directory containing your model with `t2t_usr_dir` switch. 
-    For example if you want to train model on gcloud with 1 GPU worker on IMDB sentiment task you can run your model
-    by executing following command from your model class directory. 
+    Have in mind that names are translated from camel case to snake_case `MyFC`
+    -> `my_fc` and that you need to point t2t to the directory containing your
+    model with the `--t2t_usr_dir` flag. For example if you want to train a
+    model on gcloud with 1 GPU worker on the IMDB sentiment task, you can run
+    your model by executing the following command from your model class
+    directory.
 
-```bash
+    ```bash
     t2t-trainer \
       --model=my_fc \
       --t2t_usr_dir=.
@@ -111,4 +113,4 @@ Method Signature:
       --hparams_set=basic_fc_small \
       --train_steps=10000 \
       --eval_steps=10 \
-```
+    ```