tf-models-nightly 2.11.0.dev20230321__py2.py3-none-any.whl → 2.11.0.dev20230322__py2.py3-none-any.whl

official/projects/yt8m/configs/yt8m.py

@@ -15,7 +15,6 @@
 """Video classification configuration definition."""
 import dataclasses
 from typing import Optional, Tuple
-from absl import flags
 
 from official.core import config_definitions as cfg
 from official.core import exp_factory
@@ -23,7 +22,6 @@ from official.modeling import hyperparams
 from official.modeling import optimization
 from official.vision.configs import common
 
-FLAGS = flags.FLAGS
 
 YT8M_TRAIN_EXAMPLES = 3888919
 YT8M_VAL_EXAMPLES = 1112356
@@ -105,7 +103,6 @@ def yt8m(is_training):
 class MoeModel(hyperparams.Config):
   """The model config."""
   num_mixtures: int = 5
-  l2_penalty: float = 1e-5
   use_input_context_gate: bool = False
   use_output_context_gate: bool = False
   vocab_as_last_dim: bool = False
@@ -121,7 +118,7 @@ class DbofModel(hyperparams.Config):
   use_context_gate_cluster_layer: bool = False
   context_gate_cluster_bottleneck_size: int = 0
   pooling_method: str = 'average'
-  yt8m_agg_classifier_model: str = 'MoeModel'
+  agg_classifier_model: str = 'MoeModel'
   agg_model: hyperparams.Config = MoeModel()
   norm_activation: common.NormActivation = common.NormActivation(
       activation='relu', use_sync_bn=False)

official/projects/yt8m/modeling/nn_layers.py

@@ -13,22 +13,156 @@
 # limitations under the License.
 
 """Contains model definitions."""
+
+import functools
 from typing import Any, Dict, Optional
 
 import tensorflow as tf
+
+from official.modeling import tf_utils
+from official.projects.yt8m.configs import yt8m as yt8m_cfg
 from official.projects.yt8m.modeling import yt8m_model_utils as utils
 
+
 layers = tf.keras.layers
 
 
-class LogisticModel():
-  """Logistic model with L2 regularization."""
+class Dbof(tf.keras.Model):
+  """A YT8M model class builder.
+
+  Creates a Deep Bag of Frames model.
+  The model projects the features for each frame into a higher dimensional
+  'clustering' space, pools across frames in that space, and then
+  uses a configurable video-level model to classify the now aggregated features.
+  The model will randomly sample either frames or sequences of frames during
+  training to speed up convergence.
+  """
+
+  def __init__(
+      self,
+      params: yt8m_cfg.DbofModel,
+      num_classes: int = 3862,
+      input_specs: layers.InputSpec = layers.InputSpec(
+          shape=[None, None, 1152]),
+      l2_weight_decay: Optional[float] = None,
+      **kwargs):
+    """YT8M initialization function.
+
+    Args:
+      params: model configuration parameters
+      num_classes: `int` number of classes in dataset.
+      input_specs: `tf.keras.layers.InputSpec` specs of the input tensor.
+        [batch_size x num_frames x num_features]
+      l2_weight_decay: An optional `float` of kernel regularizer weight decay.
+      **kwargs: keyword arguments to be passed.
+    """
+    self._self_setattr_tracking = False
+    self._num_classes = num_classes
+    self._input_specs = input_specs
+    self._params = params
+    self._l2_weight_decay = l2_weight_decay
+    self._act_fn = tf_utils.get_activation(params.norm_activation.activation)
+    self._norm = functools.partial(
+        layers.BatchNormalization,
+        momentum=params.norm_activation.norm_momentum,
+        epsilon=params.norm_activation.norm_epsilon,
+        synchronized=params.norm_activation.use_sync_bn)
+
+    # Divide weight decay by 2.0 to match the implementation of tf.nn.l2_loss.
+    # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2)
+    # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss)
+    l2_regularizer = (
+        tf.keras.regularizers.l2(l2_weight_decay / 2.0)
+        if l2_weight_decay
+        else None
+    )
+
+    # [batch_size x num_frames x num_features]
+    feature_size = input_specs.shape[-1]
+    # shape 'excluding' batch_size
+    model_input = tf.keras.Input(shape=self._input_specs.shape[1:])
+    # normalize input features
+    input_data = tf.nn.l2_normalize(model_input, -1)
+    tf.summary.histogram("input_hist", input_data)
+
+    # configure model
+    if params.add_batch_norm:
+      input_data = self._norm(name="input_bn")(input_data)
+
+    # activation = reshaped input * cluster weights
+    if params.cluster_size > 0:
+      activation = layers.Dense(
+          params.cluster_size,
+          kernel_regularizer=l2_regularizer,
+          kernel_initializer=tf.random_normal_initializer(
+              stddev=1 / tf.sqrt(tf.cast(feature_size, tf.float32))))(
+                  input_data)
+
+    if params.add_batch_norm:
+      activation = self._norm(name="cluster_bn")(activation)
+    else:
+      cluster_biases = tf.Variable(
+          tf.random_normal_initializer(stddev=1 / tf.math.sqrt(feature_size))(
+              shape=[params.cluster_size]),
+          name="cluster_biases")
+      tf.summary.histogram("cluster_biases", cluster_biases)
+      activation += cluster_biases
+
+    activation = self._act_fn(activation)
+    tf.summary.histogram("cluster_output", activation)
 
-  def create_model(self, model_input, vocab_size, l2_penalty=1e-8, **kwargs):
+    if params.use_context_gate_cluster_layer:
+      pooling_method = None
+      norm_args = dict(name="context_gate_bn")
+      activation = utils.context_gate(
+          activation,
+          normalizer_fn=self._norm,
+          normalizer_params=norm_args,
+          pooling_method=pooling_method,
+          hidden_layer_size=params.context_gate_cluster_bottleneck_size,
+          kernel_regularizer=l2_regularizer)
+
+    activation = utils.frame_pooling(activation, params.pooling_method)
+
+    # activation = activation * hidden1_weights
+    activation = layers.Dense(
+        params.hidden_size,
+        kernel_regularizer=l2_regularizer,
+        kernel_initializer=tf.random_normal_initializer(
+            stddev=1 / tf.sqrt(tf.cast(params.cluster_size, tf.float32))))(
+                activation)
+
+    if params.add_batch_norm:
+      activation = self._norm(name="hidden1_bn")(activation)
+
+    else:
+      hidden1_biases = tf.Variable(
+          tf.random_normal_initializer(stddev=0.01)(shape=[params.hidden_size]),
+          name="hidden1_biases")
+
+      tf.summary.histogram("hidden1_biases", hidden1_biases)
+      activation += hidden1_biases
+
+    activation = self._act_fn(activation)
+    tf.summary.histogram("hidden1_output", activation)
+
+    super().__init__(inputs=model_input, outputs=activation, **kwargs)
+
+
+class LogisticModel(tf.keras.Model):
+  """Logistic prediction head model with L2 regularization."""
+
+  def __init__(
+      self,
+      input_specs: layers.InputSpec = layers.InputSpec(shape=[None, 128]),
+      vocab_size: int = 3862,
+      l2_penalty: float = 1e-8,
+      **kwargs,
+  ):
     """Creates a logistic model.
 
     Args:
-      model_input: 'batch' x 'num_features' matrix of input features.
+      input_specs: 'batch' x 'num_features' matrix of input features.
       vocab_size: The number of classes in the dataset.
       l2_penalty: L2 weight regularization ratio.
       **kwargs: extra key word args.
@@ -38,43 +172,44 @@ class LogisticModel():
       model in the 'predictions' key. The dimensions of the tensor are
       batch_size x num_classes.
     """
-    del kwargs  # Unused.
+    inputs = tf.keras.Input(shape=input_specs.shape[1:])
     output = layers.Dense(
         vocab_size,
         activation=tf.nn.sigmoid,
         kernel_regularizer=tf.keras.regularizers.l2(l2_penalty))(
-            model_input)
-    return {"predictions": output}
+            inputs)
+
+    super().__init__(inputs=inputs, outputs={"predictions": output}, **kwargs)
 
 
-class MoeModel():
+class MoeModel(tf.keras.Model):
   """A softmax over a mixture of logistic models (with L2 regularization)."""
 
-  def create_model(self,
-                   model_input,
-                   vocab_size,
-                   num_mixtures: int = 2,
-                   use_input_context_gate: bool = False,
-                   use_output_context_gate: bool = False,
-                   normalizer_fn=None,
-                   normalizer_params: Optional[Dict[str, Any]] = None,
-                   vocab_as_last_dim: bool = False,
-                   l2_penalty: float = 1e-5,
-                   **kwargs):
+  def __init__(
+      self,
+      input_specs: layers.InputSpec = layers.InputSpec(shape=[None, 128]),
+      vocab_size: int = 3862,
+      num_mixtures: int = 2,
+      use_input_context_gate: bool = False,
+      use_output_context_gate: bool = False,
+      normalizer_params: Optional[Dict[str, Any]] = None,
+      vocab_as_last_dim: bool = False,
+      l2_penalty: float = 1e-5,
+      **kwargs,
+  ):
     """Creates a Mixture of (Logistic) Experts model.
 
      The model consists of a per-class softmax distribution over a
      configurable number of logistic classifiers. One of the classifiers
      in the mixture is not trained, and always predicts 0.
     Args:
-      model_input: 'batch_size' x 'num_features' matrix of input features.
+      input_specs: 'batch_size' x 'num_features' matrix of input features.
       vocab_size: The number of classes in the dataset.
       num_mixtures: The number of mixtures (excluding a dummy 'expert' that
         always predicts the non-existence of an entity).
       use_input_context_gate: if True apply context gate layer to the input.
       use_output_context_gate: if True apply context gate layer to the output.
-      normalizer_fn: normalization op constructor (e.g. batch norm).
-      normalizer_params: parameters to the `normalizer_fn`.
+      normalizer_params: parameters of the batch normalization.
       vocab_as_last_dim: if True reshape `activations` and make `vocab_size` as
         the last dimension to avoid small `num_mixtures` as the last dimension.
         XLA pads up the dimensions of tensors: typically the last dimension will
@@ -88,11 +223,13 @@ class MoeModel():
       of the model in the 'predictions' key. The dimensions of the tensor
       are batch_size x num_classes.
     """
-    del kwargs  # Unused.
+    inputs = tf.keras.Input(shape=input_specs.shape[1:])
+    model_input = inputs
+
     if use_input_context_gate:
       model_input = utils.context_gate(
           model_input,
-          normalizer_fn=normalizer_fn,
+          normalizer_fn=layers.BatchNormalization,
           normalizer_params=normalizer_params,
       )
 
@@ -132,7 +269,11 @@ class MoeModel():
     if use_output_context_gate:
       final_probabilities = utils.context_gate(
           final_probabilities,
-          normalizer_fn=normalizer_fn,
+          normalizer_fn=layers.BatchNormalization,
           normalizer_params=normalizer_params,
       )
-    return {"predictions": final_probabilities}
+    super().__init__(
+        inputs=inputs,
+        outputs={"predictions": final_probabilities},
+        **kwargs,
+    )

official/projects/yt8m/modeling/yt8m_model.py

@@ -12,17 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""YT8M model definition."""
+"""YT8M prediction model definition."""
 
 import functools
-from typing import Optional
+from typing import Any, Optional
 
+from absl import logging
 import tensorflow as tf
 
-from official.modeling import tf_utils
 from official.projects.yt8m.configs import yt8m as yt8m_cfg
 from official.projects.yt8m.modeling import nn_layers
-from official.projects.yt8m.modeling import yt8m_model_utils as utils
 
 
 layers = tf.keras.layers
@@ -45,202 +44,58 @@ class DbofModel(tf.keras.Model):
       num_classes: int = 3862,
       input_specs: layers.InputSpec = layers.InputSpec(
           shape=[None, None, 1152]),
-      activation: str = "relu",
-      use_sync_bn: bool = False,
-      norm_momentum: float = 0.99,
-      norm_epsilon: float = 0.001,
       l2_weight_decay: Optional[float] = None,
-      **kwargs):
-    """YT8M initialization function.
+      **kwargs,
+  ):
+    """YT8M Dbof model initialization function.
 
     Args:
       params: model configuration parameters
       num_classes: `int` number of classes in dataset.
       input_specs: `tf.keras.layers.InputSpec` specs of the input tensor.
         [batch_size x num_frames x num_features]
-      activation: A `str` of name of the activation function.
-      use_sync_bn: If True, use synchronized batch normalization.
-      norm_momentum: A `float` of normalization momentum for the moving average.
-      norm_epsilon: A `float` added to variance to avoid dividing by zero.
       l2_weight_decay: An optional `float` of kernel regularizer weight decay.
       **kwargs: keyword arguments to be passed.
     """
-    model_input, activation = self.get_dbof(
-        params=params,
-        num_classes=num_classes,
-        input_specs=input_specs,
-        activation=activation,
-        use_sync_bn=use_sync_bn,
-        norm_momentum=norm_momentum,
-        norm_epsilon=norm_epsilon,
-        l2_weight_decay=l2_weight_decay,
-        **kwargs,
-    )
-    output = self.get_aggregation(model_input=activation, **kwargs)
-    super().__init__(
-        inputs=model_input, outputs=output.get("predictions"), **kwargs)
-
-  def get_dbof(
-      self,
-      params: yt8m_cfg.DbofModel,
-      num_classes: int = 3862,
-      input_specs: layers.InputSpec = layers.InputSpec(
-          shape=[None, None, 1152]),
-      activation: str = "relu",
-      use_sync_bn: bool = False,
-      norm_momentum: float = 0.99,
-      norm_epsilon: float = 0.001,
-      l2_weight_decay: Optional[float] = None,
-      **kwargs):
-
-    del kwargs  # Unused and reserved for future extension.
-    self._self_setattr_tracking = False
+    super().__init__()
+    self._params = params
+    self._num_classes = num_classes
+    self._input_specs = input_specs
+    self._l2_weight_decay = l2_weight_decay
     self._config_dict = {
+        "params": params,
         "input_specs": input_specs,
         "num_classes": num_classes,
-        "params": params,
-        "use_sync_bn": use_sync_bn,
-        "activation": activation,
         "l2_weight_decay": l2_weight_decay,
-        "norm_momentum": norm_momentum,
-        "norm_epsilon": norm_epsilon,
     }
-    self._num_classes = num_classes
-    self._input_specs = input_specs
-    self._params = params
-    self._activation = activation
-    self._l2_weight_decay = l2_weight_decay
-    self._use_sync_bn = use_sync_bn
-    self._norm_momentum = norm_momentum
-    self._norm_epsilon = norm_epsilon
-    self._act_fn = tf_utils.get_activation(activation)
-    self._norm = functools.partial(
-        layers.BatchNormalization, synchronized=use_sync_bn)
-
-    # Divide weight decay by 2.0 to match the implementation of tf.nn.l2_loss.
-    # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2)
-    # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss)
-    l2_regularizer = (
-        tf.keras.regularizers.l2(l2_weight_decay / 2.0)
-        if l2_weight_decay
-        else None
-    )
 
