לולאות אימון בסיסיות

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

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

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

להכין

import tensorflow as tf

פתרון בעיות למידת מכונה

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

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

למטרות המחשה, במדריך זה תפתח מודל לינארי פשוט, $ f (x) = x * W + b $, הכולל שני משתנים: $ W $ (משקולות) ו- $ b $ (הטיה).

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

נתונים

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

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

להלן מספר נתונים המסונתזים על ידי הוספת רעש גאוס (רגיל) לנקודות לאורך קו.

# The actual line
TRUE_W = 3.0
TRUE_B = 2.0

NUM_EXAMPLES = 1000

# A vector of random x values
x = tf.random.normal(shape=[NUM_EXAMPLES])

# Generate some noise
noise = tf.random.normal(shape=[NUM_EXAMPLES])

# Calculate y
y = x * TRUE_W + TRUE_B + noise
# Plot all the data
import matplotlib.pyplot as plt

plt.scatter(x, y, c="b")
plt.show()

png

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

הגדר את הדגם

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

השתמשו tf.Module לתמצת את המשתנים ואת החישוב. אתה יכול להשתמש בכל אובייקט Python, אך כך ניתן לשמור אותו בקלות.

הנה, אתה מגדיר גם w ו- B כמשתנים.

class MyModel(tf.Module):
  def __init__(self, **kwargs):
    super().__init__(**kwargs)
    # Initialize the weights to `5.0` and the bias to `0.0`
    # In practice, these should be randomly initialized
    self.w = tf.Variable(5.0)
    self.b = tf.Variable(0.0)

  def __call__(self, x):
    return self.w * x + self.b

model = MyModel()

# List the variables tf.modules's built-in variable aggregation.
print("Variables:", model.variables)

# Verify the model works
assert model(3.0).numpy() == 15.0
Variables: (<tf.Variable 'Variable:0' shape=() dtype=float32, numpy=0.0>, <tf.Variable 'Variable:0' shape=() dtype=float32, numpy=5.0>)
2021-09-22 20:35:50.826720: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.

המשתנים הראשוניים נקבעים כאן באופן קבוע, אבל Keras מגיע עם כול מספר של initalizers אתה יכול להשתמש, עם או בלי שאר Keras.

הגדר פונקציית אובדן

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

# This computes a single loss value for an entire batch
def loss(target_y, predicted_y):
  return tf.reduce_mean(tf.square(target_y - predicted_y))

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

plt.scatter(x, y, c="b")
plt.scatter(x, model(x), c="r")
plt.show()

print("Current loss: %1.6f" % loss(y, model(x)).numpy())

png

Current loss: 8.964072

הגדר לולאת אימון

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

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

לדוגמה, אתה יכול לאמן את המודל באמצעות ממוצא שיפוע .

ישנן גרסאות רבות של ערכת ממוצא שיפוע כי נלכדים tf.keras.optimizers . אבל ברוח בונה מן העקרונות ראשונים, כאן תוכל ליישם את המתמטיקה הבסיסית עצמך בעזרת tf.GradientTape לבידול אוטומטי tf.assign_sub עבור decrementing ערך (המשלב tf.assign ו tf.sub ):

# Given a callable model, inputs, outputs, and a learning rate...
def train(model, x, y, learning_rate):

  with tf.GradientTape() as t:
    # Trainable variables are automatically tracked by GradientTape
    current_loss = loss(y, model(x))

  # Use GradientTape to calculate the gradients with respect to W and b
  dw, db = t.gradient(current_loss, [model.w, model.b])

  # Subtract the gradient scaled by the learning rate
  model.w.assign_sub(learning_rate * dw)
  model.b.assign_sub(learning_rate * db)

לקבלת מבט אימון, אתה יכול לשלוח אותה תצווה של x ו- y דרך לולאת אימונים, ולראות איך W ו- b להתפתח.

model = MyModel()

# Collect the history of W-values and b-values to plot later
Ws, bs = [], []
epochs = range(10)

# Define a training loop
def training_loop(model, x, y):

  for epoch in epochs:
    # Update the model with the single giant batch
    train(model, x, y, learning_rate=0.1)

    # Track this before I update
    Ws.append(model.w.numpy())
    bs.append(model.b.numpy())
    current_loss = loss(y, model(x))

    print("Epoch %2d: W=%1.2f b=%1.2f, loss=%2.5f" %
          (epoch, Ws[-1], bs[-1], current_loss))
print("Starting: W=%1.2f b=%1.2f, loss=%2.5f" %
      (model.w, model.b, loss(y, model(x))))

# Do the training
training_loop(model, x, y)

# Plot it
plt.plot(epochs, Ws, "r",
         epochs, bs, "b")

