Se usó la API de Cloud Translation para traducir esta página.
Switch to English

Migrar su código TensorFlow 1 a 2 TensorFlow

Ver en TensorFlow.org Ejecutar en Google Colab Ver código fuente en GitHub Descargar portátil

Este documento para los usuarios de bajo nivel TensorFlow API. Si está utilizando la API de alto nivel ( tf.keras ) puede haber poca o ninguna acción que debe tomar para hacer que el código totalmente compatibles TensorFlow 2.0:

Todavía es posible ejecutar 1.X código, no modificada ( a excepción de contrib ), en TensorFlow 2.0:

 import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
 

Sin embargo, esto no le permite tomar ventaja de muchas de las mejoras realizadas en TensorFlow 2.0. Esta guía le ayudará a actualizar su código, por lo que es más simple, con más prestaciones y más fácil de mantener.

script de conversión automática

El primer paso, antes de intentar poner en práctica los cambios descritos en este documento, es tratar de ejecutar el script de actualización .

Esto va a hacer un pase inicial en la actualización de su código para TensorFlow 2.0. Pero no puede hacer que su código idiomático a 2,0. Su código puede todavía hacer uso de tf.compat.v1 puntos finales a los marcadores de posición de acceso, sesiones, colecciones, y otras funcionalidades de estilo 1.x.

cambios de comportamiento de nivel superior

Si el código funciona en TensorFlow 2.0 utilizando tf.compat.v1.disable_v2_behavior() , todavía hay cambios en el comportamiento global que pueda necesitar a la dirección. Los cambios más importantes son:

  • Ejecución ansiosos, v1.enable_eager_execution() : Cualquier código que utiliza implícitamente una tf.Graph fallará. Asegúrese de envolver el código en una with tf.Graph().as_default() contexto.

  • Las variables de recurso, v1.enable_resource_variables() : Un poco de código Puede depende de los comportamientos no deterministas habilitadas por las variables de referencia TF. variables de recursos están bloqueados mientras se está escribiendo a, y así proporcionan garantía de consistencia más intuitivos.

    • Esto puede cambiar el comportamiento en casos extremos.
    • Esto puede crear copias adicionales y puede tener un mayor uso de la memoria.
    • Esto se puede desactivar mediante el paso use_resource=False a la tf.Variable constructor.
  • Tensor formas, v1.enable_v2_tensorshape() : TF 2.0 simplifica el comportamiento de formas tensor. En lugar de t.shape[0].value se puede decir t.shape[0] . Estos cambios deben ser pequeñas, y tiene sentido para solucionarlos de inmediato. Ver TensorShape de ejemplos.

  • Control de flujo, v1.enable_control_flow_v2() : El TF control 2.0 aplicación de flujo se ha simplificado, y así produce diferentes representaciones de gráficos. Por favor informar de errores para cualquier problema.

Hacer que el código nativo de 2.0

Esta guía caminar a través de varios ejemplos de conversión de código 1.x TensorFlow a TensorFlow 2.0. Estos cambios permitirán que su código de aprovechar las optimizaciones de rendimiento y llamadas a la API simplificadas.

En cada caso, el patrón es:

1. Reemplazar v1.Session.run llamadas

Cada v1.Session.run llamada debe ser reemplazada por una función de Python.

  • Los feed_dict y v1.placeholder s se convierten en argumentos de la función.
  • Las fetches se convierten en valor de retorno de la función.
  • Durante la conversión de ejecución ansiosos permite una fácil depuración con herramientas estándar de Python como pdb .

Después de que añadir un tf.function decorador para que funcione de manera eficiente en el gráfico. Ver la Guía de autógrafos para más información sobre cómo funciona esto.

Tenga en cuenta que:

  • A diferencia de v1.Session.run un tf.function tiene una firma de rendimiento fijo, y siempre devuelve todas las salidas. Si esto causa problemas de rendimiento, crear dos funciones separadas.

  • No hay necesidad de un tf.control_dependencies u operaciones similares: Un tf.function se comporta como si se ejecutan en el orden escrita. tf.Variable misiones y tf.assert s, por ejemplo, se ejecutan automáticamente.

2. Uso de Python se opone a las variables y las pérdidas de la pista

Todo basado en nombre de seguimiento variable se desaconseja en TF 2.0. El uso de objetos de Python para realizar un seguimiento de las variables.

Uso tf.Variable en lugar de v1.get_variable .

Cada v1.variable_scope debe ser convertido a un objeto Python. Típicamente, esto será uno de:

Si necesita listas agregadas de variables (como tf.Graph.get_collection(tf.GraphKeys.VARIABLES) ), utilice los .variables y .trainable_variables atributos de la Layer y el Model objetos.

Estas Layer y Model clases implementan varias otras propiedades que eliminan la necesidad de colecciones globales. Su .losses propiedad puede ser un reemplazo para el uso de la tf.GraphKeys.LOSSES colección.

Ver las guías Keras para obtener más detalles.

3. Actualización de sus bucles de formación

Utilice el más alto nivel de API que funciona para su caso de uso. Prefiero tf.keras.Model.fit sobre la construcción de sus propios bucles de formación.

Estas funciones de alto nivel gestionar muchos de los detalles de bajo nivel que podrían ser fácil perderse si usted escribe su propio bucle de entrenamiento. Por ejemplo, ellos automáticamente a cobro revertido las pérdidas de regularización, y establecer el training=True argumento cuando se llama el modelo.

4. Actualización de sus tuberías de entrada de datos

Utilice tf.data conjuntos de datos para la entrada de datos. Estos objetos son eficientes, expresivo, y se integran bien con tensorflow.

Ellos pueden pasar directamente a la tf.keras.Model.fit método.

 model.fit(dataset, epochs=5)
 

Pueden ser directamente repiten a lo largo estándar de Python:

 for example_batch, label_batch in dataset:
    break
 

5. Migrate fuera compat.v1 símbolos

El tf.compat.v1 módulo contiene la API completa TensorFlow 1.x, con su semántica original.

El script de actualización TF2 convertirá símbolos a sus equivalentes 2.0 si tal conversión es seguro, es decir, si se puede determinar que el comportamiento de la versión 2.0 es exactamente equivalente (por ejemplo, se cambiará el nombre v1.arg_max a tf.argmax , ya esos son la misma función).

Después de que el script de actualización se realiza con una pieza de código, es probable que haya muchas menciones de compat.v1 . Vale la pena ir a través del código y convertir de forma manual al equivalente de 2.0 (se debe mencionar en el registro si hay uno).

La conversión de los modelos

Preparar

 import tensorflow as tf


import tensorflow_datasets as tfds
 

las variables de nivel bajo y la ejecución del operador

Ejemplos de uso API de bajo nivel incluyen:

antes de convertir