-    bn_axis = -1
-    # [batch_size x num_frames x num_features]
-    feature_size = input_specs.shape[-1]
-    # shape 'excluding' batch_size
-    model_input = tf.keras.Input(shape=self._input_specs.shape[1:])
-    # normalize input features
-    input_data = tf.nn.l2_normalize(model_input, -1)
-    tf.summary.histogram("input_hist", input_data)
-
-    # configure model
-    if params.add_batch_norm:
-      input_data = self._norm(
-          axis=bn_axis,
-          momentum=norm_momentum,
-          epsilon=norm_epsilon,
-          name="input_bn")(
-              input_data)
-
-    # activation = reshaped input * cluster weights
-    if params.cluster_size > 0:
-      activation = layers.Dense(
-          params.cluster_size,
-          kernel_regularizer=l2_regularizer,
-          kernel_initializer=tf.random_normal_initializer(
-              stddev=1 / tf.sqrt(tf.cast(feature_size, tf.float32))))(
-                  input_data)
-
-    if params.add_batch_norm:
-      activation = self._norm(
-          axis=bn_axis,
-          momentum=norm_momentum,
-          epsilon=norm_epsilon,
-          name="cluster_bn")(
-              activation)
-    else:
-      cluster_biases = tf.Variable(
-          tf.random_normal_initializer(stddev=1 / tf.math.sqrt(feature_size))(
-              shape=[params.cluster_size]),
-          name="cluster_biases")
-      tf.summary.histogram("cluster_biases", cluster_biases)
-      activation += cluster_biases
-
-    activation = self._act_fn(activation)
-    tf.summary.histogram("cluster_output", activation)
-
-    if params.use_context_gate_cluster_layer:
-      pooling_method = None
-      norm_args = dict(
-          axis=bn_axis,
-          momentum=norm_momentum,
-          epsilon=norm_epsilon,
-          name="context_gate_bn")
-      activation = utils.context_gate(
-          activation,
-          normalizer_fn=self._norm,
-          normalizer_params=norm_args,
-          pooling_method=pooling_method,
-          hidden_layer_size=params.context_gate_cluster_bottleneck_size,
-          kernel_regularizer=l2_regularizer)
-
-    activation = utils.frame_pooling(activation, params.pooling_method)
-
-    # activation = activation * hidden1_weights
-    activation = layers.Dense(
-        params.hidden_size,
-        kernel_regularizer=l2_regularizer,
-        kernel_initializer=tf.random_normal_initializer(
-            stddev=1 / tf.sqrt(tf.cast(params.cluster_size, tf.float32))))(
-                activation)
-
-    if params.add_batch_norm:
-      activation = self._norm(
-          axis=bn_axis,
-          momentum=norm_momentum,
-          epsilon=norm_epsilon,
-          name="hidden1_bn")(
-              activation)
-
-    else:
-      hidden1_biases = tf.Variable(
-          tf.random_normal_initializer(stddev=0.01)(shape=[params.hidden_size]),
-          name="hidden1_biases")
-
-      tf.summary.histogram("hidden1_biases", hidden1_biases)
-      activation += hidden1_biases
-
-    activation = self._act_fn(activation)
-    tf.summary.histogram("hidden1_output", activation)
-
-    return model_input, activation
-
-  def get_aggregation(self, model_input, **kwargs):
-    del kwargs  # Unused and reserved for future extension.
-    normalizer_fn = functools.partial(
-        layers.BatchNormalization, synchronized=self._use_sync_bn)
-    normalizer_params = dict(
-        axis=-1, momentum=self._norm_momentum, epsilon=self._norm_epsilon)
-    aggregated_model = getattr(
-        nn_layers, self._params.yt8m_agg_classifier_model)
-
-    output = aggregated_model().create_model(
-        model_input=model_input,
-        vocab_size=self._num_classes,
-        num_mixtures=self._params.agg_model.num_mixtures,
-        normalizer_fn=normalizer_fn,
-        normalizer_params=normalizer_params,
-        vocab_as_last_dim=self._params.agg_model.vocab_as_last_dim,
-        l2_penalty=self._params.agg_model.l2_penalty,
+    self.dbof_backbone = nn_layers.Dbof(
+        params,
+        num_classes,
+        input_specs,
+        l2_weight_decay,
+        **kwargs,
     )
-    return output
 
-  @property
-  def checkpoint_items(self):
-    """Returns a dictionary of items to be additionally checkpointed."""
-    return dict()
+    logging.info("Build DbofModel with %s.", params.agg_classifier_model)
+    if hasattr(nn_layers, params.agg_classifier_model):
+      aggregation_head = getattr(nn_layers, params.agg_classifier_model)
+      if params.agg_classifier_model == "MoeModel":
+        normalizer_params = dict(
+            synchronized=params.norm_activation.use_sync_bn,
+            momentum=params.norm_activation.norm_momentum,
+            epsilon=params.norm_activation.norm_epsilon,
+        )
+        aggregation_head = functools.partial(
+            aggregation_head, normalizer_params=normalizer_params)
+
+      if params.agg_model is not None:
+        kwargs.update(params.agg_model.as_dict())
+      self.head = aggregation_head(
+          input_specs=layers.InputSpec(shape=[None, params.hidden_size]),
+          vocab_size=num_classes,
+          l2_penalty=l2_weight_decay,
+          **kwargs)
 
   def get_config(self):
     return self._config_dict
@@ -248,3 +103,10 @@ class DbofModel(tf.keras.Model):
   @classmethod
   def from_config(cls, config):
     return cls(**config)
+
+  def call(
+      self, inputs: tf.Tensor, training: Any = None, mask: Any = None
+  ) -> tf.Tensor:
+    features = self.dbof_backbone(inputs)
+    outputs = self.head(features)
+    return outputs["predictions"]

official/projects/yt8m/modeling/yt8m_model_utils.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 """Contains a collection of util functions for model construction."""
+
 from typing import Any, Dict, Optional, Union
 
 import tensorflow as tf
@@ -177,8 +178,7 @@ def context_gate(
           kernel_initializer=kernel_initializer,
           bias_initializer=bias_initializer,
           kernel_regularizer=kernel_regularizer,
-      )(
-          context_features)
+      )(context_features)
       if normalizer_fn:
         gates_bottleneck = normalizer_fn(**normalizer_params)(gates_bottleneck)
     else:
@@ -191,14 +191,13 @@ def context_gate(
         kernel_initializer=kernel_initializer,
         bias_initializer=bias_initializer,
         kernel_regularizer=kernel_regularizer,
-    )(
-        gates_bottleneck)
+    )(gates_bottleneck)
     if normalizer_fn:
       gates = normalizer_fn(**normalizer_params)(gates)
 
     if additive_residual:
-      input_features += gates
+      input_features += tf.cast(gates, input_features.dtype)
     else:
-      input_features *= gates
+      input_features *= tf.cast(gates, input_features.dtype)
 
     return input_features

official/projects/yt8m/tasks/yt8m_task.py

@@ -45,15 +45,10 @@ class YT8MTask(base_task.Task):
     l2_weight_decay = self.task_config.losses.l2_weight_decay
     # Model configuration.
     model_config = self.task_config.model
-    norm_activation_config = model_config.norm_activation
     model = DbofModel(
         params=model_config,
         input_specs=input_specs,
         num_classes=train_cfg.num_classes,
-        activation=norm_activation_config.activation,
-        use_sync_bn=norm_activation_config.use_sync_bn,
-        norm_momentum=norm_activation_config.norm_momentum,
-        norm_epsilon=norm_activation_config.norm_epsilon,
         l2_weight_decay=l2_weight_decay)
 
     non_trainable_batch_norm_variables = []
