Consellos para escribir código limpo en TensorFlow 2

Contido da visión xeral Overview Instalacións Recomendacións para idiomático TensorFlow 2 Transforma o teu código en módulos máis pequenos Axustar a taxa de aprendizaxe por defecto para algúns tf.keras.optimizers Utiliza tf.Modules e capas Keras para xestionar variables Combina tf.data.Datasets e tf.function Use loops de adestramento Keras Personaliza o adestramento e escribe o teu propio loop Take advantage of tf.function with Python control flow Novas métricas e perdas Debuxo Non manteña tf.Tensors nos seus obxectos Recursos e máis lectura Overview Esta guía proporciona unha lista de boas prácticas para escribir código usando TensorFlow 2 (TF2), está escrita para usuarios que recentemente cambiaron de TensorFlow 1 (TF1). Para obter máis información sobre como migrar o seu código TF1 a TF2. migrate section of the guide Instalacións Importar TensorFlow e outras dependencias para os exemplos desta 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 Recommendations for idiomatic TensorFlow 2 Transforma o teu código en módulos máis pequenos Unha boa práctica é refactorizar o seu código en funcións máis pequenas que se chaman segundo sexa necesario.Para o mellor rendemento, debes tratar de decorar os maiores bloques de computación que poidas nun (Nota que as funcións de Python anexadas chamadas a non requiren as súas propias decoracións separadas, a menos que queira usar diferentes Instalacións para o Dependendo do seu caso de uso, este pode ser varios pasos de adestramento ou mesmo toda a súa ciclo de adestramento. tf.function tf.function jit_compile tf.function Axustar a taxa de aprendizaxe por defecto para algúns s tf.keras.optimizer Algúns optimizadores Keras teñen diferentes taxas de aprendizaxe en TF2.Se ves un cambio no comportamento de converxencia dos teus modelos, comproba as taxas de aprendizaxe por defecto. Non hai cambios para , ou . optimizers.SGD optimizers.Adam optimizers.RMSprop As seguintes taxas de aprendizaxe por defecto cambiaron: optimizers.Adagrad de 0.01 a 0.001 optimizers.Adadelta de 1.0 a 0.001 from to optimizers.Adamax 0.002 0.001 optimizers.Nadam de 0.002 a 0.001 Utilización Liñas s e Keras para xestionar variables tf.Module s e Ofrece o conveniente e propiedades, que recursivamente reúnen todas as variables dependentes. Isto fai que sexa fácil xestionar as variables localmente ata onde están a ser utilizadas. tf.Module tf.keras.layers.Layer variables trainable_variables As capas de Keras / modelos herdados de Están integrados con , o que fai posible o checkpoint ou a exportación directa de SavedModels a partir de obxectos Keras. API para aproveitar estas integracións. tf.train.Checkpointable @tf.function Model.fit Ler a sección en na guía Keras para aprender como recoller un subconxunto de variables relevantes usando Keras. Aprendizaxe de transferencia e fine-tuning Combinación s e tf.data.Dataset tf.function A súa package ( ) contén utilidades para cargar conxuntos de datos predefinidos como objects. For this example, you can load the MNIST dataset using : Conxunto 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 os datos para a formación: Reescale cada imaxe. Xoga a orde dos exemplos. Collect batches of images and labels. 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 manter o exemplo curto, corte o conxunto de datos para devolver só 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. Use regular Python iteration to iterate over training data that fits in memory. Otherwise, is the best way to stream training data from disk. Datasets are , e funciona como outros iterables de Python en execución ansiosa. Pode aproveitar plenamente as funcións de prefetching/streaming de datasets async enrolando o seu código en , que substitúe a iteración de Python coas operacións de gráfico equivalentes usando AutoGraph. tf.data.Dataset iterables (non 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)) If you use the Keras API, you won't have to worry about dataset iteration. Model.fit model.compile(optimizer=optimizer, loss=loss_fn) model.fit(dataset) Use loops de adestramento Keras Se non precisa de control de baixo nivel do seu proceso de adestramento, use o built-in de Keras , , and methods is recommended. These methods provide a uniform interface to train the model regardless of the implementation (sequential, functional, or sub-classed). fit evaluate predict As vantaxes destes métodos inclúen: Eles aceptan arreglos Numpy, xeradores de Python e, tf.data.Datasets. Aplican regularización e perdas de activación automaticamente. Eles soportan tf.distribute onde o código de adestramento permanece o mesmo independentemente da configuración do hardware. They support arbitrary callables as losses and metrics. They support callbacks like , and custom callbacks. tf.keras.callbacks.TensorBoard They are performant, automatically using TensorFlow graphs. Aquí tes un exemplo de como usar un modelo de Para máis información sobre como funciona, consulte o . Dataset tutorials 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 o adestramento e escribe o teu propio loop If Keras models work for you, but you need more flexibility and control of the training step or the outer training loops, you can implement your own training steps or even entire training loops. See the Keras guide on to learn more. customizacións fit You can also implement many things as a . tf.keras.callbacks.Callback This method has many of the advantages , pero dálle o control do paso do tren e mesmo o loop exterior. mencionado anteriormente Hai tres pasos para un ciclo de adestramento estándar: Iterate sobre un xerador de Python ou tf.data.Dataset para obter lotes de exemplos. Use tf.GradientTape para recoller gradientes. Use one of the to apply weight updates to the model's variables. tf.keras.optimizers Recorda que: Always include a argument on the method of subclassed layers and models. training call Asegúrese de chamar o modelo co argumento de adestramento configurado correctamente. Dependendo do uso, as variables do modelo poden non existir ata que o modelo se execute nun lote de datos. You need to manually handle things like regularization losses for the model. There is no need to run variable initializers or to add manual control dependencies. handles automatic control dependencies and variable initialization on creation for you. 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. Aproveitar o with Python control flow tf.function proporciona unha forma de converter o fluxo de control dependente de datos en equivalentes de modo gráfico como and . tf.function tf.cond tf.while_loop Un lugar común onde o fluxo de control dependente de datos aparece é en modelos de secuencia. wraps an RNN cell, allowing you to either statically or dynamically unroll the recurrence. As an example, you could reimplement dynamic unroll as follows. 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) Read the guide for a more information. tf.function Novas métricas e perdas Metrics and losses are both objects that work eagerly and in O s. tf.function Un obxecto de perda é chamable, e espera ( , Como os 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 recoller e mostrar datos Podes usar para agregar datos e para rexistrar resumos e redirixilo a un escritor usando un xestor de contexto. Os resumos emítense directamente ao escritor, o que significa que debe proporcionar o 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) Utilización para agregar datos antes de rexistralos como resumos.As métricas son estatais; acumulan valores e devolven un resultado cumulativo cando chama o metodoloxía (como 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 os resumos xerados apuntando TensorBoard ao directorio de rexistro de resumo: tensorboard --logdir /tmp/summaries Utiliza o API para escribir datos resumidos para a visualización en TensorBoard. Unha 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. Nomes metálicos Os modelos de Keras son consistentes no manexo de nomes métricos. Cando pasa unha cadea na lista de métricas, que A corda é usada como unha métrica. Estes nomes son visibles no obxecto de historia devolto por e, nas liñas que pasan, . está configurado para a cadea que pasou na lista métrica. Exactamente 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']) Debuxo Use a execución ansiosa para executar o código paso a paso para inspeccionar formas, tipos de datos e valores. , , etc. están deseñados para usar a execución de gráficos, para o rendemento e a portabilidade. to use eager execution inside this code. tf.function tf.keras tf.config.run_functions_eagerly(True) Por exemplo: @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] Isto tamén funciona dentro dos modelos Keras e outras APIs que soportan a execución ansiosa: 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 como axustar, avaliar e predicir executar como gráficos con tf.función baixo o capó. When using , set to disable the logic from being wrapped in a . tf.keras.Model.compile run_eagerly = True Model tf.function Use tf.data.experimental.enable_debug_mode para habilitar o modo de debug para tf.data. Lea os documentos da API para obter máis detalles. Do not keep nos teus obxectos tf.Tensors These tensor objects might get created either in a or in the eager context, and these tensors behave differently. Always use S só para valores intermedios. tf.function tf.Tensor To track state, use como sempre son usables desde ambos os dous contextos. guide to learn more. tf.Variable tf.Variable Resources and further reading Read the TF2 and to learn more about how to use TF2. guides tutorials Se xa usou TF1.x, recoméndase migrar o seu código a TF2. 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 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