Padomi tīra koda rakstīšanai TensorFlow 2

Satura pārskats Overview Setup Recommendations for idiomatic TensorFlow 2 Pārveidojiet savu kodu par mazākiem moduļiem Pielāgojiet noklusējuma mācīšanās ātrumu dažiem tf.keras.optimizers Izmantojiet tf.Modules un Keras slāņus, lai pārvaldītu mainīgās Combine tf.data.Datasets and tf.function Use Keras training loops Customize training and write your own loop Take advantage of tf.function with Python control flow Jauna stila metrikas un zaudējumi Debugēšana Neuzglabājiet tf.Tensors jūsu objektos Resursi un turpmāka lasīšana Pārskats Šajā rokasgrāmatā ir sniegts saraksts ar labāko praksi, kā rakstīt kodu, izmantojot TensorFlow 2 (TF2), tas ir rakstīts lietotājiem, kuri nesen ir pāriet no TensorFlow 1 (TF1). lai iegūtu vairāk informācijas par TF1 koda migrāciju uz TF2. Migrācijas rokasgrāmata Setup Importēt TensorFlow un citas atkarības piemēriem šajā rokasgrāmatā. import tensorflow as tf import tensorflow_datasets as tfds 2023-10-04 01:22:53.526066: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered 2023-10-04 01:22:53.526110: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered 2023-10-04 01:22:53.526158: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered Recommendations for idiomatic TensorFlow 2 Pārveidojiet savu kodu par mazākiem moduļiem Labā prakse ir pārveidot savu kodu mazākās funkcijās, kas tiek sauktas pēc vajadzības.Lai iegūtu vislabāko sniegumu, jums vajadzētu mēģināt izrotāt lielākos aprēķinu blokus, ko varat (piezīme, ka iebūvētais python funkcijas sauc par a nav nepieciešama sava atsevišķa dekorācija, ja vien jūs nevēlaties izmantot citu settings for the Atkarībā no jūsu lietošanas gadījuma tas var būt vairāki apmācības soļi vai pat visa jūsu apmācības sloksne. tf.function tf.function jit_compile tf.function Pielāgojiet noklusējuma mācīšanās ātrumu dažiem 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. Nav izmaiņu attiecībā uz , vai . optimizers.SGD optimizers.Adam optimizers.RMSprop Ir mainījušies šādi noklusējuma mācīšanās rādītāji: optimizers.Adagrad no 0.01 līdz 0.001 optimizers.Adadelta no 1.0 līdz 0.001 from to optimizers.Adamax 0.002 0.001 optimizers.Nadam no 0.002 līdz 0.001 Use s un Keras slāņi, lai pārvaldītu mainīgās tf.Module s and Piedāvājiet ērtāko un 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 layers/models inherit from and are integrated with , which makes it possible to directly checkpoint or export SavedModels from Keras objects. You do not necessarily have to use Keras' API to take advantage of these integrations. tf.train.Checkpointable @tf.function Model.fit Lasīt sadaļu par in the Keras guide to learn how to collect a subset of relevant variables using Keras. Mācīšanās un fin-tuning Kombinācija S un tf.data.Dataset tf.function Tās Iepakojums ( ) contains utilities for loading predefined datasets as objects. For this example, you can load the MNIST dataset using : TensorFlow datu kopas 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... Pēc tam sagatavojiet datus apmācībai: Re-scale each image. Izmantojiet piemēru secību. Savāc attēlu un marķējumu partijas. 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 To keep the example short, trim the dataset to only return 5 batches: 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. Izmantojiet regulāru Python iterāciju, lai iterētu apmācības datus, kas atbilst atmiņai. ir labākais veids, kā straumēt apmācības datus no diska. , and work just like other Python iterables in eager execution. You can fully utilize dataset async prefetching/streaming features by wrapping your code in , kas aizstāj Python iterāciju ar līdzvērtīgām grafikas operācijām, izmantojot AutoGraph. tf.data.Dataset iterables (not iterators) 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)) Ja jūs izmantojat Keras API, jums nebūs jāuztraucas par datu kopu iterāciju. Model.fit model.compile(optimizer=optimizer, loss=loss_fn) model.fit(dataset) Izmantojiet Keras trenažieru lokus If you don't need low-level control of your training process, using Keras' built-in , , and Šīs metodes nodrošina vienotu saskarni, lai apmācītu modeli neatkarīgi no īstenošanas (sekvenciāla, funkcionāla vai subklasificēta). fit evaluate predict The advantages of these methods include: Viņi pieņem Numpy diapazonus, Python ģeneratorus un tf.data.Datasets. They apply regularization, and activation losses automatically. Tie atbalsta tf.distribute, kur apmācības kods paliek nemainīgs neatkarīgi no aparatūras konfigurācijas. They support arbitrary callables as losses and metrics. Tie atbalsta atpakaļsaišu, piemēram, tf.keras.callbacks.TensorBoard un pielāgotus atpakaļsaišus. Tie ir veiktspējīgi, automātiski izmantojot TensorFlow grafikus. Here is an example of training a model using a Sīkāku informāciju par to, kā tas darbojas, skatiet . 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. Pielāgojiet apmācību un uzrakstiet savu gaitu If Keras models work for you, but you need more flexibility and control of the training step or the outer training loops, you can implement your own training steps or even entire training loops. See the Keras guide on Lai uzzinātu vairāk. Parastā fit Jūs varat arī izmantot daudzas lietas, piemēram, . tf.keras.callbacks.Callback This method has many of the advantages , bet dod jums kontroli pār vilciena soli un pat ārējo loku. Iepriekš minētie There are three steps to a standard training loop: Iterējiet Python ģeneratoru vai tf.data.Dataset, lai iegūtu piemēru partijas. Use to collect gradients. tf.GradientTape Use one of the to apply weight updates to the model's variables. tf.keras.optimizers Atcerieties to: Vienmēr iekļaujiet apmācības argumentu par subklasificēto slāņu un modeļu izsaukuma metodi. Pārliecinieties, ka modelis ar apmācības argumentu iestatīts pareizi. Atkarībā no izmantošanas modeļa mainīgie var neeksistēt, kamēr modelis netiek palaists uz datu partijas. You need to manually handle things like regularization losses for the model. Nav nepieciešams palaist mainīgos inicializatorus vai pievienot manuālās vadības atkarības. apstrādā automātiskās kontroles atkarības un mainīgo inicializāciju jūsu izveidē. 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 kontroles plūsma tf.function provides a way to convert data-dependent control flow into graph-mode equivalents like un . tf.function tf.cond tf.while_loop Viena kopīga vieta, kur datu atkarīga vadības plūsma parādās secību modeļos. wraps an RNN cell, allowing you to either statically or dynamically unroll the recurrence. As an example, you could reimplement dynamic unroll as follows. tf.keras.layers.RNN class DynamicRNN(tf.keras.Model): def __init__(self, rnn_cell): super(DynamicRNN, self).__init__(self) self.cell = rnn_cell @tf.function(input_signature=[tf.TensorSpec(dtype=tf.float32, shape=[None, None, 3])]) def call(self, input_data): # [batch, time, features] -> [time, batch, features] input_data = tf.transpose(input_data, [1, 0, 2]) timesteps = tf.shape(input_data)[0] batch_size = tf.shape(input_data)[1] outputs = tf.TensorArray(tf.float32, timesteps) state = self.cell.get_initial_state(batch_size = batch_size, dtype=tf.float32) for i in tf.range(timesteps): output, state = self.cell(input_data[i], state) outputs = outputs.write(i, output) return tf.transpose(outputs.stack(), [1, 0, 2]), state lstm_cell = tf.keras.layers.LSTMCell(units = 13) my_rnn = DynamicRNN(lstm_cell) outputs, state = my_rnn(tf.random.normal(shape=[10,20,3])) print(outputs.shape) (10, 20, 13) Read the guide for a more information. tf.function New-style metrics and losses Metrics and losses are both objects that work eagerly and in S ir tf.function zaudējumu objekts ir saucams, un gaida ( , ) as arguments: y_true y_pred cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True) cce([[1, 0]], [[-1.0,3.0]]).numpy() 4.01815 Izmantojiet metriku, lai vāktu un rādītu datus You can use to aggregate data and lai ierakstītu kopsavilkumus un pāradresētu tos rakstniekam, izmantojot kontekstu pārvaldnieku. Vērtība pie 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 metodes (piemēram, ). Clear accumulated values with . 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 to write summary data for visualization in TensorBoard. For more info, read the 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 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 , and in the logs passed to . is set to the string you passed in the metric list. Precīzi 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 , , utt. ir paredzēti, lai izmantotu Graph izpildes, sniegumu un pārnesamību. 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] 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: tf.keras.Model metodes, piemēram, fit, novērtēt un prognozēt izpildīt kā grafiku ar tf.funkcija zem vāka. Izmantojot tf.keras.Model.compile, iestatīt run_eagerly = True, lai izslēgtu Model loģiku no iesaiņošanas tf.funkcijā. Use to enable the debug mode for . Read the for more details. tf.data.experimental.enable_debug_mode tf.data API docs Do not keep in your objects tf.Tensors Šie objekti var tikt izveidoti vai nu a vai vērienīgajā kontekstā, un šie tensori uzvedas atšķirīgi. Tikai vidējās vērtības. tf.function tf.Tensor To track state, use Tās vienmēr ir lietderīgas abos kontekstos. Ceļvedis, lai uzzinātu vairāk tf.Variable tf.Variable Resursi un turpmāka lasīšana Read the TF2 and to learn more about how to use TF2. guides tutorials Ja iepriekš esat izmantojis TF1.x, ir ļoti ieteicams pārvietot savu kodu uz TF2. Originally published on the website, this article appears here under a new headline and is licensed under CC BY 4.0. Code samples shared under the Apache 2.0 License. TensorFlow Originally published on the website, this article appears here under a new headline and is licensed under CC BY 4.0. Code samples shared under the Apache 2.0 License. TensorFlow TensorFlow TensorFlow

Padomi tīra koda rakstīšanai TensorFlow 2

About Author

KOMENTĀRI

PAKARINĀT TAGUS

ŠIS RAKSTS TIKS PĀRSTRĀDĀTS

Related Stories

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps