אזהרה: פרויקט זה הוצא משימוש.

דף זה תורגם על ידי Cloud Translation API.

כוונון דגם רחב ועמוק באמצעות Google Cloud

הצג באתר TensorFlow.org

בדוגמה זו נשתמש ב-CloudTuner וב-Google Cloud כדי לכוונן מודל רחב ועמוק בהתבסס על המודל הניתן לכוונון שהוצג בלמידה מובנית של נתונים עם רשתות רחבות, עמוקות וחוצות . בדוגמה זו נשתמש במערך הנתונים של CAIIS Dogfood Day

ייבוא מודולים נדרשים

import datetime
import uuid

import numpy as np
import pandas as pd
import tensorflow as tf
import os
import sys
import subprocess

from tensorflow.keras import datasets, layers, models
from sklearn.model_selection import train_test_split

# Install the latest version of tensorflow_cloud and other required packages.
if os.environ.get("TF_KERAS_RUNNING_REMOTELY", True):
    subprocess.run(
        ['python3', '-m', 'pip', 'install', 'tensorflow-cloud', '-q'])
    subprocess.run(
        ['python3', '-m', 'pip', 'install', 'google-cloud-storage', '-q'])
    subprocess.run(
        ['python3', '-m', 'pip', 'install', 'fsspec', '-q'])
    subprocess.run(
        ['python3', '-m', 'pip', 'install', 'gcsfs', '-q'])

import tensorflow_cloud as tfc
print(tfc.__version__)

0.1.15

tf.version.VERSION

'2.6.0'

תצורות פרויקט

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

# Set Google Cloud Specific parameters

# TODO: Please set GCP_PROJECT_ID to your own Google Cloud project ID.
GCP_PROJECT_ID = 'YOUR_PROJECT_ID' 

# TODO: Change the Service Account Name to your own Service Account
SERVICE_ACCOUNT_NAME = 'YOUR_SERVICE_ACCOUNT_NAME'
SERVICE_ACCOUNT = f'{SERVICE_ACCOUNT_NAME}@{GCP_PROJECT_ID}.iam.gserviceaccount.com'

# TODO: set GCS_BUCKET to your own Google Cloud Storage (GCS) bucket.
GCS_BUCKET = 'YOUR_GCS_BUCKET_NAME'

# DO NOT CHANGE: Currently only the 'us-central1' region is supported.
REGION = 'us-central1'

# Set Tuning Specific parameters

# OPTIONAL: You can change the job name to any string.
JOB_NAME = 'wide_and_deep'

# OPTIONAL: Set Number of concurrent tuning jobs that you would like to run.
NUM_JOBS = 5

# TODO: Set the study ID for this run. Study_ID can be any unique string.
# Reusing the same Study_ID will cause the Tuner to continue tuning the
# Same Study parameters. This can be used to continue on a terminated job,
# or load stats from a previous study.
STUDY_NUMBER = '00001'
STUDY_ID = f'{GCP_PROJECT_ID}_{JOB_NAME}_{STUDY_NUMBER}'

# Setting location were training logs and checkpoints will be stored
GCS_BASE_PATH = f'gs://{GCS_BUCKET}/{JOB_NAME}/{STUDY_ID}'
TENSORBOARD_LOGS_DIR = os.path.join(GCS_BASE_PATH,"logs")

אימות המחברת לשימוש ב-Google Cloud Project שלך

עבור Kaggle Notebooks לחץ על "תוספות"->"Google Cloud SDK" לפני הפעלת התא למטה.

# Using tfc.remote() to ensure this code only runs in notebook
if not tfc.remote():

    # Authentication for Kaggle Notebooks
    if "kaggle_secrets" in sys.modules:
        from kaggle_secrets import UserSecretsClient
        UserSecretsClient().set_gcloud_credentials(project=GCP_PROJECT_ID)

    # Authentication for Colab Notebooks
    if "google.colab" in sys.modules:
        from google.colab import auth
        auth.authenticate_user()
        os.environ["GOOGLE_CLOUD_PROJECT"] = GCP_PROJECT_ID