@@ -66,18 +61,32 @@ class YT8MTask(base_task.Task):
           non_trainable_extra_variables.append(var)
 
     logging.info(
-        'Trainable model variables:\n%s', '\n'.join(
-            [f'{var.name}\t{var.shape}' for var in model.trainable_variables]))
+        'Trainable model variables:\n%s',
+        '\n'.join(
+            [f'{var.name}\t{var.shape}' for var in model.trainable_variables]
+        ),
+    )
     logging.info(
-        'Non-trainable batch norm variables (get updated in training mode):\n%s',
-        '\n'.join([
-            f'{var.name}\t{var.shape}'
-            for var in non_trainable_batch_norm_variables
-        ]))
+        (
+            'Non-trainable batch norm variables (get updated in training'
+            ' mode):\n%s'
+        ),
+        '\n'.join(
+            [
+                f'{var.name}\t{var.shape}'
+                for var in non_trainable_batch_norm_variables
+            ]
+        ),
+    )
     logging.info(
-        'Non-trainable frozen model variables:\n%s', '\n'.join([
-            f'{var.name}\t{var.shape}' for var in non_trainable_extra_variables
-        ]))
+        'Non-trainable frozen model variables:\n%s',
+        '\n'.join(
+            [
+                f'{var.name}\t{var.shape}'
+                for var in non_trainable_extra_variables
+            ]
+        ),
+    )
     return model
 
   def build_inputs(self, params: yt8m_cfg.DataConfig, input_context=None):
@@ -173,7 +182,10 @@ class YT8MTask(base_task.Task):
     for name in metric_names:
       metrics.append(tf.keras.metrics.Mean(name, dtype=tf.float32))
 
-    if self.task_config.evaluation.average_precision is not None and not training:
+    if (
+        self.task_config.evaluation.average_precision is not None
+        and not training
+    ):
       # Cannot run in train step.
       num_classes = self.task_config.validation_data.num_classes
       top_k = self.task_config.evaluation.average_precision.top_k
@@ -183,14 +195,16 @@ class YT8MTask(base_task.Task):
 
     return metrics
 
-  def process_metrics(self,
-                      metrics: List[tf.keras.metrics.Metric],
-                      labels: tf.Tensor,
-                      outputs: tf.Tensor,
-                      model_losses: Optional[Dict[str, tf.Tensor]] = None,
-                      label_weights: Optional[tf.Tensor] = None,
-                      training: bool = True,
-                      **kwargs) -> Dict[str, Tuple[tf.Tensor, ...]]:
+  def process_metrics(
+      self,
+      metrics: List[tf.keras.metrics.Metric],
+      labels: tf.Tensor,
+      outputs: tf.Tensor,
+      model_losses: Optional[Dict[str, tf.Tensor]] = None,
+      label_weights: Optional[tf.Tensor] = None,
+      training: bool = True,
+      **kwargs,
+  ) -> Dict[str, Tuple[tf.Tensor, ...]]:
     """Updates metrics.
 
     Args:
@@ -210,7 +224,10 @@ class YT8MTask(base_task.Task):
       model_losses = {}
 
     logs = {}
-    if self.task_config.evaluation.average_precision is not None and not training:
+    if (
+        self.task_config.evaluation.average_precision is not None
+        and not training
+    ):
       logs.update({self.avg_prec_metric.name: (labels, outputs)})
 
     for m in metrics:

official/vision/dataloaders/maskrcnn_input.py

@@ -211,19 +211,18 @@ class Parser(parser.Parser):
     image = preprocess_ops.normalize_image(image)
 
     # Flips image randomly during training.
-    if self._aug_rand_hflip:
-      if self._include_mask:
-        image, boxes, masks = preprocess_ops.random_horizontal_flip(
-            image, boxes, masks)
-      else:
-        image, boxes, _ = preprocess_ops.random_horizontal_flip(
-            image, boxes)
-    if self._aug_rand_vflip:
-      if self._include_mask:
-        image, boxes, masks = preprocess_ops.random_vertical_flip(
-            image, boxes, masks)
-      else:
-        image, boxes, _ = preprocess_ops.random_vertical_flip(image, boxes)
+    image, boxes, masks = preprocess_ops.random_horizontal_flip(
+        image,
+        boxes,
+        masks=None if not self._include_mask else masks,
+        prob=tf.where(self._aug_rand_hflip, 0.5, 0.0),
+    )
+    image, boxes, masks = preprocess_ops.random_vertical_flip(
+        image,
+        boxes,
+        masks=None if not self._include_mask else masks,
+        prob=tf.where(self._aug_rand_vflip, 0.5, 0.0),
+    )
 
     # Converts boxes from normalized coordinates to pixel coordinates.
     # Now the coordinates of boxes are w.r.t. the original image.

official/vision/dataloaders/tfds_classification_decoders.py

@@ -35,4 +35,5 @@ TFDS_ID_TO_DECODER_MAP = {
     'cifar10': ClassificationDecorder,
     'cifar100': ClassificationDecorder,
     'imagenet2012': ClassificationDecorder,
+    'imagenet2012_fewshot/10shot': ClassificationDecorder,
 }

official/vision/evaluation/instance_metrics.py

@@ -465,213 +465,6 @@ def _count_detection_type(
   return count
 
 
-def _compute_fp_tp_gt_count(
-    y_true: Dict[str, tf.Tensor],
-    y_pred: Dict[str, tf.Tensor],
-    num_classes: int,
-    mask_output_boundary: Tuple[int, int] = (640, 640),
-    iou_thresholds: Tuple[float, ...] = (0.5,),
-    matching_algorithm: Optional[MatchingAlgorithm] = None,
-    num_confidence_bins: int = 1000,
-    use_masks: bool = False,
-) -> Tuple[tf.Tensor, tf.Tensor, tf.Tensor]:
-  """Computes the true and false positives."""
-
-  if matching_algorithm is None:
-    matching_algorithm = COCOMatchingAlgorithm(iou_thresholds)
-
-  # (batch_size, num_detections, 4) in absolute coordinates.
-  detection_boxes = tf.cast(y_pred['detection_boxes'], tf.float32)
-  # (batch_size, num_detections)
-  detection_classes = tf.cast(y_pred['detection_classes'], tf.int32)
-  # (batch_size, num_detections)
-  detection_scores = tf.cast(y_pred['detection_scores'], tf.float32)
-  # (batch_size, num_gts, 4) in absolute coordinates.
-  gt_boxes = tf.cast(y_true['boxes'], tf.float32)
-  # (batch_size, num_gts)
-  gt_classes = tf.cast(y_true['classes'], tf.int32)
-  # (batch_size, num_gts)
-  if 'is_crowds' in y_true:
-    gt_is_crowd = tf.cast(y_true['is_crowds'], tf.bool)
-  else:
-    gt_is_crowd = tf.zeros_like(gt_classes, dtype=tf.bool)
-
-  image_scale = tf.tile(y_true['image_info'][:, 2:3, :], multiples=[1, 1, 2])
-  detection_boxes = detection_boxes / tf.cast(
-      image_scale, dtype=detection_boxes.dtype
-  )
-
-  # Step 1: Computes IoUs between the detections and the non-crowd ground
-  # truths and IoAs between the detections and the crowd ground truths.
-  if not use_masks:
-    # (batch_size, num_detections, num_gts)
-    detection_to_gt_ious = box_ops.bbox_overlap(detection_boxes, gt_boxes)
-    detection_to_gt_ioas = box_ops.bbox_intersection_over_area(
-        detection_boxes, gt_boxes
-    )
-  else:
-    # (batch_size, num_detections, mask_height, mask_width)
-    detection_masks = tf.cast(y_pred['detection_masks'], tf.float32)
-    # (batch_size, num_gts, gt_mask_height, gt_mask_width)
-    gt_masks = tf.cast(y_true['masks'], tf.float32)
-
-    num_detections = detection_boxes.get_shape()[1]
-    # (batch_size, num_detections + num_gts, 4)
-    all_boxes = _shift_and_rescale_boxes(
-        tf.concat([detection_boxes, gt_boxes], axis=1),
-        mask_output_boundary,
-    )
-    detection_boxes = all_boxes[:, :num_detections, :]
-    gt_boxes = all_boxes[:, num_detections:, :]
-    # (batch_size, num_detections, num_gts)
-    detection_to_gt_ious, detection_to_gt_ioas = (
-        mask_ops.instance_masks_overlap(
-            detection_boxes,
-            detection_masks,
-            gt_boxes,
-            gt_masks,
-            output_size=mask_output_boundary,
-        )
-    )
-
-  # (batch_size, num_detections, num_gts)
-  detection_to_gt_ious = tf.where(
-      gt_is_crowd[:, tf.newaxis, :], 0.0, detection_to_gt_ious
-  )
-  detection_to_crowd_ioas = tf.where(
-      gt_is_crowd[:, tf.newaxis, :], detection_to_gt_ioas, 0.0
-  )
-
-  # Step 2: counts true positives grouped by IoU thresholds, classes and
-  # confidence bins.
-
-  # (batch_size, num_detections, num_iou_thresholds)
-  detection_is_tp, _ = matching_algorithm(
-      detection_to_gt_ious, detection_classes, detection_scores, gt_classes
-  )
-  # (batch_size * num_detections,)
-  flattened_binned_confidence = tf.reshape(
-      tf.cast(detection_scores * num_confidence_bins, tf.int32), [-1]
-  )
-  # (batch_size * num_detections, num_confidence_bins + 1)
-  flattened_binned_confidence_one_hot = tf.one_hot(
-      flattened_binned_confidence, num_confidence_bins + 1, axis=1
-  )
-  # (num_iou_thresholds, num_classes, num_confidence_bins + 1)
-  tp_count = _count_detection_type(
-      detection_is_tp,
-      detection_classes,
-      flattened_binned_confidence_one_hot,
-      num_classes,
-  )
-
-  # Step 3: Counts false positives grouped by IoU thresholds, classes and
-  # confidence bins.
-  # False positive: detection is not true positive (see above) and not part of
-  # the crowd ground truth with the same class.
-
-  # (batch_size, num_detections, num_gts, num_iou_thresholds)
-  detection_matches_crowd = (
-      (detection_to_crowd_ioas[..., tf.newaxis] > iou_thresholds)
-      & (
-          detection_classes[:, :, tf.newaxis, tf.newaxis]
-          == gt_classes[:, tf.newaxis, :, tf.newaxis]
-      )
-      & (detection_classes[:, :, tf.newaxis, tf.newaxis] > 0)
-  )
-  # (batch_size, num_detections, num_iou_thresholds)
-  detection_matches_any_crowd = tf.reduce_any(
-      detection_matches_crowd & ~detection_is_tp[:, :, tf.newaxis, :], axis=2
-  )
-  detection_is_fp = ~detection_is_tp & ~detection_matches_any_crowd
-  # (num_iou_thresholds, num_classes, num_confidence_bins + 1)
-  fp_count = _count_detection_type(
-      detection_is_fp,
-      detection_classes,
-      flattened_binned_confidence_one_hot,
-      num_classes,
-  )
-
-  # Step 4: Counts non-crowd groundtruths grouped by classes.
-  # (num_classes, )
-  gt_count = tf.reduce_sum(
-      tf.one_hot(
-          tf.where(gt_is_crowd, -1, gt_classes), num_classes, axis=-1
-      ),
-      axis=[0, 1],
-  )
-  # Clears the count of class 0 (background).
-  gt_count *= 1.0 - tf.eye(1, num_classes, dtype=gt_count.dtype)[0]
-
-  return tp_count, fp_count, gt_count
-
-
-def _compute_metrics(
-    tp_count: tf.Tensor,
-    fp_count: tf.Tensor,
-    gt_count: tf.Tensor,
-    confidence_thresholds: Tuple[float, ...] = (),
-    num_confidence_bins: int = 1000,
-    average_precision_algorithms: Optional[
-        Dict[str, AveragePrecision]] = None,
-) -> Dict[str, tf.Tensor]:
-  """Returns the metrics values as a dict."""
-
-  if average_precision_algorithms is None:
-    average_precision_algorithms = {'ap': COCOAveragePrecision()}
-
-  result = {
-      # (num_classes,)
-      'valid_classes': gt_count != 0,
-  }
-
-  # (num_iou_thresholds, num_classes, num_confidence_bins + 1)
-  tp_count_cum_by_confidence = tf.math.cumsum(
-      tp_count, axis=-1, reverse=True
-  )
-  # (num_iou_thresholds, num_classes, num_confidence_bins + 1)
-  fp_count_cum_by_confidence = tf.math.cumsum(
-      fp_count, axis=-1, reverse=True
-  )
-
-  # (num_iou_thresholds, num_classes, num_confidence_bins + 1)
-  precisions = tf.math.divide_no_nan(
-      tp_count_cum_by_confidence,
-      tp_count_cum_by_confidence + fp_count_cum_by_confidence,
-  )
-  # (num_iou_thresholds, num_classes, num_confidence_bins + 1)
-  recalls = tf.math.divide_no_nan(
-      tp_count_cum_by_confidence, gt_count[..., tf.newaxis]
-  )
-
-  if confidence_thresholds:
-    # If confidence_thresholds is set, reports precision and recall at each
-    # confidence threshold.
-    confidence_thresholds = tf.cast(
-        tf.constant(confidence_thresholds, dtype=tf.float32)
-        * num_confidence_bins,
-        dtype=tf.int32,
-    )
-    # (num_confidence_thresholds, num_iou_thresholds, num_classes)
-    result['precisions'] = tf.gather(
-        tf.transpose(precisions, [2, 0, 1]), confidence_thresholds
-    )
-    result['recalls'] = tf.gather(
-        tf.transpose(recalls, [2, 0, 1]), confidence_thresholds
-    )
-
-  precisions = tf.reverse(precisions, axis=[-1])
-  recalls = tf.reverse(recalls, axis=[-1])
-  result.update(
-      {
-          # (num_iou_thresholds, num_classes)
-          key: ap_algorithm(precisions, recalls)
-          for key, ap_algorithm in average_precision_algorithms.items()
-      }
-  )
-  return result
-
-
 class InstanceMetrics(tf.keras.metrics.Metric):
   """Reports the metrics of instance detection & segmentation."""
 
@@ -780,22 +573,138 @@ class InstanceMetrics(tf.keras.metrics.Metric):
 
   def reset_state(self):
     """Resets all of the metric state variables."""
-    for v in self.variables:
-      tf.keras.backend.set_value(v, np.zeros(v.shape))
+    self.tp_count.assign(tf.zeros_like(self.tp_count))
+    self.fp_count.assign(tf.zeros_like(self.fp_count))
+    self.gt_count.assign(tf.zeros_like(self.gt_count))
 
   def update_state(
       self, y_true: Dict[str, tf.Tensor], y_pred: Dict[str, tf.Tensor]
   ):
+    # (batch_size, num_detections, 4) in absolute coordinates.
+    detection_boxes = tf.cast(y_pred['detection_boxes'], tf.float32)
+    # (batch_size, num_detections)
+    detection_classes = tf.cast(y_pred['detection_classes'], tf.int32)
+    # (batch_size, num_detections)
+    detection_scores = tf.cast(y_pred['detection_scores'], tf.float32)
+    # (batch_size, num_gts, 4) in absolute coordinates.
+    gt_boxes = tf.cast(y_true['boxes'], tf.float32)
+    # (batch_size, num_gts)
+    gt_classes = tf.cast(y_true['classes'], tf.int32)
+    # (batch_size, num_gts)
+    if 'is_crowds' in y_true:
+      gt_is_crowd = tf.cast(y_true['is_crowds'], tf.bool)
+    else:
+      gt_is_crowd = tf.zeros_like(gt_classes, dtype=tf.bool)
 
-    tp_count, fp_count, gt_count = _compute_fp_tp_gt_count(
-        y_true=y_true,
-        y_pred=y_pred,
-        num_classes=self._num_classes,
-        mask_output_boundary=self._mask_output_boundary,
-        iou_thresholds=self._iou_thresholds,
-        matching_algorithm=self._matching_algorithm,
-        num_confidence_bins=self._num_confidence_bins,
-        use_masks=self._use_masks)
+    image_scale = tf.tile(y_true['image_info'][:, 2:3, :], multiples=[1, 1, 2])
+    detection_boxes = detection_boxes / tf.cast(
+        image_scale, dtype=detection_boxes.dtype
+    )
+
+    # Step 1: Computes IoUs between the detections and the non-crowd ground
+    # truths and IoAs between the detections and the crowd ground truths.
+    if not self._use_masks:
+      # (batch_size, num_detections, num_gts)
+      detection_to_gt_ious = box_ops.bbox_overlap(detection_boxes, gt_boxes)
+      detection_to_gt_ioas = box_ops.bbox_intersection_over_area(
+          detection_boxes, gt_boxes
+      )
+    else:
+      # Use outer boxes to generate the masks if available.
+      if 'detection_outer_boxes' in y_pred:
+        detection_boxes = tf.cast(y_pred['detection_outer_boxes'], tf.float32)
+
+      # (batch_size, num_detections, mask_height, mask_width)
+      detection_masks = tf.cast(y_pred['detection_masks'], tf.float32)
+      # (batch_size, num_gts, gt_mask_height, gt_mask_width)
+      gt_masks = tf.cast(y_true['masks'], tf.float32)
+
+      num_detections = detection_boxes.get_shape()[1]
+      # (batch_size, num_detections + num_gts, 4)
+      all_boxes = _shift_and_rescale_boxes(
+          tf.concat([detection_boxes, gt_boxes], axis=1),
+          self._mask_output_boundary,
+      )
+      detection_boxes = all_boxes[:, :num_detections, :]
+      gt_boxes = all_boxes[:, num_detections:, :]
+      # (batch_size, num_detections, num_gts)
+      detection_to_gt_ious, detection_to_gt_ioas = (
+          mask_ops.instance_masks_overlap(
+              detection_boxes,
+              detection_masks,
+              gt_boxes,
+              gt_masks,
+              output_size=self._mask_output_boundary,
+          )
+      )
+    # (batch_size, num_detections, num_gts)
+    detection_to_gt_ious = tf.where(
+        gt_is_crowd[:, tf.newaxis, :], 0.0, detection_to_gt_ious
+    )
+    detection_to_crowd_ioas = tf.where(
+        gt_is_crowd[:, tf.newaxis, :], detection_to_gt_ioas, 0.0
+    )
+
+    # Step 2: counts true positives grouped by IoU thresholds, classes and
+    # confidence bins.
+
+    # (batch_size, num_detections, num_iou_thresholds)
+    detection_is_tp, _ = self._matching_algorithm(
+        detection_to_gt_ious, detection_classes, detection_scores, gt_classes
+    )
+    # (batch_size * num_detections,)
+    flattened_binned_confidence = tf.reshape(
+        tf.cast(detection_scores * self._num_confidence_bins, tf.int32), [-1]
+    )
+    # (batch_size * num_detections, num_confidence_bins + 1)
+    flattened_binned_confidence_one_hot = tf.one_hot(
+        flattened_binned_confidence, self._num_confidence_bins + 1, axis=1
+    )
+    # (num_iou_thresholds, num_classes, num_confidence_bins + 1)
+    tp_count = _count_detection_type(
+        detection_is_tp,
+        detection_classes,
+        flattened_binned_confidence_one_hot,
+        self._num_classes,
+    )
+
+    # Step 3: Counts false positives grouped by IoU thresholds, classes and
+    # confidence bins.
+    # False positive: detection is not true positive (see above) and not part of
+    # the crowd ground truth with the same class.
+
+    # (batch_size, num_detections, num_gts, num_iou_thresholds)
+    detection_matches_crowd = (
+        (detection_to_crowd_ioas[..., tf.newaxis] > self._iou_thresholds)
+        & (
+            detection_classes[:, :, tf.newaxis, tf.newaxis]
+            == gt_classes[:, tf.newaxis, :, tf.newaxis]
+        )
+        & (detection_classes[:, :, tf.newaxis, tf.newaxis] > 0)
+    )
+    # (batch_size, num_detections, num_iou_thresholds)
+    detection_matches_any_crowd = tf.reduce_any(
+        detection_matches_crowd & ~detection_is_tp[:, :, tf.newaxis, :], axis=2
+    )
+    detection_is_fp = ~detection_is_tp & ~detection_matches_any_crowd
+    # (num_iou_thresholds, num_classes, num_confidence_bins + 1)
+    fp_count = _count_detection_type(
+        detection_is_fp,
+        detection_classes,
+        flattened_binned_confidence_one_hot,
+        self._num_classes,
+    )
+
+    # Step 4: Counts non-crowd groundtruths grouped by classes.
+    # (num_classes, )
+    gt_count = tf.reduce_sum(
+        tf.one_hot(
+            tf.where(gt_is_crowd, -1, gt_classes), self._num_classes, axis=-1
+        ),
+        axis=[0, 1],
+    )
+    # Clears the count of class 0 (background).
+    gt_count *= 1.0 - tf.eye(1, self._num_classes, dtype=gt_count.dtype)[0]
 
     # Accumulates the variables.
     self.fp_count.assign_add(tf.cast(fp_count, self.fp_count.dtype))
@@ -818,13 +727,55 @@ class InstanceMetrics(tf.keras.metrics.Metric):
         'valid_classes': a bool tensor in shape (num_classes,). If False, there
         is no instance of the class in the ground truth.
     """
