Tips för att skriva ren kod i TensorFlow 2

Innehållsöversikt Översikt Setup Rekommendationer för idiomatisk TensorFlow 2 Omformar din kod till mindre moduler Adjust the default learning rate for some tf.keras.optimizers Använd tf.Modules och Keras-lager för att hantera variabler Kombinera tf.data.Datasets och tf.function Använd Keras Training Loops Anpassa träningen och skriv din egen loop Utnyttja tf.function med Python-kontrollflöde Nya metriker och förluster Debuggering Håll inte tf.Tensors i dina föremål Resurser och vidare läsning Översikt Den här guiden innehåller en lista över bästa praxis för att skriva kod med TensorFlow 2 (TF2), den är skriven för användare som nyligen har bytt från TensorFlow 1 (TF1). för mer information om att migrera din TF1-kod till TF2. migrera avsnittet av guiden Setup Importera TensorFlow och andra beroenden för exemplen i den här guiden. 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 Rekommendationer för idiomatisk TensorFlow 2 Omformar din kod till mindre moduler En bra praxis är att omformulera din kod till mindre funktioner som kallas efter behov. För bästa prestanda, bör du försöka dekorera de största blocken av beräkning som du kan i en (Observera att de inbäddade python-funktionerna kallas av en inte kräver egna separata dekorationer, om du inte vill använda olika Inställningar för den Beroende på ditt användningsfall kan detta vara flera träningssteg eller till och med hela din träningscykel. tf.function tf.function jit_compile tf.function Justera standardinlärningsgraden för vissa s tf.keras.optimizer Vissa Keras-optimerare har olika inlärningshastigheter i TF2.Om du ser en förändring i konvergensbeteende för dina modeller, kontrollera standardinlärningshastigheterna. Det finns inga förändringar för och eller . optimizers.SGD optimizers.Adam optimizers.RMSprop Följande standardkurser har ändrats: optimizers.Adagrad från 0,01 till 0,001 optimizers.Adadelta från 1.0 till 0.001 optimizers.Adamax från 0,002 till 0,001 optimizers.Nadam från 0.002 till 0.001 Använd s och Keras lager för att hantera variabler tf.Module S och Erbjuder det bekväma och egenskaper, som återkommande samlar alla beroende variabler. Detta gör det enkelt att hantera variabler lokalt till där de används. tf.Module tf.keras.layers.Layer variables trainable_variables Keras lager/modeller ärvda från De är integrerade med , vilket gör det möjligt att direkt kontrollera eller exportera SavedModels från Keras-objekt. API för att dra nytta av dessa integrationer. tf.train.Checkpointable @tf.function Model.fit Läs avsnittet på i Keras-guiden för att lära dig hur du samlar in en deluppsättning av relevanta variabler med Keras. Överföringsinlärning och fine-tuning Kombinera S och tf.data.Dataset tf.function den förpackning ( ) innehåller verktyg för att ladda fördefinierade datamängder som objekt. I det här exemplet kan du ladda MNIST-dataset med hjälp av : TensorFlow Datasatser 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... Förbered sedan data för träning: Skala upp varje bild. Ta reda på ordningen i exemplen. Samla partier av bilder och etiketter. 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 För att hålla exemplet kort, trimma datamängden så att endast 5 partier returneras: 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. Använd vanlig Python iteration för att iterera över träningsdata som passar i minnet. är det bästa sättet att strömma träningsdata från en disk. , och fungerar precis som andra Python iterables i ivrig utförande. Du kan fullt ut utnyttja dataset async prefetching/streaming funktioner genom att wrapp din kod i , som ersätter Python iteration med motsvarande grafoperationer med hjälp av AutoGraph. tf.data.Dataset iterables (inte iteratorer) 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)) Om du använder Keras API, du behöver inte oroa dig för dataset iteration. Model.fit model.compile(optimizer=optimizer, loss=loss_fn) model.fit(dataset) Använd Keras Training Loops Om du inte behöver kontroll på låg nivå över din träningsprocess, använd Keras inbyggda och och Dessa metoder ger ett enhetligt gränssnitt för att träna modellen oavsett implementering (sekventiell, funktionell eller underklassad). fit evaluate predict Fördelarna med dessa metoder inkluderar: De accepterar Numpy-sorter, Python-generatorer och tf.data.Datasets. De tillämpar normalisering och aktivering förluster automatiskt. De stöder tf.distribute där träningskoden förblir densamma oavsett hårdvarukonfiguration. De stöder godtyckliga kallelser som förluster och mätvärden. De stöder samtal som tf.keras.callbacks.TensorBoard och anpassade samtal. De är prestanda, automatiskt med TensorFlow-grafik. Här är ett exempel på hur man tränar en modell med en För detaljer om hur detta fungerar, kolla in . 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. Anpassa träningen och skriv din egen loop Om Keras-modellerna fungerar för dig, men du behöver mer flexibilitet och kontroll över träningssteget eller de yttre träningslooparna, kan du implementera dina egna träningsloopar eller till och med hela träningsloopar. Att lära sig mer. customiserar fit Du kan också utföra många saker som en . tf.keras.callbacks.Callback Denna metod har många av fördelarna , men ger dig kontroll över tåget steg och även den yttre slingan. som tidigare nämnts Det finns tre steg till en standardutbildning: Iterera över en Python-generator eller tf.data.Dataset för att få batcher av exempel. Använd tf.GradientTape för att samla gradienter. Använd en av tf.keras.optimizers för att tillämpa viktuppdateringar på modellens variabler. Kom ihåg: Inkludera alltid ett träningsargument om kallningsmetoden för underklassade lager och modeller. Se till att du ringer modellen med träningsargumentet korrekt. Beroende på användning kan modellvariabler inte existera förrän modellen körs på en batch av data. Du måste manuellt hantera saker som normaliseringsförluster för modellen. Det finns inget behov av att köra variabla initialiserare eller lägga till manuella kontrollberoenden. hanterar automatiska kontrollberoenden och variabel initialisering på skapelse för dig. 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. Dra nytta av med Python kontrollflöde tf.function ger ett sätt att konvertera data-beroende kontrollflöde till graf-läge ekvivalenter som and . tf.function tf.cond tf.while_loop En vanlig plats där databeroende kontrollflöde visas är i sekvensmodeller. omsluter en RNN-cell, så att du antingen statiskt eller dynamiskt kan avrulla återkommande. Som exempel kan du återimplementera dynamisk avrullning enligt följande. 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) Läs den Guide för mer information. tf.function Nya metriker och förluster Metrik och förluster är båda objekt som arbetar ivrigt och i och s. tf.function Ett förlustobjekt kan kallas, och förväntar sig ( och och som argument: y_true y_pred cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True) cce([[1, 0]], [[-1.0,3.0]]).numpy() 4.01815 Använd metriker för att samla in och visa data Du kan använda to aggregate data and logga sammanfattningar och omdirigera den till en författare med hjälp av en kontexthanterare. värde på callsidan. 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) Använd Metriker är statliga; de ackumulerar värden och returnerar ett kumulativt resultat när du ringer metoder (såsom ) Klara ackumulerade värden med . 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 Använd den API för att skriva sammanfattande data för visualisering i TensorBoard. 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 metriska namn Keras modeller är konsekventa när det gäller att hantera metriknamn. När du passerar en sträng i listan över metriker, String används som metrikens Dessa namn är synliga i det historikobjekt som returneras av , and in the logs passed to . är inställd på strängen du passerade i metriklistan. 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']) Debuggering Använd eager execution för att köra din kod steg för steg för att inspektera former, datatyper och värden. och , etc. are designed to use Graph execution, for performance and portability. When debugging, use för att använda eager execution inuti denna kod. tf.function tf.keras tf.config.run_functions_eagerly(True) Till exempel: @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] Detta fungerar också inom Keras-modeller och andra API-program som stöder ivrig utförande: 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])) Anteckningar : tf.keras.Modellmetoder som passa, utvärdera och förutsäga utför som diagram med tf.funktion under locket. När du använder tf.keras.Model.compile ställer du in run_eagerly = True för att inaktivera modelllogiken från att vara inslagna i en tf.funktion. Använd tf.data.experimental.enable_debug_mode för att aktivera debug-läget för tf.data. Läs API-dokumenten för mer information. Håll inte I dina föremål tf.Tensors Dessa tensorobjekt kan skapas antingen i en or in the eager context, and these tensors behave differently. Always use s endast för mellanliggande värden. tf.function tf.Tensor För att spåra tillstånd, använd s as they are always usable from both contexts. Read the Guide för att lära sig mer. tf.Variable tf.Variable Resources and further reading Läs TF2-guiderna och handledningarna för att lära dig mer om hur du använder TF2. Om du tidigare har använt TF1.x rekommenderas det starkt att du migrerar din kod till TF2. Läs migreringsguiderna för att lära dig mer. Ursprungligen publicerad på TensorFlow-webbplatsen, visas den här artikeln här under en ny rubrik och är licensierad under CC BY 4.0. Ursprungligen publicerad på TensorFlow-webbplatsen, visas den här artikeln här under en ny rubrik och är licensierad under CC BY 4.0. Tensorflöde Tensorflöde

Tips för att skriva ren kod i TensorFlow 2

About Author

KOMMENTARER

HÄNG TAGGAR

DENNA ARTIKEL PRESENTERAS I

Related Stories

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps