יש שאלה? התחבר לקהילה בפורום הביקור של TensorFlow

הכשרת דגמי Keras עם ענן TensorFlow

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

מבוא

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

להכין

נתחיל בהתקנת TensorFlow Cloud, וייבוא ​​החבילות שנצטרך במדריך זה.

pip install -q tensorflow_cloud
import tensorflow as tf
import tensorflow_cloud as tfc

from tensorflow import keras
from tensorflow.keras import layers

סקירת API: דוגמה ראשונה מקצה לקצה

נתחיל בתסריט הדרכה למודל של Keras, כגון CNN הבא:

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

model = keras.Sequential(
    [
        keras.Input(shape=(28, 28)),
        # Use a Rescaling layer to make sure input values are in the [0, 1] range.
        layers.experimental.preprocessing.Rescaling(1.0 / 255),
        # The original images have shape (28, 28), so we reshape them to (28, 28, 1)
        layers.Reshape(target_shape=(28, 28, 1)),
        # Follow-up with a classic small convnet
        layers.Conv2D(32, 3, activation="relu"),
        layers.MaxPooling2D(2),
        layers.Conv2D(32, 3, activation="relu"),
        layers.MaxPooling2D(2),
        layers.Conv2D(32, 3, activation="relu"),
        layers.Flatten(),
        layers.Dense(128, activation="relu"),
        layers.Dense(10),
    ]
)

model.compile(
    optimizer=keras.optimizers.Adam(),
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics=keras.metrics.SparseCategoricalAccuracy(),
)

model.fit(x_train, y_train, epochs=20, batch_size=128, validation_split=0.1)

כדי להכשיר את המודל הזה ב- Google Cloud אנחנו רק צריכים להוסיף שיחה run() בתחילת הסקריפט, לפני הייבוא:

tfc.run()

אינך צריך לדאוג למשימות ספציפיות לענן כגון יצירת מופעי VM ואסטרטגיות הפצה בעת שימוש ב- TensorFlow Cloud. ה- API כולל ברירות מחדל חכמות לכל הפרמטרים - הכל ניתן להגדרה, אך דגמים רבים יכולים להסתמך על ברירות מחדל אלה.

עם קריאת run() , ענן TensorFlow:

  • הפוך את סקריפט ה- Python או את הפצת המחשב שלך למוכנים.
  • המירו אותו לתמונת Docker עם תלות נדרשת.
  • הפעל את עבודת האימון ב- VMP המופעל על ידי GCP.
  • זרם יומנים רלוונטיים ומידע משרה.

תצורת ה- VM המוגדרת כברירת מחדל היא 1 ראשי ו- 0 עובדים עם 8 ליבות מעבד ו- GPU אחד של טסלה T4.

תצורת ענן גוגל

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

  1. צור פרויקט GCP;
  2. אפשר שירותי פלטפורמת AI;
  3. צור חשבון שירות;
  4. הורד מפתח הרשאה;
  5. צור דלי אחסון בענן.

הוראות מפורטות להגדרה בפעם הראשונה ניתן למצוא ב TensorFlow Cloud README , ודוגמת הגדרה נוספת מוצגת בבלוג TensorFlow .

זרימות עבודה נפוצות ואחסון בענן

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

def create_model():
    model = keras.Sequential(
        [
            keras.Input(shape=(28, 28)),
            layers.experimental.preprocessing.Rescaling(1.0 / 255),
            layers.Reshape(target_shape=(28, 28, 1)),
            layers.Conv2D(32, 3, activation="relu"),
            layers.MaxPooling2D(2),
            layers.Conv2D(32, 3, activation="relu"),
            layers.MaxPooling2D(2),
            layers.Conv2D(32, 3, activation="relu"),
            layers.Flatten(),
            layers.Dense(128, activation="relu"),
            layers.Dense(10),
        ]
    )

    model.compile(
        optimizer=keras.optimizers.Adam(),
        loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
        metrics=keras.metrics.SparseCategoricalAccuracy(),
    )
    return model

בואו נשמור את יומני TensorBoard ומחסומי המודל שנוצרו במהלך האימון בדלי אחסון הענן שלנו.

import datetime
import os

# Note: Please change the gcp_bucket to your bucket name.
gcp_bucket = "keras-examples"

checkpoint_path = os.path.join("gs://", gcp_bucket, "mnist_example", "save_at_{epoch}")

tensorboard_path = os.path.join(  # Timestamp included to enable timeseries graphs
    "gs://", gcp_bucket, "logs", datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
)

callbacks = [
    # TensorBoard will store logs for each epoch and graph performance for us.
    keras.callbacks.TensorBoard(log_dir=tensorboard_path, histogram_freq=1),
    # ModelCheckpoint will save models after each epoch for retrieval later.
    keras.callbacks.ModelCheckpoint(checkpoint_path),
    # EarlyStopping will terminate training when val_loss ceases to improve.
    keras.callbacks.EarlyStopping(monitor="val_loss", patience=3),
]

model = create_model()

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

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

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