plt.plot([TRUE_W] * len(epochs), "r--",
         [TRUE_B] * len(epochs), "b--")

plt.legend(["W", "b", "True W", "True b"])
plt.show()
Starting: W=5.00 b=0.00, loss=8.96407
Epoch  0: W=4.62 b=0.40, loss=6.17553
Epoch  1: W=4.31 b=0.73, loss=4.36827
Epoch  2: W=4.06 b=0.99, loss=3.19682
Epoch  3: W=3.85 b=1.19, loss=2.43738
Epoch  4: W=3.69 b=1.36, loss=1.94497
Epoch  5: W=3.56 b=1.49, loss=1.62565
Epoch  6: W=3.45 b=1.60, loss=1.41855
Epoch  7: W=3.36 b=1.68, loss=1.28421
Epoch  8: W=3.29 b=1.75, loss=1.19705
Epoch  9: W=3.23 b=1.80, loss=1.14050

png

# Visualize how the trained model performs
plt.scatter(x, y, c="b")
plt.scatter(x, model(x), c="r")
plt.show()

print("Current loss: %1.6f" % loss(model(x), y).numpy())

png

Current loss: 1.140498

אותו פתרון, אבל עם קרס

כדאי להשוות את הקוד למעלה עם המקבילה בקראס.

הגדרה נראה הדגם בדיוק אותו הדבר אם אתה תת tf.keras.Model . זכור שדגמי Keras יורשים בסופו של דבר ממודול.

class MyModelKeras(tf.keras.Model):
  def __init__(self, **kwargs):
    super().__init__(**kwargs)
    # Initialize the weights to `5.0` and the bias to `0.0`
    # In practice, these should be randomly initialized
    self.w = tf.Variable(5.0)
    self.b = tf.Variable(0.0)

  def call(self, x):
    return self.w * x + self.b

keras_model = MyModelKeras()

# Reuse the training loop with a Keras model
training_loop(keras_model, x, y)

# You can also save a checkpoint using Keras's built-in support
keras_model.save_weights("my_checkpoint")
Epoch  0: W=4.62 b=0.40, loss=6.17553
Epoch  1: W=4.31 b=0.73, loss=4.36827
Epoch  2: W=4.06 b=0.99, loss=3.19682
Epoch  3: W=3.85 b=1.19, loss=2.43738
Epoch  4: W=3.69 b=1.36, loss=1.94497
Epoch  5: W=3.56 b=1.49, loss=1.62565
Epoch  6: W=3.45 b=1.60, loss=1.41855
Epoch  7: W=3.36 b=1.68, loss=1.28421
Epoch  8: W=3.29 b=1.75, loss=1.19705
Epoch  9: W=3.23 b=1.80, loss=1.14050

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

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

keras_model = MyModelKeras()

# compile sets the training parameters
keras_model.compile(
    # By default, fit() uses tf.function().  You can
    # turn that off for debugging, but it is on now.
    run_eagerly=False,

    # Using a built-in optimizer, configuring as an object
    optimizer=tf.keras.optimizers.SGD(learning_rate=0.1),

    # Keras comes with built-in MSE error
    # However, you could use the loss function
    # defined above
    loss=tf.keras.losses.mean_squared_error,
)

Keras fit מצפה לכלך נתונים או במערך שלם כמערך numpy. מערכי NumPy נחתכים לקבוצות וברירת מחדל לגודל אצווה של 32.

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

print(x.shape[0])
keras_model.fit(x, y, epochs=10, batch_size=1000)
1000
Epoch 1/10
1/1 [==============================] - 0s 227ms/step - loss: 8.9641
Epoch 2/10
1/1 [==============================] - 0s 2ms/step - loss: 6.1755
Epoch 3/10
1/1 [==============================] - 0s 3ms/step - loss: 4.3683
Epoch 4/10
1/1 [==============================] - 0s 2ms/step - loss: 3.1968
Epoch 5/10
1/1 [==============================] - 0s 2ms/step - loss: 2.4374
Epoch 6/10
1/1 [==============================] - 0s 3ms/step - loss: 1.9450
Epoch 7/10
1/1 [==============================] - 0s 2ms/step - loss: 1.6257
Epoch 8/10
1/1 [==============================] - 0s 2ms/step - loss: 1.4185
Epoch 9/10
1/1 [==============================] - 0s 2ms/step - loss: 1.2842
Epoch 10/10
1/1 [==============================] - 0s 2ms/step - loss: 1.1971
<keras.callbacks.History at 0x7fe0e83b5a90>

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

הצעדים הבאים

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

עם זאת, מדובר בבעיה פשוטה ביותר. להיכרות מעשי יותר, רואה בהדרכה והכשרה מותאמת אישית .

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