Esto es lo que estos patrones pueden parecerse en código usando TensorFlow 1.x.

 in_a = tf.placeholder(dtype=tf.float32, shape=(2))
in_b = tf.placeholder(dtype=tf.float32, shape=(2))

def forward(x):
  with tf.variable_scope("matmul", reuse=tf.AUTO_REUSE):
    W = tf.get_variable("W", initializer=tf.ones(shape=(2,2)),
                        regularizer=tf.contrib.layers.l2_regularizer(0.04))
    b = tf.get_variable("b", initializer=tf.zeros(shape=(2)))
    return W * x + b

out_a = forward(in_a)
out_b = forward(in_b)

reg_loss=tf.losses.get_regularization_loss(scope="matmul")

with tf.Session() as sess:
  sess.run(tf.global_variables_initializer())
  outs = sess.run([out_a, out_b, reg_loss],
                feed_dict={in_a: [1, 0], in_b: [0, 1]})

 

después de la conversión

En el código convertido:

  • Las variables son objetos locales Python.
  • El forward función todavía define el cálculo.
  • El Session.run llamada se sustituye con una llamada a forward
  • El opcional tf.function decorador puede ser añadido para el rendimiento.
  • Las regularizaciones se calculan de forma manual, sin hacer referencia a cualquier colección mundial.
  • No hay sesiones o marcadores de posición.
 W = tf.Variable(tf.ones(shape=(2,2)), name="W")
b = tf.Variable(tf.zeros(shape=(2)), name="b")

@tf.function
def forward(x):
  return W * x + b

out_a = forward([1,0])
print(out_a)
 
tf.Tensor(
[[1. 0.]
 [1. 0.]], shape=(2, 2), dtype=float32)

 out_b = forward([0,1])

regularizer = tf.keras.regularizers.l2(0.04)
reg_loss=regularizer(W)
 

Los modelos basados en tf.layers

El v1.layers módulo se utiliza para contener la capa de funciones que se basaban en v1.variable_scope para definir y variables de reutilización.

antes de convertir

 def model(x, training, scope='model'):
  with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):
    x = tf.layers.conv2d(x, 32, 3, activation=tf.nn.relu,
          kernel_regularizer=tf.contrib.layers.l2_regularizer(0.04))
    x = tf.layers.max_pooling2d(x, (2, 2), 1)
    x = tf.layers.flatten(x)
    x = tf.layers.dropout(x, 0.1, training=training)
    x = tf.layers.dense(x, 64, activation=tf.nn.relu)
    x = tf.layers.batch_normalization(x, training=training)
    x = tf.layers.dense(x, 10)
    return x

train_out = model(train_data, training=True)
test_out = model(test_data, training=False)
 

después de la conversión

La mayoría de los argumentos se mantuvo igual. Pero notar las diferencias:

  • La training argumento se pasa a cada capa por el modelo cuando se ejecuta.
  • El primer argumento de la original model de función (la entrada x ) se ha ido. Esto se debe a que las capas de objetos separado sobre la creación del modelo de llamar el modelo.

También tenga en cuenta que:

  • Si estaba utilizando regularizers de inicializadores de tf.contrib , estos tienen más cambios de argumentos que otros.
  • El código ya no escribe a las colecciones, así como funciones v1.losses.get_regularization_loss ya no volverán estos valores, lo que podría romper sus lazos de formación.
 model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.04),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
])

train_data = tf.ones(shape=(1, 28, 28, 1))
test_data = tf.ones(shape=(1, 28, 28, 1))
 
 train_out = model(train_data, training=True)
print(train_out)
 
tf.Tensor([[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]], shape=(1, 10), dtype=float32)

 test_out = model(test_data, training=False)
print(test_out)
 
tf.Tensor(
[[-0.11456077 -0.3126101   0.13154565 -0.50197905 -0.02416557  0.36460522
  -0.24887308 -0.37784547  0.05524942  0.01696768]], shape=(1, 10), dtype=float32)

 # Here are all the trainable variables.
len(model.trainable_variables)
 
8
 # Here is the regularization loss.
model.losses
 
[<tf.Tensor: shape=(), dtype=float32, numpy=0.077528305>]

Variables y mixtos v1.layers

Código existentes a menudo mezclas de nivel inferior TF 1.x variables y operaciones con mayor nivel v1.layers .

antes de convertir

 def model(x, training, scope='model'):
  with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):
    W = tf.get_variable(
      "W", dtype=tf.float32,
      initializer=tf.ones(shape=x.shape),
      regularizer=tf.contrib.layers.l2_regularizer(0.04),
      trainable=True)
    if training:
      x = x + W
    else:
      x = x + W * 0.5
    x = tf.layers.conv2d(x, 32, 3, activation=tf.nn.relu)
    x = tf.layers.max_pooling2d(x, (2, 2), 1)
    x = tf.layers.flatten(x)
    return x

train_out = model(train_data, training=True)
test_out = model(test_data, training=False)
 

después de la conversión

Para convertir este código, seguir el patrón de la cartografía de capas a capas como en el ejemplo anterior.

El patrón general es:

  • Parámetros de la capa se acumulan en __init__ .
  • Construir las variables de build .
  • Ejecutar los cálculos de call , y devolver el resultado.

El v1.variable_scope es esencialmente una capa de su propio. Así que volver a escribir como un tf.keras.layers.Layer . Ver la guía para más detalles.

 # Create a custom layer for part of the model
class CustomLayer(tf.keras.layers.Layer):
  def __init__(self, *args, **kwargs):
    super(CustomLayer, self).__init__(*args, **kwargs)

  def build(self, input_shape):
    self.w = self.add_weight(
        shape=input_shape[1:],
        dtype=tf.float32,
        initializer=tf.keras.initializers.ones(),
        regularizer=tf.keras.regularizers.l2(0.02),
        trainable=True)

  # Call method will sometimes get used in graph mode,
  # training will get turned into a tensor
  @tf.function
  def call(self, inputs, training=None):
    if training:
      return inputs + self.w
    else:
      return inputs + self.w * 0.5
 
 custom_layer = CustomLayer()
print(custom_layer([1]).numpy())
print(custom_layer([1], training=True).numpy())
 
[1.5]
[2.]

 train_data = tf.ones(shape=(1, 28, 28, 1))
test_data = tf.ones(shape=(1, 28, 28, 1))

# Build the model including the custom layer
model = tf.keras.Sequential([
    CustomLayer(input_shape=(28, 28, 1)),
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
])

train_out = model(train_data, training=True)
test_out = model(test_data, training=False)

 

