עקבו אחרי TensorFlow TensorFlow TensorFlow 2

תוכן תצפית תצפית התקנת תגית: TensorFlow 2 מחדש את הקוד שלך לתוך מודולים קטנים יותר התאמת שיעור למידה ברירת המחדל עבור כמה tf.keras.optimizers השתמש tf.Modules ו Keras שכבות לניהול משתנים שילוב של tf.data.Datasets ו- tf.function השתמש Keras Training Loops Customize training and write your own loop היתרונות של tf.function עם Python שליטה זרימה מטריקים בסגנון חדש והפסדים Debugging לא לשמור tf.Tensors באובייקטים שלך משאבים וקריאה נוספת תצפית מדריך זה מספק רשימה של שיטות הטובות ביותר עבור כתיבת קוד באמצעות TensorFlow 2 (TF2), הוא נכתב עבור משתמשים אשר עברו לאחרונה מ TensorFlow 1 (TF1). לקבלת מידע נוסף על העברת קוד TF1 ל- TF2. סעיף ההגירה של המדריך התקנת ייבוא TensorFlow ותלות אחרות לדוגמאות במדריך זה. 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 תגית: TensorFlow 2 מחדש את הקוד שלך לתוך מודולים קטנים יותר שיטה טובה היא לשחזר את הקוד שלך לתוך פונקציות קטנות יותר כי נקראים לפי הצורך.לביצועים הטובים ביותר, אתה צריך לנסות לקשט את הבלוקים הגדולים ביותר של חישובים שאתה יכול ב (ציין כי הפונקציות הנגועות Python נקראות על ידי a אינם דורשים קישוטים נפרדים משלהם, אלא אם כן ברצונך להשתמש בהם. ההגדרות עבור בהתאם למקרה השימוש שלך, זה יכול להיות שלבים אימונים מרובים או אפילו כל מעגל האימונים שלך. tf.function tf.function jit_compile tf.function התאמת שיעור ההכשרה המוגדר כברירת מחדל עבור חלק s tf.keras.optimizer כמה אופטימיזרים של Keras יש שיעורי למידה שונים ב- TF2.אם אתה רואה שינוי בהתנהגות התכנסות עבור המודלים שלך, בדוק את שיעורי למידה ברירת המחדל. אין שינויים עבור , , or . optimizers.SGD optimizers.Adam optimizers.RMSprop שיעורי ההכשרה הבאים השתנו: optimizers.Adagrad מ 0.01 ל 0.001 optimizers.Adadelta מ 1.0 עד 0.001 optimizers.Adamax מ 0.002 ל 0.001 optimizers.Nadam מ 0.002 ל 0.001 שימוש שכבות s ו-Keras לניהול משתנים tf.Module s ו מציעים את הנוחות ו תכונות, אשר לאסוף מחדש את כל המשתנים תלויים, מה שהופך את זה קל לנהל את המשתנים באופן מקומי למקום שבו הם משמשים. tf.Module tf.keras.layers.Layer variables trainable_variables דוגמאות / דוגמאות מורשת הם משולבים עם , מה שמאפשר לבדוק ישירות או לייצא SavedModels מהאובייקטים של Keras. API כדי לנצל את האינטגרציות האלה. tf.train.Checkpointable @tf.function Model.fit קראו את החלק על במדריך Keras ללמוד כיצד לאסוף תת קבוצה של משתנים רלוונטיים באמצעות Keras. למידה מתקדמת ו-Fine Tuning שילוב s ו tf.data.Dataset tf.function The החבילה ( ) מכיל משאבים לטעון קבוצות נתונים מוגדרות מראש כגון עבור דוגמה זו, באפשרותך להוריד את קבוצת הנתונים MNIST באמצעות : נתונים TensorFlow 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... לאחר מכן להכין את הנתונים לאימון: Re-scale each image. שימו לב לסדר הדוגמאות. לאסוף חבילות של תמונות ותוויות. 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 כדי לשמור על הדוגמה קצרה, לחתוך את קבוצת הנתונים כדי להחזיר רק 5 קבוצות: 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. השתמש באיטראציה רגילה של Python כדי לחזור על נתוני אימון שמתאימים לזיכרון. היא הדרך הטובה ביותר להעביר את נתוני האימון מהדיסק. , ולעבוד בדיוק כמו Python iterables אחרים בביצוע נלהב. אתה יכול לנצל את התכונות async prefetching/streaming של קבוצת נתונים באופן מלא על ידי מעוטר את הקוד שלך ב , אשר מחליף iteration Python עם פעולות גרף שווה ערך באמצעות 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)) אם אתם משתמשים בקירור API, you won't have to worry about dataset iteration. Model.fit model.compile(optimizer=optimizer, loss=loss_fn) model.fit(dataset) השתמש Keras Training Loops אם אינך זקוק לשלוט ברמה נמוכה בתהליך האימון שלך, השתמש ב-Keras' , , ו שיטות אלה מספקות ממשק משותף כדי להכשיר את המודל ללא קשר לביצועים (סדרתיים, פונקציונליים או מתחת לכיתות). fit evaluate predict The advantages of these methods include: הם מקבלים מספרי Numpy, גנרטורים Python ו, tf.data.Datasets. הם מיישמים נורמליזציה, ואובדן הפעלת באופן אוטומטי. הם תומכים tf.distribute שבו קוד ההכשרה נשאר זהה ללא קשר להגדרת החומרה. הם תומכים בשמות אובייקטיביים כגון הפסדים ומטריקים. הם תומכים בקשות חזרה כגון tf.keras.callbacks.TensorBoard, וקשות חזרה מותאמות אישית. They are performant, automatically using TensorFlow graphs. הנה דוגמה של אימון מודל באמצעות a לפרטים על איך זה עובד, בדוק את . 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. להתאים אישית את האימון ולכתוב את המעגל שלך אם מודלים Keras לעבוד בשבילך, אבל אתה צריך גמישות רבה יותר ושליטה של שלב האימון או זרמי האימון החיצוניים, אתה יכול ליישם את שלבי האימון שלך או אפילו זרמי אימון שלמים. ללמוד עוד קואליציה fit אתה יכול גם לבצע הרבה דברים כמו . tf.keras.callbacks.Callback לשיטה זו יש יתרונות רבים , אבל נותן לך שליטה של צעד הרכבת ואפילו את המעגל החיצוני. הוזכר בעבר ישנם שלושה צעדים ללימודים סטנדרטיים: Iterate מעל גנרטור Python או tf.data.Dataset כדי לקבל מנות של דוגמאות. השתמש tf.GradientTape כדי לאסוף gradients. Use one of the to apply weight updates to the model's variables. tf.keras.optimizers זכרו : תמיד לכלול רמז הכשרה על שיטת החיפוש של שכבות ומודלים מסומנים. Make sure to call the model with the argument set correctly. training בהתאם לשימוש, משתנים מודל עשויים לא להתקיים עד שהמודל פועל על קבוצה של נתונים. You need to manually handle things like regularization losses for the model. There is no need to run variable initializers or to add manual control dependencies. פועלת בשליטה אוטומטית של תלויות ותחילת משתנה על יצירה בשבילך. 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 with Python control flow tf.function מספק דרך להמיר זרימת בקרה תלויה בנתונים לתוך שווה ערך של מצב גרף כגון ו . tf.function tf.cond tf.while_loop מקום נפוץ אחד שבו זרימת בקרה תלויה בנתונים מופיעה הוא במודלים רצופים. מכסה תא RNN, ומאפשר לך לפתוח את ההפעלה באופן סטטי או דינמי.לדוגמה, באפשרותך ליישם מחדש את הפעלה הדינמית כדלקמן. 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) קרא את מדריך למידע נוסף. tf.function New-style metrics and losses מטרים ואובדן הם שני אובייקטים שעובדים בהתלהבות ובאופן ס tf.function אובדן אובייקט יכול להיקרא, ומחכה ( , ) as arguments: y_true y_pred cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True) cce([[1, 0]], [[-1.0,3.0]]).numpy() 4.01815 השתמש במטריקים כדי לאסוף ולהציג נתונים אתה יכול להשתמש כדי לאסוף נתונים ו כדי להקליט סיכום ולהפנות אותו לסופר באמצעות מנהל הקשר.סיכום הועבר ישירות לסופר, כלומר עליך לספק את הערך של 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) שימוש 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 ). 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) חזות את הסיכום שנוצר על-ידי הצגת TensorBoard לתיקיית יומן סיכום: tensorboard --logdir /tmp/summaries Use the API to write summary data for visualization in TensorBoard. For more info, read the מדריך 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 הן עקביות לגבי עיבוד שמות מטרי. המילון משמש כמרכיב של שמות אלה נראים באובייקט ההיסטוריה שהוחזר על ידי ובכל זאת, בכתבי הקודש עברו הוא מוגדר לקו שהעלית ברשימת המטריקים. מדויק 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. נועדו להשתמש בביצוע גרף, עבור ביצועים ונוחות. כדי להשתמש בביצועים נלהבים בתוך קוד זה. tf.function tf.keras tf.config.run_functions_eagerly(True) למשל : @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] זה גם עובד בתוך מודלים Keras ו- APIs אחרים התומכים בביצועים נלהבים: 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])) הערות : methods such as , , and execute as with under the hood. tf.keras.Model fit evaluate predict graphs tf.function When using , set to disable the logic from being wrapped in a . tf.keras.Model.compile run_eagerly = True Model tf.function השתמש ב- tf.data.experimental.enable_debug_mode כדי להפעיל את מצב הבועה עבור tf.data. אל תישארו בתוך האובייקטים שלך tf.Tensors אובייקטים אלה עשויים להיווצר או ב או בהקשר המבוקש, והטנטורים האלה מתנהגים באופן שונה. S רק עבור ערכים ביניים. tf.function tf.Tensor To track state, use כמו כן, ניתן להשתמש בשני המקרים: קראו את מדריך ללמוד עוד tf.Variable tf.Variable משאבים וקריאה נוספת קרא את מדריכים TF2 ומדריכים כדי ללמוד עוד על איך להשתמש TF2. אם השתמשת בעבר ב- TF1.x, מומלץ מאוד להעביר את הקוד שלך ל- TF2. פורסם במקור באתר TensorFlow, מאמר זה מופיע כאן תחת כותרת חדשה והוא מורשה תחת CC BY 4.0. פורסם במקור באתר TensorFlow, מאמר זה מופיע כאן תחת כותרת חדשה והוא מורשה תחת CC BY 4.0. TensorFlow TensorFlow