Crea una secuencia de comandos de entrenamiento

Para crear un modelo personalizado, necesitas una secuencia de comandos de entrenamiento de Python que cree y entrene el modelo personalizado. Inicializa el trabajo de entrenamiento con la secuencia de comandos de entrenamiento de Python y, luego, invoca el método run del trabajo de entrenamiento para ejecutar la secuencia de comandos.

En este tema, crearás la secuencia de comandos de entrenamiento y, luego, especificarás los argumentos del comando para la secuencia de comandos de entrenamiento.

Crea una secuencia de comandos de entrenamiento

En esta sección, crearás una secuencia de comandos de entrenamiento. Esta secuencia de comandos es un archivo nuevo en tu entorno de notebook llamado task.py. Más adelante en este instructivo, pasarás esta secuencia de comandos al constructor aiplatform.CustomTrainingJob. Cuando se ejecuta la secuencia de comandos, hace lo siguiente:

• Carga los datos en el conjunto de datos de BigQuery que creaste.

• Usa la API de Keras de TensorFlow para compilar, compilar y entrenar tu modelo.

• Especifica la cantidad de ciclos de entrenamiento y el tamaño del lote que se debe usar cuando se invoca el método Model.fit de Keras.

• Especifica dónde se deben guardar los artefactos del modelo con la variable de entorno AIP_MODEL_DIR. AIP_MODEL_DIR que establece Vertex AI y contiene el URI de un directorio para guardar artefactos de modelos. Si quieres obtener más información, consulta Variables de entorno para directorios especiales de Cloud Storage.

• Exporta un SavedModel de TensorFlow al directorio del modelo. Para obtener más información, consulta Usa el formato SavedModel en el sitio web de TensorFlow.

Para crear tu secuencia de comandos de entrenamiento, ejecuta el siguiente código en tu notebook:

%%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"))

Después de crear la secuencia de comandos, aparecerá en la carpeta raíz de tu notebook:

Define argumentos para tu secuencia de comandos de entrenamiento

Debes pasar los siguientes argumentos de la línea de comandos a la secuencia de comandos de entrenamiento:

• label_column: Identifica la columna en tus datos que contiene lo que deseas predecir. En este caso, esa columna es species. Definiste esto en una variable llamada LABEL_COLUMN cuando procesaste tus datos. Para obtener más información, consulta Descarga, procesa y divide los datos.

• epochs: Es la cantidad de ciclos de entrenamiento que se usan cuando entrenas tu modelo. Un ciclo de entrenamiento es una iteración sobre los datos cuando se entrena tu modelo. En este instructivo, se usan 20 ciclos de entrenamiento.

• batch_size: Es la cantidad de muestras que se procesan antes de que se actualice el modelo. En este instructivo, se usa un tamaño de lote de 10.

Para definir los argumentos que se pasan a tu secuencia de comandos, ejecuta el siguiente código:

JOB_NAME = "custom_job_unique"

EPOCHS = 20
BATCH_SIZE = 10

CMDARGS = [
    "--label_column=" + LABEL_COLUMN,
    "--epochs=" + str(EPOCHS),
    "--batch_size=" + str(BATCH_SIZE),
]