Algunas cosas para tomar nota:

  • modelos y capas subclase Keras necesitan para funcionar en ambos gráficos V1 (sin dependencias de control automático) y en modo ansioso

    • Envuelva la call() en un tf.function() para obtener autógrafos y dependencias de control automático
  • No se olvide de aceptar una training argumento para call .

    • A veces es una tf.Tensor
    • A veces es un valor lógico Python.
  • Crear las variables del modelo de constructor o Model.build usando self.add_weight() .

    • En Model.build tiene acceso a la forma de entrada, por lo que puede crear pesas con forma complementaria.
    • Usando tf.keras.layers.Layer.add_weight permite Keras a las variables de la pista y las pérdidas de regularización.
  • No mantenga tf.Tensors en sus objetos.

    • Puede ser que se crean ya sea en un tf.function o en el contexto ansiosos, y estos tensores se comportan de manera diferente.
    • Uso tf.Variable es para el estado, son siempre utilizable a partir de los dos contextos
    • tf.Tensors son sólo para valores intermedios.

Una nota sobre Slim & contrib.layers

Una gran cantidad de código mayores TensorFlow 1.x utiliza el Slim biblioteca, que fue empaquetado con TensorFlow 1.x como tf.contrib.layers . Como contrib módulo, esto ya no es disponible en TensorFlow 2.0, incluso en tf.compat.v1 . Código de conversión de uso de Slim a 2.0 TF es más complicado que la conversión de los repositorios que utilizan v1.layers . De hecho, puede tener sentido para convertir su código de Slim a v1.layers en primer lugar, a continuación, convertir a Keras.

  • Retire arg_scopes , todos los argumentos tienen que ser explícitos
  • Si los usa, dividida normalizer_fn y activation_fn en sus propias capas
  • capas conv separables se asignan a una o más capas diferentes Keras (profundidad para dar lugar, por puntos, y las capas Keras separables)
  • Slim y v1.layers tienen diferentes nombres y valores por defecto arg
  • Algunos argumentos tienen diferentes escalas
  • Si utiliza Slim modelos pre-entrenado, probar los modelos pre-traimed de Keras de tf.keras.applications o TF Hub 's TF2 SavedModels exporte del código original Slim.

Algunos tf.contrib capas podrían no haber sido movido a base TensorFlow sino que se han trasladado a la Adiciones del paquete TF .

Formación

Hay muchas maneras a los datos de alimentación a un tf.keras modelo. Se aceptarán los generadores de Python y matrices numpy como entrada.

La forma recomendada de alimentación de datos a un modelo es utilizar el tf.data paquete, que contiene una colección de clases de alto rendimiento para la manipulación de datos.

Si usted todavía está utilizando tf.queue , estos son ahora sólo se admiten como estructuras de datos, no como las tuberías de entrada.

utilizando conjuntos de datos

El TensorFlow Conjuntos de datos de paquete ( tfds ) contiene utilidades para los conjuntos de datos predefinidos de carga como tf.data.Dataset objetos.

Para este ejemplo, cargar el MNISTdataset, usando tfds :

 datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
mnist_train, mnist_test = datasets['train'], datasets['test']
 
Downloading and preparing dataset mnist/3.0.1 (download: 11.06 MiB, generated: 21.00 MiB, total: 32.06 MiB) to /home/kbuilder/tensorflow_datasets/mnist/3.0.1...

Warning:absl:Dataset mnist is hosted on GCS. It will automatically be downloaded to your
local data directory. If you'd instead prefer to read directly from our public
GCS bucket (recommended if you're running on GCP), you can instead pass
`try_gcs=True` to `tfds.load` or set `data_dir=gs://tfds-data/datasets`.


Dataset mnist downloaded and prepared to /home/kbuilder/tensorflow_datasets/mnist/3.0.1. Subsequent calls will reuse this data.

A continuación, preparar los datos para el entrenamiento:

  • Re-escalar cada imagen.
  • Mezclar el orden de los ejemplos.
  • lotes de cobro revertido de imágenes y etiquetas.
 BUFFER_SIZE = 10 # Use a much larger value for real code.
BATCH_SIZE = 64
NUM_EPOCHS = 5


def scale(image, label):
  image = tf.cast(image, tf.float32)
  image /= 255

  return image, label
 

Para que el ejemplo sea corta, recortar el conjunto de datos para devolver sólo 5 lotes:

 train_data = mnist_train.map(scale).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
test_data = mnist_test.map(scale).batch(BATCH_SIZE)

STEPS_PER_EPOCH = 5

train_data = train_data.take(STEPS_PER_EPOCH)
test_data = test_data.take(STEPS_PER_EPOCH)
 
 image_batch, label_batch = next(iter(train_data))
 

bucles de formación Uso Keras

Si no es necesario el control de bajo nivel de su proceso de formación, el uso de Keras incorporada fit , evaluate y predict métodos se recomienda. Estos métodos proporcionan una interfaz uniforme para entrenar el modelo, independientemente de la aplicación (secuencial, funcional o sub-clasificado).

Las ventajas de estos métodos incluyen:

  • Ellos aceptan matrices numpy, generadores y Python, tf.data.Datasets
  • Se aplican las pérdidas de regularización, y activación automática.
  • Apoyan tf.distribute para la formación de múltiples dispositivos .
  • Apoyan callables arbitrarias como las pérdidas y las métricas.
  • Apoyan devoluciones de llamada como tf.keras.callbacks.TensorBoard y devoluciones de llamada personalizados.
  • Son performant, automáticamente utilizando gráficos TensorFlow.

Aquí está un ejemplo de la formación de un modelo utilizando un Dataset . (Para más detalles sobre cómo funciona este ver tutoriales .)

 model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.02),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
])

# Model is the full model w/o custom layers
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

model.fit(train_data, epochs=NUM_EPOCHS)
loss, acc = model.evaluate(test_data)

print("Loss {}, Accuracy {}".format(loss, acc))
 
Epoch 1/5
5/5 [==============================] - 0s 6ms/step - loss: 1.5323 - accuracy: 0.5063
Epoch 2/5
5/5 [==============================] - 0s 6ms/step - loss: 0.4105 - accuracy: 0.9219
Epoch 3/5
5/5 [==============================] - 0s 7ms/step - loss: 0.2495 - accuracy: 0.9531
Epoch 4/5
5/5 [==============================] - 0s 6ms/step - loss: 0.1806 - accuracy: 0.9875
Epoch 5/5
5/5 [==============================] - 0s 6ms/step - loss: 0.1416 - accuracy: 0.9937
5/5 [==============================] - 0s 4ms/step - loss: 1.5655 - accuracy: 0.6469
Loss 1.565544605255127, Accuracy 0.6468750238418579

Escribir su propio bucle

Si la etapa de formación del modelo Keras funciona para usted, pero se necesita más fuera de control que paso, considere el uso de la tf.keras.Model.train_on_batch método, en su propio bucle de datos de iteración.

Recuerde: Hay muchas cosas que se pueden implementar como un tf.keras.callbacks.Callback .

