Use o Vertex AI TensorBoard com o Vertex AI Pipelines

O seu código de preparação pode ser incluído num componente de preparação personalizado e executado numa tarefa de pipeline. Os registos do TensorBoard são transmitidos automaticamente para a sua experiência do TensorBoard do Vertex AI. Pode usar esta integração para monitorizar a sua preparação quase em tempo real, à medida que o Vertex AI TensorBoard transmite registos do Vertex AI TensorBoard à medida que são escritos no Cloud Storage.

Para a configuração inicial, consulte o artigo Configure o Vertex AI TensorBoard.

Alterações ao seu script de preparação

O seu script de preparação tem de ser configurado para escrever registos do TensorBoard no contentor do Cloud Storage, cuja localização o serviço Vertex AI Training disponibiliza automaticamente através de uma variável de ambiente predefinida AIP_TENSORBOARD_LOG_DIR.

Normalmente, pode fazê-lo fornecendo os.environ['AIP_TENSORBOARD_LOG_DIR'] como o diretório de registo às APIs de escrita de registos do TensorBoard de código aberto. Normalmente, a localização do AIP_TENSORBOARD_LOG_DIR é definida com a variável staging_bucket.

Para configurar o seu script de preparação no TensorFlow 2.x, crie um callback do TensorBoard e defina a variável log_dir como os.environ['AIP_TENSORBOARD_LOG_DIR']. O callback do TensorBoard é, em seguida, incluído na lista de callbacks do TensorFlow model.fit.

  tensorboard_callback = tf.keras.callbacks.TensorBoard(
       log_dir=os.environ['AIP_TENSORBOARD_LOG_DIR'],
       histogram_freq=1
  )
  
  model.fit(
       x=x_train,
       y=y_train,
       epochs=epochs,
       validation_data=(x_test, y_test),
       callbacks=[tensorboard_callback],
  )

Saiba como a Vertex AI define variáveis de ambiente no seu ambiente de preparação personalizado.

Crie e execute uma pipeline

O exemplo seguinte mostra como criar e executar um pipeline usando o pacote DSL do Kubeflow Pipelines. Para ver mais exemplos e detalhes adicionais, consulte a documentação do Vertex AI Pipelines.

Crie um componente de preparação

Empacote o código de preparação num componente personalizado, certificando-se de que o código está configurado para escrever registos do TensorBoard num contentor do Cloud Storage. Para ver mais exemplos, consulte o artigo Crie os seus próprios componentes de pipeline.

from kfp.v2.dsl import component

@component(
    base_image="tensorflow/tensorflow:latest",
    packages_to_install=["tensorflow_datasets"],
)
def train_tensorflow_model_with_tensorboard():
    import datetime, os
    import tensorflow as tf

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

    def create_model():
        return tf.keras.models.Sequential(
            [
                tf.keras.layers.Flatten(input_shape=(28, 28)),
                tf.keras.layers.Dense(512, activation="relu"),
            ]
        )

    model = create_model()
    model.compile(
        optimizer="adam",
        loss="sparse_categorical_crossentropy",
        metrics=["accuracy"]
    )

    tensorboard_callback = tf.keras.callbacks.TensorBoard(
        log_dir=os.environ['AIP_TENSORBOARD_LOG_DIR'],
        histogram_freq=1
    )

    model.fit(
        x=x_train,
        y=y_train,
        epochs=5,
        validation_data=(x_test, y_test),
        callbacks=[tensorboard_callback],
    )

Crie e compile uma pipeline

Crie uma tarefa de preparação personalizada a partir do componente que criou especificando a especificação do componente em create_custom_training_job_op_from_component. Defina o tensorboard_resource_name para a sua instância do TensorBoard e o staging_bucket para a localização onde preparar os artefactos durante as chamadas API (incluindo registos do TensorBoard).

Em seguida, crie um pipeline para incluir esta tarefa e compile o pipeline num ficheiro JSON.

Para ver mais exemplos e informações, consulte os artigos Componentes de tarefas personalizadas e Crie um pipeline.

from kfp.v2 import compiler
from google_cloud_pipeline_components.v1.custom_job.utils import \
    create_custom_training_job_op_from_component
from kfp.v2 import dsl

def create_tensorboard_pipeline_sample(
    project, location, staging_bucket, display_name, service_account, experiment, tensorboard_resource_name
):

    @dsl.pipeline(
        pipeline_root=f"{staging_bucket}/pipeline_root",
        name=display_name,
    )
    def pipeline():
        custom_job_op = create_custom_training_job_op_from_component(
            component_spec=train_tensorflow_model_with_tensorboard,
            tensorboard=tensorboard_resource_name,
            base_output_directory=staging_bucket,
            service_account=service_account,
        )
        custom_job_op(project=project, location=location)

    compiler.Compiler().compile(
        pipeline_func=pipeline, package_path=f"{display_name}.json"
    )

Envie um pipeline do Vertex AI

Envie o seu pipeline através do SDK Vertex AI para Python. Para mais informações, consulte o artigo Execute um pipeline.

Python

from typing import Any, Dict, Optional

from google.cloud import aiplatform


def log_pipeline_job_to_experiment_sample(
    experiment_name: str,
    pipeline_job_display_name: str,
    template_path: str,
    pipeline_root: str,
    project: str,
    location: str,
    parameter_values: Optional[Dict[str, Any]] = None,
):
    aiplatform.init(project=project, location=location)

    pipeline_job = aiplatform.PipelineJob(
        display_name=pipeline_job_display_name,
        template_path=template_path,
        pipeline_root=pipeline_root,
        parameter_values=parameter_values,
    )

    pipeline_job.submit(experiment=experiment_name)
  • experiment_name: indique um nome para a sua experiência.
  • pipeline_job_display_name: o nome a apresentar para a tarefa do pipeline.
  • template_path: o caminho para o modelo de pipeline compilado.
  • pipeline_root: especifique um URI do Cloud Storage ao qual a conta de serviço das suas pipelines pode aceder. Os artefactos das execuções do pipeline são armazenados na raiz do pipeline.
  • parameter_values: os parâmetros do pipeline a transmitir a esta execução. Por exemplo, crie um dict() com os nomes dos parâmetros como as chaves do dicionário e os valores dos parâmetros como os valores do dicionário.
  • project: . O projeto do Google Cloud para executar o pipeline. Pode encontrar os seus IDs na página de Google Cloud boas-vindas da consola.
  • location: a localização onde executar o pipeline. Esta deve ser a mesma localização que a instância do TensorBoard que está a usar.

O que se segue?