Tipps zum Schreiben von sauberem Code in TensorFlow 2

Content Übersicht Übersicht Setup Empfehlungen für idiomatische TensorFlow 2 Umwandeln Sie Ihren Code in kleinere Module Anpassen der Standard-Lernrate für einige tf.keras.optimizers Verwenden Sie tf.Modules und Keras-Lager zum Verwalten von Variablen Kombinieren von tf.data.Datasets und tf.function Verwenden Sie Keras Training Loops Personalisieren Sie das Training und schreiben Sie Ihre eigene Schleife Profitieren Sie von tf.function mit Python Control Flow New-Style Metriken und Verluste Debugging Do not keep tf.Tensors in your objects Ressourcen und weiterlesen Übersicht Dieser Leitfaden enthält eine Liste der Best Practices für das Schreiben von Code mit TensorFlow 2 (TF2), er ist für Benutzer geschrieben, die vor kurzem von TensorFlow 1 (TF1) gewechselt haben. Weitere Informationen zum Migrieren Ihres TF1-Codes zu TF2. Migrationsabschnitt des Guides Setup Import TensorFlow and other dependencies for the examples in this guide. 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 Empfehlungen für idiomatische TensorFlow 2 Umwandeln Sie Ihren Code in kleinere Module Eine gute Praxis ist, Ihren Code in kleinere Funktionen umzuwandeln, die nach Bedarf genannt werden.Für die beste Leistung sollten Sie versuchen, die größten Berechnungsblöcke zu dekorieren, die Sie in einer (beachtet, dass die eingebetteten Python-Funktionen, die durch eine benötigen keine eigenen separaten Dekorationen, es sei denn, Sie möchten andere Einstellungen für die Abhängig von Ihrem Anwendungsfall kann dies mehrere Trainingsschritte oder sogar Ihre gesamte Trainingsschleife sein. tf.function tf.function jit_compile tf.function Adjust the default learning rate for some s tf.keras.optimizer Einige Keras-Optimierer haben unterschiedliche Lernraten in TF2. Wenn Sie eine Änderung im Konvergenzverhalten für Ihre Modelle sehen, überprüfen Sie die Standard-Lernraten. Es gibt keine Änderungen für , der oder . optimizers.SGD optimizers.Adam optimizers.RMSprop Die folgenden Standardlernraten haben sich geändert: optimizers.Adagrad von 0.01 bis 0.001 optimizers.Adadelta von 1.0 bis 0.001 optimizers.Adamax von 0.002 bis 0.001 optimizers.Nadam von 0.002 bis 0.001 Benutze s und Keras, um Variablen zu verwalten tf.Module s und Das Angebot der bequemen und properties, which recursively gather up all dependent variables. This makes it easy to manage variables locally to where they are being used. tf.Module tf.keras.layers.Layer variables trainable_variables Keras Schichten / Modelle geerbt von Sie sind integriert mit , wodurch es möglich ist, SavedModels direkt von Keras-Objekten zu überprüfen oder zu exportieren. API, um diese Integrationen zu nutzen. tf.train.Checkpointable @tf.function Model.fit Read the section on In der Keras-Anleitung erfahren Sie, wie Sie mithilfe von Keras eine Untergruppe relevanter Variablen sammeln. transfer learning and fine-tuning Kombinieren s und tf.data.Dataset tf.function Die package ( ) enthält Dienstprogramme zum Laden vordefinierter Datensätze wie Objekte. Für dieses Beispiel können Sie den MNIST-Datensatz mit : TensorFlow Datensätze 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... Dann bereiten Sie die Daten für das Training vor: Re-scale jedes Bild Schieben Sie die Reihenfolge der Beispiele. Sammeln Sie Batches von Bildern und Etiketten. 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 Um das Beispiel kurz zu halten, schneiden Sie den Datensatz so, dass nur 5 Batches zurückgegeben werden: 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, ist der beste Weg, um Trainingsdaten von der Festplatte zu streamen. , und funktionieren wie andere Python-Iterablen in eager Ausführung. Sie können die Funktionen des asynchronen Prefetching/Streaming-Datensatzes vollständig nutzen, indem Sie Ihren Code in , die die Python-Iteration durch die gleichwertigen Grafikoperationen mit AutoGraph ersetzt. tf.data.Dataset iterables (nicht iterative Geräte) 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) Verwenden Sie Keras Training Loops If you don't need low-level control of your training process, using Keras' built-in , der und 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 Die Vorteile dieser Methoden umfassen: Sie akzeptieren Numpy-Arrays, Python-Generatoren und tf.data.Datasets. Sie wenden Regulierung und Aktivierungsverluste automatisch an. Sie unterstützen tf.distribute, wo der Trainingscode unabhängig von der Hardware-Konfiguration gleich bleibt. Sie unterstützen willkürliche Callables als Verluste und Metriken. They support callbacks like , and custom callbacks. tf.keras.callbacks.TensorBoard Sie sind leistungsstark und verwenden automatisch TensorFlow-Diagramme. Hier ein Beispiel, wie man ein Modell mit einem Für Details darüber, wie dies funktioniert, überprüfen Sie die . 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. Personalisieren Sie das Training und schreiben Sie Ihre eigene Schleife Wenn Keras-Modelle für Sie funktionieren, aber Sie mehr Flexibilität und Kontrolle über den Trainingsschritt oder die äußeren Trainingsschleifen benötigen, können Sie Ihre eigenen Trainingsschritte oder sogar ganze Trainingsschleifen implementieren. to learn more. Gewöhnung fit Sie können auch viele Dinge wie eine . tf.keras.callbacks.Callback Diese Methode hat viele der Vorteile , aber gibt Ihnen die Kontrolle über den Zugschritt und sogar die äußere Schleife. zuvor erwähnt Es gibt drei Schritte zu einer Standard-Trainingslücke: Iterieren Sie über einen Python-Generator oder tf.data.Dataset, um Batches von Beispielen zu erhalten. Use to collect gradients. tf.GradientTape Verwenden Sie einen der tf.keras.optimizers, um Gewicht-Updates auf die Variablen des Modells anzuwenden. Denken Sie daran: Immer ein Ausbildungsargument über die Aufrufmethode von unterklassifizierten Schichten und Modellen enthalten. Stellen Sie sicher, dass Sie das Modell mit dem Ausbildungsargument richtig anrufen. Abhängig von der Verwendung existieren Modellvariablen möglicherweise nicht, bis das Modell auf einer Batch von Daten ausgeführt wird. Sie müssen Dinge wie Normalisierungsverluste für das Modell manuell handhaben. Es besteht keine Notwendigkeit, variable Initializer auszuführen oder manuelle Steuerungsabhängigkeiten hinzuzufügen. automatische Steuerung von Abhängigkeiten und variabler Initialisierung bei der Erstellung für Sie. 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. Profitieren Sie von Mit Python Control Flow tf.function bietet eine Möglichkeit, datenabhängige Steuerungsströme in Graph-Mode-Äquivalente wie und . tf.function tf.cond tf.while_loop Ein gemeinsamer Ort, an dem datenabhängige Steuerungsströme erscheinen, ist in Sequenzmodellen. 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 für weitere Informationen. tf.function New-Style Metriken und Verluste Metrics and losses are both objects that work eagerly and in s. tf.function A loss object is callable, and expects ( , der ) as arguments: y_true y_pred cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True) cce([[1, 0]], [[-1.0,3.0]]).numpy() 4.01815 Metriken verwenden, um Daten zu sammeln und anzuzeigen You can use Um Daten zu aggregieren und um Zusammenfassungen zu protokollieren und sie an einen Schriftsteller mit einem Kontextmanager zu leiten. Die Zusammenfassungen werden direkt an den Schriftsteller ausgestellt, was bedeutet, dass Sie die 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) Use Metriken sind statistisch; sie akkumulieren Werte und geben ein kumulatives Ergebnis zurück, wenn Sie die Methoden (wie zum Beispiel ) Klare akkumulierte Werte mit . 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) Visualisieren Sie die generierten Zusammenfassungen, indem Sie TensorBoard auf den Zusammenfassungslog-Verzeichnis weisen: tensorboard --logdir /tmp/summaries Use the API zum Schreiben von Zusammenfassungsdaten für die Visualisierung in TensorBoard. Der Guide. 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 Keras-Modelle sind bei der Handhabung von metrischen Namen konsistent. Wenn Sie eine Zeichenfolge in der Liste der Metriken String wird als Metrik verwendet . These names are visible in the history object returned by Und in den Logs ging es über . is set to the string you passed in the metric list. exakt 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 , der , etc. sind so konzipiert, dass Graph-Ausführung für Leistung und Portabilität verwendet wird. um eiferhafte Ausführung innerhalb dieses Codes zu verwenden. 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: methods such as , , and execute as with under the hood. tf.keras.Model fit evaluate predict graphs tf.function Wenn Sie tf.keras.Model.compile verwenden, stellen Sie run_eagerly = True ein, um die Modelllogik in einer tf.funktion zu deaktivieren. Verwenden Sie tf.data.experimental.enable_debug_mode, um den Debug-Modus für tf.data zu aktivieren. Halten Sie nicht in your objects tf.Tensors Diese Tensorobjekte könnten entweder in einer oder im eifrigen Kontext, und diese Tensoren verhalten sich anders. s nur für Zwischenwerte. tf.function tf.Tensor To track state, use S wie sie immer aus beiden Kontexten nutzbar sind. Leitfaden, um mehr zu erfahren. tf.Variable tf.Variable Ressourcen und weiterlesen Lesen Sie die TF2-Anleitungen und Tutorials, um mehr über die Verwendung von TF2 zu erfahren. Wenn Sie zuvor TF1.x verwendet haben, wird Ihnen dringend empfohlen, Ihren Code auf TF2 zu migrieren. 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 Ursprünglich auf der TensorFlow-Website veröffentlicht, erscheint dieser Artikel hier unter einer neuen Überschrift und ist unter CC BY 4.0 lizenziert. TensorFlow TensorFlow