Tipy na písanie čistého kódu v TensorFlow 2

Obsahový prehľad Prehľad nastaviť Odporúčania pre idiomatický TensorFlow 2 Prepracujte svoj kód na menšie moduly Nastavte predvolenú rýchlosť učenia pre niektoré tf.keras.optimizers Použite tf.Modules a Keras vrstvy na správu premenných Kombinácia tf.data.Datasets a tf.function Používajte Keras tréningové kruhy Prispôsobte si školenie a napíšte si vlastný cyklus Take advantage of tf.function with Python control flow Nový štýl metriky a straty Debugovanie Nenechávajte tf.Tensors vo vašich objektoch Zdroje a ďalšie čítanie Overview Táto príručka poskytuje zoznam najlepších postupov pre písanie kódu pomocou TensorFlow 2 (TF2), je napísaná pre používateľov, ktorí nedávno prešli z TensorFlow 1 (TF1). pre viac informácií o migrácii kódu TF1 na TF2. migrácia časť sprievodcu nastaviť 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 Odporúčania pre idiomatický TensorFlow 2 Prepracujte svoj kód na menšie moduly Dobrou praxou je prepracovať váš kód na menšie funkcie, ktoré sa volajú podľa potreby.Pre najlepší výkon by ste sa mali pokúsiť vyzdobiť najväčšie bloky výpočtu, ktoré môžete v (Všimnite si, že vniknuté pythonové funkcie sa nazývajú nevyžadujú vlastné samostatné dekorácie, pokiaľ nechcete používať iné Nastavenia pre V závislosti od vášho prípadu použitia by to mohlo byť viacero tréningových krokov alebo dokonca celý tréningový kruh. tf.function tf.function jit_compile tf.function Upravte predvolenú mieru učenia pre niektoré s tf.keras.optimizer Some Keras optimizers have different learning rates in TF2. If you see a change in convergence behavior for your models, check the default learning rates. Neexistujú žiadne zmeny pre , , alebo . optimizers.SGD optimizers.Adam optimizers.RMSprop The following default learning rates have changed: optimizers.Adagrad od 0,01 do 0,001 optimizers.Adadelta od 1.0 do 0.001 from to optimizers.Adamax 0.002 0.001 optimizers.Nadam od 0,002 do 0,001 Use s and Keras layers to manage variables tf.Module s a Ponúkame Vám vhodné a vlastnosti, ktoré recursívne zhromažďujú všetky závislé premenné.To uľahčuje správu premenných lokálne tam, kde sa používajú. tf.Module tf.keras.layers.Layer variables trainable_variables Keras vrstvy / modely zdedené od and are integrated with , čo umožňuje priamo kontrolovať alebo exportovať SavedModels z objektov Keras. nemusíte nevyhnutne používať Keras' API na využitie týchto integrácií. tf.train.Checkpointable @tf.function Model.fit Prečítajte si sekciu na v sprievodcovi Keras sa dozviete, ako zhromaždiť podskupinu relevantných premenných pomocou Keras. transfer learning and fine-tuning kombinovať s a tf.data.Dataset tf.function The balíček ( ) obsahuje nástroje na načítanie preddefinovaných dátových súborov ako objektov. V tomto príklade môžete načítať databázu MNIST pomocou : TensorFlow dátové súbory 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... Then prepare the data for training: Re-scale každý obrázok Zmeňte poradie príkladov. 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 Ak chcete, aby bol príklad krátky, vystrihnite databázu tak, aby sa vrátilo iba 5 dávok: 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. Použite pravidelnú iteráciu Pythonu na iteráciu cez tréningové dáta, ktoré sa zmestia do pamäte. je najlepší spôsob, ako preniesť školiace dáta z disku. , and work just like other Python iterables in eager execution. You can fully utilize dataset async prefetching/streaming features by wrapping your code in , ktorý nahrádza iteráciu Pythonu ekvivalentnými grafovými operáciami pomocou AutoGraph. tf.data.Dataset iterácie (nie sú iterátory) 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)) Ak používate keratín API, you won't have to worry about dataset iteration. Model.fit model.compile(optimizer=optimizer, loss=loss_fn) model.fit(dataset) Používajte Keras tréningové kruhy Ak nepotrebujete nízku úroveň kontroly vášho tréningového procesu, použite vstavaný systém Keras , , , and Tieto metódy poskytujú jednotné rozhranie na výcvik modelu bez ohľadu na implementáciu (sekvenčná, funkčná alebo podtriedená). fit evaluate predict The advantages of these methods include: Prijímajú množiny Numpy, generátory Python a tf.data.Datasets. Aplikujú normalizáciu a automaticky aktivujú straty. Podporujú tf.distribute, kde kód školenia zostáva rovnaký bez ohľadu na hardvérovú konfiguráciu. Podporujú svojvoľné výzvy ako straty a metriky. Podporujú spätné hovory ako tf.keras.callbacks.TensorBoard a vlastné spätné hovory. Sú výkonné, automaticky pomocou grafov TensorFlow. Tu je príklad výcviku modelu s použitím Podrobnosti o tom, ako to funguje, si pozrite na . Dataset Tutoriály 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. Prispôsobte si školenie a napíšte si vlastný cyklus Ak Keras modely pracujú pre vás, ale potrebujete väčšiu flexibilitu a kontrolu tréningového kroku alebo vonkajších tréningových kruhov, môžete implementovať svoje vlastné tréningové kroky alebo dokonca celé tréningové kruhy. Naučiť sa viac. customizing fit You can also implement many things as a . tf.keras.callbacks.Callback Táto metóda má mnoho výhod , ale dáva vám kontrolu nad krokom vlaku a dokonca aj vonkajšou slučkou. mentioned previously There are three steps to a standard training loop: Iterovať cez Python generátor alebo tf.data.Dataset získať dávky príkladov. Use to collect gradients. tf.GradientTape Use one of the to apply weight updates to the model's variables. tf.keras.optimizers Pamätajte si: Vždy zahrňte školiaci argument o metóde volania subkategorizovaných vrstiev a modelov. Make sure to call the model with the argument set correctly. training Depending on usage, model variables may not exist until the model is run on a batch of data. You need to manually handle things like regularization losses for the model. Nie je potrebné spúšťať variabilné inicializátory alebo pridávať manuálne ovládacie závislosti. 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. Take advantage of Python ovládanie toku tf.function poskytuje spôsob, ako previesť tok riadenia závislý od údajov na ekvivalenty grafového režimu, ako sú a . tf.function tf.cond tf.while_loop Jedným z bežných miest, kde sa zobrazuje tok riadenia závislý od údajov, je v sekvenčných modeloch. 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 Sprievodca pre viac informácií. tf.function New-style metrics and losses Metrics and losses are both objects that work eagerly and in s. tf.function Strata objektu je volateľná a očakáva sa ( , , ) as arguments: y_true y_pred cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True) cce([[1, 0]], [[-1.0,3.0]]).numpy() 4.01815 Použitie metrík na zhromažďovanie a zobrazovanie údajov You can use zhromažďovať údaje a to log summaries and redirect it to a writer using a context manager. The summaries are emitted directly to the writer which means that you must provide the Hodnota na 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 to aggregate data before logging them as summaries. Metrics are stateful; they accumulate values and return a cumulative result when you call the method (such as Vyčistenie akumulovaných hodnôt s . 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 the generated summaries by pointing TensorBoard to the summary log directory: tensorboard --logdir /tmp/summaries Používajte to API na písanie súhrnných údajov pre vizualizáciu v TensorBoard. Pre viac informácií si prečítajte 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 modely sú konzistentné pri manipulácii s metrickými názvami. Keď prejdete reťazec v zozname metrík, že String sa používa ako metriky Tieto mená sú viditeľné v objekte histórie vrátenom , and in the logs passed to . is set to the string you passed in the metric list. 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']) Debugovanie Use eager execution to run your code step-by-step to inspect shapes, data types and values. Certain APIs, like , , , etc. are designed to use Graph execution, for performance and portability. When debugging, use to use eager execution inside this code. tf.function tf.keras tf.config.run_functions_eagerly(True) Napríklad : @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] Funguje to aj vo vnútri modelov Keras a iných rozhraní API, ktoré podporujú túžbu vykonať: 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 Keď používate tf.keras.Model.compile, nastavte run_eagerly = True na to, aby sa v funkcii tf.funkcia zablokovala logika modelu. Použite tf.data.experimental.enable_debug_mode na zapnutie režimu debugingu pre tf.data. Prečítajte si ďalšie podrobnosti v dokumentoch API. Nenechaj si in your objects tf.Tensors These tensor objects might get created either in a alebo v náročnom kontexte a tieto tenzory sa správajú inak.Vždy používajte s len pre stredné hodnoty. tf.function tf.Tensor To track state, use s as they are always usable from both contexts. Read the Sprievodca sa dozvedieť viac. tf.Variable tf.Variable Zdroje a ďalšie čítanie Read the TF2 and to learn more about how to use TF2. guides tutorials If you previously used TF1.x, it is highly recommended you migrate your code to TF2. Read the to learn more. migration guides 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