סקלרים של TensorBoard: מדדי אימון רישום בקראס

סקירה כללית

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

Scalars Dashboard של TensorBoard מאפשר לך לדמיין את הערכים האלה באמצעות API פשוט עם מעט מאוד מאמץ. מדריך זה מציג דוגמאות בסיסיות מאוד שיעזרו לך ללמוד כיצד להשתמש בממשקי API אלה עם TensorBoard בעת פיתוח מודל Keras שלך. תלמד כיצד להשתמש ב-Keras TensorBoard callback ו- TensorFlow Summary APIs כדי לדמיין סקלרים של ברירת מחדל וסקלרים מותאמים אישית.

להכין

# Load the TensorBoard notebook extension.
%load_ext tensorboard

from datetime import datetime
from packaging import version

import tensorflow as tf
from tensorflow import keras

import numpy as np

print("TensorFlow version: ", tf.__version__)
assert version.parse(tf.__version__).release[0] >= 2, \
    "This notebook requires TensorFlow 2.0 or above."

TensorFlow version:  2.2

הגדר נתונים עבור רגרסיה פשוטה

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

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

ראשית, ליצור 1000 נקודות נתונים בערך לאורך הקו y = 0.5x + 2. פצל את נקודות הנתונים הללו לקבוצות אימון ומבחנים. התקווה שלך היא שהרשת העצבית תלמד את הקשר הזה.

data_size = 1000
# 80% of the data is for training.
train_pct = 0.8

train_size = int(data_size * train_pct)

# Create some input data between -1 and 1 and randomize it.
x = np.linspace(-1, 1, data_size)
np.random.shuffle(x)

# Generate the output data.
# y = 0.5x + 2 + noise
y = 0.5 * x + 2 + np.random.normal(0, 0.05, (data_size, ))

# Split into test and train pairs.
x_train, y_train = x[:train_size], y[:train_size]
x_test, y_test = x[train_size:], y[train_size:]

אימון המודל ואובדן רישום

כעת אתה מוכן להגדיר, לאמן ולהעריך את המודל שלך.

כדי לתעד את סקלר אובדן כפי שאתה הרכבת, תעשה את הדברים הבאים:

1. צור את Keras התקשרות TensorBoard
2. ציין ספריית יומן
3. תעביר את התקשרות TensorBoard ל Keras Model.fit () .

TensorBoard קורא נתוני יומן מהיררכיית ספריות היומן. במחברת זו, ספריית יומן השורש היא logs/scalars , מצמיד ידי ספריית משנת timestamped. ספריית המשנה עם חותמת הזמן מאפשרת לך לזהות ולבחור בקלות ריצות אימון בזמן שאתה משתמש ב-TensorBoard וחוזר על המודל שלך.

logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

model = keras.models.Sequential([
    keras.layers.Dense(16, input_dim=1),
    keras.layers.Dense(1),
])

model.compile(
    loss='mse', # keras.losses.mean_squared_error
    optimizer=keras.optimizers.SGD(learning_rate=0.2),
)

print("Training ... With default parameters, this takes less than 10 seconds.")
training_history = model.fit(
    x_train, # input
    y_train, # output
    batch_size=train_size,
    verbose=0, # Suppress chatty output; use Tensorboard instead
    epochs=100,
    validation_data=(x_test, y_test),
    callbacks=[tensorboard_callback],
)

print("Average test loss: ", np.average(training_history.history['loss']))

Training ... With default parameters, this takes less than 10 seconds.
Average test loss:  0.05271831926424056

בחינת אובדן באמצעות TensorBoard

כעת, הפעל את TensorBoard, ציין את ספריית יומן השורש שבה השתמשת למעלה.

המתן מספר שניות עד שממשק המשתמש של TensorBoard יתהפך.

%tensorboard --logdir logs/scalars

