Classes de acompanhamento

O SDK da Vertex AI para Python inclui classes que ajudam na visualização, nas medições e no rastreamento. Essas classes podem ser agrupadas em três tipos:

  • Classes que usam metadados para rastrear recursos no fluxo de trabalho de machine learning (ML)
  • Classes usadas para experimentos da Vertex AI
  • Classes usadas para um TensorBoard da Vertex AI

Os tópicos a seguir fornecem uma visão geral das classes relacionadas ao rastreamento e monitoramento de um fluxo de trabalho de ML no SDK da Vertex AI para Python.

Classes de metadados

É possível usar o SDK da Vertex AI para Python para criar Vertex ML Metadata. Isso ajuda a rastrear e analisar os metadados no fluxo de trabalho de ML. Para mais informações, consulte Introdução aos Vertex ML Metadata.

Artifact

A classe Artifact representa os metadados em um artefato na Vertex AI. Um artefato é uma entidade discreta ou um dado produzido por um fluxo de trabalho de ML. Exemplos de um artefato são um conjunto de dados, um modelo e um arquivo de entrada. Para mais informações, consulte Rastrear execuções e artefatos.

Ao criar um recurso Artifact, você precisa especificar o esquema dele. Cada tipo de artefato tem um esquema exclusivo. Por exemplo, o esquema system.Dataset representa um conjunto de dados, e o esquema system.Metrics representa métricas de avaliação. Para saber mais, consulte Como usar esquemas do sistema.

O exemplo de código a seguir mostra como criar um recurso Artifact que representa um modelo:

model_artifact = aiplatform.Artifact.create(
        schema_title="system.Model",
        display_name=PREPROCESSED_DATASET_NAME,
        uri=PREPROCESSED_DATASET_URI,

Execution

A classe Execution representa os metadados em uma execução na Vertex AI. Uma execução é uma etapa em um fluxo de trabalho de ML. Exemplos de execução são processamento de dados, treinamento e avaliação de modelo. Uma execução pode consumir artefatos, como um conjunto de dados, e produzir um artefato, como um modelo.

Use aiplatform.start_execution para criar um recurso Execution. Depois de criar um recurso Execution, use o mesmo método aiplatform.start_execution com o parâmetro resume definido como True para retomá-lo.

O exemplo de código a seguir mostra como criar um recurso Execution:

with aiplatform.start_execution(schema_title='system.ContainerExecution',
                                display_name='trainer') as execution:
    execution.assign_input_artifacts([my_artifact])
    model = aiplatform.Artifact.create(uri='gs://my-uri', schema_title='system.Model')
    execution.assign_output_artifacts([model])

Aulas de experimentos da Vertex AI

É possível usar o SDK da Vertex AI para Python para criar e executar experimentos da Vertex AI. Use os experimentos da Vertex AI para rastrear métricas e parâmetros registrados para ajudar a analisar e otimizar seu fluxo de trabalho de ML. Para mais informações, consulte Introdução aos experimentos da Vertex AI.

Para saber mais sobre como usar as classes Experiment e ExperimentRun, siga um destes tutoriais:

Experiment

A classe Experiment representa um experimento na Vertex AI. Usar um experimento para analisar as execuções do experimento e as execuções do pipeline com diferentes configurações, como vários artefatos de entrada e hiperparâmetros.

Há duas maneiras de criar um recurso Experiment:

  1. A maneira preferencial de criar um Experiment é especificando um nome para o experimento como um parâmetro ao chamar aiplatform.init:

    # In a real world scenario it's likely you would specify more parameters
# when you call aiplatform.init. This sample shows only how to use the
# parameter used to create an Experiment.

# Specify a name for the experiment
EXPERIMENT_NAME = "your-experiment-name"

# Create the experiment
aiplatform.init(experiment=EXPERIMENT_NAME)

  2. Também é possível criar um Experiment chamando aiplatform.Experiment.create. aiplatform.Experiment.create cria o recurso Experiment, mas não o define como um ambiente global. Por isso, não é possível executar o experimento com aiplatform.start_run. O código de exemplo a seguir mostra como usar o aiplatform.Experiment.create para criar um experimento e, em seguida, executá-lo:

    # Specify a name for the experiment
EXPERIMENT_NAME = "your-experiment-name"
EXPERIMENT_RUN_NAME = "your-run"

# Create the experiment
experiment = aiplatform.Experiment.create(experiment_name=EXPERIMENT_NAME)
experiment_run = aiplatform.ExperimentRun.create(EXPERIMENT_RUN_NAME, experiment=EXPERIMENT_NAME)

ExperimentRun

A classe ExperimentRun representa a execução de um experimento.

O código de exemplo a seguir mostra como criar e iniciar uma execução de experimento e usá-lo para receber informações sobre o experimento. Para excluir a execução do experimento, acesse uma referência à instância ExperimentRun e chame o método delete dela (em inglês).

# Specify your project name, location, experiment name, and run name
PROJECT_NAME = "my-project"
LOCATION = "us-central1"
EXPERIMENT_NAME = "experiment-1"
RUN_NAME = "run-1"

# Create the experiment to run
aiplatform.init(experiment=EXPERIMENT_NAME,
                project=PROJECT_NAME,
                location=LOCATION)

# Create and run an ExperimentRun resource. Next, you can use it to get
# information about your experiment. For example, you can log parameters and
# metrics with specified key-value pairs.
with aiplatform.start_run(RUN_NAME):
     aiplatform.log_params({'learning_rate': 0.1, 'dropout_rate': 0.2})
     aiplatform.log_metrics({'accuracy': 0.9, 'recall': 0.8})

# Get a reference to the ExperimentRun resource, get the parameters logged to 
# the run, get the summary metrics logged to the run, then delete it.
with aiplatform.start_run(RUN_NAME, resume=True) as run:
     run.get_params()
     run.get_metrics()
     run.delete()

Classes do TensorBoard da Vertex AI

O SDK da Vertex AI para Python inclui classes para trabalhar com uma versão gerenciada do TensorBoard da Vertex AI de código aberto. O TensorBoard da Vertex AI é uma ferramenta usada para monitorar medições e visualizações durante o fluxo de trabalho de ML. Para mais informações, consulte Primeiros passos com o Vertex AI TensorBoard.

Para saber mais sobre como usar o SDK da Vertex AI para Python para trabalhar com o Vertex AI TensorBoard, siga um destes tutoriais de notebook:

Tensorboard

A classe Tensorboard representa um recurso gerenciado que armazena experimentos do Vertex AI TensorBoard. Você precisa criar uma instância Tensorboard antes que os experimentos possam ser visualizados. É possível criar mais de uma instância do Tensorboard em um projeto do Google Cloud.

O exemplo de código a seguir mostra como criar uma instância Tensorboard:

# Specify your project name, location, and the name of your Tensorboard
PROJECT_NAME = "my-project"
LOCATION = "us-central1"
TENSORBOARD_NAME = "my-tensorboard"

aiplatform.init(project=PROJECT_NAME, location=LOCATION)

tensorboard = aiplatform.Tensorboard.create(
    display_name=TENSORBOARD_NAME,
    project=PROJECT_NAME,
    location=LOCATION,
)

TensorboardExperiment

O TensorboardExperiment representa um grupo de objetos TensorboardRun. Uma instância TensorboardRun representa os resultados de um job de treinamento executado em um TensorBoard.

TensorboardRun

Uma instância da classe TensorboardRun é mapeada para um job de treinamento executado em um TensorBoard com um conjunto especificado de hiperparâmetros, uma definição de modelo, um conjunto de dados e muito mais.

TensorboardTimeSeries

A classe TensorboardTimeSeries representa uma série produzida em execuções de treinamento.

A seguir