Este método tiene muchas de las ventajas de los métodos mencionados en la sección anterior, pero da el control de usuario del lazo externo.

También puede utilizar tf.keras.Model.test_on_batch o tf.keras.Model.evaluate con el desempeño de verificación durante el entrenamiento.

Para continuar con el entrenamiento del modelo anterior:

 # Model is the full model w/o custom layers
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

for epoch in range(NUM_EPOCHS):
  #Reset the metric accumulators
  model.reset_metrics()

  for image_batch, label_batch in train_data:
    result = model.train_on_batch(image_batch, label_batch)
    metrics_names = model.metrics_names
    print("train: ",
          "{}: {:.3f}".format(metrics_names[0], result[0]),
          "{}: {:.3f}".format(metrics_names[1], result[1]))
  for image_batch, label_batch in test_data:
    result = model.test_on_batch(image_batch, label_batch,
                                 # return accumulated metrics
                                 reset_metrics=False)
  metrics_names = model.metrics_names
  print("\neval: ",
        "{}: {:.3f}".format(metrics_names[0], result[0]),
        "{}: {:.3f}".format(metrics_names[1], result[1]))
 
train:  loss: 0.122 accuracy: 0.984
train:  loss: 0.133 accuracy: 0.984
train:  loss: 0.164 accuracy: 0.969
train:  loss: 0.167 accuracy: 0.969
train:  loss: 0.161 accuracy: 0.984

eval:  loss: 1.583 accuracy: 0.669
train:  loss: 0.074 accuracy: 1.000
train:  loss: 0.090 accuracy: 1.000
train:  loss: 0.089 accuracy: 1.000
train:  loss: 0.095 accuracy: 1.000
train:  loss: 0.090 accuracy: 1.000

eval:  loss: 1.567 accuracy: 0.747
train:  loss: 0.065 accuracy: 1.000
train:  loss: 0.068 accuracy: 1.000
train:  loss: 0.056 accuracy: 1.000
train:  loss: 0.069 accuracy: 1.000
train:  loss: 0.067 accuracy: 1.000

eval:  loss: 1.545 accuracy: 0.772
train:  loss: 0.053 accuracy: 1.000
train:  loss: 0.063 accuracy: 0.984
train:  loss: 0.050 accuracy: 1.000
train:  loss: 0.051 accuracy: 1.000
train:  loss: 0.049 accuracy: 1.000

eval:  loss: 1.520 accuracy: 0.778
train:  loss: 0.049 accuracy: 1.000
train:  loss: 0.046 accuracy: 1.000
train:  loss: 0.044 accuracy: 1.000
train:  loss: 0.045 accuracy: 1.000
train:  loss: 0.044 accuracy: 1.000

eval:  loss: 1.494 accuracy: 0.791

Personalizar el paso de la formación

Si necesita más flexibilidad y control, se puede tener mediante la implementación de su propio bucle de entrenamiento. Hay tres pasos:

  1. Iterar sobre un generador de Python o tf.data.Dataset para obtener lotes de ejemplos.
  2. Utilice tf.GradientTape a los gradientes de cobro revertido.
  3. Utilice uno de los tf.keras.optimizers para aplicar las actualizaciones de peso a las variables del modelo.

Recuerda:

  • Siempre incluya una training argumento en la call método de capas y modelos subclases.
  • Asegúrese de llamar el modelo con la training correcta conjunto argumento.
  • Dependiendo del uso, pueden no existir las variables del modelo hasta que el modelo se ejecuta en un lote de datos.
  • Es necesario para manejar manualmente cosas como las pérdidas de regularización para el modelo.

Tenga en cuenta el simplificaciones con respecto a V1:

  • No hay necesidad de correr inicializadores de variables. Las variables se inicializan en la creación.
  • No hay necesidad de agregar dependencias de control manual. Incluso en tf.function operaciones actúan como en el modo ansiosos.
 model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.02),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
])

optimizer = tf.keras.optimizers.Adam(0.001)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

@tf.function
def train_step(inputs, labels):
  with tf.GradientTape() as tape:
    predictions = model(inputs, training=True)
    regularization_loss=tf.math.add_n(model.losses)
    pred_loss=loss_fn(labels, predictions)
    total_loss=pred_loss + regularization_loss

  gradients = tape.gradient(total_loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))

for epoch in range(NUM_EPOCHS):
  for inputs, labels in train_data:
    train_step(inputs, labels)
  print("Finished epoch", epoch)

 
Finished epoch 0
Finished epoch 1
Finished epoch 2
Finished epoch 3
Finished epoch 4

métricas y pérdidas de nuevo estilo

En TensorFlow 2.0, las métricas y las pérdidas son objetos. Estos funcionan tanto con entusiasmo y en tf.function s.

Un objeto pérdida es exigible, y espera que el (y_true, y_pred) como argumentos:

 cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
cce([[1, 0]], [[-1.0,3.0]]).numpy()
 
4.01815

Un objeto métrica tiene los siguientes métodos:

El objeto en sí es exigible. Llamando a las actualizaciones del estado con nuevas observaciones, al igual que con update_state , y devuelve el nuevo resultado de la métrica.

Usted no tiene que inicializar manualmente una de las variables métricas, y debido a TensorFlow 2.0 tiene dependencias de control automático, usted no necesita preocuparse por aquellos tampoco.

El código siguiente utiliza una métrica para realizar un seguimiento de la pérdida media observada dentro de un bucle de entrenamiento personalizado.

 # Create the metrics
loss_metric = tf.keras.metrics.Mean(name='train_loss')
accuracy_metric = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')

@tf.function
def train_step(inputs, labels):
  with tf.GradientTape() as tape:
    predictions = model(inputs, training=True)
    regularization_loss=tf.math.add_n(model.losses)
    pred_loss=loss_fn(labels, predictions)
    total_loss=pred_loss + regularization_loss

  gradients = tape.gradient(total_loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))
  # Update the metrics
  loss_metric.update_state(total_loss)
  accuracy_metric.update_state(labels, predictions)


for epoch in range(NUM_EPOCHS):
  # Reset the metrics
  loss_metric.reset_states()
  accuracy_metric.reset_states()

  for inputs, labels in train_data:
    train_step(inputs, labels)
  # Get the metric results
  mean_loss=loss_metric.result()
  mean_accuracy = accuracy_metric.result()

  print('Epoch: ', epoch)
  print('  loss:     {:.3f}'.format(mean_loss))
  print('  accuracy: {:.3f}'.format(mean_accuracy))

 
Epoch:  0
  loss:     0.175
  accuracy: 0.994
Epoch:  1
  loss:     0.149
  accuracy: 0.991
Epoch:  2
  loss:     0.133
  accuracy: 0.991
Epoch:  3
  loss:     0.113
  accuracy: 0.997