ייתכן שתראה את TensorBoard מציג את ההודעה "אין לוחות מחוונים פעילים עבור מערך הנתונים הנוכחי". הסיבה לכך היא שנתוני רישום ראשוניים עדיין לא נשמרו. ככל שהאימון מתקדם, מודל Keras יתחיל לרשום נתונים. TensorBoard ירענן מעת לעת ויראה לך את המדדים הסקלרים שלך. אם אתה חסר סבלנות, אתה יכול להקיש על החץ רענן בפינה השמאלית העליונה.

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

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

שימו לב לבורר "ריצות" בצד שמאל. "ריצה" מייצגת קבוצה של יומנים מסבב אימון, במקרה זה התוצאה של Model.fit(). למפתחים יש בדרך כלל הרבה הרבה ריצות, כשהם מתנסים ומפתחים את המודל שלהם לאורך זמן.

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

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

בהינתן נתוני הקלט (60, 25, 2), הקו y = 0.5x + 2 צריך להניב (32, 14.5, 3). האם הדגם מסכים?

print(model.predict([60, 25, 2]))
# True values to compare predictions against: 
# [[32.0]
#  [14.5]
#  [ 3.0]]

[[32.234306 ]
 [14.5974245]
 [ 3.0074697]]

לא רע!

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

מה אם אתה רוצה להיכנס ערכים מותאמים אישית, כגון קצב למידה דינמית ? כדי לעשות זאת, עליך להשתמש ב- TensorFlow Summary API.

אמן מחדש את מודל הרגרסיה ורשם קצב למידה מותאם אישית. כך:

1. צור סופר קובץ, באמצעות tf.summary.create_file_writer() .
2. הגדר פונקציית קצב למידה מותאמת אישית. זה יועבר אלי Keras LearningRateScheduler ההתקשרות.
3. בתוך פונקצית שיעור למידה, השימוש tf.summary.scalar() כדי להתחבר שיעור הלמידה המותאם אישית.
4. העבר את ההתקשרות חזרה של LearningRateScheduler אל Model.fit().

באופן כללי, כדי להיכנס סקלר אישית, עליך להשתמש tf.summary.scalar() עם הסופר קובץ. כותב הקובץ הוא אחראי על כתיבת נתונים עבור בטווח הזה לספרייה שצוינה משמש במשתמע בעת שימוש tf.summary.scalar() .

logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S")
file_writer = tf.summary.create_file_writer(logdir + "/metrics")
file_writer.set_as_default()

def lr_schedule(epoch):
  """
  Returns a custom learning rate that decreases as epochs progress.
  """
  learning_rate = 0.2
  if epoch > 10:
    learning_rate = 0.02
  if epoch > 20:
    learning_rate = 0.01
  if epoch > 50:
    learning_rate = 0.005

  tf.summary.scalar('learning rate', data=learning_rate, step=epoch)
  return learning_rate

lr_callback = keras.callbacks.LearningRateScheduler(lr_schedule)
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

model = keras.models.Sequential([
    keras.layers.Dense(16, input_dim=1),
    keras.layers.Dense(1),
])

model.compile(
    loss='mse', # keras.losses.mean_squared_error
    optimizer=keras.optimizers.SGD(),
)

training_history = model.fit(
    x_train, # input
    y_train, # output
    batch_size=train_size,
    verbose=0, # Suppress chatty output; use Tensorboard instead
    epochs=100,
    validation_data=(x_test, y_test),
    callbacks=[tensorboard_callback, lr_callback],
)

בואו נסתכל שוב על TensorBoard.

%tensorboard --logdir logs/scalars

באמצעות הבורר "פועל" בצד השמאל, הודעה כי יש לך <timestamp>/metrics ריצה. בחירה בריצה זו מציגה גרף "קצב למידה" המאפשר לך לאמת את התקדמות קצב הלמידה במהלך ריצה זו.

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

איך הדגם הזה מסתדר?

print(model.predict([60, 25, 2]))
# True values to compare predictions against: 
# [[32.0]
#  [14.5]
#  [ 3.0]]

[[32.234013 ]
 [14.5973015]
 [ 3.0074618]]