Tippek a tiszta kód írásához a TensorFlow 2-ben

Tartalom áttekintése Áttekintés Setup Idiomatikus TensorFlow 2 Átalakítsa kódját kisebb modulokba Állítsa be az alapértelmezett tanulási arányt egyes tf.keras.optimizers Használja a tf.Modules és a Keras rétegeket a változók kezeléséhez A tf.data.Datasets és a tf.function kombinációja Use Keras training loops Személyre szabott képzés és írja meg a saját görbe Használja ki a tf.function előnyeit a Python vezérlőáramlással Új stílusú metrikák és veszteségek Debugálás Do not keep tf.Tensors in your objects Források és további olvasmányok Overview Ez az útmutató a TensorFlow 2 (TF2) használatával történő kódolásra vonatkozó legjobb gyakorlatok listáját tartalmazza, és azoknak a felhasználóknak készült, akik nemrégiben váltottak át a TensorFlow 1 (TF1) alkalmazásról. További információ a TF1 kód TF2-re történő átviteléről. A migrációs útmutató szakasza beállítva Importálja a TensorFlow és más függőségek a példák ebben az útmutatóban. 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 Idiomatikus TensorFlow 2 Átalakítsa kódját kisebb modulokba Egy jó gyakorlat az, hogy a kódot kisebb funkciókká alakítsuk át, amelyeket szükség szerint hívunk.A legjobb teljesítmény érdekében meg kell próbálnod díszíteni a számítások legnagyobb blokkjait, amiket egy (megjegyzendő, hogy a beágyazott python funkciókat a nem igényelnek saját külön díszítéseket, hacsak nem szeretné használni a különböző A beállítások a A használati esettől függően ez több képzési lépés lehet, vagy akár az egész képzési kör. tf.function tf.function jit_compile tf.function Adjust the default learning rate for some s tf.keras.optimizer Néhány Keras optimalizátor különböző tanulási arányokkal rendelkezik a TF2-ben.Ha a modellek konvergencia viselkedésének változását látja, ellenőrizze az alapértelmezett tanulási arányokat. Nincs változás a az , vagy . optimizers.SGD optimizers.Adam optimizers.RMSprop The following default learning rates have changed: optimizers.Adagrad a 0.01 és a 0.001 között optimizers.Adadelta 1.0 és 0.001 között optimizers.Adamax a 0.002 és a 0.001 között optimizers.Nadam a 0.002 és a 0.001 között Használat s és Keras rétegek a változók kezeléséhez tf.Module s és A kényelmes ajánlat és tulajdonságok, amelyek ismétlődően összegyűjtik az összes függő változót. Ez megkönnyíti a változók helyi kezelését, ahol használják őket. tf.Module tf.keras.layers.Layer variables trainable_variables Keras layers/models inherit from integrálva vannak a , amely lehetővé teszi a SavedModels közvetlen ellenőrzését vagy exportálását a Keras objektumokból. API, hogy kihasználják ezeket az integrációkat. tf.train.Checkpointable @tf.function Model.fit Olvassa el a szakaszt A Keras útmutatóban megtudhatja, hogyan kell összegyűjteni a Keras segítségével a releváns változók egy alcsoportját. Transzfer tanulás és finomhangolás kombináció s és tf.data.Dataset tf.function A A csomagolás ( Az előzetesen meghatározott adathalmazok feltöltésére szolgáló segédprogramokat tartalmaz, mint objects. For this example, you can load the MNIST dataset using : TensorFlow adatbázis 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: Mindegyik kép újratölthető. A példák sorrendjének megváltoztatása. 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 A példa rövidítéséhez vágja le az adatkészletet, hogy csak 5 tételt adjon vissza: 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. Használjon rendszeres Python iterációt a memóriába illeszkedő képzési adatokon keresztül történő iterációhoz. a legjobb módja a képzési adatok streamelésének a lemezről. adatkészletek , és ugyanúgy működik, mint a többi Python iterábilis a vágyakozó végrehajtásban. Teljes mértékben kihasználhatja az adatkészlet async prefetching/streaming funkcióit a kód csomagolásával , which replaces Python iteration with the equivalent graph operations using AutoGraph. tf.data.Dataset Az iterátorok (nem iterátorok) 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, nem kell aggódnia az adatkészletek iterációjáról. Model.fit model.compile(optimizer=optimizer, loss=loss_fn) model.fit(dataset) Keras tréning foltok használata If you don't need low-level control of your training process, using Keras' built-in az , és Ezek a módszerek egységes felületet biztosítanak a modell képzéséhez, függetlenül a végrehajtástól (szekvenciális, funkcionális vagy alkategóriás). fit evaluate predict The advantages of these methods include: Ezek elfogadják a Numpy sorozatok, Python generátorok és, tf.data.Datasets. A normalizálást és az aktiválási veszteségeket automatikusan alkalmazzák. They support where the training code remains the same . tf.distribute regardless of the hardware configuration Támogatják az önkényes hívásokat, mint a veszteségeket és a métereket. They support callbacks like , and custom callbacks. tf.keras.callbacks.TensorBoard Ezek teljesítményesek, automatikusan használják a TensorFlow grafikonokat. Íme egy példa arra, hogyan lehet egy modellt használni a . For details on how this works, check out the . 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. Személyre szabott képzés és írja meg a saját görbe Ha a Keras modellek az Ön számára működnek, de nagyobb rugalmasságra és irányításra van szüksége a képzési lépés vagy a külső képzési csomópontok felett, akkor saját képzési lépéseket vagy akár teljes képzési csomópontokat is végrehajthat. to learn more. megszokás fit Számos módszert is használhatunk, mint a . tf.keras.callbacks.Callback Ennek a módszernek számos előnye van , de lehetővé teszi a vonat lépésének és még a külső görbe irányítását is. mentioned previously There are three steps to a standard training loop: Iteráljon egy Python generátoron vagy tf.data.Dataset-en, hogy példákat kapjon. Használja a tf.GradientTape a gradiensek összegyűjtéséhez. Használja a tf.keras.optimizers egyikét, hogy súlyfrissítéseket alkalmazzon a modell változóira. Emlékezzünk meg: Mindig tartalmazzon egy képzési érvet az alkategóriás rétegek és modellek hívási módjáról. 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. Kézi módon kell kezelni a modellek szabályozási veszteségeit. Nincs szükség változó initializátorok futtatására vagy manuális vezérlési függőségek hozzáadására. 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. Használja ki a Python vezérlőfolyamat tf.function provides a way to convert data-dependent control flow into graph-mode equivalents like és . tf.function tf.cond tf.while_loop Az egyik leggyakoribb hely, ahol az adatfüggő vezérlőáramlás megjelenik, a szekvenciális modellek. RNN cellát csomagol, lehetővé téve az ismétlés statikus vagy dinamikus feloldását. Például a dinamikus feloldást a következőképpen hajthatja végre. 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 Új stílusú metrikák és veszteségek Metrikák és veszteségek mind objektumok, amelyek dolgoznak buzgón és s. tf.function A loss object is callable, and expects ( , ) as arguments: y_true y_pred cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True) cce([[1, 0]], [[-1.0,3.0]]).numpy() 4.01815 Metrikák használata az adatok gyűjtéséhez és megjelenítéséhez You can use to aggregate data and az összefoglalók naplózásához és átirányításához egy szerzőhöz egy kontextuskezelő használatával. Az összefoglalókat közvetlenül az írónak adják ki, ami azt jelenti, hogy meg kell adnia a Érték a CallSite-en 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) Használat 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 A felhalmozott értékek tisztázása a . 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 Use the API az összefoglaló adatok írásához a TensorBoard vizualizálásához. További információkért olvassa el a Az útmutató. 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 models are consistent about handling metric names. When you pass a string in the list of metrics, that string is used as the metric's . These names are visible in the history object returned by A logókon átment a . 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']) Debugging 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) 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] Ez a Keras modellekben és más API-kban is működik, amelyek támogatják a vágyakozó végrehajtást: 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: tf.keras.Model módszerek, mint például az illeszkedés, értékelés és előrejelzés, mint grafikonok, tf.funkcióval a fedél alatt. A tf.keras.Model.compile használatakor állítsa be a run_eagerly = True beállítást, hogy a Model logika ne legyen csomagolva egy tf.funkcióba. Használja a tf.data.experimental.enable_debug_mode módot a tf.data hibakeresési módjának engedélyezéséhez. További részletekért olvassa el az API-dokumentumokat. Ne tartsa A tárgyakban tf.Tensors These tensor objects might get created either in a or in the eager context, and these tensors behave differently. Always use s csak közbenső értékekre vonatkozik. tf.function tf.Tensor Állapot követése, használata Mindig mindkét oldalról lehet használni. olvassa el a guide to learn more. tf.Variable tf.Variable Források és további olvasmányok Olvassa el a TF2 útmutatókat és oktatóanyagokat, hogy többet megtudjon a TF2 használatáról. 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 Eredetileg a TensorFlow weboldalán jelent meg, ez a cikk itt egy új címsor alatt jelenik meg, és CC BY 4.0 alatt van engedélyezve. TensorFlow TensorFlow szolgáltatás