Ayuda a proteger la Gran Barrera de Coral con TensorFlow en Kaggle Únete Challenge

Utilice modelos TF1.x en flujos de trabajo TF2

Ver en TensorFlow.org Ejecutar en Google Colab Ver en GitHub Descargar libreta

Esta guía proporciona una descripción general y ejemplos de un código de modelado shim que puede emplear para usar sus modelos TF1.x existentes en flujos de trabajo de TF2, como estrategias de ejecución, tf.function y distribución con cambios mínimos en su código de modelado.

Ámbito de uso

La cuña descrita en esta guía está diseñada para modelos TF1.x que dependen de:

  1. tf.compat.v1.get_variable y tf.compat.v1.variable_scope para controlar la creación y reutilización de variables, y
  2. API basadas en recopilación de gráficos como tf.compat.v1.global_variables() , tf.compat.v1.trainable_variables , tf.compat.v1.losses.get_regularization_losses() y tf.compat.v1.get_collection() para realizar un seguimiento de pesos y pérdidas de regularización

Esto incluye la mayoría de los modelos creados sobre las API tf.compat.v1.layer , tf.contrib.layers y TensorFlow-Slim .

El calce NO es necesario para los siguientes modelos TF1.x:

  1. Modelos independientes de Keras que ya rastrean todos sus pesos entrenables y pérdidas de regularización a través model.trainable_weights y model.losses respectivamente.
  2. tf.Module s que ya rastrean todos sus pesos entrenables a través de module.trainable_variables , y solo crean pesos si aún no se han creado.

Es probable que estos modelos funcionen en TF2 con una ejecución entusiasta y tf.function s listos para usar.

Configuración

Importa TensorFlow y otras dependencias.

pip uninstall -y -q tensorflow
# Install tf-nightly as the DeterministicRandomTestTool is available only in
# Tensorflow 2.8

pip install -q tf-nightly
import tensorflow as tf
import tensorflow.compat.v1 as v1
import sys
import numpy as np

from contextlib import contextmanager

El decorador track_tf1_style_variables

El calce clave que se describe en esta guía es tf.compat.v1.keras.utils.track_tf1_style_variables , un decorador que puede usar dentro de los métodos que pertenecen a tf.keras.layers.Layer y tf.Module para realizar un seguimiento de los pesos de estilo TF1.x y capturar las pérdidas de regularización.

Decorar los métodos de llamada de tf.keras.layers.Layer o tf.Module con tf.compat.v1.keras.utils.track_tf1_style_variables permite la creación y reutilización de variables a través tf.compat.v1.get_variable (y por extensión tf.compat.v1.layers ) para que funcione correctamente dentro del método decorado en lugar de crear siempre una nueva variable en cada llamada. También hará que la capa o el módulo realice un seguimiento implícito de cualquier peso creado o al que se acceda a través get_variable dentro del método decorado.

Además de rastrear los pesos mismos bajo el estándar layer.variable / module.variable /etc. properties, si el método pertenece a tf.keras.layers.Layer , cualquier pérdida de regularización especificada a través de los argumentos del regularizador get_variable o tf.compat.v1.layers será rastreada por la capa bajo la propiedad estándar layer.losses .

Este mecanismo de seguimiento permite el uso de grandes clases de código model-forward-pass de estilo TF1.x dentro de las capas de Keras o tf.Module s en TF2, incluso con los comportamientos de TF2 habilitados.

Ejemplos de uso

Los siguientes ejemplos de uso muestran las correcciones de modelado utilizadas para decorar los métodos tf.keras.layers.Layer , pero excepto cuando interactúan específicamente con las funciones de Keras, también son aplicables al decorar los métodos tf.Module .

Capa construida con tf.compat.v1.get_variable

Imagine que tiene una capa implementada directamente encima de tf.compat.v1.get_variable de la siguiente manera:

def dense(self, inputs, units):
  out = inputs
  with tf.compat.v1.variable_scope("dense"):
    # The weights are created with a `regularizer`,
    kernel = tf.compat.v1.get_variable(
        shape=[out.shape[-1], units],
        regularizer=tf.keras.regularizers.L2(),
        initializer=tf.compat.v1.initializers.glorot_normal,
        name="kernel")
    bias = tf.compat.v1.get_variable(
        shape=[units,],
        initializer=tf.compat.v1.initializers.zeros,
        name="bias")
    out = tf.linalg.matmul(out, kernel)
    out = tf.compat.v1.nn.bias_add(out, bias)
  return out

Use la cuña para convertirlo en una capa y llamarlo en las entradas.

class DenseLayer(tf.keras.layers.Layer):

  def __init__(self, units, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.units = units

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs):
    out = inputs
    with tf.compat.v1.variable_scope("dense"):
      # The weights are created with a `regularizer`,
      # so the layer should track their regularization losses
      kernel = tf.compat.v1.get_variable(
          shape=[out.shape[-1], self.units],
          regularizer=tf.keras.regularizers.L2(),
          initializer=tf.compat.v1.initializers.glorot_normal,
          name="kernel")
      bias = tf.compat.v1.get_variable(
          shape=[self.units,],
          initializer=tf.compat.v1.initializers.zeros,
          name="bias")
      out = tf.linalg.matmul(out, kernel)
      out = tf.compat.v1.nn.bias_add(out, bias)
    return out

layer = DenseLayer(10)
x = tf.random.normal(shape=(8, 20))
layer(x)
WARNING:tensorflow:From /tmp/ipykernel_27038/795621215.py:7: The name tf.keras.utils.track_tf1_style_variables is deprecated. Please use tf.compat.v1.keras.utils.track_tf1_style_variables instead.
<tf.Tensor: shape=(8, 10), dtype=float32, numpy=
array([[-0.51018804, -0.58145535,  0.25050664, -0.09880018,  0.71741414,
        -0.08512568,  0.33404148,  0.50894034,  0.19362557,  0.03945067],
       [-0.66160053,  0.43442816, -0.6187523 ,  0.00753711,  1.3946855 ,
         0.22528797,  0.55661404, -1.6155301 ,  1.5854199 , -0.4165327 ],
       [ 0.15855707,  0.43848652,  0.04762229,  0.22020248,  0.88300526,
         0.31525093, -0.10912375,  0.03332198,  1.3462385 , -0.37986106],
       [ 0.02546233, -0.01084138,  0.0417656 ,  1.1082407 ,  0.926408  ,
         0.46938205,  1.0183189 ,  1.2039868 , -0.09619217, -0.50863194],
       [-1.6222394 ,  0.17156005, -0.07482994,  0.646423  ,  1.0284312 ,
         2.3619173 ,  0.6322627 ,  0.5350776 , -2.2700598 , -0.8211552 ],
       [-1.1044651 ,  0.7303245 ,  1.0183476 ,  1.2858934 ,  0.4575533 ,
         0.93400717,  0.5323913 , -0.01242167,  0.8308919 ,  0.03202473],
       [ 0.3880633 , -1.2345276 ,  0.7713047 , -0.33720714,  1.0418141 ,
        -1.055242  , -1.6942265 ,  1.705035  ,  0.8671215 ,  0.8162696 ],
       [ 0.02216246, -0.5235669 ,  0.01065174, -1.1682817 ,  0.44079733,
         0.25890222, -1.0779501 ,  0.37716752, -0.27636313, -0.6359312 ]],
      dtype=float32)>