טען את הנתונים

קרא נתונים גולמיים ופצל כדי לאמן ולבדוק מערכי נתונים. עבור שלב זה תצטרך להעתיק את מערך הנתונים לדלי GCS שלך כדי שניתן יהיה לגשת אליו במהלך האימון. עבור דוגמה זו אנו משתמשים במערך הנתונים מ- https://www.kaggle.com/c/caiis-dogfood-day-2020

לשם כך אתה יכול להפעיל את הפקודות הבאות כדי להוריד ולהעתיק את מערך הנתונים לדלי GCS שלך, או להוריד באופן ידני את מערך הנתונים vi Kaggle UI ולהעלות את קובץ train.csv ל- GCS bucket שלך vi GCS UI .

# Download the dataset
kaggle competitions download -c caiis-dogfood-day-2020

# Copy the training file to your bucket
gsutil cp ./caiis-dogfood-day-2020/train.csv $GCS_BASE_PATH/caiis-dogfood-day-2020/train.csv

train_URL = f'{GCS_BASE_PATH}/caiis-dogfood-day-2020/train.csv'
data = pd.read_csv(train_URL)
train, test = train_test_split(data, test_size=0.1)

# A utility method to create a tf.data dataset from a Pandas Dataframe
def df_to_dataset(df, shuffle=True, batch_size=32):
  df = df.copy()
  labels = df.pop('target')
  ds = tf.data.Dataset.from_tensor_slices((dict(df), labels))
  if shuffle:
    ds = ds.shuffle(buffer_size=len(df))
  ds = ds.batch(batch_size)
  return ds

sm_batch_size = 1000  # A small batch size is used for demonstration purposes
train_ds = df_to_dataset(train, batch_size=sm_batch_size)
test_ds = df_to_dataset(test, shuffle=False, batch_size=sm_batch_size)

עבד מראש את הנתונים

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

from tensorflow.keras.layers.experimental import preprocessing

def create_model_inputs():
    inputs ={}
    for name, column in data.items():
        if name in ('id','target'):
            continue
        dtype = column.dtype
        if dtype == object:
            dtype = tf.string
        else:
            dtype = tf.float32

        inputs[name] = tf.keras.Input(shape=(1,), name=name, dtype=dtype)

    return inputs

#Preprocessing the numeric inputs, and running them through a normalization layer.
def preprocess_numeric_inputs(inputs):

    numeric_inputs = {name:input for name,input in inputs.items()
                      if input.dtype==tf.float32}

    x = layers.Concatenate()(list(numeric_inputs.values()))
    norm = preprocessing.Normalization()
    norm.adapt(np.array(data[numeric_inputs.keys()]))
    numeric_inputs = norm(x)
    return numeric_inputs

# Preprocessing the categorical inputs.
def preprocess_categorical_inputs(inputs):
    categorical_inputs = []
    for name, input in inputs.items():
        if input.dtype == tf.float32:
            continue

        lookup = preprocessing.StringLookup(vocabulary=np.unique(data[name]))
        one_hot = preprocessing.CategoryEncoding(max_tokens=lookup.vocab_size())

        x = lookup(input)
        x = one_hot(x)
        categorical_inputs.append(x)

    return layers.concatenate(categorical_inputs)

הגדר את ארכיטקטורת המודל ואת הפרמטרים ההיפר

בסעיף זה אנו מגדירים את פרמטרי הכוונון שלנו באמצעות פרמטרי Keras Tuner Hyper Parameters ופונקציה של בניית מודל. פונקציית בניית המודל לוקחת ארגומנט hp שממנו ניתן לדגום הפרמטרים היפר, כגון hp.Int('units', min_value=32, max_value=512, step=32) (מספר שלם מטווח מסוים).

import kerastuner

# Configure the search space
HPS = kerastuner.engine.hyperparameters.HyperParameters()
HPS.Float('learning_rate', min_value=1e-4, max_value=1e-2, sampling='log')

