עזרה להגן על שונית המחסום הגדולה עם TensorFlow על Kaggle הצטרפו אתגר

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

הצג באתר TensorFlow.org הפעל בגוגל קולאב צפה במקור ב-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-10-26 01:27:06.061274: 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: 9.008277

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

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

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

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

ישנן גרסאות רבות של ערכת ממוצא שיפוע כי נלכדים 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=9.00828
Epoch  0: W=4.60 b=0.39, loss=6.16010
Epoch  1: W=4.28 b=0.71, loss=4.33501
Epoch  2: W=4.02 b=0.97, loss=3.16548
Epoch  3: W=3.82 b=1.17, loss=2.41602
Epoch  4: W=3.66 b=1.33, loss=1.93573
Epoch  5: W=3.53 b=1.46, loss=1.62793
Epoch  6: W=3.42 b=1.57, loss=1.43068
Epoch  7: W=3.34 b=1.65, loss=1.30426
Epoch  8: W=3.27 b=1.72, loss=1.22324
Epoch  9: W=3.22 b=1.78, loss=1.17131

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.171306

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

זה שימושי לעמת את הקוד שלמעלה עם המקביל ב-Keras.

הגדרה נראה הדגם בדיוק אותו הדבר אם אתה תת 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.60 b=0.39, loss=6.16010
Epoch  1: W=4.28 b=0.71, loss=4.33501
Epoch  2: W=4.02 b=0.97, loss=3.16548
Epoch  3: W=3.82 b=1.17, loss=2.41602
Epoch  4: W=3.66 b=1.33, loss=1.93573
Epoch  5: W=3.53 b=1.46, loss=1.62793
Epoch  6: W=3.42 b=1.57, loss=1.43068
Epoch  7: W=3.34 b=1.65, loss=1.30426
Epoch  8: W=3.27 b=1.72, loss=1.22324
Epoch  9: W=3.22 b=1.78, loss=1.17131

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

אם אתה עושה, אתה תצטרך להשתמש 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 212ms/step - loss: 9.0083
Epoch 2/10
1/1 [==============================] - 0s 2ms/step - loss: 6.1601
Epoch 3/10
1/1 [==============================] - 0s 3ms/step - loss: 4.3350
Epoch 4/10
1/1 [==============================] - 0s 2ms/step - loss: 3.1655
Epoch 5/10
1/1 [==============================] - 0s 2ms/step - loss: 2.4160
Epoch 6/10
1/1 [==============================] - 0s 2ms/step - loss: 1.9357
Epoch 7/10
1/1 [==============================] - 0s 2ms/step - loss: 1.6279
Epoch 8/10
1/1 [==============================] - 0s 2ms/step - loss: 1.4307
Epoch 9/10
1/1 [==============================] - 0s 2ms/step - loss: 1.3043
Epoch 10/10
1/1 [==============================] - 0s 2ms/step - loss: 1.2232
<keras.callbacks.History at 0x7f6c1bf96bd0>

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

הצעדים הבאים

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

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

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