Acceda a las variables rastreadas y las pérdidas de regularización capturadas como una capa estándar de Keras.

layer.trainable_variables
layer.losses
2021-12-04 02:24:42.941890: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
[<tf.Tensor: shape=(), dtype=float32, numpy=0.10789324>]

Para ver que los pesos se reutilicen cada vez que llame a la capa, establezca todos los pesos en cero y vuelva a llamar a la capa.

print("Resetting variables to zero:", [var.name for var in layer.trainable_variables])

for var in layer.trainable_variables:
  var.assign(var * 0.0)

# Note: layer.losses is not a live view and
# will get reset only at each layer call
print("layer.losses:", layer.losses)
print("calling layer again.")
out = layer(x)
print("layer.losses: ", layer.losses)
out
Resetting variables to zero: ['dense/bias:0', 'dense/kernel:0']
layer.losses: [<tf.Tensor: shape=(), dtype=float32, numpy=0.0>]
calling layer again.
layer.losses:  [<tf.Tensor: shape=(), dtype=float32, numpy=0.0>]
<tf.Tensor: shape=(8, 10), dtype=float32, numpy=
array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]], dtype=float32)>

También puede usar la capa convertida directamente en la construcción del modelo funcional de Keras.

inputs = tf.keras.Input(shape=(20))
outputs = DenseLayer(10)(inputs)
model = tf.keras.Model(inputs=inputs, outputs=outputs)

x = tf.random.normal(shape=(8, 20))
model(x)

# Access the model variables and regularization losses
model.weights
model.losses
[<tf.Tensor: shape=(), dtype=float32, numpy=0.1345337>]

Modelo construido con tf.compat.v1.layers

Imagine que tiene una capa o modelo implementado directamente sobre tf.compat.v1.layers de la siguiente manera:

def model(self, inputs, units):
  with tf.compat.v1.variable_scope('model'):
    out = tf.compat.v1.layers.conv2d(
        inputs, 3, 3,
        kernel_regularizer="l2")
    out = tf.compat.v1.layers.flatten(out)
    out = tf.compat.v1.layers.dense(
        out, units,
        kernel_regularizer="l2")
    return out

Use la cuña para convertirlo en una capa y llamarlo en las entradas.

class CompatV1LayerModel(tf.keras.layers.Layer):

  def __init__(self, units, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.units = units

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs):
    with tf.compat.v1.variable_scope('model'):
      out = tf.compat.v1.layers.conv2d(
          inputs, 3, 3,
          kernel_regularizer="l2")
      out = tf.compat.v1.layers.flatten(out)
      out = tf.compat.v1.layers.dense(
          out, self.units,
          kernel_regularizer="l2")
      return out

layer = CompatV1LayerModel(10)
x = tf.random.normal(shape=(8, 5, 5, 5))
layer(x)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:12: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
  if sys.path[0] == '':
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/legacy_tf_layers/convolutional.py:575: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.
  return layer.apply(inputs)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:13: UserWarning: `tf.layers.flatten` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Flatten` instead.
  del sys.path[0]
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/legacy_tf_layers/core.py:541: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.
  return layer.apply(inputs)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:16: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
  app.launch_new_instance()
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/legacy_tf_layers/core.py:261: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.
  return layer.apply(inputs)
<tf.Tensor: shape=(8, 10), dtype=float32, numpy=
array([[ 2.4439096 , -0.2912227 ,  1.5531251 ,  1.284059  ,  0.10077369,
        -0.4231838 ,  1.0458903 , -0.01530766,  0.07358164, -0.6108157 ],
       [-0.4576063 ,  0.34942552,  2.3044965 ,  1.1483003 , -1.2211238 ,
         0.5634397 ,  0.73821646, -0.07581732,  0.5747937 , -0.66470885],
       [-2.2948585 , -2.709268  ,  1.7494816 , -0.9808065 , -2.9099958 ,
         0.5067346 , -1.011502  ,  2.559535  , -3.0888772 ,  0.3522656 ],
       [ 1.7788265 ,  0.8846102 ,  0.45562026,  0.01498583, -0.12482446,
        -0.32868862, -0.7743829 ,  2.3106992 , -0.0997327 , -0.7715093 ],
       [ 0.40295708,  0.04771695, -0.21336336, -0.13069987,  2.279875  ,
         2.7284563 ,  0.6444641 , -1.1919906 ,  0.96321577,  1.0182515 ],
       [ 0.47900966,  0.04906505,  1.1335449 ,  0.2907704 ,  0.7732022 ,
         0.68217   ,  0.51932573, -0.45156685,  2.081223  ,  1.068861  ],
       [ 0.10084352,  1.6456002 ,  0.63820475,  1.5959243 ,  0.22463399,
         0.07713126,  0.7467398 , -1.5435244 ,  1.2494736 , -0.07683721],
       [ 2.1396816 ,  1.5613532 , -1.1726325 , -0.88917583,  1.6447946 ,
        -1.0071977 , -1.8496083 ,  1.1887017 ,  2.1971662 ,  2.1175954 ]],
      dtype=float32)>

Acceda a las variables rastreadas y las pérdidas de regularización capturadas como una capa estándar de Keras.

layer.trainable_variables
layer.losses
[<tf.Tensor: shape=(), dtype=float32, numpy=0.03623246>,
 <tf.Tensor: shape=(), dtype=float32, numpy=0.14618248>]

Para ver que los pesos se reutilicen cada vez que llame a la capa, establezca todos los pesos en cero y vuelva a llamar a la capa.

print("Resetting variables to zero:", [var.name for var in layer.trainable_variables])

for var in layer.trainable_variables:
  var.assign(var * 0.0)

out = layer(x)
print("layer.losses: ", layer.losses)
out
Resetting variables to zero: ['model/conv2d/bias:0', 'model/conv2d/kernel:0', 'model/dense/bias:0', 'model/dense/kernel:0']
layer.losses:  [<tf.Tensor: shape=(), dtype=float32, numpy=0.0>, <tf.Tensor: shape=(), dtype=float32, numpy=0.0>]
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:12: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
  if sys.path[0] == '':
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:13: UserWarning: `tf.layers.flatten` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Flatten` instead.
  del sys.path[0]
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:16: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
  app.launch_new_instance()