-    result = _compute_metrics(
-        fp_count=self.fp_count,
-        tp_count=self.tp_count,
-        gt_count=self.gt_count,
-        confidence_thresholds=self._confidence_thresholds,
-        num_confidence_bins=self._num_confidence_bins,
-        average_precision_algorithms=self._average_precision_algorithms)
+    result = {
+        # (num_classes,)
+        'valid_classes': self.gt_count != 0,
+    }
+
+    # (num_iou_thresholds, num_classes, num_confidence_bins + 1)
+    tp_count_cum_by_confidence = tf.math.cumsum(
+        self.tp_count, axis=-1, reverse=True
+    )
+    # (num_iou_thresholds, num_classes, num_confidence_bins + 1)
+    fp_count_cum_by_confidence = tf.math.cumsum(
+        self.fp_count, axis=-1, reverse=True
+    )
+
+    # (num_iou_thresholds, num_classes, num_confidence_bins + 1)
+    precisions = tf.math.divide_no_nan(
+        tp_count_cum_by_confidence,
+        tp_count_cum_by_confidence + fp_count_cum_by_confidence,
+    )
+    # (num_iou_thresholds, num_classes, num_confidence_bins + 1)
+    recalls = tf.math.divide_no_nan(
+        tp_count_cum_by_confidence, self.gt_count[..., tf.newaxis]
+    )
+
+    if self._confidence_thresholds:
+      # If confidence_thresholds is set, reports precision and recall at each
+      # confidence threshold.
+      confidence_thresholds = tf.cast(
+          tf.constant(self._confidence_thresholds, dtype=tf.float32)
+          * self._num_confidence_bins,
+          dtype=tf.int32,
+      )
+      # (num_confidence_thresholds, num_iou_thresholds, num_classes)
+      result['precisions'] = tf.gather(
+          tf.transpose(precisions, [2, 0, 1]), confidence_thresholds
+      )
+      result['recalls'] = tf.gather(
+          tf.transpose(recalls, [2, 0, 1]), confidence_thresholds
+      )
+
+    precisions = tf.reverse(precisions, axis=[-1])
+    recalls = tf.reverse(recalls, axis=[-1])
+    result.update(
+        {
+            # (num_iou_thresholds, num_classes)
+            key: ap_algorithm(precisions, recalls)
+            for key, ap_algorithm in self._average_precision_algorithms.items()
+        }
+    )
     return result
 
   def get_average_precision_metrics_keys(self):

