Dicas para escrever código limpo no TensorFlow

Conteúdo Visão Geral Visão geral Instalação Recomendações para o idiomático TensorFlow 2 Transforme seu código em módulos menores Ajuste a taxa de aprendizagem padrão para alguns tf.keras.optimizers Use tf.Modules e camadas Keras para gerenciar variáveis Combine tf.data.Datasets e tf.função Use os Loops de Treinamento Keras Personalize o treinamento e escreva seu próprio loop Aproveite a função tf.function com o fluxo de controle do Python Novas métricas e perdas Debugando Não mantenha tf.Tensors em seus objetos Recursos e Leia mais Visão geral Este guia fornece uma lista de melhores práticas para escrever código usando TensorFlow 2 (TF2), é escrito para usuários que recentemente mudaram de TensorFlow 1 (TF1). Para mais informações sobre como migrar seu código TF1 para TF2. Seção de migração do guia Instalação Importar TensorFlow e outras dependências para os exemplos neste guia. 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 Recomendações para o idiomático TensorFlow 2 Transforme seu código em módulos menores Uma boa prática é refactorizar seu código em funções menores que são chamadas de acordo com a necessidade.Para o melhor desempenho, você deve tentar decorar os maiores blocos de computação que você pode em um (Nota que as funções embutidas em Python são chamadas de não requerem suas próprias decorações separadas, a menos que você queira usar diferentes As configurações para o Dependendo do seu caso de uso, isso pode ser várias etapas de treinamento ou até mesmo o seu ciclo de treinamento inteiro. tf.function tf.function jit_compile tf.function Ajustar a taxa de aprendizagem padrão para alguns s tf.keras.optimizer Alguns otimizadores Keras têm taxas de aprendizagem diferentes em TF2.Se você ver uma mudança no comportamento de convergência para seus modelos, verifique as taxas de aprendizagem padrão. Não há alterações para , em ou . optimizers.SGD optimizers.Adam optimizers.RMSprop As seguintes taxas de aprendizagem padrão mudaram: optimizers.Adagrad de 0.01 a 0.001 optimizers.Adadelta de 1.0 a 0.001 optimizers.Adamax de 0,002 a 0,001 optimizers.Nadam de 0,002 a 0,001 Uso S e Keras para gerenciar variáveis tf.Module S e Ofereça o conveniente e As propriedades, que recursivamente reúnem todas as variáveis dependentes, facilitam o gerenciamento das variáveis localmente para onde estão sendo usadas. tf.Module tf.keras.layers.Layer variables trainable_variables As camadas de Keras / modelos herdados de São integrados com , o que torna possível verificar diretamente ou exportar SavedModels a partir de objetos Keras. API para aproveitar essas integrações. tf.train.Checkpointable @tf.function Model.fit Leia a seção em in the Keras guide to learn how to collect a subset of relevant variables using Keras. Aprendizagem de transferência e fine-tuning Combinando S e tf.data.Dataset tf.function O Composição ( ) contém utilitários para carregar conjuntos de dados predefinidos como Para este exemplo, você pode carregar o conjunto de dados MNIST usando : Dados do 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... Prepare os dados para o treinamento: Reescale cada imagem. Esqueça a ordem dos exemplos. Coletar lotes de imagens e rótulos. 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 conjunto de dados para retornar apenas 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 a iteração regular do Python para repetir os dados de treinamento que se encaixam na memória. é a melhor maneira de transmitir dados de treinamento a partir do disco. , e funcionar como outros iteráveis Python em execução ansiosa. Você pode aproveitar plenamente os recursos de pré-fetchamento/streaming assínctico do conjunto de dados, embrulhando seu código em , que substitui a iteração Python com as operações de gráfico equivalentes usando o AutoGraph. tf.data.Dataset iteráveis (não 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)) Se você usar o Keras API, você não terá que se preocupar com iteração de conjuntos de dados. Model.fit model.compile(optimizer=optimizer, loss=loss_fn) model.fit(dataset) Use os Loops de Treinamento Keras Se você não precisa de controle de baixo nível do seu processo de treinamento, use o built-in do Keras , em e Estes métodos fornecem uma interface uniforme para treinar o modelo independentemente da implementação (sequencial, funcional ou sub-classificada). fit evaluate predict As vantagens desses métodos incluem: Eles aceitam matrizes Numpy, geradores de Python e, tf.data.Datasets. Eles aplicam regularização e perdas de ativação automaticamente. Eles suportam tf.distribute onde o código de treinamento permanece o mesmo, independentemente da configuração de hardware. Eles suportam chamáveis arbitrários como perdas e métricas. Eles suportam chamadas de volta como tf.keras.callbacks.TensorBoard e chamadas de volta personalizadas. Eles são de alto desempenho, automaticamente usando gráficos TensorFlow. Aqui está um exemplo de treinamento de um modelo usando um Para mais detalhes sobre como isso funciona, confira o . Dataset Tutoriais 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. Personalize o treinamento e escreva seu próprio loop Se os modelos Keras funcionarem para você, mas você precisa de mais flexibilidade e controle da etapa de treinamento ou dos circuitos de treinamento externos, você pode implementar suas próprias etapas de treinamento ou até mesmo circuitos de treinamento inteiros. Para aprender mais. customização fit Você também pode implementar muitas coisas como uma . tf.keras.callbacks.Callback Este método tem muitas das vantagens , mas dá-lhe o controle do passo do trem e até mesmo o loop exterior. mencionado anteriormente Existem três etapas para um ciclo de treinamento padrão: Iterate sobre um gerador de Python ou tf.data.Dataset para obter lotes de exemplos. Use tf.GradientTape para coletar gradientes. Use um dos tf.keras.optimizers para aplicar atualizações de peso às variáveis do modelo. Lembrei de: Inclua sempre um argumento de treinamento sobre o método de chamada de camadas e modelos subclassificados. Certifique-se de chamar o modelo com o argumento de treinamento configurado corretamente. Dependendo do uso, as variáveis do modelo podem não existir até que o modelo seja executado em um lote de dados. Você precisa lidar manualmente com coisas como perdas de regularização para o modelo. Não há necessidade de executar inicializadores variáveis ou adicionar dependências de controle manual. gerencia dependências de controle automático e inicialização variável na criação para você. 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. Aproveite a vantagem de Conheça o Python Control Flow tf.function fornece uma maneira de converter fluxo de controle dependente de dados em equivalentes de modo de gráfico, como e . tf.function tf.cond tf.while_loop Um lugar comum onde o fluxo de controle dependente de dados aparece é em modelos de sequência. Envolve uma célula RNN, permitindo que você desenrole a recorrência de forma estática ou dinâmica. Como exemplo, você pode reimplementar o desenrolar dinâmico da seguinte forma. 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) Leia o Guia para mais informações. tf.function Novas métricas e perdas Métriques e perdas são ambos objetos que trabalham ansiosamente e em do s. tf.function Um objeto de perda é chamável, e espera ( , em ) as arguments: y_true y_pred cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True) cce([[1, 0]], [[-1.0,3.0]]).numpy() 4.01815 Use métricas para coletar e exibir dados Você pode usar para agregar dados e para registrar resumos e redirecioná-los para um escritor usando um gerenciador de contexto. Os resumos são emitidos diretamente para o escritor, o que significa que você deve fornecer o Valor no 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 dados antes de logá-los como resumos.As métricas são estatísticas; acumulam valores e retornam um resultado cumulativo quando você chama o O método (como ) Valores acumulados claros com . 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) Visualize os resumos gerados apontando TensorBoard para o diretório de log de resumo: tensorboard --logdir /tmp/summaries Use o API para escrever dados resumidos para visualização no TensorBoard. O Guia. 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 métricos Os modelos Keras são consistentes em lidar com nomes métricos. Quando você passa uma cadeia na lista de métricas, que A metáfora é usada como metáfora Esses nomes são visíveis no objeto de histórico devolvido por E, nas folhas que passam, . é definida para a cadeia que você passou na lista métrica. Exatamente 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']) Debugando Use a execução ansiosa para executar o seu código passo a passo para inspeccionar formas, tipos de dados e valores. , em , etc. são projetados para usar a execução de gráficos, para desempenho e portabilidade. para usar a execução ansiosa dentro deste código. 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] Isso também funciona dentro dos modelos Keras e outras APIs que suportam a execução 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])) As notas: Métodos de modelo como ajustar, avaliar e prever executar como gráficos com tf.função sob o capô. Ao usar tf.keras.Model.compile, defina run_eagerly = True para desativar a lógica do Modelo de ser embrulhada em uma função tf. Use tf.data.experimental.enable_debug_mode para ativar o modo de depuração para tf.data. Leia os documentos da API para obter mais detalhes. Não mantenha Em seus objetos tf.Tensors These tensor objects might get created either in a ou no contexto ansioso, e esses tensores se comportam de forma diferente. Apenas para valores intermediários. tf.function tf.Tensor Para rastrear o estado, use como sempre são usáveis a partir de ambos os contextos. Guia para aprender mais. tf.Variable tf.Variable Resources and further reading Leia os guias e tutoriais do TF2 para saber mais sobre como usar o TF2. If you previously used TF1.x, it is highly recommended you migrate your code to TF2. Read the to learn more. migration guides Originalmente publicado no site TensorFlow, este artigo aparece aqui sob um novo título e é licenciado sob CC BY 4.0. Originalmente publicado no site TensorFlow, este artigo aparece aqui sob um novo título e é licenciado sob CC BY 4.0. TensorFlow TensorFlow