Epoch:  4
  loss:     0.101
  accuracy: 0.997

nombres métricas Keras

En TensorFlow 2.0 Keras modelos son más consistentes sobre el manejo de nombres métricas.

Ahora bien, cuando se pasa una cadena en la lista de métricas, exactamente esa cadena se utiliza como métrica del name . Estos nombres son visibles en la historia del objeto devuelto por model.fit , y en los registros pasan a keras.callbacks . se establece en la cadena que ha pasado en la lista de métrica.

 model.compile(
    optimizer = tf.keras.optimizers.Adam(0.001),
    loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics = ['acc', 'accuracy', tf.keras.metrics.SparseCategoricalAccuracy(name="my_accuracy")])
history = model.fit(train_data)
 
5/5 [==============================] - 0s 6ms/step - loss: 0.1076 - acc: 0.9969 - accuracy: 0.9969 - my_accuracy: 0.9969

 history.history.keys()
 
dict_keys(['loss', 'acc', 'accuracy', 'my_accuracy'])

Esto difiere de las versiones anteriores, donde pasan a metrics=["accuracy"] resultaría en dict_keys(['loss', 'acc'])

optimizadores Keras

Los optimizadores en v1.train , como v1.train.AdamOptimizer y v1.train.GradientDescentOptimizer , tienen equivalentes en tf.keras.optimizers .

Convertir v1.train a keras.optimizers

Estas son las cosas a tener en cuenta a la hora de convertir sus optimizadores:

Nuevos valores por defecto para algunos tf.keras.optimizers

No hay cambios para optimizers.SGD , optimizers.Adam o optimizers.RMSprop .

Los siguientes ritmos de aprendizaje predeterminados han cambiado:

TensorBoard

TensorFlow 2 incluye cambios significativos en el tf.summary API se utiliza para escribir los datos de resumen para la visualización en TensorBoard. Para una introducción general a la nueva tf.summary , hay varios tutoriales disponibles que utilizan la API TF 2. Esto incluye una Guía de migración TensorBoard TF 2

Ahorro y carga

compatibilidad puesto de control

TensorFlow 2.0 utiliza puntos de control objeto de base .

puestos de control basados ​​en nombres de estilo antiguo todavía se pueden cargar, si usted tiene cuidado. El proceso de conversión de código puede resultar en cambios en nombres de variables, pero hay soluciones.

El más simple abordan para alinear los nombres del nuevo modelo con los nombres en el puesto de control:

  • Variables todavía todos tienen un name argumento se puede establecer.
  • Modelos Keras también toman un name argumento como el que establecen como prefijo para sus variables.
  • El v1.name_scope función puede ser utilizada para establecer los prefijos de nombre de variable. Esto es muy diferente de tf.variable_scope . Sólo afecta a los nombres, y no hace un seguimiento de variables y reutilización.

Si eso no funciona para su caso de uso, probar el v1.train.init_from_checkpoint función. Se necesita una assignment_map argumento, que especifica la correspondencia entre los nombres antiguos a nuevos nombres.

El repositorio TensorFlow Estimador incluye una herramienta de conversión para actualizar los puntos de control para los estimadores prefabricados de TensorFlow 1.xa 2.0. Puede servir como un ejemplo de cómo construir una herramienta para un caso de uso similar.

Guardado compatibilidad modelos

No hay problemas de compatibilidad significativos para los modelos guardados.

  • TensorFlow 1.x saved_models trabajo en TensorFlow 2.x.
  • TensorFlow 2.x saved_models trabajo en TensorFlow 1.x, si todas las operaciones son compatibles.

A Graph.pb o Graph.pbtxt

No hay una forma sencilla de actualizar una prima Graph.pb archivo a TensorFlow 2.0. Su mejor opción es actualizar el código que genera el archivo.

Pero, si usted tiene un "gráfico congelado" (un tf.Graph donde las variables se han convertido en constantes), entonces es posible convertir a un concrete_function usando v1.wrap_function :

 def wrap_frozen_graph(graph_def, inputs, outputs):
  def _imports_graph_def():
    tf.compat.v1.import_graph_def(graph_def, name="")
  wrapped_import = tf.compat.v1.wrap_function(_imports_graph_def, [])
  import_graph = wrapped_import.graph
  return wrapped_import.prune(
      tf.nest.map_structure(import_graph.as_graph_element, inputs),
      tf.nest.map_structure(import_graph.as_graph_element, outputs))
 

Por ejemplo, aquí es un gráfico Frozed para Inception v1, a partir de 2016:

 path = tf.keras.utils.get_file(
    'inception_v1_2016_08_28_frozen.pb',
    'http://storage.googleapis.com/download.tensorflow.org/models/inception_v1_2016_08_28_frozen.pb.tar.gz',
    untar=True)
 
Downloading data from http://storage.googleapis.com/download.tensorflow.org/models/inception_v1_2016_08_28_frozen.pb.tar.gz
24698880/24695710 [==============================] - 1s 0us/step

Cargar el tf.GraphDef :

 graph_def = tf.compat.v1.GraphDef()
loaded = graph_def.ParseFromString(open(path,'rb').read())
 

Envolverlo en un concrete_function :

 inception_func = wrap_frozen_graph(
    graph_def, inputs='input:0',
    outputs='InceptionV1/InceptionV1/Mixed_3b/Branch_1/Conv2d_0a_1x1/Relu:0')
 

Pasar un tensor como entrada:

 input_img = tf.ones([1,224,224,3], dtype=tf.float32)
inception_func(input_img).shape
 
TensorShape([1, 28, 28, 96])

estimadores

El entrenamiento con estimadores

Estimadores se admiten en TensorFlow 2.0.

Cuando se utiliza estimadores, puede utilizar input_fn() , tf.estimator.TrainSpec y tf.estimator.EvalSpec de TensorFlow 1.x.

Aquí está un ejemplo usando input_fn con el tren y evaluar especificaciones.

Creación de la input_fn y tren / Especificaciones eval

 # Define the estimator's input_fn
def input_fn():
  datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
  mnist_train, mnist_test = datasets['train'], datasets['test']

  BUFFER_SIZE = 10000
  BATCH_SIZE = 64

  def scale(image, label):
    image = tf.cast(image, tf.float32)
    image /= 255

    return image, label[..., tf.newaxis]

  train_data = mnist_train.map(scale).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
  return train_data.repeat()

# Define train & eval specs
train_spec = tf.estimator.TrainSpec(input_fn=input_fn,
                                    max_steps=STEPS_PER_EPOCH * NUM_EPOCHS)
eval_spec = tf.estimator.EvalSpec(input_fn=input_fn,
                                  steps=STEPS_PER_EPOCH)

 

Usando una definición de modelo Keras