official/vision/ops/preprocess_ops.py

@@ -182,7 +182,12 @@ def resize_and_crop_image(image,
   with tf.name_scope('resize_and_crop_image'):
     image_size = tf.cast(tf.shape(image)[0:2], tf.float32)
 
-    random_jittering = (aug_scale_min != 1.0 or aug_scale_max != 1.0)
+    random_jittering = (
+        isinstance(aug_scale_min, tf.Tensor)
+        or isinstance(aug_scale_max, tf.Tensor)
+        or not math.isclose(aug_scale_min, 1.0)
+        or not math.isclose(aug_scale_max, 1.0)
+    )
 
     if random_jittering:
       random_scale = tf.random.uniform(
@@ -292,7 +297,12 @@ def resize_and_crop_image_v2(image,
         scaled_size)
     desired_size = scaled_size
 
-    random_jittering = (aug_scale_min != 1.0 or aug_scale_max != 1.0)
+    random_jittering = (
+        isinstance(aug_scale_min, tf.Tensor)
+        or isinstance(aug_scale_max, tf.Tensor)
+        or not math.isclose(aug_scale_min, 1.0)
+        or not math.isclose(aug_scale_max, 1.0)
+    )
 
     if random_jittering:
       random_scale = tf.random.uniform(
@@ -641,10 +651,12 @@ def horizontal_flip_masks(masks):
   return masks[:, :, ::-1]
 
 
-def random_horizontal_flip(image, normalized_boxes=None, masks=None, seed=1):
+def random_horizontal_flip(
+    image, normalized_boxes=None, masks=None, seed=1, prob=0.5
+):
   """Randomly flips input image and bounding boxes horizontally."""
   with tf.name_scope('random_horizontal_flip'):
-    do_flip = tf.greater(tf.random.uniform([], seed=seed), 0.5)
+    do_flip = tf.less(tf.random.uniform([], seed=seed), prob)
 
     image = tf.cond(
         do_flip,
@@ -713,10 +725,12 @@ def random_horizontal_flip_with_roi(
     return image, boxes, masks, roi_boxes
 
 
-def random_vertical_flip(image, normalized_boxes=None, masks=None, seed=1):
+def random_vertical_flip(
+    image, normalized_boxes=None, masks=None, seed=1, prob=0.5
+):
   """Randomly flips input image and bounding boxes vertically."""
   with tf.name_scope('random_vertical_flip'):
-    do_flip = tf.greater(tf.random.uniform([], seed=seed), 0.5)
+    do_flip = tf.less(tf.random.uniform([], seed=seed), prob)
 
     image = tf.cond(
         do_flip,

{tf_models_nightly-2.11.0.dev20230321.dist-info → tf_models_nightly-2.11.0.dev20230322.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tf-models-nightly
-Version: 2.11.0.dev20230321
+Version: 2.11.0.dev20230322
 Summary: TensorFlow Official Models
 Home-page: https://github.com/tensorflow/models
 Author: Google Inc.

{tf_models_nightly-2.11.0.dev20230321.dist-info → tf_models_nightly-2.11.0.dev20230322.dist-info}/RECORD

@@ -759,15 +759,15 @@ official/projects/yt8m/__init__.py,sha256=XKqEvUISyqNK_cFqr7umxt6r-vnABJ2OqGEKE3
 official/projects/yt8m/train.py,sha256=NNzjalMAmrRSQlYGZlXNAbnwdXK2OMJXfS6qwv6_cTk,987
 official/projects/yt8m/train_test.py,sha256=TUqDVIJeDrkbmVUlJ1rw5RqOtRBzyYwguO-09OdLmkk,3892
 official/projects/yt8m/configs/__init__.py,sha256=sItZXhE5JuW4RRDBhX9EW4eSrp1HdDxhmEv9420aaD0,692
-official/projects/yt8m/configs/yt8m.py,sha256=PCez9EyP1ne4_wn6S7uO29Vwxzd2wWdb3HdipAfRsZA,8704
+official/projects/yt8m/configs/yt8m.py,sha256=R-wUAo-udQYYEfS7SJ4JzyCcifC8NJqnpUiiSltUVFM,8629
 official/projects/yt8m/configs/yt8m_test.py,sha256=5zyL8EVpP127q6yZkBlAve3Fko2ujDCThsWZ9pUDGBM,1561
 official/projects/yt8m/modeling/__init__.py,sha256=XKqEvUISyqNK_cFqr7umxt6r-vnABJ2OqGEKE395w20,609
-official/projects/yt8m/modeling/nn_layers.py,sha256=qMJyW4ZR7FI1yYOJdbltooBGp0q8eF6k7Sf_yZM8fbc,5490
-official/projects/yt8m/modeling/yt8m_model.py,sha256=dfF2qhS5-rHdQMuq5ZjcSKBdE7stOAjFIY4o3npiDFA,8697
+official/projects/yt8m/modeling/nn_layers.py,sha256=DK3yKXBC3yPMfpGqYW1Se5AhQcNBul3376uOFpFc0QQ,10392
+official/projects/yt8m/modeling/yt8m_model.py,sha256=QkRW1yktCJPqE7x2cGOkcBzF605D0D1Gb5ndEIENF9E,3720
 official/projects/yt8m/modeling/yt8m_model_test.py,sha256=k5zPv4lFCJ9UjD2BSJpo4ggVHX5ZAbZ1m7kFWLe-SIM,2131
-official/projects/yt8m/modeling/yt8m_model_utils.py,sha256=bXoALSMfyMixux4BDUFAcTVadSz6uav9sIA-dtK4x8E,8408
+official/projects/yt8m/modeling/yt8m_model_utils.py,sha256=lrSjCKjfBTTlhr3ledY5mit9Qy5P5dAnO_IgBX9gUSs,8451
 official/projects/yt8m/tasks/__init__.py,sha256=tS1Bb__H9G0UtOQMi7sdvaJv4c4ROqNVwaSSQuwCC0Y,692
-official/projects/yt8m/tasks/yt8m_task.py,sha256=G9PI6NkMFEc_0tViQez7Jiaks1KKu2wkmaii5PUSZqk,14615
+official/projects/yt8m/tasks/yt8m_task.py,sha256=BJhvjVnaRPYNrScjDlXUxtKL09bZOijP_EfwuO3Zdio,14438
 official/recommendation/__init__.py,sha256=XKqEvUISyqNK_cFqr7umxt6r-vnABJ2OqGEKE395w20,609
 official/recommendation/constants.py,sha256=aTDcZc7_1Ir3Wt3NAzM96exWcV41iXDLUAz33kf5z4g,2877
 official/recommendation/create_ncf_data.py,sha256=oP6ueDrWfS7bDKW099TFdy9LiYfdd40jFp4Zv6WlENE,4008
@@ -851,7 +851,7 @@ official/vision/dataloaders/classification_input.py,sha256=nyAzbzuorMIusOQd2h8bm
 official/vision/dataloaders/decoder.py,sha256=XGvZHeqJzGr1cgXY4VpEQzGvapkd80u_FDfKqD4LfRs,1016
 official/vision/dataloaders/input_reader.py,sha256=S7NlBfBcGfdqWrIvQNpL5nM7YDFBQWceZv5PQZRCWME,10410
 official/vision/dataloaders/input_reader_factory.py,sha256=Gc5eZ4kEUfwp7E5U_Bl9JaEN6WRZCgtku69gP7a6zjw,1623
-official/vision/dataloaders/maskrcnn_input.py,sha256=8siryuNYgSNbe_5U5__K2p1LHrD3FjpVHQq6I6ZILWQ,16922
+official/vision/dataloaders/maskrcnn_input.py,sha256=F1BfbUjZpwHzAG7NrKQCPbKYyOvjR1qWQ3DMjTPPqC8,16837
 official/vision/dataloaders/parser.py,sha256=7TJNrl28Ddf7w1Nx7FMMbt_aX0SRDX8h0UZa-upemo4,2315
 official/vision/dataloaders/retinanet_input.py,sha256=osZU-_eh70aK5CUD9dwzfoOv8xDfSMQPYxAn3hlQR78,13594
 official/vision/dataloaders/segmentation_input.py,sha256=xNHHSnX_VTaHE6A1WHyvabGmbPLwpJ3JNOmK8B2-RM0,11828
@@ -859,7 +859,7 @@ official/vision/dataloaders/tf_example_decoder.py,sha256=0J-rQzSkUwgR_xEZ-UR5ToS
 official/vision/dataloaders/tf_example_decoder_test.py,sha256=sPvAtExClFz7C6MYqg0pEgZzZ5-PcZYipHU0bKk2Fn8,12619
 official/vision/dataloaders/tf_example_label_map_decoder.py,sha256=SkNyEohAFvUJCVP1XRqy4lTT7bn7agULtgrExfFeLzE,2588
 official/vision/dataloaders/tf_example_label_map_decoder_test.py,sha256=FAXpKc8BZq2y28XjsbTaxlMRwe9vS53mPLW3r61ShHI,7746
-official/vision/dataloaders/tfds_classification_decoders.py,sha256=sQHsswMcbeCixDX0kvii9m_KbE3xxMv5ovFcYFJh1d4,1242
+official/vision/dataloaders/tfds_classification_decoders.py,sha256=X_WUL3QwgGBtE0K0oguONRD38NJs7DNP7yW_gukqimY,1301
 official/vision/dataloaders/tfds_detection_decoders.py,sha256=-2l3aSCOEoJZO3h0LOrdyUn7TBgFy_iWMzQKE_DuN-Q,2273
 official/vision/dataloaders/tfds_factory.py,sha256=wEZCTW8h6CRHEO8cniSEgxXsrtrFZS_WSjaDiEFvqHc,2568
 official/vision/dataloaders/tfds_factory_test.py,sha256=PmgbXmfkmh8erSSii8GYLXu_coShbIdCEjzTeOepd3w,4010
@@ -873,7 +873,7 @@ official/vision/evaluation/__init__.py,sha256=XKqEvUISyqNK_cFqr7umxt6r-vnABJ2OqG
 official/vision/evaluation/coco_evaluator.py,sha256=LMl4rACazArEGsI5RlgRiQW3q5DeQimhh72NjfXhDLs,15535
 official/vision/evaluation/coco_utils.py,sha256=9-5uF3ofhhNdlGbdPBYM8ySbtxxXc_NorGFnU9kCxjg,17911
 official/vision/evaluation/coco_utils_test.py,sha256=PjqRYETQsOAEtcA5Pod8NPmA1xc-7wm_poYU7W_mOXw,1710
-official/vision/evaluation/instance_metrics.py,sha256=HJzrhyl2ETX86zXnyCNBaWG4Lz_z27oqxvVDUt2pcAI,30175
+official/vision/evaluation/instance_metrics.py,sha256=X2McJng7V57AZdoo6-k3C117SUhpKGnsuLbtEOxIgKE,29104
 official/vision/evaluation/instance_metrics_test.py,sha256=GqtAgSpl4hR-wrnk55Efm8dX2b3hHNbHR9hvvR4sJ6s,10813
 official/vision/evaluation/iou.py,sha256=8VH0AHMquWvmdLtr9Yl0ZWv7efJGhhi1sKtAYUyVhCY,6272
 official/vision/evaluation/iou_test.py,sha256=1aPmTZmvp6_bL6yr2c9Wa2StUZU2xZ3mICN11pJoojg,5380
@@ -981,7 +981,7 @@ official/vision/ops/iou_similarity_test.py,sha256=SMq2wPl98_HenxAKk4p4By_ZoRy6LY
 official/vision/ops/mask_ops.py,sha256=9yR6KWC9croKvzMtSFUU3cK87-ileUD8MzHfJ-IvBJo,10260
 official/vision/ops/mask_ops_test.py,sha256=34mwpK2-GRS0BWLcOz2Dk2h9kaNBu5zBV70pElpAGsI,2825
 official/vision/ops/nms.py,sha256=Q5iGXJ-f_hcLNzyCu7CXKigCK4yHSq40ed7ornqZfVQ,8115
-official/vision/ops/preprocess_ops.py,sha256=xiQgsetqA380Po751xaKPMZYUG_3YAmyWIBA0lyfwPw,39149
+official/vision/ops/preprocess_ops.py,sha256=NEcNSEZP1mvWD-XmS8nBvsGxE7EpY_i5MyIsmjM1yp4,39477
 official/vision/ops/preprocess_ops_3d.py,sha256=aUn1OTLkr1046sAfVefybRxHzhaVAtywlmP0R1UGbIg,15378
 official/vision/ops/preprocess_ops_3d_test.py,sha256=mrs0IVby6WFc2gcD8pIYU__KQFfhmP4m9U000hrpIJQ,7239
 official/vision/ops/preprocess_ops_test.py,sha256=_6ozeiWsDMBxSQslNJ2y5SCqqTLwbGzgLBjU7dohqmE,11710
@@ -1069,9 +1069,9 @@ tensorflow_models/__init__.py,sha256=021FKgqdPz3ds1xxfV67FWL7e5ECQ7WHbo67D37vAQI
 tensorflow_models/tensorflow_models_test.py,sha256=3oRV5seq-V1La0eY0IFpGLD7AKkiemylW8GyvZIRtmo,1385
 tensorflow_models/nlp/__init__.py,sha256=ro-1L0G8Z1wby8D1Jbaa3No-n73tiNEx7C4f8pAUNlk,807
 tensorflow_models/vision/__init__.py,sha256=3qeLW_6HkgH5hEclFog2DIRu1FSzOr3JynyM23zGhu8,833
-tf_models_nightly-2.11.0.dev20230321.dist-info/AUTHORS,sha256=1dG3fXVu9jlo7bul8xuix5F5vOnczMk7_yWn4y70uw0,337
-tf_models_nightly-2.11.0.dev20230321.dist-info/LICENSE,sha256=WxeBS_DejPZQabxtfMOM_xn8qoZNJDQjrT7z2wG1I4U,11512
-tf_models_nightly-2.11.0.dev20230321.dist-info/METADATA,sha256=ONfrJ2f_hyv4tO-2Dj8AVq-IBYx3v_a9Q8ViV5oJfAQ,1426
-tf_models_nightly-2.11.0.dev20230321.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
-tf_models_nightly-2.11.0.dev20230321.dist-info/top_level.txt,sha256=gum2FfO5R4cvjl2-QtP-S1aNmsvIZaFFT6VFzU0f4-g,33
-tf_models_nightly-2.11.0.dev20230321.dist-info/RECORD,,
+tf_models_nightly-2.11.0.dev20230322.dist-info/AUTHORS,sha256=1dG3fXVu9jlo7bul8xuix5F5vOnczMk7_yWn4y70uw0,337
+tf_models_nightly-2.11.0.dev20230322.dist-info/LICENSE,sha256=WxeBS_DejPZQabxtfMOM_xn8qoZNJDQjrT7z2wG1I4U,11512
+tf_models_nightly-2.11.0.dev20230322.dist-info/METADATA,sha256=nDQJeoSeIrhNpJ_zLaHs0TTJh6nTufa15zPzqMjIZUk,1426
+tf_models_nightly-2.11.0.dev20230322.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
+tf_models_nightly-2.11.0.dev20230322.dist-info/top_level.txt,sha256=gum2FfO5R4cvjl2-QtP-S1aNmsvIZaFFT6VFzU0f4-g,33
+tf_models_nightly-2.11.0.dev20230322.dist-info/RECORD,,