דף זה תורגם על ידי Cloud Translation API.
Switch to English

העבר את קוד TensorFlow 1 שלך ל- TensorFlow 2

צפה ב- TensorFlow.org הפעל בגוגל קולאב צפה במקור ב- GitHub הורד מחברת

מסמך זה למשתמשים בממשקי API של TensorFlow ברמה נמוכה. אם אתה משתמש בממשקי ה- API ברמה הגבוהה ( tf.keras ), ייתכן שתצטרך לבצע פעולות מועטות או לא כדי להפוך את הקוד שלך לתואם לחלוטין ל- TensorFlow 2.0:

עדיין ניתן להפעיל קוד 1.X, ללא שינוי ( למעט תור), ב- TensorFlow 2.0:

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

עם זאת, זה לא מאפשר לך לנצל רבים מהשיפורים שבוצעו ב- TensorFlow 2.0. מדריך זה יעזור לך לשדרג את הקוד שלך, להפוך אותו לפשוט יותר, ביצועי יותר וקל יותר לתחזוקה.

סקריפט המרה אוטומטי

השלב הראשון, לפני שניסה ליישם את השינויים המתוארים במסמך זה, הוא לנסות להריץ את סקריפט השדרוג .

זה יעשה מעבר ראשוני בשדרוג הקוד שלך ל- TensorFlow 2.0. אבל זה לא יכול להפוך את הקוד שלך לאידיומטי ל -2.0. הקוד שלך עשוי עדיין להשתמש tf.compat.v1 קצה tf.compat.v1 כדי לגשת למקומות מיקום, הפעלות, אוספים ופונקציונליות אחרת בסגנון 1.x.

שינויים התנהגותיים ברמה העליונה

אם הקוד שלך עובד ב- TensorFlow 2.0 באמצעות tf.compat.v1.disable_v2_behavior() , עדיין קיימים שינויים התנהגותיים גלובליים שתצטרך לטפל בהם. השינויים העיקריים הם:

  • ביצוע להוט, v1.enable_eager_execution() : כל קוד שמשתמש באופן מרומז ב- tf.Graph ייכשל. הקפד לעטוף את הקוד הזה בהקשר with tf.Graph().as_default() .

  • משתני משאבים, v1.enable_resource_variables() : ייתכן שקוד כלשהו תלוי בהתנהגויות לא דטרמיניסטיות המופעלות על ידי משתני התייחסות TF. משתני משאבים נעולים בזמן כתיבתם, וכך מספקים ערבויות עקביות אינטואיטיביות יותר.

    • זה עשוי לשנות את ההתנהגות במקרי קצה.
    • זה עשוי ליצור עותקים נוספים ויכולים להשתמש בזיכרון גבוה יותר.
    • ניתן להשבית את זה על ידי העברת use_resource=False tf.Variable .
  • צורות טנסור, v1.enable_v2_tensorshape() : TF 2.0 מפשט את ההתנהגות של צורות טנסור. במקום t.shape[0].value אתה יכול לומר t.shape[0] . שינויים אלה צריכים להיות קטנים, והגיוני לתקן אותם מיד. ראה TensorShape לדוגמאות.

  • זרימת בקרה, v1.enable_control_flow_v2() : יישום זרימת הבקרה TF 2.0 הופשט, ולכן מייצר ייצוגים שונים של גרפים. אנא הגש באגים בכל בעיה.

הפוך את הקוד 2.0 למקור

מדריך זה יעבור בין כמה דוגמאות להמרת קוד TensorFlow 1.x ל- TensorFlow 2.0. שינויים אלה יאפשרו לקוד שלך לנצל אופטימיזציות ביצועים ושיחות API פשוטות.

בכל מקרה, התבנית היא:

1. החלף את שיחות v1.Session.run

כל שיחת v1.Session.run צריכה להיות מוחלפת על ידי פונקציית Python.

  • ה- feed_dict ו- v1.placeholder הופכים לטיעוני פונקציה.
  • fetches הופכות לערך ההחזר של הפונקציה.
  • במהלך ההמרה ביצוע להוט מאפשר איתור באגים בקלות בעזרת כלי פייתון סטנדרטיים כמו pdb .

לאחר מכן הוסף מעצב tf.function כדי לגרום לו לרוץ ביעילות בגרף. עיין במדריך החתימה למידע נוסף על אופן פעולתו.

שים לב ש:

  • שלא כמו v1.Session.run tf.function יש חתימת החזרה קבועה ותמיד מחזירה את כל הפלטים. אם זה גורם לבעיות ביצועים, צור שתי פונקציות נפרדות.

  • אין צורך ב- tf.control_dependencies או בפעולות דומות: tf.function מתנהגת כאילו הופעלה בסדר שנכתב. מטלות tf.Variable . tf.assert ו- tf.assert , למשל, מבוצעות באופן אוטומטי.

החלק של דגמי המרה מכיל דוגמא לעבודה לתהליך המרה זה.

2. השתמש באובייקטים של פייתון כדי לעקוב אחר משתנים והפסדים

כל מעקב אחר משתנים מבוססי שמות מיואש מאוד ב- TF 2.0. השתמש באובייקטים של פייתון כדי לעקוב אחר משתנים.

השתמש ב- tf.Variable במקום ב- v1.get_variable .

יש להמיר כל v1.variable_scope לאובייקט פייתון. בדרך כלל זה יהיה אחד מ:

אם עליכם לצבור רשימות של משתנים (כמו tf.Graph.get_collection(tf.GraphKeys.VARIABLES) ), השתמשו .variables .trainable_variables ו- .trainable_variables של אובייקטים Layer ו- Model .

מחלקות Layer Model אלה מיישמות כמה מאפיינים אחרים שמסירים את הצורך באוספים גלובליים. המאפיין .losses שלהם יכול להוות תחליף לשימוש באוסף tf.GraphKeys.LOSSES .

לפרטים נוספים עיין במדריכי keras .

3. שדרג את לולאות האימון שלך

השתמש ב- API ברמה הגבוהה ביותר שעובד במקרה שלך. tf.keras.Model.fit על פני בניית לולאות אימון משלך.

פונקציות ברמה גבוהה אלה מנהלות הרבה פרטים ברמה נמוכה שעלול להיות קל לפספס אם כותבים לולאת אימונים משלך. לדוגמא, הם אוספים באופן אוטומטי את הפסדי ההסדרה, וקובעים את הארגומנט training=True כאשר מתקשרים למודל.

4. שדרג את צינורות קלט הנתונים שלך

השתמש tf.data נתונים של tf.data להזנת נתונים. אובייקטים אלה יעילים, אקספרסיביים ומשתלבים היטב עם טנסור.

ניתן להעביר אותם ישירות לשיטת tf.keras.Model.fit .

model.fit(dataset, epochs=5)

ניתן לחזור עליהם באמצעות פיתון רגיל ישירות:

for example_batch, label_batch in dataset:
    break

5. העבר את סמלי compat.v1

המודול tf.compat.v1 מכיל את ממשק ה- API של TensorFlow 1.x עם הסמנטיקה המקורית שלו.