HPS.Int('num_layers', min_value=2, max_value=5)
for i in range(5):
    HPS.Float('dropout_rate_' + str(i), min_value=0.0, max_value=0.3, step=0.1)
    HPS.Choice('num_units_' + str(i), [32, 64, 128, 256])

from tensorflow.keras import layers
from tensorflow.keras.optimizers import Adam


def create_wide_and_deep_model(hp):

    inputs = create_model_inputs()
    wide = preprocess_categorical_inputs(inputs)
    wide = layers.BatchNormalization()(wide)

    deep = preprocess_numeric_inputs(inputs)
    for i in range(hp.get('num_layers')):
        deep = layers.Dense(hp.get('num_units_' + str(i)))(deep)
        deep = layers.BatchNormalization()(deep)
        deep = layers.ReLU()(deep)
        deep = layers.Dropout(hp.get('dropout_rate_' + str(i)))(deep)

    both = layers.concatenate([wide, deep])
    outputs = layers.Dense(1, activation='sigmoid')(both)
    model = tf.keras.Model(inputs=inputs, outputs=outputs)
    metrics = [
        tf.keras.metrics.Precision(name='precision'),
        tf.keras.metrics.Recall(name='recall'),
        'accuracy',
        'mse'
    ]

    model.compile(
        optimizer=Adam(lr=hp.get('learning_rate')),
        loss='binary_crossentropy',
        metrics=metrics)
    return model

הגדר CloudTuner

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

from tensorflow_cloud import CloudTuner

distribution_strategy = None
if not tfc.remote():
    # Using MirroredStrategy to use a single instance with multiple GPUs
    # during remote execution while using no strategy for local.
    distribution_strategy = tf.distribute.MirroredStrategy()

tuner = CloudTuner(
    create_wide_and_deep_model,
    project_id=GCP_PROJECT_ID,
    project_name=JOB_NAME,
    region=REGION,
    objective='accuracy',
    hyperparameters=HPS,
    max_trials=100,
    directory=GCS_BASE_PATH,
    study_id=STUDY_ID,
    overwrite=True,
    distribution_strategy=distribution_strategy)

# Configure Tensorboard logs
callbacks=[
    tf.keras.callbacks.TensorBoard(log_dir=TENSORBOARD_LOGS_DIR)]

# Setting to run tuning remotely, you can run tuner locally to validate it works first.
if tfc.remote():
    tuner.search(train_ds, epochs=20, validation_data=test_ds, callbacks=callbacks)

# You can uncomment the code below to run the tuner.search() locally to validate
# everything works before submitting the job to Cloud. Stop the job manually
# after one epoch.

# else:
#     tuner.search(train_ds, epochs=1, validation_data=test_ds, callbacks=callbacks)

התחל את האימון מרחוק

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

tfc.run_cloudtuner(
    distribution_strategy='auto',
    docker_config=tfc.DockerConfig(
        image_build_bucket=GCS_BUCKET
        ),
    chief_config=tfc.MachineConfig(
        cpu_cores=16,
        memory=60,
    ),
    job_labels={'job': JOB_NAME},
    service_account=SERVICE_ACCOUNT,
    num_jobs=NUM_JOBS
)

תוצאות אימון

חבר מחדש את מופע ה-Colab שלך

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

ייבוא מודולים נדרשים
תצורות פרויקט
אימות המחברת לשימוש ב-Google Cloud Project שלך

טען Tensorboard

בזמן שהאימון בעיצומו אתה יכול להשתמש ב-Tensorboard כדי לראות את התוצאות. שימו לב שהתוצאות יופיעו רק לאחר תחילת האימון. זה יכול לקחת כמה דקות.

%load_ext tensorboard
%tensorboard --logdir $TENSORBOARD_LOGS_DIR

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

if not tfc.remote():
    tuner.results_summary(1)
    best_model = tuner.get_best_models(1)[0]
    best_hyperparameters = tuner.get_best_hyperparameters(1)[0]

    # References to best trial assets
    best_trial_id = tuner.oracle.get_best_trials(1)[0].trial_id
    best_trial_dir = tuner.get_trial_dir(best_trial_id)