Hay algunas diferencias en la forma de construir sus estimadores en TensorFlow 2.0.

Le recomendamos que defina su modelo usando Keras, a continuación, utilizar el tf.keras.estimator.model_to_estimator utilidad para convertir su modelo en un estimador. El código siguiente muestra cómo utilizar esta utilidad en la creación y la formación de un estimador.

 def make_model():
  return tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.02),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
  ])
 
 model = make_model()

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

estimator = tf.keras.estimator.model_to_estimator(
  keras_model = model
)

tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
 
INFO:tensorflow:Using default config.

INFO:tensorflow:Using default config.

Warning:tensorflow:Using temporary folder as model directory: /tmp/tmpb3_a632k

Warning:tensorflow:Using temporary folder as model directory: /tmp/tmpb3_a632k

INFO:tensorflow:Using the Keras model provided.

INFO:tensorflow:Using the Keras model provided.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/resource_variable_ops.py:1666: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.
Instructions for updating:
If using Keras pass *_constraint arguments to layers.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/resource_variable_ops.py:1666: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.
Instructions for updating:
If using Keras pass *_constraint arguments to layers.

INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpb3_a632k', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpb3_a632k', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

INFO:tensorflow:Not using Distribute Coordinator.

INFO:tensorflow:Not using Distribute Coordinator.

INFO:tensorflow:Running training and evaluation locally (non-distributed).

INFO:tensorflow:Running training and evaluation locally (non-distributed).

INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.

INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Warm-starting with WarmStartSettings: WarmStartSettings(ckpt_to_initialize_from='/tmp/tmpb3_a632k/keras/keras_model.ckpt', vars_to_warm_start='.*', var_name_to_vocab_info={}, var_name_to_prev_var_name={})

INFO:tensorflow:Warm-starting with WarmStartSettings: WarmStartSettings(ckpt_to_initialize_from='/tmp/tmpb3_a632k/keras/keras_model.ckpt', vars_to_warm_start='.*', var_name_to_vocab_info={}, var_name_to_prev_var_name={})

INFO:tensorflow:Warm-starting from: /tmp/tmpb3_a632k/keras/keras_model.ckpt

INFO:tensorflow:Warm-starting from: /tmp/tmpb3_a632k/keras/keras_model.ckpt

INFO:tensorflow:Warm-starting variables only in TRAINABLE_VARIABLES.

INFO:tensorflow:Warm-starting variables only in TRAINABLE_VARIABLES.

INFO:tensorflow:Warm-started 8 variables.

INFO:tensorflow:Warm-started 8 variables.

INFO:tensorflow:Create CheckpointSaverHook.

INFO:tensorflow:Create CheckpointSaverHook.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...

INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpb3_a632k/model.ckpt.

INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpb3_a632k/model.ckpt.

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:loss = 2.270717, step = 0

INFO:tensorflow:loss = 2.270717, step = 0

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpb3_a632k/model.ckpt.

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpb3_a632k/model.ckpt.

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Starting evaluation at 2020-07-23T01:32:32Z

INFO:tensorflow:Starting evaluation at 2020-07-23T01:32:32Z

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Restoring parameters from /tmp/tmpb3_a632k/model.ckpt-25

INFO:tensorflow:Restoring parameters from /tmp/tmpb3_a632k/model.ckpt-25

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Evaluation [1/5]

INFO:tensorflow:Evaluation [1/5]

INFO:tensorflow:Evaluation [2/5]

INFO:tensorflow:Evaluation [2/5]

INFO:tensorflow:Evaluation [3/5]

INFO:tensorflow:Evaluation [3/5]

INFO:tensorflow:Evaluation [4/5]

INFO:tensorflow:Evaluation [4/5]

INFO:tensorflow:Evaluation [5/5]

INFO:tensorflow:Evaluation [5/5]

INFO:tensorflow:Inference Time : 1.01619s

INFO:tensorflow:Inference Time : 1.01619s

INFO:tensorflow:Finished evaluation at 2020-07-23-01:32:33

INFO:tensorflow:Finished evaluation at 2020-07-23-01:32:33

INFO:tensorflow:Saving dict for global step 25: accuracy = 0.671875, global_step = 25, loss = 1.5162958

INFO:tensorflow:Saving dict for global step 25: accuracy = 0.671875, global_step = 25, loss = 1.5162958

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpb3_a632k/model.ckpt-25

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpb3_a632k/model.ckpt-25

INFO:tensorflow:Loss for final step: 0.39261085.

INFO:tensorflow:Loss for final step: 0.39261085.

({'accuracy': 0.671875, 'loss': 1.5162958, 'global_step': 25}, [])

El uso de un encargo model_fn

Si usted tiene un estimador personalizado existente model_fn que necesita para mantener, puede convertir su model_fn utilizar un modelo Keras.

Sin embargo, por razones de compatibilidad, una costumbre model_fn seguirá funcionando en modo gráfico 1.x-estilo. Esto significa que no hay ejecución ansiosos y sin dependencias de control automático.

model_fn personalizado con cambios mínimos

Para hacer su encargo model_fn trabajo en TF 2.0, si lo prefiere cambios mínimos en el código existente, tf.compat.v1 símbolos como optimizers y metrics se pueden utilizar.

Utilizando un modelo de Keras en una costumbre model_fn es similar a usar en un bucle de entrenamiento personalizado:

  • Establecer la training de fase apropiada, basada en el mode argumento.
  • Explícitamente pasar del modelo trainable_variables al optimizador.

Sin embargo, hay diferencias importantes, en relación con un lazo de encargo :

  • En lugar de utilizar Model.losses , extraer las pérdidas utilizando Model.get_losses_for .
  • Extraer actualizaciones del modelo usando Model.get_updates_for .

El siguiente código crea un estimador de una costumbre model_fn , que ilustra todas estas preocupaciones.

 def my_model_fn(features, labels, mode):
  model = make_model()

  optimizer = tf.compat.v1.train.AdamOptimizer()
  loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

  training = (mode == tf.estimator.ModeKeys.TRAIN)
  predictions = model(features, training=training)

  if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

  reg_losses = model.get_losses_for(None) + model.get_losses_for(features)
  total_loss=loss_fn(labels, predictions) + tf.math.add_n(reg_losses)

  accuracy = tf.compat.v1.metrics.accuracy(labels=labels,
                                           predictions=tf.math.argmax(predictions, axis=1),
                                           name='acc_op')

  update_ops = model.get_updates_for(None) + model.get_updates_for(features)
  minimize_op = optimizer.minimize(
      total_loss,
      var_list=model.trainable_variables,
      global_step=tf.compat.v1.train.get_or_create_global_step())
  train_op = tf.group(minimize_op, update_ops)

  return tf.estimator.EstimatorSpec(
    mode=mode,
    predictions=predictions,
    loss=total_loss,
    train_op=train_op, eval_metric_ops={'accuracy': accuracy})