סקריפט השדרוג של TF2 ימיר סמלים לשווי המקביל שלהם אם המרה כזו בטוחה, כלומר אם היא יכולה לקבוע שההתנהגות של גרסת 2.0 שווה בדיוק (למשל, היא תשנה את שם v1.arg_max ל- tf.argmax , מכיוון אלה אותה פונקציה).

לאחר שסקריפט השדרוג נעשה עם פיסת קוד, סביר להניח שיש אזכורים רבים של compat.v1 . כדאי לעבור על הקוד ולהמיר אותם באופן ידני לשווה ערך 2.0 (יש להזכיר אותו ביומן אם יש כזה).

המרת דגמים

משתנים ברמה נמוכה וביצוע מפעיל

דוגמאות לשימוש ברמה נמוכה של API כוללות:

לפני גיור

הנה איך דפוסים אלה עשויים להיראות בקוד באמצעות TensorFlow 1.x.

import tensorflow as tf
import tensorflow.compat.v1 as v1

import tensorflow_datasets as tfds
g = v1.Graph()

with g.as_default():
  in_a = v1.placeholder(dtype=v1.float32, shape=(2))
  in_b = v1.placeholder(dtype=v1.float32, shape=(2))

  def forward(x):
    with v1.variable_scope("matmul", reuse=v1.AUTO_REUSE):
      W = v1.get_variable("W", initializer=v1.ones(shape=(2,2)),
                          regularizer=lambda x:tf.reduce_mean(x**2))
      b = v1.get_variable("b", initializer=v1.zeros(shape=(2)))
      return W * x + b

  out_a = forward(in_a)
  out_b = forward(in_b)
  reg_loss=v1.losses.get_regularization_loss(scope="matmul")

with v1.Session(graph=g) as sess:
  sess.run(v1.global_variables_initializer())
  outs = sess.run([out_a, out_b, reg_loss],
                feed_dict={in_a: [1, 0], in_b: [0, 1]})

print(outs[0])
print()
print(outs[1])
print()
print(outs[2])
[[1. 0.]
 [1. 0.]]

[[0. 1.]
 [0. 1.]]

1.0

לאחר המרה

בקוד המומר:

  • המשתנים הם אובייקטים פייתוניים מקומיים.
  • הפונקציה forward עדיין מגדירה את החישוב.
  • שיחת Session.run מוחלפת בקריאה forward
  • ניתן tf.function מעצב ה- tf.function האופציונלי לצורך ביצועים.
  • הרגולציות מחושבות באופן ידני, מבלי להתייחס לאוסף גלובלי כלשהו.
  • אין הפעלות או מצייני מקום.
W = tf.Variable(tf.ones(shape=(2,2)), name="W")
b = tf.Variable(tf.zeros(shape=(2)), name="b")

@tf.function
def forward(x):
  return W * x + b

out_a = forward([1,0])
print(out_a)
tf.Tensor(
[[1. 0.]
 [1. 0.]], shape=(2, 2), dtype=float32)

out_b = forward([0,1])

regularizer = tf.keras.regularizers.l2(0.04)
reg_loss=regularizer(W)

מודלים המבוססים על tf.layers

מודול ה- v1.layers משמש להכיל פונקציות שכבות שהסתמכו על v1.variable_scope כדי להגדיר ומשתנים מחדש.

לפני גיור

def model(x, training, scope='model'):
  with v1.variable_scope(scope, reuse=v1.AUTO_REUSE):
    x = v1.layers.conv2d(x, 32, 3, activation=v1.nn.relu,
          kernel_regularizer=lambda x:0.004*tf.reduce_mean(x**2))
    x = v1.layers.max_pooling2d(x, (2, 2), 1)
    x = v1.layers.flatten(x)
    x = v1.layers.dropout(x, 0.1, training=training)
    x = v1.layers.dense(x, 64, activation=v1.nn.relu)
    x = v1.layers.batch_normalization(x, training=training)
    x = v1.layers.dense(x, 10)
    return x
train_data = tf.ones(shape=(1, 28, 28, 1))
test_data = tf.ones(shape=(1, 28, 28, 1))

train_out = model(train_data, training=True)
test_out = model(test_data, training=False)

print(train_out)
print()
print(test_out)
WARNING:tensorflow:From <ipython-input-1-1c8189d0d453>:4: conv2d (from tensorflow.python.keras.legacy_tf_layers.convolutional) is deprecated and will be removed in a future version.
Instructions for updating:
Use `tf.keras.layers.Conv2D` instead.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/convolutional.py:424: Layer.apply (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
Please use `layer.__call__` method instead.
WARNING:tensorflow:From <ipython-input-1-1c8189d0d453>:5: max_pooling2d (from tensorflow.python.keras.legacy_tf_layers.pooling) is deprecated and will be removed in a future version.
Instructions for updating:
Use keras.layers.MaxPooling2D instead.
WARNING:tensorflow:From <ipython-input-1-1c8189d0d453>:6: flatten (from tensorflow.python.keras.legacy_tf_layers.core) is deprecated and will be removed in a future version.
Instructions for updating:
Use keras.layers.Flatten instead.
WARNING:tensorflow:From <ipython-input-1-1c8189d0d453>:7: dropout (from tensorflow.python.keras.legacy_tf_layers.core) is deprecated and will be removed in a future version.
Instructions for updating:
Use keras.layers.dropout instead.
WARNING:tensorflow:From <ipython-input-1-1c8189d0d453>:8: dense (from tensorflow.python.keras.legacy_tf_layers.core) is deprecated and will be removed in a future version.
Instructions for updating:
Use keras.layers.Dense instead.
WARNING:tensorflow:From <ipython-input-1-1c8189d0d453>:9: batch_normalization (from tensorflow.python.keras.legacy_tf_layers.normalization) is deprecated and will be removed in a future version.
Instructions for updating:
Use keras.layers.BatchNormalization instead.  In particular, `tf.control_dependencies(tf.GraphKeys.UPDATE_OPS)` should not be used (consult the `tf.keras.layers.BatchNormalization` documentation).
tf.Tensor([[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]], shape=(1, 10), dtype=float32)

tf.Tensor(
[[ 0.07562444 -0.27538717  0.21692204  0.2411264  -0.01209673 -0.0923705
   0.19058049 -0.00468709 -0.17215249 -0.07528099]], shape=(1, 10), dtype=float32)

לאחר המרה

רוב הוויכוחים נותרו על כנם. אבל שימו לב להבדלים:

  • טיעון training מועבר לכל שכבה על ידי המודל כשהוא פועל.
  • הטיעון הראשון לפונקציית model המקורית (קלט x ) נעלם. הסיבה לכך היא ששכבות אובייקט מפרידות בין בניית המודל לבין קריאת המודל.

שימו לב גם כי:

  • אם השתמשת tf.contrib של tf.contrib מ- tf.contrib , יש בהם שינויים בוויכוח יותר מאחרים.
  • הקוד כבר לא כותב לאוספים, ולכן פונקציות כמו v1.losses.get_regularization_loss כבר לא יחזירו את הערכים הללו, v1.losses.get_regularization_loss לשבור את לולאות האימון שלך.
model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.04),
                           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)
])

train_data = tf.ones(shape=(1, 28, 28, 1))
test_data = tf.ones(shape=(1, 28, 28, 1))
train_out = model(train_data, training=True)
print(train_out)
tf.Tensor([[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]], shape=(1, 10), dtype=float32)

test_out = model(test_data, training=False)
print(test_out)
tf.Tensor(
[[-0.32132083  0.22252844 -0.11330387 -0.4613616  -0.08817139 -0.52697927
  -0.1538124   0.23069203 -0.15860984 -0.453844  ]], shape=(1, 10), dtype=float32)

# Here are all the trainable variables.
len(model.trainable_variables)
8
# Here is the regularization loss.
model.losses
[<tf.Tensor: shape=(), dtype=float32, numpy=0.08671833>]

משתנים מעורבים v1.layers

קוד קיים לעתים קרובות מערבב משתני TF 1.x ברמה נמוכה יותר ופעולות עם v1.layers ברמה גבוהה יותר.

לפני גיור

def model(x, training, scope='model'):
  with v1.variable_scope(scope, reuse=v1.AUTO_REUSE):
    W = v1.get_variable(
      "W", dtype=v1.float32,
      initializer=v1.ones(shape=x.shape),
      regularizer=lambda x:0.004*tf.reduce_mean(x**2),
      trainable=True)
    if training:
      x = x + W
    else:
      x = x + W * 0.5
    x = v1.layers.conv2d(x, 32, 3, activation=tf.nn.relu)
    x = v1.layers.max_pooling2d(x, (2, 2), 1)
    x = v1.layers.flatten(x)
    return x

train_out = model(train_data, training=True)
test_out = model(test_data, training=False)

לאחר המרה

כדי להמיר קוד זה, עקוב אחר התבנית של מיפוי שכבות לשכבות כמו בדוגמה הקודמת.

הדפוס הכללי הוא:

  • אסוף פרמטרים של שכבות ב- __init__ .
  • בנה את המשתנים build .
  • בצע את החישובים call והחזיר את התוצאה.

v1.variable_scope הוא למעשה שכבה משלו. אז tf.keras.layers.Layer אותו מחדש כ- tf.keras.layers.Layer . לפרטים עיין במדריך .

# Create a custom layer for part of the model
class CustomLayer(tf.keras.layers.Layer):
  def __init__(self, *args, **kwargs):
    super(CustomLayer, self).__init__(*args, **kwargs)

  def build(self, input_shape):
    self.w = self.add_weight(
        shape=input_shape[1:],
        dtype=tf.float32,
        initializer=tf.keras.initializers.ones(),
        regularizer=tf.keras.regularizers.l2(0.02),
        trainable=True)

  # Call method will sometimes get used in graph mode,
  # training will get turned into a tensor
  @tf.function
  def call(self, inputs, training=None):
    if training:
      return inputs + self.w
    else:
      return inputs + self.w * 0.5
custom_layer = CustomLayer()
print(custom_layer([1]).numpy())
print(custom_layer([1], training=True).numpy())
[1.5]
[2.]

train_data = tf.ones(shape=(1, 28, 28, 1))
test_data = tf.ones(shape=(1, 28, 28, 1))

# Build the model including the custom layer
model = tf.keras.Sequential([
    CustomLayer(input_shape=(28, 28, 1)),
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
])

train_out = model(train_data, training=True)
test_out = model(test_data, training=False)

כמה דברים שיש לציין:

  • מודלים ושכבות של Keras המסווגים בתחתית צריכים לפעול בשני גרפים v1 (ללא תלות בקרה אוטומטית) ובמצב להוט

    • עטוף את call() tf.function() כדי לקבל תלות בחתימה ובקרה אוטומטית
  • אל תשכח לקבל טיעון training call .

    • לפעמים זה tf.Tensor
    • לפעמים זה בוליאני פיתון.
  • צור משתני מודל Model.build או ב- self.add_weight() באמצעות self.add_weight() .

    • ב- Model.build יש לך גישה לצורת הקלט, כך שתוכל ליצור משקולות עם צורה תואמת.
    • השימוש ב- tf.keras.layers.Layer.add_weight מאפשר ל- Keras לעקוב אחר משתנים והפסדי הסדרה.
  • אל תשמור את tf.Tensors באובייקטים שלך.

    • הם עשויים להיווצר tf.function או בהקשר הנלהב, tf.function אלה מתנהגים אחרת.
    • השתמש ב- tf.Variable . tf.Variable למצב, הם תמיד ניתנים לשימוש משני ההקשרים
    • tf.Tensors מיועדים רק לערכי ביניים.

הערה על Slim & contrib.layers

כמות גדולה של קוד TensorFlow 1.x ישן יותר משתמשת בספריית Slim , שנארזה ב- TensorFlow 1.x כ- tf.contrib.layers . כתוצאה contrib מודול, זה כבר לא זמין TensorFlow 2.0, אפילו tf.compat.v1 . המרת קוד באמצעות Slim ל- TF 2.0 מעורבת יותר מאשר המרת מאגרים המשתמשים ב- v1.layers . למעשה, זה עשוי להיות הגיוני להמיר קודם את קוד ה- Slim שלך ל- v1.layers ואז להמיר ל- Keras.

  • הסר arg_scopes , כל args צריך להיות מפורש
  • אם אתה משתמש בהם, פצל את normalizer_fn ואת normalizer_fn activation_fn לשכבות שלהם
  • שכבות המפרדות נפרדות ממפות לשכבת קרס אחת או יותר (שכבה של Keras בעומק, נקודתי ומופרד)
  • v1.layers Slim ו- v1.layers יש שמות v1.layers וערכי ברירת מחדל שונים
  • לחלק מהוויכוחים יש סולמות שונים
  • אם אתה משתמש במודלים שהוכשרו מראש של Slim, נסה את הדגמים של Keras שהוכנו מראש מ- tf.keras.applications או מדגם TF2 SavedModels של TF Hub המיוצא מהקוד Slim המקורי.

ייתכן ששכבות tf.contrib לא הועברו לליבה TensorFlow אלא הועברו לחבילת התוספות TF .

הַדְרָכָה

ישנן דרכים רבות להזין נתונים למודל tf.keras . הם יקבלו מחוללי פייתון ומערכים Numpy כקלט.

הדרך המומלצת להזין נתונים למודל היא להשתמש בחבילת tf.data , המכילה אוסף של שיעורי ביצועים גבוהים לצורך מניפולציה בנתונים.

אם אתה עדיין משתמש ב- tf.queue , אלה נתמכים כעת רק tf.queue נתונים, ולא tf.queue קלט.

שימוש במערכי נתונים

חבילת מערכי הנתונים TensorFlow ( tfds ) מכילה כלי עזר לטעינת מערכי נתונים מוגדרים מראש כאובייקטיםtf.data.Dataset .

לדוגמא זו, טען את מערך tfds באמצעות tfds :

datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
mnist_train, mnist_test = datasets['train'], datasets['test']
Downloading and preparing dataset mnist/3.0.1 (download: 11.06 MiB, generated: 21.00 MiB, total: 32.06 MiB) to /home/kbuilder/tensorflow_datasets/mnist/3.0.1...

Warning:absl:Dataset mnist is hosted on GCS. It will automatically be downloaded to your
local data directory. If you'd instead prefer to read directly from our public
GCS bucket (recommended if you're running on GCP), you can instead pass
`try_gcs=True` to `tfds.load` or set `data_dir=gs://tfds-data/datasets`.


Dataset mnist downloaded and prepared to /home/kbuilder/tensorflow_datasets/mnist/3.0.1. Subsequent calls will reuse this data.

ואז הכינו את הנתונים לאימון:

  • קנה מידה מחדש של כל תמונה.
  • ערבב את סדר הדוגמאות.
  • אסוף קבוצות של תמונות ותוויות.
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))

השתמש בלולאות אימון של Keras

אם אתה לא צריך שליטה ברמה נמוכה של תהליך ההכשרה שלך, באמצעות המובנה של Keras fit , evaluate , וגם predict שיטות מומלצות. שיטות אלה מספקות ממשק אחיד להכשרת המודל ללא קשר ליישום (רציף, פונקציונלי או תת-סיווג).

היתרונות של שיטות אלה כוללים:

הנה דוגמה לאימון מודל באמצעות Dataset . (לפרטים על אופן פעולה זה עיין במדריכים .)

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 [==============================] - 0s 6ms/step - loss: 1.5665 - accuracy: 0.4969
Epoch 2/5
5/5 [==============================] - 0s 6ms/step - loss: 0.5249 - accuracy: 0.8656
Epoch 3/5
5/5 [==============================] - 0s 5ms/step - loss: 0.3246 - accuracy: 0.9438
Epoch 4/5
5/5 [==============================] - 0s 6ms/step - loss: 0.2407 - accuracy: 0.9719
Epoch 5/5
5/5 [==============================] - 0s 5ms/step - loss: 0.1841 - accuracy: 0.9906
5/5 [==============================] - 0s 4ms/step - loss: 1.5957 - accuracy: 0.5375
Loss 1.5956770181655884, Accuracy 0.5375000238418579

כתוב לולאה משלך

אם שלב האימון של מודל Keras עובד בשבילך, אך אתה זקוק לשליטה רבה יותר מחוץ לשלב זה, שקול להשתמש בשיטת tf.keras.Model.train_on_batch , בלולאת איטרציה הנתונים שלך.

זכור: ניתן ליישם דברים רבים כ- tf.keras.callbacks.Callback .

לשיטה זו יתרונות רבים של השיטות שהוזכרו בסעיף הקודם, אך נותנת למשתמש שליטה על הלולאה החיצונית.

אתה יכול גם להשתמש ב- tf.keras.Model.test_on_batch או ב- tf.keras.Model.evaluate כדי לבדוק את הביצועים במהלך האימון.

להמשך אימון המודל הנ"ל:

# Model is the full model w/o custom layers
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

for epoch in range(NUM_EPOCHS):
  #Reset the metric accumulators
  model.reset_metrics()

  for image_batch, label_batch in train_data:
    result = model.train_on_batch(image_batch, label_batch)
    metrics_names = model.metrics_names
    print("train: ",
          "{}: {:.3f}".format(metrics_names[0], result[0]),
          "{}: {:.3f}".format(metrics_names[1], result[1]))
  for image_batch, label_batch in test_data:
    result = model.test_on_batch(image_batch, label_batch,
                                 # return accumulated metrics
                                 reset_metrics=False)
  metrics_names = model.metrics_names
  print("\neval: ",
        "{}: {:.3f}".format(metrics_names[0], result[0]),
        "{}: {:.3f}".format(metrics_names[1], result[1]))
train:  loss: 0.145 accuracy: 1.000
train:  loss: 0.183 accuracy: 0.984
train:  loss: 0.216 accuracy: 0.953
train:  loss: 0.229 accuracy: 0.938
train:  loss: 0.201 accuracy: 0.969

eval:  loss: 1.588 accuracy: 0.628
train:  loss: 0.097 accuracy: 1.000
train:  loss: 0.101 accuracy: 1.000
train:  loss: 0.086 accuracy: 1.000
train:  loss: 0.130 accuracy: 0.984
train:  loss: 0.127 accuracy: 1.000

eval:  loss: 1.580 accuracy: 0.766
train:  loss: 0.086 accuracy: 1.000
train:  loss: 0.081 accuracy: 1.000
train:  loss: 0.079 accuracy: 1.000
train:  loss: 0.076 accuracy: 1.000
train:  loss: 0.077 accuracy: 1.000

eval:  loss: 1.542 accuracy: 0.809
train:  loss: 0.067 accuracy: 1.000
train:  loss: 0.068 accuracy: 1.000
train:  loss: 0.063 accuracy: 1.000
train:  loss: 0.063 accuracy: 1.000
train:  loss: 0.056 accuracy: 1.000

eval:  loss: 1.503 accuracy: 0.816
train:  loss: 0.055 accuracy: 1.000
train:  loss: 0.056 accuracy: 1.000
train:  loss: 0.048 accuracy: 1.000
train:  loss: 0.051 accuracy: 1.000
train:  loss: 0.048 accuracy: 1.000

eval:  loss: 1.482 accuracy: 0.828

התאם אישית את שלב האימון

אם אתה זקוק ליותר גמישות ושליטה, תוכל לקבל את זה על ידי יישום לולאת האימון שלך. ישנם שלושה שלבים:

  1. חזר על פני מחולל פייתון אוtf.data.Dataset כדי לקבל קבוצות של דוגמאות.
  2. השתמש ב-tf.GradientTape כדי לאסוף שיפועים.
  3. השתמש באחד tf.keras.optimizers כדי להחיל עדכוני משקל על המשתנים של המודל.

זכור:

  • כלול תמיד טיעון training על שיטת call של שכבות ומודלים המשויכים לסיווג משנה.
  • הקפד להתקשר למודל עם טיעון training שהוגדר כהלכה.
  • בהתאם לשימוש, ייתכן שמשתני המודל לא קיימים עד שהמודל מופעל על מנת נתונים.
  • אתה צריך לטפל ידנית בדברים כמו הפסדי רגולציה עבור המודל.

שימו לב לפשטות ביחס ל- v1:

  • אין צורך להפעיל אתחול משתנה. משתנים מאותחל בעת היצירה.
  • אין צורך להוסיף תלות בקרה ידנית. אפילו בפעולות 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)
Finished epoch 0
Finished epoch 1
Finished epoch 2
Finished epoch 3
Finished epoch 4

מדדים והפסדים בסגנון חדש

ב- TensorFlow 2.0, מדדים והפסדים הם אובייקטים. אלה פועלים בשקיקה וגם tf.function .

ניתן לקרוא לאובייקט אובדן ומצפה ל (y_true, y_pred) כארגומנטים:

cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
cce([[1, 0]], [[-1.0,3.0]]).numpy()
4.01815

לאובייקט מטרי יש את השיטות הבאות:

האובייקט עצמו ניתן לקריאה. שיחה מעדכנת את המדינה בתצפיות חדשות, כמו עם update_state ומחזירה את התוצאה החדשה של המדד.

אינך צריך לאתחל ידנית את המשתנים של המדד ומכיוון של- TensorFlow 2.0 יש תלות בקרה אוטומטית, אינך צריך לדאוג גם לאלה.

הקוד שלהלן משתמש במדד כדי לעקוב אחר ההפסד הממוצע שנצפה בלולאת אימונים מותאמת אישית.

