Cómo escribir código limpio en TensorFlow 2

Contenido Overview Overview Instalación Recomendaciones para el idiomático TensorFlow 2 Refactoriza tu código en módulos más pequeños Ajustar la tasa de aprendizaje predeterminada para algunos tf.keras.optimizers Utilice las capas tf.Modules y Keras para administrar las variables Combina tf.data.Datasets y tf.function Utilice las curvas de entrenamiento Keras Personaliza el entrenamiento y escribe tu propio loop Aproveche tf.function con el flujo de control de Python Nuevo estilo métricas y pérdidas Debugando No mantenga tf.Tensors en sus objetos Recursos y Leer más Vista general Esta guía proporciona una lista de las mejores prácticas para escribir código utilizando TensorFlow 2 (TF2), está escrita para usuarios que han cambiado recientemente de TensorFlow 1 (TF1). Para obtener más información sobre la migración de su código TF1 a TF2. Sección de migración de la guía Instalación Importar TensorFlow y otras dependencias para los ejemplos en esta guía. import tensorflow as tf import tensorflow_datasets as tfds 2023-10-04 01:22:53.526066: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered 2023-10-04 01:22:53.526110: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered 2023-10-04 01:22:53.526158: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered Recomendaciones para el idiomático TensorFlow 2 Refactoriza tu código en módulos más pequeños A good practice is to refactor your code into smaller functions that are called as needed. For best performance, you should try to decorate the largest blocks of computation that you can in a (Nota que las funciones de Python enmarcadas se llaman a no requieren sus propias decoraciones separadas, a menos que desee usar diferentes Establecimientos para la Dependiendo de su caso de uso, esto podría ser múltiples pasos de entrenamiento o incluso su ciclo de entrenamiento completo. tf.function tf.function jit_compile tf.function Adjust the default learning rate for some s tf.keras.optimizer Algunos optimizadores Keras tienen diferentes tasas de aprendizaje en TF2.Si ve un cambio en el comportamiento de convergencia para sus modelos, compruebe las tasas de aprendizaje predeterminadas. No hay cambios para , de , o . optimizers.SGD optimizers.Adam optimizers.RMSprop Las siguientes tasas de aprendizaje por defecto han cambiado: optimizers.Adagrad de 0.01 a 0.001 optimizers.Adadelta de 1.0 a 0.001 optimizers.Adamax de 0.002 a 0.001 from to optimizers.Nadam 0.002 0.001 Uso Capas s y Keras para administrar variables tf.Module S y Ofrece el conveniente y propiedades, que recursivamente reúnen todas las variables dependientes. Esto hace que sea fácil administrar las variables localmente a donde están siendo utilizadas. tf.Module tf.keras.layers.Layer variables trainable_variables Las capas de Keras / modelos heredados de and are integrated with , que permite el control directo o la exportación de SavedModels desde los objetos Keras. API para aprovechar estas integraciones. tf.train.Checkpointable @tf.function Model.fit Leer la sección en en la guía Keras para aprender cómo recoger un subconjunto de variables relevantes utilizando Keras. Aprendizaje de transferencia y fine-tuning Combina S y tf.data.Dataset tf.function El Encuentro ( ) contiene utilidades para cargar conjuntos de datos predefinidos como Para este ejemplo, puede cargar el conjunto de datos MNIST utilizando : Conjuntos de datos TensorFlow tfds tf.data.Dataset tfds datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True) mnist_train, mnist_test = datasets['train'], datasets['test'] 2023-10-04 01:22:57.406511: W tensorflow/core/common_runtime/gpu/gpu_device.cc:2211] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform. Skipping registering GPU devices... Prepara los datos para la formación: Reescalar cada imagen. Escribe el orden de los ejemplos. Recoger lotes 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 mantener el ejemplo corto, corte el conjunto de datos para devolver solo 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)) 2023-10-04 01:22:58.048011: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Utilice la iteración regular de Python para iterar sobre los datos de entrenamiento que se ajustan a la memoria. es la mejor manera de transmitir los datos de entrenamiento desde el disco. , and work just like other Python iterables in eager execution. You can fully utilize dataset async prefetching/streaming features by wrapping your code in , que reemplaza la iteración de Python con las operaciones de gráficos equivalentes usando AutoGraph. tf.data.Dataset iterables (no iteradores) tf.function @tf.function def train(model, dataset, optimizer): for x, y in dataset: with tf.GradientTape() as tape: # training=True is only needed if there are layers with different # behavior during training versus inference (e.g. Dropout). prediction = model(x, training=True) loss = loss_fn(prediction, y) gradients = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) Si usted utiliza el Keras API, no tendrá que preocuparse por la iteración de conjuntos de datos. Model.fit model.compile(optimizer=optimizer, loss=loss_fn) model.fit(dataset) Use Keras training loops Si no necesita un control de bajo nivel sobre su proceso de entrenamiento, use el sistema integrado de Keras , de , y Estos métodos proporcionan una interfaz uniforme para entrenar el modelo independientemente de la implementación (sequencial, funcional o subclasificada). fit evaluate predict Las ventajas de estos métodos incluyen: Ellos aceptan arreglos Numpy, generadores de Python y, tf.data.Datasets. Aplican regularización y pérdidas de activación automáticamente. Apoyan tf.distribute donde el código de entrenamiento permanece el mismo independientemente de la configuración del hardware. Apoyan las denominables arbitrarias como pérdidas y métricas. Apoyan llamadas como tf.keras.callbacks.TensorBoard y llamadas personalizadas. They are performant, automatically using TensorFlow graphs. A continuación se muestra un ejemplo de un modelo que utiliza un Para obtener más detalles sobre cómo funciona, consulte el . Dataset 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 [==============================] - 2s 44ms/step - loss: 1.6644 - accuracy: 0.4906 Epoch 2/5 2023-10-04 01:22:59.569439: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. 5/5 [==============================] - 0s 9ms/step - loss: 0.5173 - accuracy: 0.9062 Epoch 3/5 2023-10-04 01:23:00.062308: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. 5/5 [==============================] - 0s 9ms/step - loss: 0.3418 - accuracy: 0.9469 Epoch 4/5 2023-10-04 01:23:00.384057: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. 5/5 [==============================] - 0s 8ms/step - loss: 0.2707 - accuracy: 0.9781 Epoch 5/5 2023-10-04 01:23:00.766486: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. 5/5 [==============================] - 0s 8ms/step - loss: 0.2195 - accuracy: 0.9812 2023-10-04 01:23:01.120149: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. 5/5 [==============================] - 0s 4ms/step - loss: 1.6036 - accuracy: 0.6250 Loss 1.6036441326141357, Accuracy 0.625 2023-10-04 01:23:01.572685: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Personaliza el entrenamiento y escribe tu propio loop Si los modelos de Keras funcionan para usted, pero necesita más flexibilidad y control del paso de entrenamiento o de los circuitos de entrenamiento externos, puede implementar sus propios pasos de entrenamiento o incluso los circuitos de entrenamiento enteros. to learn more. costumbre fit También se pueden hacer muchas cosas como una . tf.keras.callbacks.Callback This method has many of the advantages , pero le da el control del paso del tren e incluso el ciclo exterior. mencionado anteriormente Hay tres pasos para un ciclo de entrenamiento estándar: Iterate sobre un generador de Python o tf.data.Dataset para obtener lotes de ejemplos. Utilice tf.GradientTape para recoger gradientes. Utilice uno de los optimizadores tf.keras. para aplicar actualizaciones de peso a las variables del modelo. Recuerda que: Siempre incluye un argumento de formación sobre el método de llamada de las capas y modelos subclasificados. Asegúrese de llamar correctamente al modelo con el argumento de entrenamiento. Dependiendo del uso, las variables del modelo pueden no existir hasta que el modelo se ejecute en un lote de datos. Usted necesita manejar manualmente cosas como las pérdidas de regularización para el modelo. There is no need to run variable initializers or to add manual control dependencies. maneja dependencias de control automático y inicialización variable en la creación para usted. tf.function 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) 2023-10-04 01:23:02.652222: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Finished epoch 0 2023-10-04 01:23:02.957452: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Finished epoch 1 2023-10-04 01:23:03.632425: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Finished epoch 2 2023-10-04 01:23:03.877866: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Finished epoch 3 Finished epoch 4 2023-10-04 01:23:04.197488: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Tome ventaja de Control de flujo de Python tf.function proporciona una manera de convertir el flujo de control dependiente de los datos en equivalentes de modo gráfico como y . tf.function tf.cond tf.while_loop Un lugar común donde el flujo de control dependiente de los datos aparece es en los modelos de secuencia. Envuelve una celda RNN, lo que le permite desarollar la recurrencia de forma estática o dinámica. tf.keras.layers.RNN class DynamicRNN(tf.keras.Model): def __init__(self, rnn_cell): super(DynamicRNN, self).__init__(self) self.cell = rnn_cell @tf.function(input_signature=[tf.TensorSpec(dtype=tf.float32, shape=[None, None, 3])]) def call(self, input_data): # [batch, time, features] -> [time, batch, features] input_data = tf.transpose(input_data, [1, 0, 2]) timesteps = tf.shape(input_data)[0] batch_size = tf.shape(input_data)[1] outputs = tf.TensorArray(tf.float32, timesteps) state = self.cell.get_initial_state(batch_size = batch_size, dtype=tf.float32) for i in tf.range(timesteps): output, state = self.cell(input_data[i], state) outputs = outputs.write(i, output) return tf.transpose(outputs.stack(), [1, 0, 2]), state lstm_cell = tf.keras.layers.LSTMCell(units = 13) my_rnn = DynamicRNN(lstm_cell) outputs, state = my_rnn(tf.random.normal(shape=[10,20,3])) print(outputs.shape) (10, 20, 13) Leer el Guía para más información. tf.function Nuevo estilo métricas y pérdidas Las métricas y las pérdidas son ambos objetos que trabajan ansiosamente y en s. tf.function Un objeto de pérdida es llamable, y espera ( , de Como los argumentos: y_true y_pred cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True) cce([[1, 0]], [[-1.0,3.0]]).numpy() 4.01815 Utilice métricas para recopilar y mostrar datos Puedes utilizar para agregar datos y para registrar resúmenes y redirigirlos a un escritor usando un gestor de contexto. Los resúmenes se emiten directamente al escritor, lo que significa que debe proporcionar el value at the callsite. tf.metrics tf.summary step summary_writer = tf.summary.create_file_writer('/tmp/summaries') with summary_writer.as_default(): tf.summary.scalar('loss', 0.1, step=42) Uso para agregar datos antes de registrarlos como resúmenes. Las métricas son estadísticas; acumulan valores y devuelven un resultado acumulativo cuando se llama el method (such as ) Valores acumulados claros con . tf.metrics result Mean.result Model.reset_states def train(model, optimizer, dataset, log_freq=10): avg_loss = tf.keras.metrics.Mean(name='loss', dtype=tf.float32) for images, labels in dataset: loss = train_step(model, optimizer, images, labels) avg_loss.update_state(loss) if tf.equal(optimizer.iterations % log_freq, 0): tf.summary.scalar('loss', avg_loss.result(), step=optimizer.iterations) avg_loss.reset_states() def test(model, test_x, test_y, step_num): # training=False is only needed if there are layers with different # behavior during training versus inference (e.g. Dropout). loss = loss_fn(model(test_x, training=False), test_y) tf.summary.scalar('loss', loss, step=step_num) train_summary_writer = tf.summary.create_file_writer('/tmp/summaries/train') test_summary_writer = tf.summary.create_file_writer('/tmp/summaries/test') with train_summary_writer.as_default(): train(model, optimizer, dataset) with test_summary_writer.as_default(): test(model, test_x, test_y, optimizer.iterations) Visualizar los resúmenes generados apuntando TensorBoard al directorio de registros de resumen: tensorboard --logdir /tmp/summaries Use the API para escribir datos resumidos para la visualización en TensorBoard. Para más información, lea el La guía. tf.summary tf.summary # 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)) 2023-10-04 01:23:05.220607: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Epoch: 0 loss: 0.176 accuracy: 0.994 2023-10-04 01:23:05.554495: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Epoch: 1 loss: 0.153 accuracy: 0.991 2023-10-04 01:23:06.043597: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Epoch: 2 loss: 0.134 accuracy: 0.994 2023-10-04 01:23:06.297768: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Epoch: 3 loss: 0.108 accuracy: 1.000 Epoch: 4 loss: 0.095 accuracy: 1.000 2023-10-04 01:23:06.678292: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. Keras metric names Los modelos de Keras son consistentes en el manejo de nombres métricos. Cuando pasas una cadena en la lista de métricas, que Las cuerdas se utilizan como la métrica . These names are visible in the history object returned by y en los logos pasaron a . está configurado para la cadena que pasó en la lista de métricas. exact name model.fit keras.callbacks 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 [==============================] - 1s 9ms/step - loss: 0.1077 - acc: 0.9937 - accuracy: 0.9937 - my_accuracy: 0.9937 2023-10-04 01:23:07.849601: W tensorflow/core/kernels/data/cache_dataset_ops.cc:854] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead. history.history.keys() dict_keys(['loss', 'acc', 'accuracy', 'my_accuracy']) Debugging Use eager execution to run your code step-by-step to inspect shapes, data types and values. Certain APIs, like , , etc. están diseñados para usar la ejecución de gráficos, para el rendimiento y la portabilidad. para utilizar la ejecución ansiosa dentro de este código. tf.function tf.keras tf.config.run_functions_eagerly(True) For example: @tf.function def f(x): if x > 0: import pdb pdb.set_trace() x = x + 1 return x tf.config.run_functions_eagerly(True) f(tf.constant(1)) >>> f() -> x = x + 1 (Pdb) l 6 @tf.function 7 def f(x): 8 if x > 0: 9 import pdb 10 pdb.set_trace() 11 -> x = x + 1 12 return x 13 14 tf.config.run_functions_eagerly(True) 15 f(tf.constant(1)) [EOF] This also works inside Keras models and other APIs that support eager execution: class CustomModel(tf.keras.models.Model): @tf.function def call(self, input_data): if tf.reduce_mean(input_data) > 0: return input_data else: import pdb pdb.set_trace() return input_data // 2 tf.config.run_functions_eagerly(True) model = CustomModel() model(tf.constant([-2, -4])) >>> call() -> return input_data // 2 (Pdb) l 10 if tf.reduce_mean(input_data) > 0: 11 return input_data 12 else: 13 import pdb 14 pdb.set_trace() 15 -> return input_data // 2 16 17 18 tf.config.run_functions_eagerly(True) 19 model = CustomModel() 20 model(tf.constant([-2, -4])) Notes: Métodos de modelo tales como ajustar, evaluar y predecir ejecutar como gráficos con tf.función bajo el capó. When using , set to disable the logic from being wrapped in a . tf.keras.Model.compile run_eagerly = True Model tf.function Utilice tf.data.experimental.enable_debug_mode para habilitar el modo de depuración de tf.data. Lea los documentos de la API para obtener más detalles. No se mantenga En sus objetos tf.Tensors These tensor objects might get created either in a or in the eager context, and these tensors behave differently. Always use s only for intermediate values. tf.function tf.Tensor Para rastrear el estado, use como siempre son usables desde ambos contextos. guide to learn more. tf.Variable tf.Variable Recursos y Leer más Lea las guías y tutoriales de TF2 para aprender más sobre cómo usar TF2. Si ha utilizado anteriormente TF1.x, se recomienda migrar su código a TF2. Originalmente publicado en el sitio web de TensorFlow, este artículo aparece aquí bajo un nuevo título y está licenciado bajo CC BY 4.0. Originally published on the website, this article appears here under a new headline and is licensed under CC BY 4.0. Code samples shared under the Apache 2.0 License. TensorFlow TensorFlow TensorFlow