# Create the Estimator & Train
estimator = tf.estimator.Estimator(model_fn=my_model_fn)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
 
INFO:tensorflow:Using default config.

INFO:tensorflow:Using default config.

Warning:tensorflow:Using temporary folder as model directory: /tmp/tmpjb2yik9a

Warning:tensorflow:Using temporary folder as model directory: /tmp/tmpjb2yik9a

INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpjb2yik9a', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpjb2yik9a', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

INFO:tensorflow:Not using Distribute Coordinator.

INFO:tensorflow:Not using Distribute Coordinator.

INFO:tensorflow:Running training and evaluation locally (non-distributed).

INFO:tensorflow:Running training and evaluation locally (non-distributed).

INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.

INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Create CheckpointSaverHook.

INFO:tensorflow:Create CheckpointSaverHook.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...

INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpjb2yik9a/model.ckpt.

INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpjb2yik9a/model.ckpt.

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:loss = 2.6231384, step = 0

INFO:tensorflow:loss = 2.6231384, step = 0

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpjb2yik9a/model.ckpt.

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpjb2yik9a/model.ckpt.

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Starting evaluation at 2020-07-23T01:32:36Z

INFO:tensorflow:Starting evaluation at 2020-07-23T01:32:36Z

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Restoring parameters from /tmp/tmpjb2yik9a/model.ckpt-25

INFO:tensorflow:Restoring parameters from /tmp/tmpjb2yik9a/model.ckpt-25

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Evaluation [1/5]

INFO:tensorflow:Evaluation [1/5]

INFO:tensorflow:Evaluation [2/5]

INFO:tensorflow:Evaluation [2/5]

INFO:tensorflow:Evaluation [3/5]

INFO:tensorflow:Evaluation [3/5]

INFO:tensorflow:Evaluation [4/5]

INFO:tensorflow:Evaluation [4/5]

INFO:tensorflow:Evaluation [5/5]

INFO:tensorflow:Evaluation [5/5]

INFO:tensorflow:Inference Time : 1.09900s

INFO:tensorflow:Inference Time : 1.09900s

INFO:tensorflow:Finished evaluation at 2020-07-23-01:32:37

INFO:tensorflow:Finished evaluation at 2020-07-23-01:32:37

INFO:tensorflow:Saving dict for global step 25: accuracy = 0.621875, global_step = 25, loss = 1.6634324

INFO:tensorflow:Saving dict for global step 25: accuracy = 0.621875, global_step = 25, loss = 1.6634324

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpjb2yik9a/model.ckpt-25

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpjb2yik9a/model.ckpt-25

INFO:tensorflow:Loss for final step: 0.56862533.

INFO:tensorflow:Loss for final step: 0.56862533.

({'accuracy': 0.621875, 'loss': 1.6634324, 'global_step': 25}, [])

Custom model_fn con símbolos TF 2.0

Si desea deshacerse de todos los símbolos 1.x TF y actualizar su costumbre model_fn a TF nativa 2.0, es necesario actualizar el optimizador y métricas para tf.keras.optimizers y tf.keras.metrics .

En la costumbre model_fn , además de los anteriores cambios , más mejoras deben hacerse:

Para el ejemplo anterior de my_model_fn , el código migrado con 2,0 símbolos se muestra como:

 def my_model_fn(features, labels, mode):
  model = make_model()

  training = (mode == tf.estimator.ModeKeys.TRAIN)
  loss_obj = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
  predictions = model(features, training=training)

  # Get both the unconditional losses (the None part)
  # and the input-conditional losses (the features part).
  reg_losses = model.get_losses_for(None) + model.get_losses_for(features)
  total_loss=loss_obj(labels, predictions) + tf.math.add_n(reg_losses)

  # Upgrade to tf.keras.metrics.
  accuracy_obj = tf.keras.metrics.Accuracy(name='acc_obj')
  accuracy = accuracy_obj.update_state(
      y_true=labels, y_pred=tf.math.argmax(predictions, axis=1))

  train_op = None
  if training:
    # Upgrade to tf.keras.optimizers.
    optimizer = tf.keras.optimizers.Adam()
    # Manually assign tf.compat.v1.global_step variable to optimizer.iterations
    # to make tf.compat.v1.train.global_step increased correctly.
    # This assignment is a must for any `tf.train.SessionRunHook` specified in
    # estimator, as SessionRunHooks rely on global step.
    optimizer.iterations = tf.compat.v1.train.get_or_create_global_step()
    # Get both the unconditional updates (the None part)
    # and the input-conditional updates (the features part).
    update_ops = model.get_updates_for(None) + model.get_updates_for(features)
    # Compute the minimize_op.
    minimize_op = optimizer.get_updates(
        total_loss,
        model.trainable_variables)[0]
    train_op = tf.group(minimize_op, *update_ops)

  return tf.estimator.EstimatorSpec(
    mode=mode,
    predictions=predictions,
    loss=total_loss,
    train_op=train_op,
    eval_metric_ops={'Accuracy': accuracy_obj})

# Create the Estimator & Train.
estimator = tf.estimator.Estimator(model_fn=my_model_fn)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
 
INFO:tensorflow:Using default config.

INFO:tensorflow:Using default config.

Warning:tensorflow:Using temporary folder as model directory: /tmp/tmppkb1q1hq

Warning:tensorflow:Using temporary folder as model directory: /tmp/tmppkb1q1hq

INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmppkb1q1hq', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmppkb1q1hq', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

INFO:tensorflow:Not using Distribute Coordinator.

INFO:tensorflow:Not using Distribute Coordinator.

INFO:tensorflow:Running training and evaluation locally (non-distributed).

INFO:tensorflow:Running training and evaluation locally (non-distributed).

INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.

INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Create CheckpointSaverHook.

INFO:tensorflow:Create CheckpointSaverHook.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...

INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmppkb1q1hq/model.ckpt.

INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmppkb1q1hq/model.ckpt.

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:loss = 2.6947184, step = 0

INFO:tensorflow:loss = 2.6947184, step = 0

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmppkb1q1hq/model.ckpt.

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmppkb1q1hq/model.ckpt.

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Starting evaluation at 2020-07-23T01:32:40Z

INFO:tensorflow:Starting evaluation at 2020-07-23T01:32:40Z

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Restoring parameters from /tmp/tmppkb1q1hq/model.ckpt-25

INFO:tensorflow:Restoring parameters from /tmp/tmppkb1q1hq/model.ckpt-25

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Evaluation [1/5]

INFO:tensorflow:Evaluation [1/5]

INFO:tensorflow:Evaluation [2/5]

INFO:tensorflow:Evaluation [2/5]

INFO:tensorflow:Evaluation [3/5]