# 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))
Epoch:  0
  loss:     0.207
  accuracy: 0.991
Epoch:  1
  loss:     0.167
  accuracy: 0.994
Epoch:  2
  loss:     0.147
  accuracy: 0.997
Epoch:  3
  loss:     0.123
  accuracy: 0.997
Epoch:  4
  loss:     0.109
  accuracy: 0.997

שמות מדדיים של קרס

במודלים של Keras ב- TensorFlow 2.0 הם עקביים יותר לגבי טיפול בשמות מדדים.

כעת, כאשר אתה עובר מחרוזת ברשימת המדדים, כי מחרוזת מדויקת משמשת של מטרי 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 [==============================] - 0s 6ms/step - loss: 0.1233 - acc: 0.9937 - accuracy: 0.9937 - my_accuracy: 0.9937

history.history.keys()
dict_keys(['loss', 'acc', 'accuracy', 'my_accuracy'])

זה שונה מגרסאות קודמות שבהן העברת metrics=["accuracy"] תביא ל- dict_keys(['loss', 'acc'])

מיטבי קרס

v1.train האופטימיזציה ב- v1.train , כמו v1.train.AdamOptimizer ו- v1.train.GradientDescentOptimizer , יש שווי ערך ב- tf.keras.optimizers .

המרת v1.train ל- keras.optimizers

להלן דברים שיש לזכור בעת המרת האופטימיזציה שלך:

ברירות מחדל חדשות עבור כמה tf.keras.optimizers

אין שינויים עבור optimizers.SGD optimizers.Adam , optimizers.RMSprop או optimizers.RMSprop .

שיעורי הלמידה המוגדרים כברירת מחדל הבאים השתנו:

TensorBoard

TensorFlow 2 כולל שינויים משמעותיים בממשק ה- API tf.summary המשמש לכתיבת נתוני סיכום להדמיה ב- TensorBoard. לקבלת מבוא כללי ל- tf.summary החדש, קיימות מספר מדריכים הזמינים המשתמשים ב- TF 2 API. זה כולל מדריך הגירה של TensorBoard TF 2

חיסכון וטעינה

תאימות של מחסום

TensorFlow 2.0 משתמש במחסומים מבוססי עצמים .

אם אתה נזהר, עדיין ניתן לטעון מחסומים מבוססי שם ישנים. תהליך המרת הקוד עלול לגרום לשינויים בשמות משתנים, אך ישנם פתרונות לעקיפת הבעיה.

הגישה הפשוטה ביותר להתאים את שמות הדגם החדש לשמות במחסום:

  • למשתנים עדיין יש ארגומנט name שאתה יכול להגדיר.
  • מודלים של Keras לוקחים גם טיעון name לפיו הם קובעים כקידומת למשתנים שלהם.
  • ניתן v1.name_scope בפונקציה v1.name_scope כדי להגדיר קידומות לשם משתנה. זה שונה מאוד מ- tf.variable_scope . זה משפיע רק על שמות ולא עוקב אחר משתנים ושימוש חוזר.

אם זה לא עובד במקרה השימוש שלך, נסה את הפונקציה v1.train.init_from_checkpoint . נדרש טיעון assignment_map , המציין את המיפוי משמות ישנים לשמות חדשים.

המאגר TensorFlow Estimator כולל כלי המרה לשדרוג נקודות הבדיקה לאומדים מוכנים מראש מ- TensorFlow 1.X ל -2.0. זה עשוי לשמש דוגמה כיצד לבנות כלי למקרה שימוש דומה.

תאימות מודלים שמורים

אין חששות תאימות משמעותיים עבור דגמים שמורים.

  • TensorFlow 1.x להציל_מודלים עובדים ב- TensorFlow 2.x.
  • TensorFlow 2.x להציל_מודלים עובדים ב- TensorFlow 1.x - אם כל האופציות נתמכות.

Graph.pb או Graph.pbtxt

אין דרך פשוטה לשדרג קובץ Graph.pb גולמי ל- TensorFlow 2.0. הפתרון הטוב ביותר הוא שדרוג הקוד שיצר את הקובץ.

אבל, אם יש לך "גרף קפוא" (גרף tf.Graph שבו המשתנים הפכו לקבועים), אפשר להמיר זאת v1.wrap_function concrete_function באמצעות v1.wrap_function :

def wrap_frozen_graph(graph_def, inputs, outputs):
  def _imports_graph_def():
    tf.compat.v1.import_graph_def(graph_def, name="")
  wrapped_import = tf.compat.v1.wrap_function(_imports_graph_def, [])
  import_graph = wrapped_import.graph
  return wrapped_import.prune(
      tf.nest.map_structure(import_graph.as_graph_element, inputs),
      tf.nest.map_structure(import_graph.as_graph_element, outputs))

לדוגמה, הנה גרף קפוא ל- Inception v1, משנת 2016:

path = tf.keras.utils.get_file(
    'inception_v1_2016_08_28_frozen.pb',
    'http://storage.googleapis.com/download.tensorflow.org/models/inception_v1_2016_08_28_frozen.pb.tar.gz',
    untar=True)
Downloading data from http://storage.googleapis.com/download.tensorflow.org/models/inception_v1_2016_08_28_frozen.pb.tar.gz
24698880/24695710 [==============================] - 1s 0us/step

טען את ה- tf.GraphDef :

graph_def = tf.compat.v1.GraphDef()
loaded = graph_def.ParseFromString(open(path,'rb').read())

עטוף אותו לתפקוד_ concrete_function :

inception_func = wrap_frozen_graph(
    graph_def, inputs='input:0',
    outputs='InceptionV1/InceptionV1/Mixed_3b/Branch_1/Conv2d_0a_1x1/Relu:0')

העבירו אותו לטנזור כקלט:

input_img = tf.ones([1,224,224,3], dtype=tf.float32)
inception_func(input_img).shape
TensorShape([1, 28, 28, 96])

אומדנים

אימון עם אומדנים

אומדנים נתמכים ב- TensorFlow 2.0.

כאשר אתה משתמש באומדנים, אתה יכול להשתמש ב- input_fn() , tf.estimator.TrainSpec ו- tf.estimator.EvalSpec מ- TensorFlow 1.x.

להלן דוגמא לשימוש ב- input_fn עם input_fn והערכת מפרט.

יצירת מפרט input_fn ורכבות / ערכים

# Define the estimator's input_fn
def input_fn():
  datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
  mnist_train, mnist_test = datasets['train'], datasets['test']

  BUFFER_SIZE = 10000
  BATCH_SIZE = 64

  def scale(image, label):
    image = tf.cast(image, tf.float32)
    image /= 255

    return image, label[..., tf.newaxis]

  train_data = mnist_train.map(scale).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
  return train_data.repeat()

# Define train & eval specs
train_spec = tf.estimator.TrainSpec(input_fn=input_fn,
                                    max_steps=STEPS_PER_EPOCH * NUM_EPOCHS)
eval_spec = tf.estimator.EvalSpec(input_fn=input_fn,
                                  steps=STEPS_PER_EPOCH)

באמצעות הגדרת מודל Keras

ישנם כמה הבדלים כיצד לבנות את האומדנים שלך ב- TensorFlow 2.0.