if tfc.remote():
    epochs = 100
    callbacks = callbacks
    batch_size = 128
else:
    epochs = 5
    batch_size = 64
    callbacks = None

model.fit(x_train, y_train, epochs=epochs, callbacks=callbacks, batch_size=batch_size)
Epoch 1/5
938/938 [==============================] - 6s 3ms/step - loss: 0.4867 - sparse_categorical_accuracy: 0.8556
Epoch 2/5
938/938 [==============================] - 3s 3ms/step - loss: 0.0638 - sparse_categorical_accuracy: 0.9796
Epoch 3/5
938/938 [==============================] - 3s 3ms/step - loss: 0.0411 - sparse_categorical_accuracy: 0.9870
Epoch 4/5
938/938 [==============================] - 3s 3ms/step - loss: 0.0333 - sparse_categorical_accuracy: 0.9895
Epoch 5/5
938/938 [==============================] - 3s 3ms/step - loss: 0.0278 - sparse_categorical_accuracy: 0.9910
<tensorflow.python.keras.callbacks.History at 0x7fa57866c4e0>

בוא נשמור את המודל ב- GCS לאחר סיום האימון.

save_path = os.path.join("gs://", gcp_bucket, "mnist_example")

if tfc.remote():
    model.save(save_path)

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

tfc.run(docker_image_bucket_name=gcp_bucket)

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

model = keras.models.load_model(save_path)
!tensorboard dev upload --logdir "gs://keras-examples-jonah/logs/fit" --name "Guide MNIST"

פרויקטים בקנה מידה גדול

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

נקודות כניסה: תמיכה בסקריפטים של פייתון ובמחברות Jupyter

השיחה שלך ל- API של run() לא תמיד תיכלל בתוך אותו סקריפט Python כמו קוד האימון המודל שלך. לשם כך אנו מספקים פרמטר entry_point . ניתן entry_point בפרמטר entry_point כדי לציין את סקריפט או המחברת של פייתון בהם חי קוד האימון של המודל שלך. בעת קריאה ל- run() מאותו סקריפט כמו המודל שלך, השתמש entry_point המחדל entry_point של None .

תלות pip

אם הפרויקט שלך קורא לתלות pip נוספת, ניתן לציין את הספריות הנדרשות הנוספות על ידי הכללת קובץ requirements.txt . בקובץ זה פשוט הכניסו רשימה של כל התלות הנדרשת ו- TensorFlow Cloud יטפל בשילוב אלה בבניית הענן שלכם.

מחברות פייתון

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

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

פרויקטים מרובי קבצים

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

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

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    entry_point="train_model.py",
    requirements="requirements.txt"
)

תצורת מכונה והדרכה מבוזרת

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

הפצה מרובת עובדים

כאן נוכל להשתמש ב- COMMON_MACHINE_CONFIGS כדי לייעד מעבד ראשי אחד ו -4 COMMON_MACHINE_CONFIGS GPU.

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    chief_config=tfc.COMMON_MACHINE_CONFIGS['CPU'],
    worker_count=2,
    worker_config=tfc.COMMON_MACHINE_CONFIGS['T4_4X']
)

כברירת מחדל, TensorFlow Cloud בוחר את אסטרטגיית ההפצה הטובה ביותר עבור תצורת המחשב שלך עם נוסחה פשוטה המשתמשת chief_config worker_config , worker_config ו- worker_count .

הפצת TPU

בואו נכשיר את אותו דגם ב- TPU, כפי שמוצג:

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    chief_config=tfc.COMMON_MACHINE_CONFIGS["CPU"],
    worker_count=1,
    worker_config=tfc.COMMON_MACHINE_CONFIGS["TPU"]
)

אסטרטגיית הפצה מותאמת אישית

כדי לציין אסטרטגיית הפצה מותאמת אישית, פרמט את הקוד שלך בדרך כלל כפי שהיית עושה לפי מדריך ההדרכה distribution_strategy והגדר את distribution_strategy ל- None . להלן נפרט אסטרטגיית הפצה משלנו עבור אותו מודל MNIST.

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

mirrored_strategy = tf.distribute.MirroredStrategy()
with mirrored_strategy.scope():
  model = create_model()

if tfc.remote():
    epochs = 100
    batch_size = 128
else:
    epochs = 10
    batch_size = 64
    callbacks = None

model.fit(
    x_train, y_train, epochs=epochs, callbacks=callbacks, batch_size=batch_size
)

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    chief_config=tfc.COMMON_MACHINE_CONFIGS['CPU'],
    worker_count=2,
    worker_config=tfc.COMMON_MACHINE_CONFIGS['T4_4X'],
    distribution_strategy=None
)

תמונות Docker מותאמות אישית

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

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    base_docker_image="tensorflow/tensorflow:2.1.0-gpu"
)

מדדים נוספים

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

job_labels = {"job": "mnist-example", "team": "keras-io", "user": "jonah"}

tfc.run(
    docker_image_bucket_name=gcp_bucket,
    job_labels=job_labels,
    stream_logs=True
)

מחברים את הכל ביחד

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