TensorFlow 2 התחלה מהירה למתחילים

הצג באתר TensorFlow.org

הפעל בגוגל קולאב

צפה במקור ב-GitHub

הורד מחברת

הקדמה קצרה זו משתמשת ב- Keras כדי:

1. טען מערך נתונים שנבנה מראש.
2. בנו מודל למידת מכונה של רשת עצבית שמסווג תמונות.
3. אמן את הרשת העצבית הזו.
4. הערך את דיוק המודל.

מדריך זה הוא מחברת Google Collaboratory . תוכניות Python מופעלות ישירות בדפדפן - דרך מצוינת ללמוד ולהשתמש ב- TensorFlow. כדי לעקוב אחר הדרכה זו, הפעל את המחברת ב-Google Colab על ידי לחיצה על הכפתור בראש עמוד זה.

1. ב-Colab, התחבר לזמן ריצה של Python: בפינה השמאלית העליונה של שורת התפריטים, בחר CONNECT .
2. הפעל את כל תאי הקוד של המחברת: בחר זמן ריצה > הפעל הכל .

הגדר את TensorFlow

ייבא את TensorFlow לתוכנית שלך כדי להתחיל:

import tensorflow as tf
print("TensorFlow version:", tf.__version__)

TensorFlow version: 2.8.0-rc1

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

טען מערך נתונים

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

mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

בניית מודל למידת מכונה

בניית מודל tf.keras.Sequential על ידי ערימת שכבות.

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10)
])

עבור כל דוגמה, המודל מחזיר וקטור של ציוני logits או log-odds , אחד עבור כל מחלקה.

predictions = model(x_train[:1]).numpy()
predictions

array([[ 0.2760778 , -0.39324787, -0.17098302,  1.2016621 , -0.03416392,
         0.5461229 , -0.7203061 , -0.41886678, -0.59480035, -0.7580608 ]],
      dtype=float32)

הפונקציה tf.nn.softmax ממירה לוגיטים אלה להסתברויות עבור כל מחלקה:

tf.nn.softmax(predictions).numpy()

array([[0.11960829, 0.06124588, 0.0764901 , 0.30181262, 0.08770514,
        0.15668967, 0.04416083, 0.05969675, 0.05006609, 0.04252464]],
      dtype=float32)

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

loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

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

מודל לא מאומן זה נותן הסתברויות קרובות לאקראיות (1/10 לכל מחלקה), כך שההפסד הראשוני צריך להיות קרוב ל- -tf.math.log(1/10) ~= 2.3 .

loss_fn(y_train[:1], predictions).numpy()

1.8534881

לפני שתתחיל באימון, הגדר והידור המודל באמצעות Keras Model.compile . הגדר את מחלקת optimizer ל- adam , הגדר את loss לפונקציה loss_fn שהגדרת קודם לכן, וציין מדד שיש להעריך עבור המודל על ידי הגדרת פרמטר metrics accuracy .

model.compile(optimizer='adam',
              loss=loss_fn,
              metrics=['accuracy'])

אימון והעריך את המודל שלך

השתמש בשיטת Model.fit כדי להתאים את פרמטרי המודל שלך ולמזער את ההפסד:

model.fit(x_train, y_train, epochs=5)

Epoch 1/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.2950 - accuracy: 0.9143
Epoch 2/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1451 - accuracy: 0.9567
Epoch 3/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.1080 - accuracy: 0.9668
Epoch 4/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.0906 - accuracy: 0.9717
Epoch 5/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.0749 - accuracy: 0.9761
<keras.callbacks.History at 0x7f062c606850>

שיטת Model.evaluate בודקת את ביצועי המודל, בדרך כלל ב-" Validation-set " או " Test-set ".

model.evaluate(x_test,  y_test, verbose=2)

313/313 - 1s - loss: 0.0783 - accuracy: 0.9755 - 588ms/epoch - 2ms/step
[0.07825208455324173, 0.9754999876022339]

מסווג התמונות מאומן כעת לדיוק של ~98% במערך הנתונים הזה. למידע נוסף, קרא את המדריכים של TensorFlow .

אם אתה רוצה שהדגם שלך יחזיר הסתברות, אתה יכול לעטוף את הדגם המאומן ולצרף אליו את ה-softmax:

probability_model = tf.keras.Sequential([
  model,
  tf.keras.layers.Softmax()
])

probability_model(x_test[:5])

<tf.Tensor: shape=(5, 10), dtype=float32, numpy=
array([[2.72807270e-08, 2.42517650e-08, 7.75602894e-06, 1.28684027e-04,
        7.66215633e-11, 3.54162950e-07, 3.04894151e-14, 9.99857187e-01,
        2.32766553e-08, 5.97762892e-06],
       [7.37396704e-08, 4.73638036e-04, 9.99523997e-01, 7.20633352e-07,
        4.54133671e-17, 1.42298268e-06, 5.96959016e-09, 1.23534145e-13,
        7.77225608e-08, 6.98619169e-16],
       [1.95462448e-07, 9.99295831e-01, 1.02249986e-04, 1.86699708e-05,
        5.65737491e-06, 1.12115902e-06, 5.32719559e-06, 5.22767776e-04,
        4.79981136e-05, 1.76624681e-07],
       [9.99649286e-01, 1.80224735e-09, 3.73612856e-05, 1.52324446e-07,
        1.30824594e-06, 2.82781020e-05, 6.99703523e-05, 3.30940424e-07,
        2.13184350e-07, 2.13106396e-04],
       [1.53770895e-06, 1.72272063e-08, 1.98980865e-06, 3.97882580e-08,
        9.97192323e-01, 1.10544443e-05, 1.54713348e-06, 2.81727880e-05,
        3.48721733e-06, 2.75991508e-03]], dtype=float32)>

סיכום

מזל טוב! אימנת מודל למידת מכונה באמצעות מערך נתונים שנבנה מראש באמצעות ה-API של Keras .

לדוגמאות נוספות לשימוש ב-Keras, עיין במדריכי הלימוד . למידע נוסף על בניית דגמים עם Keras, קרא את המדריכים . אם אתה רוצה ללמוד עוד על טעינת נתונים והכנתם, עיין במדריכים על טעינת נתוני תמונה או טעינת נתוני CSV .