אנו ממליצים לך להגדיר את המודל שלך באמצעות Keras, ואז להשתמש tf.keras.estimator.model_to_estimator השירות tf.keras.estimator.model_to_estimator כדי להפוך את המודל שלך לאומדן. הקוד שלהלן מראה כיצד להשתמש בכלי השירות הזה בעת יצירה והדרכה של אומדן.

def make_model():
  return 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 = make_model()

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

estimator = tf.keras.estimator.model_to_estimator(
  keras_model = model
)

tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
INFO:tensorflow:Using default config.

INFO:tensorflow:Using default config.

Warning:tensorflow:Using temporary folder as model directory: /tmp/tmp333woaev

Warning:tensorflow:Using temporary folder as model directory: /tmp/tmp333woaev

INFO:tensorflow:Using the Keras model provided.

INFO:tensorflow:Using the Keras model provided.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_estimator/python/estimator/keras.py:220: set_learning_phase (from tensorflow.python.keras.backend) is deprecated and will be removed after 2020-10-11.
Instructions for updating:
Simply pass a True/False value to the `training` argument of the `__call__` method of your layer or model.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_estimator/python/estimator/keras.py:220: set_learning_phase (from tensorflow.python.keras.backend) is deprecated and will be removed after 2020-10-11.
Instructions for updating:
Simply pass a True/False value to the `training` argument of the `__call__` method of your layer or model.

INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp333woaev', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp333woaev', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

INFO:tensorflow:Not using Distribute Coordinator.

INFO:tensorflow:Not using Distribute Coordinator.

INFO:tensorflow:Running training and evaluation locally (non-distributed).

INFO:tensorflow:Running training and evaluation locally (non-distributed).

INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.

INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Warm-starting with WarmStartSettings: WarmStartSettings(ckpt_to_initialize_from='/tmp/tmp333woaev/keras/keras_model.ckpt', vars_to_warm_start='.*', var_name_to_vocab_info={}, var_name_to_prev_var_name={})

INFO:tensorflow:Warm-starting with WarmStartSettings: WarmStartSettings(ckpt_to_initialize_from='/tmp/tmp333woaev/keras/keras_model.ckpt', vars_to_warm_start='.*', var_name_to_vocab_info={}, var_name_to_prev_var_name={})

INFO:tensorflow:Warm-starting from: /tmp/tmp333woaev/keras/keras_model.ckpt

INFO:tensorflow:Warm-starting from: /tmp/tmp333woaev/keras/keras_model.ckpt

INFO:tensorflow:Warm-starting variables only in TRAINABLE_VARIABLES.

INFO:tensorflow:Warm-starting variables only in TRAINABLE_VARIABLES.

INFO:tensorflow:Warm-started 8 variables.

INFO:tensorflow:Warm-started 8 variables.

INFO:tensorflow:Create CheckpointSaverHook.

INFO:tensorflow:Create CheckpointSaverHook.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...

INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp333woaev/model.ckpt.

INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp333woaev/model.ckpt.

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:loss = 2.946777, step = 0

INFO:tensorflow:loss = 2.946777, step = 0

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmp333woaev/model.ckpt.

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmp333woaev/model.ckpt.

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Calling model_fn.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/engine/training_v1.py:2048: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/engine/training_v1.py:2048: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Starting evaluation at 2020-10-15T01:27:37Z

INFO:tensorflow:Starting evaluation at 2020-10-15T01:27:37Z

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Restoring parameters from /tmp/tmp333woaev/model.ckpt-25

INFO:tensorflow:Restoring parameters from /tmp/tmp333woaev/model.ckpt-25

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Evaluation [1/5]

INFO:tensorflow:Evaluation [1/5]

INFO:tensorflow:Evaluation [2/5]

INFO:tensorflow:Evaluation [2/5]

INFO:tensorflow:Evaluation [3/5]

INFO:tensorflow:Evaluation [3/5]

INFO:tensorflow:Evaluation [4/5]

INFO:tensorflow:Evaluation [4/5]

INFO:tensorflow:Evaluation [5/5]

INFO:tensorflow:Evaluation [5/5]

INFO:tensorflow:Inference Time : 0.84716s

INFO:tensorflow:Inference Time : 0.84716s

INFO:tensorflow:Finished evaluation at 2020-10-15-01:27:38

INFO:tensorflow:Finished evaluation at 2020-10-15-01:27:38

INFO:tensorflow:Saving dict for global step 25: accuracy = 0.715625, global_step = 25, loss = 1.5356585

INFO:tensorflow:Saving dict for global step 25: accuracy = 0.715625, global_step = 25, loss = 1.5356585

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp333woaev/model.ckpt-25

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp333woaev/model.ckpt-25

INFO:tensorflow:Loss for final step: 0.52498615.

INFO:tensorflow:Loss for final step: 0.52498615.

({'accuracy': 0.715625, 'loss': 1.5356585, 'global_step': 25}, [])

באמצעות model_fn מותאם אישית

אם יש לך model_fn מותאם אישית קיים שעליך לתחזק, תוכל להמיר את model_fn שלך לשימוש במודל Keras.

עם זאת, מסיבות תאימות, model_fn מותאם אישית עדיין יפעל במצב גרף בסגנון 1.x. המשמעות היא שאין ביצוע להוט ואין תלות בקרה אוטומטית.

Model_fn מותאם אישית עם שינויים מינימליים

כדי לגרום model_fn המותאם אישית שלך לעבוד ב- TF 2.0, אם אתה מעדיף שינויים מינימליים בקוד הקיים, ניתן tf.compat.v1 בסמלים tf.compat.v1 כגון optimizers metrics .

שימוש במודלים של model_fn דומה לשימוש בו בלולאת אימון מותאמת אישית:

  • הגדר את שלב training כראוי, בהתבסס על טיעון mode .
  • העבר במפורש את trainable_variables למודל למיטוב.

אך ישנם הבדלים חשובים ביחס לולאה מותאמת אישית :

  • במקום להשתמש ב- Model.losses , הוצא את ההפסדים באמצעות Model.get_losses_for .
  • חלץ את עדכוני המודל באמצעות Model.get_updates_for .

הקוד הבא יוצר אומדן model_fn מותאם אישית, וממחיש את כל החששות הללו.

def my_model_fn(features, labels, mode):
  model = make_model()

  optimizer = tf.compat.v1.train.AdamOptimizer()
  loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

  training = (mode == tf.estimator.ModeKeys.TRAIN)
  predictions = model(features, training=training)

  if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

  reg_losses = model.get_losses_for(None) + model.get_losses_for(features)
  total_loss=loss_fn(labels, predictions) + tf.math.add_n(reg_losses)

  accuracy = tf.compat.v1.metrics.accuracy(labels=labels,
                                           predictions=tf.math.argmax(predictions, axis=1),
                                           name='acc_op')

  update_ops = model.get_updates_for(None) + model.get_updates_for(features)
  minimize_op = optimizer.minimize(
      total_loss,
      var_list=model.trainable_variables,
      global_step=tf.compat.v1.train.get_or_create_global_step())
  train_op = tf.group(minimize_op, update_ops)

  return tf.estimator.EstimatorSpec(
    mode=mode,
    predictions=predictions,
    loss=total_loss,
    train_op=train_op, eval_metric_ops={'accuracy': accuracy})