<tf.Tensor: shape=(8, 10), dtype=float32, numpy=
array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]], dtype=float32)>

También puede usar la capa convertida directamente en la construcción del modelo funcional de Keras.

inputs = tf.keras.Input(shape=(5, 5, 5))
outputs = CompatV1LayerModel(10)(inputs)
model = tf.keras.Model(inputs=inputs, outputs=outputs)

x = tf.random.normal(shape=(8, 5, 5, 5))
model(x)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:12: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
  if sys.path[0] == '':
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/legacy_tf_layers/base.py:573: UserWarning: `layer.updates` will be removed in a future version. This property should not be used in TensorFlow 2.0, as `updates` are applied automatically.
  _add_elements_to_collection(self.updates, tf.compat.v1.GraphKeys.UPDATE_OPS)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:13: UserWarning: `tf.layers.flatten` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Flatten` instead.
  del sys.path[0]
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:16: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
  app.launch_new_instance()
<tf.Tensor: shape=(8, 10), dtype=float32, numpy=
array([[ 0.19487001,  0.54727787,  1.1044168 , -0.6613899 , -0.26437742,
        -1.1580509 , -0.24707682,  0.97752655,  0.59436107,  0.13125825],
       [ 0.48974586, -1.3510125 ,  0.7186962 , -0.8996632 , -0.60448873,
         0.06332532,  0.31494308,  0.23021704, -1.9166642 ,  0.3890404 ],
       [-0.06499191, -0.21485235,  0.01158494,  1.4407377 , -0.0488929 ,
        -0.37594396, -0.4386894 , -0.08751169,  1.0905663 , -1.5450519 ],
       [-2.2749739 , -2.4603422 , -1.3834419 , -2.8800466 ,  0.8954872 ,
        -3.0429187 , -0.7885461 ,  1.6037437 , -3.1845028 , -1.0725503 ],
       [ 0.98735195, -0.45159122,  0.892656  ,  0.477053  ,  0.31193537,
        -0.44723228, -0.01815075, -0.47465172, -1.665448  , -2.105824  ],
       [-2.5408387 , -1.7552321 , -1.924145  , -0.6395873 ,  0.4081779 ,
        -0.48731515, -3.2637763 , -1.4409767 , -2.032539  ,  0.10204412],
       [ 2.1583526 ,  0.78955674, -0.07266375,  0.06652926,  2.1300716 ,
        -1.6256162 ,  0.56154627, -0.76179224,  2.2985756 , -1.5504618 ],
       [ 2.062847  ,  0.971378  , -1.0830508 ,  1.8224751 , -0.3542943 ,
         0.74113446, -0.6204865 ,  1.4503044 , -0.4979878 , -0.4383126 ]],
      dtype=float32)>
# Access the model variables and regularization losses
model.weights
model.losses
[<tf.Tensor: shape=(), dtype=float32, numpy=0.03079858>,
 <tf.Tensor: shape=(), dtype=float32, numpy=0.12991619>]

Capture actualizaciones de normalización por lotes y argumentos training de modelos

En TF1.x, realiza una normalización por lotes de esta manera:

  x_norm = tf.compat.v1.layers.batch_normalization(x, training=training)

  # ...

  update_ops = tf.compat.v1.get_collection(tf.GraphKeys.UPDATE_OPS)
  train_op = optimizer.minimize(loss)
  train_op = tf.group([train_op, update_ops])

Tenga en cuenta que:

  1. Las actualizaciones de promedio móvil de normalización por lotes son rastreadas por get_collection , que se llamó por separado de la capa
  2. tf.compat.v1.layers.batch_normalization requiere un argumento de training (generalmente llamado is_training cuando se usan capas de normalización por lotes TF-Slim)

En TF2, debido a la rápida ejecución y las dependencias de control automático, las actualizaciones del promedio móvil de normalización por lotes se ejecutarán de inmediato. No es necesario recopilarlos por separado de la colección de actualizaciones y agregarlos como dependencias de control explícitas.

Además, si le da un argumento de training al método de paso hacia adelante de su tf.keras.layers.Layer , Keras podrá pasarle la fase de entrenamiento actual y cualquier capa anidada como lo hace con cualquier otra capa. Consulte los documentos de API para tf.keras.Model para obtener más información sobre cómo Keras maneja el argumento de training .

Si está decorando métodos tf.Module , debe asegurarse de pasar manualmente todos los argumentos de training según sea necesario. Sin embargo, las actualizaciones de la media móvil de normalización por lotes seguirán aplicándose automáticamente sin necesidad de dependencias de control explícitas.

Los siguientes fragmentos de código demuestran cómo incrustar capas de normalización por lotes en el shim y cómo funciona su uso en un modelo de Keras (aplicable a tf.keras.layers.Layer ).

class CompatV1BatchNorm(tf.keras.layers.Layer):

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs, training=None):
    print("Forward pass called with `training` =", training)
    with v1.variable_scope('batch_norm_layer'):
      return v1.layers.batch_normalization(x, training=training)
print("Constructing model")
inputs = tf.keras.Input(shape=(5, 5, 5))
outputs = CompatV1BatchNorm()(inputs)
model = tf.keras.Model(inputs=inputs, outputs=outputs)

print("Calling model in inference mode")
x = tf.random.normal(shape=(8, 5, 5, 5))
model(x, training=False)

print("Moving average variables before training: ",
      {var.name: var.read_value() for var in model.non_trainable_variables})

# Notice that when running TF2 and eager execution, the batchnorm layer directly
# updates the moving averages while training without needing any extra control
# dependencies
print("calling model in training mode")
model(x, training=True)

print("Moving average variables after training: ",
      {var.name: var.read_value() for var in model.non_trainable_variables})
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:7: UserWarning: `tf.layers.batch_normalization` is deprecated and will be removed in a future version. Please use `tf.keras.layers.BatchNormalization` instead. In particular, `tf.control_dependencies(tf.GraphKeys.UPDATE_OPS)` should not be used (consult the `tf.keras.layers.BatchNormalization` documentation).
  import sys
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/legacy_tf_layers/normalization.py:463: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.
  return layer.apply(inputs, training=training)
Constructing model
Forward pass called with `training` = None
Calling model in inference mode
Forward pass called with `training` = False
Moving average variables before training:  {'batch_norm_layer/batch_normalization/moving_mean:0': <tf.Tensor: shape=(5,), dtype=float32, numpy=array([0., 0., 0., 0., 0.], dtype=float32)>, 'batch_norm_layer/batch_normalization/moving_variance:0': <tf.Tensor: shape=(5,), dtype=float32, numpy=array([1., 1., 1., 1., 1.], dtype=float32)>}
calling model in training mode
Forward pass called with `training` = True
Moving average variables after training:  {'batch_norm_layer/batch_normalization/moving_mean:0': <tf.Tensor: shape=(5,), dtype=float32, numpy=
array([-0.00177554, -0.00036542, -0.00099426, -0.00112544,  0.0008541 ],
      dtype=float32)>, 'batch_norm_layer/batch_normalization/moving_variance:0': <tf.Tensor: shape=(5,), dtype=float32, numpy=
array([1.0005339, 1.0003369, 0.9976748, 1.0001523, 1.0009514],
      dtype=float32)>}

Reutilización de variables basadas en alcance variable

Todas las creaciones de variables en el pase hacia adelante basadas en get_variable mantendrán la misma nomenclatura de variables y reutilizarán la semántica que tienen los ámbitos de variables en TF1.x. Esto es cierto siempre que tenga al menos un ámbito externo no vacío para cualquier tf.compat.v1.layers con nombres generados automáticamente, como se mencionó anteriormente.

Ejecución ansiosa y tf.function

Como se vio anteriormente, los métodos decorados para tf.keras.layers.Layer y tf.Module se ejecutan dentro de una ejecución entusiasta y también son compatibles con tf.function . Esto significa que puede usar pdb y otras herramientas interactivas para recorrer su paso hacia adelante mientras se ejecuta.

Estrategias de distribución

Las llamadas a get_variable dentro de @track_tf1_style_variables métodos de capa o módulo decorados usan creaciones de variables estándar tf.Variable bajo el capó. Esto significa que puede usarlos con las diversas estrategias de distribución disponibles con tf.distribute , como MirroredStrategy y TPUStrategy .

Anidamiento tf.Variable s, tf.Module s, tf.keras.layers & tf.keras.models en llamadas decoradas

Decorar su llamada de capa en tf.compat.v1.keras.utils.track_tf1_style_variables solo agregará un seguimiento implícito automático de las variables creadas (y reutilizadas) a través tf.compat.v1.get_variable . No capturará los pesos creados directamente por las llamadas de tf.Variable , como las que usan las capas típicas de Keras y la mayoría de los tf.Module . Esta sección describe cómo manejar estos casos anidados.

(Usos preexistentes) tf.keras.layers y tf.keras.models

Para usos preexistentes de capas y modelos de Keras anidados, use tf.compat.v1.keras.utils.get_or_create_layer . Esto solo se recomienda para facilitar la migración de los usos de Keras anidados de TF1.x existentes; el nuevo código debe usar una configuración de atributo explícita como se describe a continuación para tf.Variables y tf.Modules.

Para usar tf.compat.v1.keras.utils.get_or_create_layer , envuelva el código que construye su modelo anidado en un método y páselo al método. Ejemplo:

class NestedModel(tf.keras.Model):

  def __init__(self, units, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.units = units

  def build_model(self):
    inp = tf.keras.Input(shape=(5, 5))
    dense_layer = tf.keras.layers.Dense(
        10, name="dense", kernel_regularizer="l2",
        kernel_initializer=tf.compat.v1.ones_initializer())
    model = tf.keras.Model(inputs=inp, outputs=dense_layer(inp))
    return model

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs):
    # Get or create a nested model without assigning it as an explicit property
    model = tf.compat.v1.keras.utils.get_or_create_layer(
        "dense_model", self.build_model)
    return model(inputs)

layer = NestedModel(10)
layer(tf.ones(shape=(5,5)))
<tf.Tensor: shape=(5, 10), dtype=float32, numpy=
array([[5., 5., 5., 5., 5., 5., 5., 5., 5., 5.],
       [5., 5., 5., 5., 5., 5., 5., 5., 5., 5.],
       [5., 5., 5., 5., 5., 5., 5., 5., 5., 5.],
       [5., 5., 5., 5., 5., 5., 5., 5., 5., 5.],
       [5., 5., 5., 5., 5., 5., 5., 5., 5., 5.]], dtype=float32)>

Este método garantiza que estas capas anidadas sean reutilizadas y rastreadas correctamente por tensorflow. Tenga en cuenta que el decorador @track_tf1_style_variables aún se requiere en el método apropiado. El método de creación de modelos que se pasa a get_or_create_layer (en este caso, self.build_model ), no debe aceptar argumentos.

Los pesos se rastrean:

assert len(layer.weights) == 2
weights = {x.name: x for x in layer.variables}

assert set(weights.keys()) == {"dense/bias:0", "dense/kernel:0"}

layer.weights
[<tf.Variable 'dense/kernel:0' shape=(5, 10) dtype=float32, numpy=
 array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]], dtype=float32)>,
 <tf.Variable 'dense/bias:0' shape=(10,) dtype=float32, numpy=array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)>]

Y pérdida de regularización también:

tf.add_n(layer.losses)
<tf.Tensor: shape=(1,), dtype=float32, numpy=array([0.5], dtype=float32)>

Migración incremental: tf.Variables y tf.Modules

Si necesita incrustar llamadas tf.Variable o tf.Module s en sus métodos decorados (por ejemplo, si está siguiendo la migración incremental a API TF2 no heredadas que se describe más adelante en esta guía), aún necesita realizar un seguimiento explícito de estos, con los siguientes requisitos:

  • Asegúrese explícitamente de que la variable/módulo/capa solo se cree una vez
  • Adjuntarlos explícitamente como atributos de instancia tal como lo haría al definir un módulo o capa típica
  • Reutilice explícitamente el objeto ya creado en las llamadas de seguimiento

Esto asegura que los pesos no se creen nuevos en cada llamada y se reutilicen correctamente. Además, esto también garantiza que se realice un seguimiento de los pesos existentes y las pérdidas de regularización.

Aquí hay un ejemplo de cómo podría verse esto:

class NestedLayer(tf.keras.layers.Layer):

  def __init__(self, units, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.units = units

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def __call__(self, inputs):
    out = inputs
    with tf.compat.v1.variable_scope("inner_dense"):
      # The weights are created with a `regularizer`,
      # so the layer should track their regularization losses
      kernel = tf.compat.v1.get_variable(
          shape=[out.shape[-1], self.units],
          regularizer=tf.keras.regularizers.L2(),
          initializer=tf.compat.v1.initializers.glorot_normal,
          name="kernel")
      bias = tf.compat.v1.get_variable(
          shape=[self.units,],
          initializer=tf.compat.v1.initializers.zeros,
          name="bias")
      out = tf.linalg.matmul(out, kernel)
      out = tf.compat.v1.nn.bias_add(out, bias)
    return out

class WrappedDenseLayer(tf.keras.layers.Layer):

  def __init__(self, units, **kwargs):
    super().__init__(**kwargs)
    self.units = units
    # Only create the nested tf.variable/module/layer/model
    # once, and then reuse it each time!
    self._dense_layer = NestedLayer(self.units)

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs):
    with tf.compat.v1.variable_scope('outer'):
      outputs = tf.compat.v1.layers.dense(inputs, 3)
      outputs = tf.compat.v1.layers.dense(inputs, 4)
      return self._dense_layer(outputs)

layer = WrappedDenseLayer(10)

layer(tf.ones(shape=(5, 5)))
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:38: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:39: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
<tf.Tensor: shape=(5, 10), dtype=float32, numpy=
array([[-0.4987283 ,  0.06630042, -0.09875254,  0.20954818,  0.03599668,
         0.3980474 ,  0.11181635,  0.6891558 , -0.33903462,  0.15674731],
       [-0.4987283 ,  0.06630042, -0.09875254,  0.20954818,  0.03599668,
         0.3980474 ,  0.11181635,  0.6891558 , -0.33903462,  0.15674731],
       [-0.4987283 ,  0.06630042, -0.09875254,  0.20954818,  0.03599668,
         0.3980474 ,  0.11181635,  0.6891558 , -0.33903462,  0.15674731],
       [-0.4987283 ,  0.06630042, -0.09875254,  0.20954818,  0.03599668,
         0.3980474 ,  0.11181635,  0.6891558 , -0.33903462,  0.15674731],
       [-0.4987283 ,  0.06630042, -0.09875254,  0.20954818,  0.03599668,
         0.3980474 ,  0.11181635,  0.6891558 , -0.33903462,  0.15674731]],
      dtype=float32)>

Tenga en cuenta que se necesita un seguimiento explícito del módulo anidado aunque esté decorado con el decorador track_tf1_style_variables . Esto se debe a que cada módulo/capa con métodos decorados tiene su propio almacén de variables asociado.

Los pesos están correctamente rastreados:

assert len(layer.weights) == 6
weights = {x.name: x for x in layer.variables}

assert set(weights.keys()) == {"outer/inner_dense/bias:0",
                               "outer/inner_dense/kernel:0",
                               "outer/dense/bias:0",
                               "outer/dense/kernel:0",
                               "outer/dense_1/bias:0",
                               "outer/dense_1/kernel:0"}

layer.trainable_weights
[<tf.Variable 'outer/inner_dense/bias:0' shape=(10,) dtype=float32, numpy=array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)>,
 <tf.Variable 'outer/inner_dense/kernel:0' shape=(4, 10) dtype=float32, numpy=
 array([[-0.20786692,  0.14702448, -0.2577947 ,  0.1885891 ,  0.28935957,
          0.02086618, -0.20579144, -0.7509229 , -0.23490003,  0.00370591],
        [ 0.09247629, -0.37428686, -0.6002815 , -0.2702465 ,  0.20350575,
          0.34964404, -0.32633537,  0.50722903, -0.0419833 , -0.61815673],
        [ 0.24821116,  0.15504731, -0.12409697, -0.2506969 ,  0.22316858,
         -0.44847375, -0.08295754, -0.8262154 ,  0.7674222 , -0.40613693],
        [-0.7447006 ,  0.2992331 , -0.45639235,  0.0669547 ,  0.39443025,
          0.3182467 ,  0.10884362,  0.5395837 ,  0.32210502, -0.30076835]],
       dtype=float32)>,
 <tf.Variable 'outer/dense/bias:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>,
 <tf.Variable 'outer/dense/kernel:0' shape=(5, 3) dtype=float32, numpy=
 array([[ 0.6283595 , -0.80413634, -0.5471641 ],
        [ 0.25296038, -0.7657203 ,  0.5884425 ],
        [-0.7180575 , -0.29509914,  0.44014376],
        [ 0.81024987,  0.39888996,  0.80002993],
        [-0.32921118, -0.7010279 ,  0.820375  ]], dtype=float32)>,
 <tf.Variable 'outer/dense_1/bias:0' shape=(4,) dtype=float32, numpy=array([0., 0., 0., 0.], dtype=float32)>,
 <tf.Variable 'outer/dense_1/kernel:0' shape=(5, 4) dtype=float32, numpy=
 array([[ 0.7941524 , -0.58552563,  0.46828055, -0.44095916],
        [-0.16019303,  0.27973688, -0.60373306, -0.20117629],
        [ 0.6345844 ,  0.30732214,  0.18921828,  0.37930095],
        [-0.50815696, -0.2471816 , -0.10282421,  0.21441567],
        [-0.71987414,  0.18304104, -0.5701992 ,  0.4926386 ]],
       dtype=float32)>]

Además de la pérdida de regularización:

layer.losses
[<tf.Tensor: shape=(), dtype=float32, numpy=0.058749676>]

Tenga en cuenta que si NestedLayer fuera un módulo tf.Module que no fuera de Keras, las variables aún se rastrearían, pero las pérdidas de regularización no se rastrearían automáticamente, por lo que tendría que rastrearlas explícitamente por separado.

Orientación sobre nombres de variables

Las llamadas tf.Variable explícitas y las capas de Keras utilizan un mecanismo de autogeneración de nombre de capa/nombre de variable diferente al que puede estar acostumbrado a partir de la combinación de get_variable y variable_scopes . Aunque el shim hará que los nombres de las variables coincidan con las variables creadas por get_variable , incluso cuando se pasa de gráficos TF1.x a ejecución ansiosa de TF2 y tf.function , no puede garantizar lo mismo para los nombres de variables generados para llamadas tf.Variable y capas de Keras que usted incrusta dentro de sus decoradores de métodos. Incluso es posible que varias variables compartan el mismo nombre en la ejecución entusiasta de TF2 y tf.function .

Debe tener especial cuidado con esto cuando siga las secciones sobre la validación de la corrección y la asignación de puntos de control de TF1.x más adelante en esta guía.

Usando tf.compat.v1.make_template en el método decorado

Se recomienda enfáticamente que use directamente tf.compat.v1.keras.utils.track_tf1_style_variables en lugar de usar tf.compat.v1.make_template , ya que es una capa más delgada sobre TF2 .

Siga las instrucciones de esta sección para el código TF1.x anterior que ya dependía de tf.compat.v1.make_template .

Debido a que tf.compat.v1.make_template envuelve el código que usa get_variable , el decorador track_tf1_style_variables le permite usar estas plantillas en llamadas de capa y rastrear con éxito los pesos y las pérdidas de regularización.

Sin embargo, asegúrese de llamar a make_template solo una vez y luego reutilice la misma plantilla en cada llamada de capa. De lo contrario, se creará una nueva plantilla cada vez que llame a la capa junto con un nuevo conjunto de variables.

Por ejemplo,

class CompatV1TemplateScaleByY(tf.keras.layers.Layer):

  def __init__(self, **kwargs):
    super().__init__(**kwargs)
    def my_op(x, scalar_name):
      var1 = tf.compat.v1.get_variable(scalar_name,
                            shape=[],
                            regularizer=tf.compat.v1.keras.regularizers.L2(),
                            initializer=tf.compat.v1.constant_initializer(1.5))
      return x * var1
    self.scale_by_y = tf.compat.v1.make_template('scale_by_y', my_op, scalar_name='y')

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs):
    with tf.compat.v1.variable_scope('layer'):
      # Using a scope ensures the `scale_by_y` name will not be incremented
      # for each instantiation of the layer.
      return self.scale_by_y(inputs)

layer = CompatV1TemplateScaleByY()

out = layer(tf.ones(shape=(2, 3)))
print("weights:", layer.weights)
print("regularization loss:", layer.losses)
print("output:", out)
weights: [<tf.Variable 'layer/scale_by_y/y:0' shape=() dtype=float32, numpy=1.5>]
regularization loss: [<tf.Tensor: shape=(), dtype=float32, numpy=0.022499999>]
output: tf.Tensor(
[[1.5 1.5 1.5]
 [1.5 1.5 1.5]], shape=(2, 3), dtype=float32)

Migración incremental a Native TF2

Como se mencionó anteriormente, track_tf1_style_variables le permite mezclar el uso de tf.Variable / tf.keras.layers.Layer / tf.Module orientado a objetos al estilo TF2 con el legado tf.compat.v1.get_variable / tf.compat.v1.layers uso dentro del mismo módulo/capa decorado.

Esto significa que una vez que haya hecho que su modelo TF1.x sea totalmente compatible con TF2, puede escribir todos los componentes del nuevo modelo con API TF2 nativas (no tf.compat.v1 ) y hacer que interactúen con su código anterior.

Sin embargo, si continúa modificando los componentes de su modelo anterior, también puede optar por cambiar gradualmente su uso de tf.compat.v1 de estilo heredado a las API orientadas a objetos puramente nativas que se recomiendan para el código TF2 recién escrito.

El uso tf.compat.v1.get_variable se puede reemplazar con llamadas self.add_weight si está decorando una capa/modelo de Keras, o con llamadas tf.Variable si está decorando objetos de Keras o tf.Module s.

Tanto las capas tf.compat.v1.layers de estilo funcional como las orientadas a objetos generalmente se pueden reemplazar con la capa equivalente tf.keras.layers sin necesidad de cambios en los argumentos.

También puede considerar fragmentos de partes de su modelo o patrones comunes en capas/módulos individuales durante su movimiento incremental a API puramente nativas, que pueden usar track_tf1_style_variables .

Una nota sobre Slim y contrib.layers

Una gran cantidad de código TF 1.x más antiguo usa la biblioteca Slim , que se empaquetó con TF 1.x como tf.contrib.layers . Convertir código usando Slim a TF 2 nativo es más complicado que convertir v1.layers . De hecho, puede tener sentido convertir su código Slim a v1.layers primero y luego convertirlo a Keras. A continuación se incluye una guía general para convertir código Slim.

  • Asegúrese de que todos los argumentos sean explícitos. Elimine arg_scopes si es posible. Si aún necesita usarlos, divida normalizer_fn y activation_fn en sus propias capas.
  • Las capas de conversión separables se asignan a una o más capas de Keras diferentes (capas de Keras separables, de profundidad y de puntos).
  • Slim y v1.layers tienen diferentes nombres de argumentos y valores predeterminados.
  • Tenga en cuenta que algunos argumentos tienen diferentes escalas.

Migración a Native TF2 ignorando la compatibilidad del punto de control

El siguiente ejemplo de código demuestra un movimiento incremental de un modelo a API puramente nativas sin tener en cuenta la compatibilidad del punto de control.

class CompatModel(tf.keras.layers.Layer):

  def __init__(self, units, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.units = units

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs, training=None):
    with tf.compat.v1.variable_scope('model'):
      out = tf.compat.v1.layers.conv2d(
          inputs, 3, 3,
          kernel_regularizer="l2")
      out = tf.compat.v1.layers.flatten(out)
      out = tf.compat.v1.layers.dropout(out, training=training)
      out = tf.compat.v1.layers.dense(
          out, self.units,
          kernel_regularizer="l2")
      return out

A continuación, reemplace las API compat.v1 con sus equivalentes nativos orientados a objetos por partes. Comience cambiando la capa de convolución a un objeto Keras creado en el constructor de capas.

class PartiallyMigratedModel(tf.keras.layers.Layer):

  def __init__(self, units, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.units = units
    self.conv_layer = tf.keras.layers.Conv2D(
      3, 3,
      kernel_regularizer="l2")

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs, training=None):
    with tf.compat.v1.variable_scope('model'):
      out = self.conv_layer(inputs)
      out = tf.compat.v1.layers.flatten(out)
      out = tf.compat.v1.layers.dropout(out, training=training)
      out = tf.compat.v1.layers.dense(
          out, self.units,
          kernel_regularizer="l2")
      return out

Use la clase v1.keras.utils.DeterministicRandomTestTool para verificar que este cambio incremental deja el modelo con el mismo comportamiento que antes.

random_tool = v1.keras.utils.DeterministicRandomTestTool(mode='num_random_ops')
with random_tool.scope():
  layer = CompatModel(10)

  inputs = tf.random.normal(shape=(10, 5, 5, 5))
  original_output = layer(inputs)

  # Grab the regularization loss as well
  original_regularization_loss = tf.math.add_n(layer.losses)

print(original_regularization_loss)
tf.Tensor(0.17953834, shape=(), dtype=float32)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:12: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
  if sys.path[0] == '':
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:13: UserWarning: `tf.layers.flatten` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Flatten` instead.
  del sys.path[0]
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:14: UserWarning: `tf.layers.dropout` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dropout` instead.
  
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/legacy_tf_layers/core.py:413: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.
  return layer.apply(inputs, training=training)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:17: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
random_tool = v1.keras.utils.DeterministicRandomTestTool(mode='num_random_ops')
with random_tool.scope():
  layer = PartiallyMigratedModel(10)

  inputs = tf.random.normal(shape=(10, 5, 5, 5))
  migrated_output = layer(inputs)

  # Grab the regularization loss as well
  migrated_regularization_loss = tf.math.add_n(layer.losses)

print(migrated_regularization_loss)
tf.Tensor(0.17953834, shape=(), dtype=float32)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:14: UserWarning: `tf.layers.flatten` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Flatten` instead.
  
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:15: UserWarning: `tf.layers.dropout` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dropout` instead.
  from ipykernel import kernelapp as app
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:18: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
# Verify that the regularization loss and output both match
np.testing.assert_allclose(original_regularization_loss.numpy(), migrated_regularization_loss.numpy())
np.testing.assert_allclose(original_output.numpy(), migrated_output.numpy())

Ahora ha reemplazado todas las capas individuales compat.v1.layers con capas nativas de Keras.

class NearlyFullyNativeModel(tf.keras.layers.Layer):

  def __init__(self, units, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.units = units
    self.conv_layer = tf.keras.layers.Conv2D(
      3, 3,
      kernel_regularizer="l2")
    self.flatten_layer = tf.keras.layers.Flatten()
    self.dense_layer = tf.keras.layers.Dense(
      self.units,
      kernel_regularizer="l2")

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs):
    with tf.compat.v1.variable_scope('model'):
      out = self.conv_layer(inputs)
      out = self.flatten_layer(out)
      out = self.dense_layer(out)
      return out
random_tool = v1.keras.utils.DeterministicRandomTestTool(mode='num_random_ops')
with random_tool.scope():
  layer = NearlyFullyNativeModel(10)

  inputs = tf.random.normal(shape=(10, 5, 5, 5))
  migrated_output = layer(inputs)

  # Grab the regularization loss as well
  migrated_regularization_loss = tf.math.add_n(layer.losses)

print(migrated_regularization_loss)
tf.Tensor(0.17953834, shape=(), dtype=float32)
# Verify that the regularization loss and output both match
np.testing.assert_allclose(original_regularization_loss.numpy(), migrated_regularization_loss.numpy())
np.testing.assert_allclose(original_output.numpy(), migrated_output.numpy())

Finalmente, elimine cualquier uso de variable_scope restante (que ya no es necesario) y el propio decorador track_tf1_style_variables .

Ahora le queda una versión del modelo que utiliza API totalmente nativas.

class FullyNativeModel(tf.keras.layers.Layer):

  def __init__(self, units, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.units = units
    self.conv_layer = tf.keras.layers.Conv2D(
      3, 3,
      kernel_regularizer="l2")
    self.flatten_layer = tf.keras.layers.Flatten()
    self.dense_layer = tf.keras.layers.Dense(
      self.units,
      kernel_regularizer="l2")

  def call(self, inputs):
    out = self.conv_layer(inputs)
    out = self.flatten_layer(out)
    out = self.dense_layer(out)
    return out
random_tool = v1.keras.utils.DeterministicRandomTestTool(mode='num_random_ops')
with random_tool.scope():
  layer = FullyNativeModel(10)

  inputs = tf.random.normal(shape=(10, 5, 5, 5))
  migrated_output = layer(inputs)

  # Grab the regularization loss as well
  migrated_regularization_loss = tf.math.add_n(layer.losses)

print(migrated_regularization_loss)
tf.Tensor(0.17953834, shape=(), dtype=float32)
# Verify that the regularization loss and output both match
np.testing.assert_allclose(original_regularization_loss.numpy(), migrated_regularization_loss.numpy())
np.testing.assert_allclose(original_output.numpy(), migrated_output.numpy())

Mantenimiento de la compatibilidad del punto de control durante la migración a Native TF2

El proceso de migración anterior a las API nativas de TF2 cambió tanto los nombres de las variables (ya que las API de Keras producen nombres de peso muy diferentes) como las rutas orientadas a objetos que apuntan a diferentes pesos en el modelo. El impacto de estos cambios es que habrán roto tanto los puntos de control basados ​​en nombres de estilo TF1 existentes como los puntos de control orientados a objetos de estilo TF2.

Sin embargo, en algunos casos, es posible que pueda tomar su punto de control original basado en el nombre y encontrar una asignación de las variables a sus nuevos nombres con enfoques como el que se detalla en la guía Reutilización de puntos de control TF1.x.

Algunos consejos para que esto sea factible son los siguientes:

  • Todas las variables todavía tienen un argumento de name que puede establecer.
  • Los modelos de Keras también toman un argumento de name que establecen como prefijo para sus variables.
  • La función v1.name_scope se puede utilizar para establecer prefijos de nombres de variables. Esto es muy diferente de tf.variable_scope . Solo afecta a los nombres y no realiza un seguimiento de las variables ni la reutilización.

Con los consejos anteriores en mente, los siguientes ejemplos de código demuestran un flujo de trabajo que puede adaptar a su código para actualizar de forma incremental parte de un modelo mientras se actualizan simultáneamente los puntos de control.

  1. Comience por cambiar tf.compat.v1.layers de estilo funcional a sus versiones orientadas a objetos.
class FunctionalStyleCompatModel(tf.keras.layers.Layer):

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs, training=None):
    with tf.compat.v1.variable_scope('model'):
      out = tf.compat.v1.layers.conv2d(
          inputs, 3, 3,
          kernel_regularizer="l2")
      out = tf.compat.v1.layers.conv2d(
          out, 4, 4,
          kernel_regularizer="l2")
      out = tf.compat.v1.layers.conv2d(
          out, 5, 5,
          kernel_regularizer="l2")
      return out

layer = FunctionalStyleCompatModel()
layer(tf.ones(shape=(10, 10, 10, 10)))
[v.name for v in layer.weights]
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:8: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
  
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:11: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
  # This is added back by InteractiveShellApp.init_path()
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:14: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
['model/conv2d/bias:0',
 'model/conv2d/kernel:0',
 'model/conv2d_1/bias:0',
 'model/conv2d_1/kernel:0',
 'model/conv2d_2/bias:0',
 'model/conv2d_2/kernel:0']
  1. A continuación, asigne los objetos compat.v1.layer y cualquier variable creada por compat.v1.get_variable como propiedades del objeto tf.keras.layers.Layer / tf.Module cuyo método está decorado con track_tf1_style_variables (tenga en cuenta que cualquier TF2 orientado a objetos los puntos de control de estilo ahora guardarán una ruta por nombre de variable y la nueva ruta orientada a objetos).
class OOStyleCompatModel(tf.keras.layers.Layer):

  def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.conv_1 = tf.compat.v1.layers.Conv2D(
          3, 3,
          kernel_regularizer="l2")
    self.conv_2 = tf.compat.v1.layers.Conv2D(
          4, 4,
          kernel_regularizer="l2")

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs, training=None):
    with tf.compat.v1.variable_scope('model'):
      out = self.conv_1(inputs)
      out = self.conv_2(out)
      out = tf.compat.v1.layers.conv2d(
          out, 5, 5,
          kernel_regularizer="l2")
      return out

layer = OOStyleCompatModel()
layer(tf.ones(shape=(10, 10, 10, 10)))
[v.name for v in layer.weights]
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:19: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
['model/conv2d/kernel:0',
 'model/conv2d/bias:0',
 'model/conv2d_1/kernel:0',
 'model/conv2d_1/bias:0',
 'model/conv2d_2/bias:0',
 'model/conv2d_2/kernel:0']
  1. Vuelva a guardar un punto de control cargado en este punto para guardar las rutas por el nombre de la variable (para compat.v1.layers) o por el gráfico de objeto orientado a objetos.
weights = {v.name: v for v in layer.weights}
assert weights['model/conv2d/kernel:0'] is layer.conv_1.kernel
assert weights['model/conv2d_1/bias:0'] is layer.conv_2.bias
  1. Ahora puede cambiar las capas compat.v1.layers orientadas a objetos por capas nativas de Keras mientras aún puede cargar el punto de control guardado recientemente. Asegúrese de conservar los nombres de las variables para las compat.v1.layers restantes al seguir registrando los ámbitos de variable_scopes generados automáticamente de las capas reemplazadas. Estas capas/variables cambiadas ahora solo usarán la ruta del atributo del objeto a las variables en el punto de control en lugar de la ruta del nombre de la variable.

En general, puede reemplazar el uso de compat.v1.get_variable en variables adjuntas a propiedades por:

  • Cambiarlos a usar tf.Variable , O
  • Actualizándolos usando tf.keras.layers.Layer.add_weight . Tenga en cuenta que si no está cambiando todas las capas de una sola vez, esto puede cambiar el nombre de capa/variable generado automáticamente para el resto de compat.v1.layers a las que les falta un argumento de name . Si ese es el caso, debe mantener iguales los nombres de las variables para las compat.v1.layers restantes abriendo y cerrando manualmente un variable_scope correspondiente al nombre de ámbito generado por la compat.v1.layer eliminada. De lo contrario, las rutas de los puntos de control existentes pueden entrar en conflicto y la carga del punto de control se comportará incorrectamente.
def record_scope(scope_name):
  """Record a variable_scope to make sure future ones get incremented."""
  with tf.compat.v1.variable_scope(scope_name):
    pass

class PartiallyNativeKerasLayersModel(tf.keras.layers.Layer):

  def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.conv_1 = tf.keras.layers.Conv2D(
          3, 3,
          kernel_regularizer="l2")
    self.conv_2 = tf.keras.layers.Conv2D(
          4, 4,
          kernel_regularizer="l2")

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs, training=None):
    with tf.compat.v1.variable_scope('model'):
      out = self.conv_1(inputs)
      record_scope('conv2d') # Only needed if follow-on compat.v1.layers do not pass a `name` arg
      out = self.conv_2(out)
      record_scope('conv2d_1') # Only needed if follow-on compat.v1.layers do not pass a `name` arg
      out = tf.compat.v1.layers.conv2d(
          out, 5, 5,
          kernel_regularizer="l2")
      return out

layer = PartiallyNativeKerasLayersModel()
layer(tf.ones(shape=(10, 10, 10, 10)))
[v.name for v in layer.weights]
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:26: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
['partially_native_keras_layers_model/model/conv2d_13/kernel:0',
 'partially_native_keras_layers_model/model/conv2d_13/bias:0',
 'partially_native_keras_layers_model/model/conv2d_14/kernel:0',
 'partially_native_keras_layers_model/model/conv2d_14/bias:0',
 'model/conv2d_2/bias:0',
 'model/conv2d_2/kernel:0']

Guardar un punto de control en este paso después de construir las variables hará que contenga solo las rutas de objetos disponibles actualmente.

Asegúrese de registrar los alcances de los compat.v1.layers eliminados para conservar los nombres de peso generados automáticamente para los compat.v1.layers restantes.

weights = set(v.name for v in layer.weights)
assert 'model/conv2d_2/kernel:0' in weights
assert 'model/conv2d_2/bias:0' in weights
  1. Repita los pasos anteriores hasta que haya reemplazado todos los compat.v1.layers y compat.v1.get_variable en su modelo con equivalentes totalmente nativos.
class FullyNativeKerasLayersModel(tf.keras.layers.Layer):

  def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.conv_1 = tf.keras.layers.Conv2D(
          3, 3,
          kernel_regularizer="l2")
    self.conv_2 = tf.keras.layers.Conv2D(
          4, 4,
          kernel_regularizer="l2")
    self.conv_3 = tf.keras.layers.Conv2D(
          5, 5,
          kernel_regularizer="l2")


  def call(self, inputs, training=None):
    with tf.compat.v1.variable_scope('model'):
      out = self.conv_1(inputs)
      out = self.conv_2(out)
      out = self.conv_3(out)
      return out

layer = FullyNativeKerasLayersModel()
layer(tf.ones(shape=(10, 10, 10, 10)))
[v.name for v in layer.weights]
['fully_native_keras_layers_model/model/conv2d_16/kernel:0',
 'fully_native_keras_layers_model/model/conv2d_16/bias:0',
 'fully_native_keras_layers_model/model/conv2d_17/kernel:0',
 'fully_native_keras_layers_model/model/conv2d_17/bias:0',
 'fully_native_keras_layers_model/model/conv2d_18/kernel:0',
 'fully_native_keras_layers_model/model/conv2d_18/bias:0']

Recuerde probar para asegurarse de que el punto de control recién actualizado todavía se comporte como espera. Aplique las técnicas descritas en la guía de corrección numérica validada en cada paso incremental de este proceso para asegurarse de que su código migrado se ejecute correctamente.

Manejo de cambios de comportamiento de TF1.x a TF2 no cubiertos por las correcciones de modelado

Las correcciones de modelado descritas en esta guía pueden garantizar que las variables, las capas y las pérdidas de regularización creadas con get_variable , tf.compat.v1.layers y variable_scope continúen funcionando como antes cuando se usa la ejecución entusiasta y tf.function , sin tener que confiar en las colecciones.

Esto no cubre todas las semánticas específicas de TF1.x en las que puede depender su modelo de pases hacia adelante. En algunos casos, las cuñas pueden ser insuficientes para que su modelo funcione en TF2 por sí solo. Lea la guía de comportamientos de TF1.x frente a TF2 para obtener más información sobre las diferencias de comportamiento entre TF1.x y TF2.