לשמור את התאריך! קלט / פלט של Google חוזר 18-20 במאי הירשם עכשיו
דף זה תורגם על ידי Cloud Translation API.
Switch to English

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

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

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

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

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

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

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

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

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

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

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

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

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

    • זה עשוי לשנות את ההתנהגות במקרי קצה.
    • זה עשוי ליצור עותקים נוספים ויכולים להשתמש בזיכרון גבוה יותר.
    • ניתן להשבית את זה על ידי העברת use_resource=False tf.Variable .

  • צורות טנסור, v1.enable_v2_tensorshape() : TensorFlow 2.x מפשט את ההתנהגות של צורות טנסור. במקום t.shape[0].value אתה יכול לומר t.shape[0] . השינויים האלה צריכים להיות קטנים, והגיוני לתקן אותם מיד. עיין בסעיף TensorShape לדוגמאות.

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

צור קוד עבור TensorFlow 2.x

מדריך זה יעבור על כמה דוגמאות להמרת קוד TensorFlow 1.x ל- TensorFlow 2.x. שינויים אלה יאפשרו לקוד שלך לנצל אופטימיזציות ביצועים ושיחות 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. השתמש באובייקטים של פייתון כדי לעקוב אחר משתנים והפסדים

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

השתמש ב- 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 המלא, עם הסמנטיקה המקורית שלו.

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

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

המרת דגמים

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

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

  • שימוש בהיקפים משתנים לבקרת שימוש חוזר.
  • יצירת משתנים עם v1.get_variable .
  • גישה לאוספים במפורש.

  • גישה לאוספים באופן מרומז בשיטות כמו:

  • באמצעות v1.placeholder תשומות גרף.

  • ביצוע גרפים עם Session.run .

  • אתחול משתנים באופן ידני.

לפני גיור

הנה איך דפוסים אלה עשויים להיראות בקוד באמצעות 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 כדי להגדיר 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)

/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/convolutional.py:414: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
  warnings.warn('`tf.layers.conv2d` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/engine/base_layer.py:2273: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.
  warnings.warn('`layer.apply` is deprecated and '
tf.Tensor([[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]], shape=(1, 10), dtype=float32)

tf.Tensor(
[[ 0.379358   -0.55901194  0.48704922  0.11619566  0.23902717  0.01691487
   0.07227738  0.14556988  0.2459927   0.2501198 ]], shape=(1, 10), dtype=float32)
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/pooling.py:310: UserWarning: `tf.layers.max_pooling2d` is deprecated and will be removed in a future version. Please use `tf.keras.layers.MaxPooling2D` instead.
  warnings.warn('`tf.layers.max_pooling2d` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/core.py:329: UserWarning: `tf.layers.flatten` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Flatten` instead.
  warnings.warn('`tf.layers.flatten` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/core.py:268: UserWarning: `tf.layers.dropout` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dropout` instead.
  warnings.warn('`tf.layers.dropout` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/core.py:171: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
  warnings.warn('`tf.layers.dense` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/normalization.py:308: UserWarning: `tf.layers.batch_normalization` is deprecated and will be removed in a future version. Please use `tf.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.layers.batch_normalization` is deprecated and '

לאחר המרה

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

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

שימו לב גם כי:

  • אם אתה משתמש 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.2145557  -0.22979769 -0.14968733  0.01208701 -0.07569927  0.3475932
   0.10718458  0.03482988 -0.04309493 -0.10469118]], 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.08174552>]

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

קוד קיים לעתים קרובות מערבב משתנים ופעולות של TensorFlow 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 או ב- Model.build באמצעות `self.add_weight:

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

  • אל תשמור tf.Tensors באובייקטים שלך:

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

הערה על שכבות דקיקות ותרומות

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

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

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

הַדְרָכָה

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

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

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

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

חבילת מערכי הנתונים 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 [==============================] - 1s 9ms/step - loss: 2.0191 - accuracy: 0.3608
Epoch 2/5
5/5 [==============================] - 0s 9ms/step - loss: 0.4736 - accuracy: 0.9059
Epoch 3/5
5/5 [==============================] - 0s 8ms/step - loss: 0.2973 - accuracy: 0.9626
Epoch 4/5
5/5 [==============================] - 0s 9ms/step - loss: 0.2108 - accuracy: 0.9911
Epoch 5/5
5/5 [==============================] - 0s 8ms/step - loss: 0.1791 - accuracy: 0.9874
5/5 [==============================] - 0s 6ms/step - loss: 1.5504 - accuracy: 0.7500
Loss 1.5504140853881836, Accuracy 0.75

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

אם שלב האימון של מודל 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.138 accuracy: 1.000
train:  loss: 0.161 accuracy: 1.000
train:  loss: 0.159 accuracy: 0.969
train:  loss: 0.241 accuracy: 0.953
train:  loss: 0.172 accuracy: 0.969

eval:  loss: 1.550 accuracy: 0.800
train:  loss: 0.086 accuracy: 1.000
train:  loss: 0.094 accuracy: 1.000
train:  loss: 0.090 accuracy: 1.000
train:  loss: 0.119 accuracy: 0.984
train:  loss: 0.099 accuracy: 1.000

eval:  loss: 1.558 accuracy: 0.841
train:  loss: 0.076 accuracy: 1.000
train:  loss: 0.068 accuracy: 1.000
train:  loss: 0.061 accuracy: 1.000
train:  loss: 0.076 accuracy: 1.000
train:  loss: 0.076 accuracy: 1.000

eval:  loss: 1.536 accuracy: 0.841
train:  loss: 0.059 accuracy: 1.000
train:  loss: 0.056 accuracy: 1.000
train:  loss: 0.058 accuracy: 1.000
train:  loss: 0.054 accuracy: 1.000
train:  loss: 0.055 accuracy: 1.000

eval:  loss: 1.497 accuracy: 0.863
train:  loss: 0.053 accuracy: 1.000
train:  loss: 0.049 accuracy: 1.000
train:  loss: 0.044 accuracy: 1.000
train:  loss: 0.049 accuracy: 1.000
train:  loss: 0.045 accuracy: 1.000

eval:  loss: 1.463 accuracy: 0.878

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

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

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

זכור:

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

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

  • אין צורך להפעיל אתחול משתנה. משתנים מאותחלים בעת היצירה.
  • אין צורך להוסיף תלות בקרה ידנית. אפילו ב- tf.function פעולות 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.x, מדדים והפסדים הם אובייקטים. אלה עובדים בשקיקה 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.x יש תלות בקרה אוטומטית, אינך צריך לדאוג גם לאלה.

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

# 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.139
  accuracy: 0.997
Epoch:  1
  loss:     0.116
  accuracy: 1.000
Epoch:  2
  loss:     0.105
  accuracy: 0.997
Epoch:  3
  loss:     0.089
  accuracy: 1.000
Epoch:  4
  loss:     0.078
  accuracy: 1.000

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

ב- TensorFlow 2.x, מודלים של 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 8ms/step - loss: 0.0901 - acc: 0.9923 - accuracy: 0.9923 - my_accuracy: 0.9923

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.x כולל שינויים משמעותיים בממשק ה- API tf.summary המשמש לכתיבת נתוני סיכום להדמיה ב- TensorBoard. לקבלת מבוא כללי ל- tf.summary החדש, ישנם מספר מדריכים זמינים המשתמשים ב- TensorFlow 2.x API. זה כולל מדריך הגירה של TensorBoard TensorFlow 2.x.

שמירה וטעינה

תאימות מחסום

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

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

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

  • למשתנים עדיין יש ארגומנט 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.x. הפתרון הטוב ביותר שלך הוא לשדרג את הקוד שיצר את הקובץ.

אבל אם יש לך "גרף קפוא" ( 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.x.

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

הנה דוגמה לשימוש ב- 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 and 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.x.

מומלץ להגדיר את המודל שלך באמצעות 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/tmp0erq3im2
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmp0erq3im2
INFO:tensorflow:Using the Keras model provided.
INFO:tensorflow:Using the Keras model provided.
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/backend.py:434: UserWarning: `tf.keras.backend.set_learning_phase` is deprecated and will be removed after 2020-10-11. To update it, simply pass a True/False value to the `training` argument of the `__call__` method of your layer or model.
  warnings.warn('`tf.keras.backend.set_learning_phase` is deprecated and '
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp0erq3im2', '_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, '_checkpoint_save_graph_def': True, '_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/tmp0erq3im2', '_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, '_checkpoint_save_graph_def': True, '_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/tmp0erq3im2/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/tmp0erq3im2/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/tmp0erq3im2/keras/keras_model.ckpt
INFO:tensorflow:Warm-starting from: /tmp/tmp0erq3im2/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/tmp0erq3im2/model.ckpt.
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp0erq3im2/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 2.4717796, step = 0
INFO:tensorflow:loss = 2.4717796, 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/tmp0erq3im2/model.ckpt.
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmp0erq3im2/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.
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/engine/training.py:2325: UserWarning: `Model.state_updates` will be removed in a future version. This property should not be used in TensorFlow 2.0, as `updates` are applied automatically.
  warnings.warn('`Model.state_updates` will be removed in a future version. '
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:17Z
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:17Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmp0erq3im2/model.ckpt-25
INFO:tensorflow:Restoring parameters from /tmp/tmp0erq3im2/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.86556s
INFO:tensorflow:Inference Time : 0.86556s
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:18
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:18
INFO:tensorflow:Saving dict for global step 25: accuracy = 0.6, global_step = 25, loss = 1.6160676
INFO:tensorflow:Saving dict for global step 25: accuracy = 0.6, global_step = 25, loss = 1.6160676
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp0erq3im2/model.ckpt-25
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp0erq3im2/model.ckpt-25
INFO:tensorflow:Loss for final step: 0.37597787.
INFO:tensorflow:Loss for final step: 0.37597787.
({'accuracy': 0.6, 'loss': 1.6160676, 'global_step': 25}, [])

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

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

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

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

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

שימוש במודל Keras במודל_ 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/tmpifj8mysl
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpifj8mysl
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpifj8mysl', '_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, '_checkpoint_save_graph_def': True, '_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/tmpifj8mysl', '_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, '_checkpoint_save_graph_def': True, '_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/tmpifj8mysl/model.ckpt.
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpifj8mysl/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 3.0136237, step = 0
INFO:tensorflow:loss = 3.0136237, 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/tmpifj8mysl/model.ckpt.
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpifj8mysl/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 2021-01-06T02:31:20Z
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:20Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpifj8mysl/model.ckpt-25
INFO:tensorflow:Restoring parameters from /tmp/tmpifj8mysl/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.97406s
INFO:tensorflow:Inference Time : 0.97406s
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:21
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:21
INFO:tensorflow:Saving dict for global step 25: accuracy = 0.59375, global_step = 25, loss = 1.6248872
INFO:tensorflow:Saving dict for global step 25: accuracy = 0.59375, global_step = 25, loss = 1.6248872
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpifj8mysl/model.ckpt-25
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpifj8mysl/model.ckpt-25
INFO:tensorflow:Loss for final step: 0.35726172.
INFO:tensorflow:Loss for final step: 0.35726172.
({'accuracy': 0.59375, 'loss': 1.6248872, 'global_step': 25}, [])

model_fn מותאם אישית עם סמלי TensorFlow 2.x

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

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

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

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 and 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/tmpc93qfnv6
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpc93qfnv6
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpc93qfnv6', '_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, '_checkpoint_save_graph_def': True, '_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/tmpc93qfnv6', '_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, '_checkpoint_save_graph_def': True, '_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/tmpc93qfnv6/model.ckpt.
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpc93qfnv6/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 2.5293791, step = 0
INFO:tensorflow:loss = 2.5293791, 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/tmpc93qfnv6/model.ckpt.
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpc93qfnv6/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 2021-01-06T02:31:24Z
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:24Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpc93qfnv6/model.ckpt-25
INFO:tensorflow:Restoring parameters from /tmp/tmpc93qfnv6/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.86534s
INFO:tensorflow:Inference Time : 0.86534s
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:25
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:25
INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.59375, global_step = 25, loss = 1.7570661
INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.59375, global_step = 25, loss = 1.7570661
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpc93qfnv6/model.ckpt-25
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpc93qfnv6/model.ckpt-25
INFO:tensorflow:Loss for final step: 0.47094986.
INFO:tensorflow:Loss for final step: 0.47094986.
({'Accuracy': 0.59375, 'loss': 1.7570661, 'global_step': 25}, [])

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

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

  1. input_layer_partitioner : הוסר ב- v2.
  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 : טענה זו עודכנה ל- tf.keras.optimizers במקום ל- tf.compat.v1.train.Optimizer .

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

  1. אין צורך input_layer_partitioner עבור input_layer_partitioner מכיוון input_layer_partitioner Distribution Strategy תטפל בה באופן אוטומטי ב- TensorFlow 2.x.
  2. לקבלת loss_reduction , בדוק את האפשרויות הנתמכות ב- tf.keras.losses.Reduction .
  3. לוויכוחים optimizer :

ממיר מחסום

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

 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  40656      0 --:--:-- --:--:-- --:--:-- 40656

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

 python checkpoint_converter.py -h

2021-01-06 02:31:26.297951: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.11.0
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.x.

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

TensorShape([16, None, 256])

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

value = shape[i].value

ואז עשה זאת ב- TensorFlow 2.x:

value = shape[i]
value

16

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

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

ואז עשה זאת ב- TensorFlow 2.x:

for value in shape:
  print(value)

16
None
256

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

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

ואז עשה זאת ב- TensorFlow 2.x:

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.x אידיומטי, אך כל שינוי מביא ל:

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