INFO:tensorflow:Evaluation [3/5]

INFO:tensorflow:Evaluation [4/5]

INFO:tensorflow:Evaluation [4/5]

INFO:tensorflow:Evaluation [5/5]

INFO:tensorflow:Evaluation [5/5]

INFO:tensorflow:Inference Time : 1.05743s

INFO:tensorflow:Inference Time : 1.05743s

INFO:tensorflow:Finished evaluation at 2020-07-23-01:32:41

INFO:tensorflow:Finished evaluation at 2020-07-23-01:32:41

INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.784375, global_step = 25, loss = 1.4717665

INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.784375, global_step = 25, loss = 1.4717665

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmppkb1q1hq/model.ckpt-25

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmppkb1q1hq/model.ckpt-25

INFO:tensorflow:Loss for final step: 0.5751184.

INFO:tensorflow:Loss for final step: 0.5751184.

({'Accuracy': 0.784375, 'loss': 1.4717665, 'global_step': 25}, [])

Estimadores de prefabricados

Estimadores prefabricados en la familia de tf.estimator.DNN* , tf.estimator.Linear* y tf.estimator.DNNLinearCombined* son aún compatibles con la API TensorFlow 2.0, sin embargo, algunos argumentos han cambiado:

  1. input_layer_partitioner : Se quitó en 2.0.
  2. loss_reduction : Se ha actualizado para tf.keras.losses.Reduction en lugar de tf.compat.v1.losses.Reduction . Su valor por defecto también se cambia a tf.keras.losses.Reduction.SUM_OVER_BATCH_SIZE de tf.compat.v1.losses.Reduction.SUM .
  3. optimizer , dnn_optimizer y linear_optimizer : este arg ha sido actualizado para tf.keras.optimizers en lugar de la tf.compat.v1.train.Optimizer .

Para migrar los cambios anteriores:

  1. No es necesaria ninguna migración de input_layer_partitioner desde Distribution Strategy se harán cargo en forma automática en la TF 2.0.
  2. Para loss_reduction , comprobar tf.keras.losses.Reduction de las opciones soportadas.
  3. Para optimizer args, si no pasa en un optimizer , dnn_optimizer o linear_optimizer arg, o si especifica el optimizer arg como una string en su código, no es necesario cambiar nada. tf.keras.optimizers se utiliza por defecto. De lo contrario, es necesario actualizarla desde tf.compat.v1.train.Optimizer a sus correspondientes tf.keras.optimizers

puesto de control del convertidor

La migración a keras.optimizers romperá los puestos de control guardados utilizando 1.x TF, como tf.keras.optimizers genera un conjunto diferente de variables para ser salvo en los puestos de control. Para hacer viejo puesto de control reutilizable después de su migración a TF 2.0, prueba la herramienta de conversión de punto de control .

 curl -O https://raw.githubusercontent.com/tensorflow/estimator/master/tensorflow_estimator/python/estimator/tools/checkpoint_converter.py
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 15157  100 15157    0     0  63684      0 --:--:-- --:--:-- --:--:-- 63684

La herramienta tiene incorporado ayuda:

 python checkpoint_converter.py -h
usage: checkpoint_converter.py [-h]
                               {dnn,linear,combined} source_checkpoint
                               source_graph target_checkpoint

positional arguments:
  {dnn,linear,combined}
                        The type of estimator to be converted. So far, the
                        checkpoint converter only supports Canned Estimator.
                        So the allowed types include linear, dnn and combined.
  source_checkpoint     Path to source checkpoint file to be read in.
  source_graph          Path to source graph file to be read in.
  target_checkpoint     Path to checkpoint file to be written out.

optional arguments:
  -h, --help            show this help message and exit

TensorShape

Esta clase se simplificó para sostener int s, en lugar de tf.compat.v1.Dimension objetos. Así que no hay necesidad de llamar a .value() para obtener una int .

Individual tf.compat.v1.Dimension objetos siguen siendo accesibles desde tf.TensorShape.dims .

El siguiente demostrar las diferencias entre TensorFlow 1.x y TensorFlow 2.0.

 # Create a shape and choose an index
i = 0
shape = tf.TensorShape([16, None, 256])
shape
 
TensorShape([16, None, 256])

Si usted tuviera esto en TF 1.x:

 value = shape[i].value
 

Luego de hacer esto en TF 2.0:

 value = shape[i]
value
 
16

Si usted tuviera esto en TF 1.x:

 for dim in shape:
    value = dim.value
    print(value)
 

Luego de hacer esto en TF 2.0:

 for value in shape:
  print(value)
 
16
None
256

Si usted tuviera esto en 1.x TF (O cualquier otro método utilizado dimensión):

 dim = shape[i]
dim.assert_is_compatible_with(other_dim)
 

Luego de hacer esto en TF 2.0:

 other_dim = 16
Dimension = tf.compat.v1.Dimension

if shape.rank is None:
  dim = Dimension(None)
else:
  dim = shape.dims[i]
dim.is_compatible_with(other_dim) # or any other dimension method
 
True
 shape = tf.TensorShape(None)

if shape:
  dim = shape.dims[i]
  dim.is_compatible_with(other_dim) # or any other dimension method
 

El valor booleano de un tf.TensorShape es True si se conoce el rango, False de lo contrario.

 print(bool(tf.TensorShape([])))      # Scalar
print(bool(tf.TensorShape([0])))     # 0-length vector
print(bool(tf.TensorShape([1])))     # 1-length vector
print(bool(tf.TensorShape([None])))  # Unknown-length vector
print(bool(tf.TensorShape([1, 10, 100])))       # 3D tensor
print(bool(tf.TensorShape([None, None, None]))) # 3D tensor with no known dimensions
print()
print(bool(tf.TensorShape(None)))  # A tensor with unknown rank.
 
True
True
True
True
True
True

False

Otros cambios

  • Retire tf.colocate_with : algoritmos de colocación del dispositivo TensorFlow han mejorado significativamente. Esto ya no debería ser necesario. Si la eliminación provoca una degradación de rendimiento informe de un error .

  • Reemplazar v1.ConfigProto uso con las funciones equivalentes de tf.config .

conclusiones

El proceso global es:

  1. Ejecutar el script de actualización.
  2. Quitar los símbolos contrib.
  3. Cambiar sus modelos a un estilo orientado a objetos (Keras).
  4. Use tf.keras o tf.estimator formación y bucles de evaluación donde se puede.
  5. De lo contrario, el uso lazos personalizados, pero asegúrese de evitar sesiones y colecciones.

Se necesita un poco de trabajo para convertir a código TensorFlow idiomática 2.0, pero cada cambio se traduce en:

  • Menos líneas de código.
  • Aumento de la claridad y simplicidad.
  • Depuración más fácil.