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

מדריך זה מיועד למשתמשים בממשקי 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.global_variables
- v1.losses.get_regularization_loss
באמצעות 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 '

לאחר המרה

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

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

טיעון 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)

# 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.keras.applications TensorFlow 2.x SavedModels של TF Hub המיוצאים מהקוד Slim המקורי.

ייתכן tf.contrib שכבות 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 שיטות מומלצות. שיטות אלה מספקות ממשק אחיד להכשרת המודל ללא קשר ליישום (רציף, פונקציונלי או תת-סיווג).

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

הם מקבלים מערכים Numpy, מחוללי פייתון ו- tf.data.Datasets .
הם מיישמים רגולציה והפסדי הפעלה באופן אוטומטי.
הם תומכים ב- tf.distribute מרובת מכשירים .
הם תומכים בפריטי שרירות שרירותיים כהפסדים וערכים.
הם תומכים tf.keras.callbacks.TensorBoard חוזרות כמו tf.keras.callbacks.TensorBoard , tf.keras.callbacks.TensorBoard חוזרות בהתאמה אישית.
הם מבצעים ביצועים אוטומטיים באמצעות גרפים של TensorFlow.

הנה דוגמה לאימון מודל באמצעות 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

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

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

חזר על פני מחולל פייתון אוtf.data.Dataset כדי לקבל קבוצות של דוגמאות.
השתמש ב-tf.GradientTape כדי לאסוף שיפועים.
השתמש באחד 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.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

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

Metric.update_state() : הוסף תצפיות חדשות.
Metric.result() : קבל את התוצאה הנוכחית של המדד, בהתחשב בערכים שנצפו.
Metric.reset_states() : נקה את כל התצפיות.

האובייקט עצמו ניתן לקריאה. שיחה מעדכנת את המדינה בתצפיות חדשות, כמו עם 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`

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

שדרוג האופטימיזציה שלך עשוי לגרום למחסומים ישנים להיות בלתי תואמים .
כעת כל אפסילונים הם ברירת המחדל ל- 1e-7 במקום ל- 1e-8 (וזה זניח ברוב מקרי השימוש).
v1.train.GradientDescentOptimizer יכול להיות מוחלף ישירות על ידי tf.keras.optimizers.SGD .
v1.train.MomentumOptimizer ניתן להחליף ישירות על ידי האופטימיזציה של SGD באמצעות ארגומנט המומנטום: tf.keras.optimizers.SGD(..., momentum=...) .
v1.train.AdamOptimizer ניתן להמיר לשימוש tf.keras.optimizers.Adam . beta1 ו beta2 ויכוחים קיבלו שם כדי beta_1 ו beta_2 .
v1.train.RMSPropOptimizer ניתן להמיר ל- tf.keras.optimizers.RMSprop . שמו של טיעון decay שונה ל- rho .
v1.train.AdadeltaOptimizer ניתן להמיר ישירות ל- tf.keras.optimizers.Adadelta .
tf.train.AdagradOptimizer ניתן להמיר ישירות tf.keras.optimizers.Adagrad .
tf.train.FtrlOptimizer ניתן להמיר ישירות tf.keras.optimizers.Ftrl . accum_name linear_name ו- linear_name הוסרו.
tf.contrib.AdamaxOptimizer ו tf.contrib.NadamOptimizer ניתן להמיר ישירות tf.keras.optimizers.Adamax ו tf.keras.optimizers.Nadam , בהתאמה. beta1 , ו beta2 ויכוחים קיבלו שם כדי beta_1 ו beta_2 .

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

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

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

optimizers.Adagrad אדגרד מ 0.01 ל 0.001
optimizers.Adadelta אדאדלטה מ 1.0 ל 0.001
optimizers.Adamax מ 0.002 ל 0.001
optimizers.Nadam נאדם מ 0.002 ל 0.001

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 והערכת מפרט.

יצירת מפרט 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 המותאם אישית, מלבד השינויים לעיל, יש לבצע שדרוגים נוספים:

השתמש ב- tf.keras.optimizers במקום ב- v1.train.Optimizer .
מפורש להעביר את המודל trainable_variables אל tf.keras.optimizers .
כדי לחשב את train_op/minimize_op ,
- השתמש ב- Optimizer.get_updates אם האובדן הוא אובדן סקלרי Tensor (לא ניתן להתקשרות). האלמנט הראשון ברשימה המוחזרת הוא train_op/minimize_op הרצוי.
- אם ניתן לאבד את האובדן (כגון פונקציה), השתמש ב- Optimizer.minimize כדי להשיג את train_op/minimize_op .
השתמש ב- tf.keras.metrics במקום ב- tf.compat.v1.metrics לצורך הערכה.

לדוגמא לעיל של 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. עם זאת, כמה טיעונים השתנו:

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

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

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

ממיר מחסום

המעבר ל- 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

אם היה לך את זה ב- 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 .

מסקנות

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

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

נדרשת מעט עבודה להמרת קוד ל- TensorFlow 2.x אידיומטית, אך כל שינוי מביא ל:

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

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

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

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

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

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

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

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

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

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

המרת דגמים

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

לפני גיור

לאחר המרה

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

לפני גיור

לאחר המרה

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

לפני גיור

לאחר המרה

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

הַדְרָכָה

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

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

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

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

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

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

מיטבי קרס

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

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

TensorBoard

שמירה וטעינה

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

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

Graph.pb או Graph.pbtxt

אומדנים

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

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

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

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

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

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

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

ממיר מחסום

TensorShape

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

מסקנות

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

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

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

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

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

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

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

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