# Create the Estimator & Train
estimator = tf.estimator.Estimator(model_fn=my_model_fn)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
INFO:tensorflow:Using default config.

INFO:tensorflow:Using default config.

Warning:tensorflow:Using temporary folder as model directory: /tmp/tmpnhx_c2r_

Warning:tensorflow:Using temporary folder as model directory: /tmp/tmpnhx_c2r_

INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpnhx_c2r_', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpnhx_c2r_', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

INFO:tensorflow:Not using Distribute Coordinator.

INFO:tensorflow:Not using Distribute Coordinator.

INFO:tensorflow:Running training and evaluation locally (non-distributed).

INFO:tensorflow:Running training and evaluation locally (non-distributed).

INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.

INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Create CheckpointSaverHook.

INFO:tensorflow:Create CheckpointSaverHook.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...

INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpnhx_c2r_/model.ckpt.

INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpnhx_c2r_/model.ckpt.

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:loss = 2.7539256, step = 0

INFO:tensorflow:loss = 2.7539256, step = 0

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpnhx_c2r_/model.ckpt.

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpnhx_c2r_/model.ckpt.

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Starting evaluation at 2020-10-15T01:27:41Z

INFO:tensorflow:Starting evaluation at 2020-10-15T01:27:41Z

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Restoring parameters from /tmp/tmpnhx_c2r_/model.ckpt-25

INFO:tensorflow:Restoring parameters from /tmp/tmpnhx_c2r_/model.ckpt-25

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Evaluation [1/5]

INFO:tensorflow:Evaluation [1/5]

INFO:tensorflow:Evaluation [2/5]

INFO:tensorflow:Evaluation [2/5]

INFO:tensorflow:Evaluation [3/5]

INFO:tensorflow:Evaluation [3/5]

INFO:tensorflow:Evaluation [4/5]

INFO:tensorflow:Evaluation [4/5]

INFO:tensorflow:Evaluation [5/5]

INFO:tensorflow:Evaluation [5/5]

INFO:tensorflow:Inference Time : 0.94175s

INFO:tensorflow:Inference Time : 0.94175s

INFO:tensorflow:Finished evaluation at 2020-10-15-01:27:42

INFO:tensorflow:Finished evaluation at 2020-10-15-01:27:42

INFO:tensorflow:Saving dict for global step 25: accuracy = 0.678125, global_step = 25, loss = 1.5622549

INFO:tensorflow:Saving dict for global step 25: accuracy = 0.678125, global_step = 25, loss = 1.5622549

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpnhx_c2r_/model.ckpt-25

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpnhx_c2r_/model.ckpt-25

INFO:tensorflow:Loss for final step: 0.39462265.

INFO:tensorflow:Loss for final step: 0.39462265.

({'accuracy': 0.678125, 'loss': 1.5622549, 'global_step': 25}, [])

model_fn מותאם אישית עם סמלי TF 2.0

אם אתה רוצה להיפטר מכל סמלי TF 1.x ולשדרג את model_fn המותאם אישית שלך ל- TF 2.0 model_fn , עליך לעדכן את האופטימיזציה והמדדים ל- tf.keras.optimizers ו- tf.keras.metrics .

model_fn המותאם אישית, מלבד השינויים לעיל, יש לבצע שדרוגים נוספים:

לדוגמא של my_model_fn לעיל, הקוד שהועבר עם סמלי 2.0 מוצג כ:

def my_model_fn(features, labels, mode):
  model = make_model()

  training = (mode == tf.estimator.ModeKeys.TRAIN)
  loss_obj = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
  predictions = model(features, training=training)

  # Get both the unconditional losses (the None part)
  # and the input-conditional losses (the features part).
  reg_losses = model.get_losses_for(None) + model.get_losses_for(features)
  total_loss=loss_obj(labels, predictions) + tf.math.add_n(reg_losses)

  # Upgrade to tf.keras.metrics.
  accuracy_obj = tf.keras.metrics.Accuracy(name='acc_obj')
  accuracy = accuracy_obj.update_state(
      y_true=labels, y_pred=tf.math.argmax(predictions, axis=1))

  train_op = None
  if training:
    # Upgrade to tf.keras.optimizers.
    optimizer = tf.keras.optimizers.Adam()
    # Manually assign tf.compat.v1.global_step variable to optimizer.iterations
    # to make tf.compat.v1.train.global_step increased correctly.
    # This assignment is a must for any `tf.train.SessionRunHook` specified in
    # estimator, as SessionRunHooks rely on global step.
    optimizer.iterations = tf.compat.v1.train.get_or_create_global_step()
    # Get both the unconditional updates (the None part)
    # and the input-conditional updates (the features part).
    update_ops = model.get_updates_for(None) + model.get_updates_for(features)
    # Compute the minimize_op.
    minimize_op = optimizer.get_updates(
        total_loss,
        model.trainable_variables)[0]
    train_op = tf.group(minimize_op, *update_ops)

  return tf.estimator.EstimatorSpec(
    mode=mode,
    predictions=predictions,
    loss=total_loss,
    train_op=train_op,
    eval_metric_ops={'Accuracy': accuracy_obj})

# Create the Estimator & Train.
estimator = tf.estimator.Estimator(model_fn=my_model_fn)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
INFO:tensorflow:Using default config.

INFO:tensorflow:Using default config.

Warning:tensorflow:Using temporary folder as model directory: /tmp/tmp3kddt__h

Warning:tensorflow:Using temporary folder as model directory: /tmp/tmp3kddt__h

INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp3kddt__h', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp3kddt__h', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

INFO:tensorflow:Not using Distribute Coordinator.

INFO:tensorflow:Not using Distribute Coordinator.

INFO:tensorflow:Running training and evaluation locally (non-distributed).

INFO:tensorflow:Running training and evaluation locally (non-distributed).

INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.

INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Create CheckpointSaverHook.

INFO:tensorflow:Create CheckpointSaverHook.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...

INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp3kddt__h/model.ckpt.

INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp3kddt__h/model.ckpt.

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...

INFO:tensorflow:loss = 2.4914804, step = 0

INFO:tensorflow:loss = 2.4914804, step = 0

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...

INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmp3kddt__h/model.ckpt.

INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmp3kddt__h/model.ckpt.

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...

INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Done calling model_fn.

INFO:tensorflow:Starting evaluation at 2020-10-15T01:27:45Z

INFO:tensorflow:Starting evaluation at 2020-10-15T01:27:45Z

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Graph was finalized.

INFO:tensorflow:Restoring parameters from /tmp/tmp3kddt__h/model.ckpt-25

INFO:tensorflow:Restoring parameters from /tmp/tmp3kddt__h/model.ckpt-25

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Done running local_init_op.

INFO:tensorflow:Evaluation [1/5]

INFO:tensorflow:Evaluation [1/5]

INFO:tensorflow:Evaluation [2/5]

INFO:tensorflow:Evaluation [2/5]

INFO:tensorflow:Evaluation [3/5]

INFO:tensorflow:Evaluation [3/5]

INFO:tensorflow:Evaluation [4/5]

