Trainingsscript erstellen

Zum Erstellen eines benutzerdefinierten Modells benötigen Sie ein Python-Trainingsskript, das das benutzerdefinierte Modell erstellt und trainiert. Sie initialisieren den Trainingsjob mit dem Python-Trainingsskript und rufen dann die Methode run des Trainingsjobs auf, um das Skript auszuführen.

In diesem Thema erstellen Sie das Trainingsskript und geben dann Befehlsargumente für Ihr Trainingsskript an.

Trainingsskript erstellen

In diesem Abschnitt erstellen Sie ein Trainingsskript. Dieses Skript ist eine neue Datei mit dem Namen task.py in Ihrer Notebookumgebung. Später in dieser Anleitung übergeben Sie dieses Skript an den Konstruktor aiplatform.CustomTrainingJob. Das Skript führt folgende Schritte aus:

  • Lädt die Daten in das von Ihnen erstellte BigQuery-Dataset.

  • Verwendet die TensorFlow Keras API zum Erstellen, Kompilieren und Trainieren Ihres Modells.

  • Gibt die Anzahl der Epochen und die Batchgröße an, die beim Aufrufen der Keras-Methode Model.fit verwendet werden soll.

  • Gibt an, wo Modellartefakte mit der Umgebungsvariable AIP_MODEL_DIR gespeichert werden. AIP_MODEL_DIR wird von Vertex AI festgelegt und enthält den URI eines Verzeichnisses zum Speichern von Modellartefakten. Weitere Informationen finden Sie unter Umgebungsvariablen für spezielle Cloud Storage-Verzeichnisse.

  • Exportiert eine TensorFlow-SavedModel in das Modellverzeichnis. Weitere Informationen finden Sie auf der TensorFlow-Website unter SavedModel-Format verwenden.

Führen Sie den folgenden Code in Ihrem Notebook aus, um das Trainingsskript zu erstellen:

%%writefile task.py

import argparse
import numpy as np
import os

import pandas as pd
import tensorflow as tf

from google.cloud import bigquery
from google.cloud import storage

# Read environmental variables
training_data_uri = os.getenv("AIP_TRAINING_DATA_URI")
validation_data_uri = os.getenv("AIP_VALIDATION_DATA_URI")
test_data_uri = os.getenv("AIP_TEST_DATA_URI")

# Read args
parser = argparse.ArgumentParser()
parser.add_argument('--label_column', required=True, type=str)
parser.add_argument('--epochs', default=10, type=int)
parser.add_argument('--batch_size', default=10, type=int)
args = parser.parse_args()

# Set up training variables
LABEL_COLUMN = args.label_column

# See https://cloud.google.com/vertex-ai/docs/workbench/managed/executor#explicit-project-selection for issues regarding permissions.
PROJECT_NUMBER = os.environ["CLOUD_ML_PROJECT_ID"]
bq_client = bigquery.Client(project=PROJECT_NUMBER)


# Download a table
def download_table(bq_table_uri: str):
    # Remove bq:// prefix if present
    prefix = "bq://"
    if bq_table_uri.startswith(prefix):
        bq_table_uri = bq_table_uri[len(prefix) :]

    # Download the BigQuery table as a dataframe
    # This requires the "BigQuery Read Session User" role on the custom training service account.
    table = bq_client.get_table(bq_table_uri)
    return bq_client.list_rows(table).to_dataframe()

# Download dataset splits
df_train = download_table(training_data_uri)
df_validation = download_table(validation_data_uri)
df_test = download_table(test_data_uri)

def convert_dataframe_to_dataset(
    df_train: pd.DataFrame,
    df_validation: pd.DataFrame,
):
    df_train_x, df_train_y = df_train, df_train.pop(LABEL_COLUMN)
    df_validation_x, df_validation_y = df_validation, df_validation.pop(LABEL_COLUMN)

    y_train = tf.convert_to_tensor(np.asarray(df_train_y).astype("float32"))
    y_validation = tf.convert_to_tensor(np.asarray(df_validation_y).astype("float32"))

    # Convert to numpy representation
    x_train = tf.convert_to_tensor(np.asarray(df_train_x).astype("float32"))
    x_test = tf.convert_to_tensor(np.asarray(df_validation_x).astype("float32"))

    # Convert to one-hot representation
    num_species = len(df_train_y.unique())
    y_train = tf.keras.utils.to_categorical(y_train, num_classes=num_species)
    y_validation = tf.keras.utils.to_categorical(y_validation, num_classes=num_species)

    dataset_train = tf.data.Dataset.from_tensor_slices((x_train, y_train))
    dataset_validation = tf.data.Dataset.from_tensor_slices((x_test, y_validation))
    return (dataset_train, dataset_validation)

# Create datasets
dataset_train, dataset_validation = convert_dataframe_to_dataset(df_train, df_validation)

# Shuffle train set
dataset_train = dataset_train.shuffle(len(df_train))

def create_model(num_features):
    # Create model
    Dense = tf.keras.layers.Dense
    model = tf.keras.Sequential(
        [
            Dense(
                100,
                activation=tf.nn.relu,
                kernel_initializer="uniform",
                input_dim=num_features,
            ),
            Dense(75, activation=tf.nn.relu),
            Dense(50, activation=tf.nn.relu),
            Dense(25, activation=tf.nn.relu),
            Dense(3, activation=tf.nn.softmax),
        ]
    )

    # Compile Keras model
    optimizer = tf.keras.optimizers.RMSprop(lr=0.001)
    model.compile(
        loss="categorical_crossentropy", metrics=["accuracy"], optimizer=optimizer
    )

    return model

# Create the model
model = create_model(num_features=dataset_train._flat_shapes[0].dims[0].value)

# Set up datasets
dataset_train = dataset_train.batch(args.batch_size)
dataset_validation = dataset_validation.batch(args.batch_size)

# Train the model
model.fit(dataset_train, epochs=args.epochs, validation_data=dataset_validation)

tf.saved_model.save(model, os.getenv("AIP_MODEL_DIR"))

Nachdem Sie das Script erstellt haben, wird es im Stammverzeichnis Ihres Notebooks angezeigt: Trainingsskript ansehen.

Argumente für Ihr Trainingsskript definieren

Sie übergeben die folgenden Befehlszeilenargumente an Ihr Trainingsskript:

  • label_column – Hiermit wird die Spalte in Ihren Daten identifiziert, die das vorherzusagende Element enthält. In diesem Fall lautet diese Spalte species. Sie haben dies bei der Verarbeitung Ihrer Daten in einer Variablen mit dem Namen LABEL_COLUMN definiert. Weitere Informationen finden Sie unter Daten herunterladen, vorverarbeiten und aufteilen.

  • epochs – Dies ist die Anzahl der Epochen, die beim Trainieren Ihres Modells verwendet werden. Eine Epoche ist eine Iteration über die Daten beim Training Ihres Modells. Diese Anleitung umfasst 20 Epochen.

  • batch_size – Die Anzahl der Stichproben, die vor der Aktualisierung Ihres Modells verarbeitet werden. In dieser Anleitung wird eine Batchgröße von 10 verwendet.

Führen Sie den folgenden Code aus, um die Argumente zu definieren, die an Ihr Skript übergeben werden:

JOB_NAME = "custom_job_unique"

EPOCHS = 20
BATCH_SIZE = 10

CMDARGS = [
    "--label_column=" + LABEL_COLUMN,
    "--epochs=" + str(EPOCHS),
    "--batch_size=" + str(BATCH_SIZE),
]
Zurück
Dataset erstellen
Weiter
Modell trainieren