INFO:tensorflow:Evaluation [4/5]

INFO:tensorflow:Evaluation [5/5]

INFO:tensorflow:Evaluation [5/5]

INFO:tensorflow:Inference Time : 0.91708s

INFO:tensorflow:Inference Time : 0.91708s

INFO:tensorflow:Finished evaluation at 2020-10-15-01:27:46

INFO:tensorflow:Finished evaluation at 2020-10-15-01:27:46

INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.690625, global_step = 25, loss = 1.554177

INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.690625, global_step = 25, loss = 1.554177

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp3kddt__h/model.ckpt-25

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp3kddt__h/model.ckpt-25

INFO:tensorflow:Loss for final step: 0.3999393.

INFO:tensorflow:Loss for final step: 0.3999393.

({'Accuracy': 0.690625, 'loss': 1.554177, 'global_step': 25}, [])

אומדנים מוכנים מראש

אומדנים מוקדמים במשפחה של tf.estimator.DNN* , tf.estimator.Linear* ו- tf.estimator.DNNLinearCombined* עדיין נתמכים בממשק ה- API של TensorFlow 2.0, עם זאת, כמה טיעונים השתנו:

  1. input_layer_partitioner : הוסר ב 2.0.
  2. loss_reduction : עודכן ל- tf.keras.losses.Reduction במקום tf.compat.v1.losses.Reduction . ערך ברירת המחדל שלה שונה גם ל- tf.keras.losses.Reduction.SUM_OVER_BATCH_SIZE מ- tf.compat.v1.losses.Reduction.SUM .
  3. optimizer , dnn_optimizer ו- linear_optimizer : linear_optimizer זה עודכן ל- tf.keras.optimizers במקום ל- tf.compat.v1.train.Optimizer .

כדי להעביר את השינויים הנ"ל:

  1. אין צורך input_layer_partitioner עבור input_layer_partitioner מכיוון input_layer_partitioner Distribution Strategy תטפל בה באופן אוטומטי ב- TF 2.0.
  2. לקבלת loss_reduction , בדוק את האפשרויות הנתמכות ב- tf.keras.losses.Reduction .
  3. עבור ארגומנטים של optimizer , אם אינך מעביר optimizer , dnn_optimizer או linear_optimizer arg, או אם אתה מציין את arg optimizer string בקוד שלך, אינך צריך לשנות דבר. tf.keras.optimizers משמש כברירת מחדל. אחרת, עליך לעדכן אותו מ- tf.compat.v1.train.Optimizer ל- tf.keras.optimizers המתאים tf.keras.optimizers

ממיר מחסום

המעבר ל- keras.optimizers ישבור נקודות מחסום שנשמרו באמצעות TF 1.x, מכיוון tf.keras.optimizers מייצר קבוצה שונה של משתנים שיש לשמור במחסומים. כדי להפוך את המחסום הישן לשימוש חוזר לאחר המעבר ל- TF 2.0, נסה את כלי ממיר המחסום .

 curl -O https://raw.githubusercontent.com/tensorflow/estimator/master/tensorflow_estimator/python/estimator/tools/checkpoint_converter.py
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 15165  100 15165    0     0  32265      0 --:--:-- --:--:-- --:--:-- 32197

הכלי כולל עזרה מובנית:

 python checkpoint_converter.py -h
2020-10-15 01:27:47.423752: I tensorflow/stream_executor/platform/default/dso_loader.cc:48] Successfully opened dynamic library libcudart.so.10.1
usage: checkpoint_converter.py [-h]
                               {dnn,linear,combined} source_checkpoint
                               source_graph target_checkpoint

positional arguments:
  {dnn,linear,combined}
                        The type of estimator to be converted. So far, the
                        checkpoint converter only supports Canned Estimator.
                        So the allowed types include linear, dnn and combined.
  source_checkpoint     Path to source checkpoint file to be read in.
  source_graph          Path to source graph file to be read in.
  target_checkpoint     Path to checkpoint file to be written out.

optional arguments:
  -h, --help            show this help message and exit

TensorShape

מחלקה זו הייתה פשוטה יותר להחזיק int s, במקום אובייקטים tf.compat.v1.Dimension . אז אין צורך להתקשר ל- .value() כדי לקבל int .

אובייקטים tf.compat.v1.Dimension בודדים עדיין נגישים מ- tf.TensorShape.dims .

להלן מדגימים את ההבדלים בין TensorFlow 1.x ל- TensorFlow 2.0.

# Create a shape and choose an index
i = 0
shape = tf.TensorShape([16, None, 256])
shape
TensorShape([16, None, 256])

אם היה לך את זה ב- TF 1.x:

value = shape[i].value

ואז בצע זאת ב- TF 2.0:

value = shape[i]
value
16

אם היה לך את זה ב- TF 1.x:

for dim in shape:
    value = dim.value
    print(value)

ואז בצע זאת ב- TF 2.0:

for value in shape:
  print(value)
16
None
256

אם היה לך את זה ב- TF 1.x (או השתמשת בכל שיטת מימד אחרת):

dim = shape[i]
dim.assert_is_compatible_with(other_dim)

ואז בצע זאת ב- TF 2.0:

other_dim = 16
Dimension = tf.compat.v1.Dimension

if shape.rank is None:
  dim = Dimension(None)
else:
  dim = shape.dims[i]
dim.is_compatible_with(other_dim) # or any other dimension method
True
shape = tf.TensorShape(None)

if shape:
  dim = shape.dims[i]
  dim.is_compatible_with(other_dim) # or any other dimension method

הערך בוליאני של tf.TensorShape הוא True אם בדרגה ידוע, False אחר.

print(bool(tf.TensorShape([])))      # Scalar
print(bool(tf.TensorShape([0])))     # 0-length vector
print(bool(tf.TensorShape([1])))     # 1-length vector
print(bool(tf.TensorShape([None])))  # Unknown-length vector
print(bool(tf.TensorShape([1, 10, 100])))       # 3D tensor
print(bool(tf.TensorShape([None, None, None]))) # 3D tensor with no known dimensions
print()
print(bool(tf.TensorShape(None)))  # A tensor with unknown rank.
True
True
True
True
True
True

False

שינויים אחרים

  • הסר את tf.colocate_with : אלגוריתמי מיקום המכשירים של TensorFlow השתפרו משמעותית. זה כבר לא צריך להיות נחוץ. אם הסרתו גורמת להשפלת ביצועים אנא הגיש באג .

  • החלף את v1.ConfigProto עם הפונקציות המקבילות מ- tf.config .

מסקנות

התהליך הכולל הוא:

  1. הפעל את סקריפט השדרוג.
  2. הסר סמלי תרומות.
  3. החלף את הדגמים שלך לסגנון מונחה עצמים (Keras).
  4. השתמש tf.keras הכשרה והערכה של tf.keras או tf.estimator היכן שאתה יכול.
  5. אחרת, השתמש בלולאות מותאמות אישית, אך הקפד להימנע מהפעלות ואוספים.

צריך מעט עבודה כדי להמיר קוד ל- TensorFlow 2.0 האידיומטי, אך כל שינוי מביא ל:

  • פחות שורות קוד.
  • בהירות ופשטות מוגברים.
  • איתור באגים קל יותר.