Acompanhamento de aulas

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

  • Classes que usam metadados para acompanhar os recursos no seu fluxo de trabalho de aprendizagem automática
  • Classes que são usadas para o Vertex AI Experiments
  • Classes usadas para um Vertex AI TensorBoard

Os tópicos seguintes oferecem uma vista geral das classes relacionadas com a monitorização e o acompanhamento de um fluxo de trabalho de ML no SDK Vertex AI para Python.

Classes de metadados

Pode usar o SDK Vertex AI para Python para criar metadados do Vertex ML que ajudam a acompanhar e analisar os metadados no seu fluxo de trabalho de ML. Para mais informações, consulte a Introdução aos metadados do Vertex ML.

Artifact

A classe Artifact representa os metadados num artefacto no Vertex AI. Um artefacto é uma entidade discreta ou um fragmento de dados produzido por um fluxo de trabalho de ML. Exemplos de um artefacto são um conjunto de dados, um modelo e um ficheiro de entrada. Para mais informações, consulte o artigo Acompanhe execuções e artefactos.

Quando cria um recurso Artifact, tem de especificar o respetivo esquema. Cada tipo de artefacto tem um esquema único. Por exemplo, o esquema system.Dataset representa um conjunto de dados e o esquema system.Metrics representa métricas de avaliação. Para mais informações, consulte o artigo Como usar esquemas do sistema.

O exemplo de código seguinte 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 numa execução no Vertex AI. Uma execução é um passo num fluxo de trabalho de ML. Exemplos de uma execução: tratamento de dados, preparação e avaliação de modelos. Uma execução pode consumir artefactos, como um conjunto de dados, e produzir um artefacto, 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 o retomar.

O seguinte exemplo de código 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])

Classes do Vertex AI Experiments

Pode usar o SDK Vertex AI para Python para criar e executar experiências do Vertex AI. Use o Vertex AI Experiments para acompanhar as métricas e os parâmetros registados, o que ajuda a analisar e otimizar o fluxo de trabalho de ML. Para mais informações, consulte o artigo Introdução às experiências da Vertex AI.

Para saber como usar as classes Experiment e ExperimentRun, experimente um dos seguintes tutoriais:

Experiment

A classe Experiment representa uma experiência no Vertex AI. Use uma experiência para analisar as respetivas execuções de experiências e execuções de pipelines com diferentes configurações, como vários artefactos de entrada e hiperparâmetros.

Existem duas formas de criar um recurso Experiment:

  1. A forma preferencial de criar uma Experiment é especificar um nome para a experiência como um parâmetro quando chama 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 pode criar um Experiment ligando para aiplatform.Experiment.create. aiplatform.Experiment.create cria o recurso Experiment, mas não o define para um ambiente global. Por este motivo, não pode executar a experiência com aiplatform.start_run. O código de exemplo seguinte mostra como usar aiplatform.Experiment.create para criar uma experiência e, em seguida, executá-la:

    # 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 uma experiência.

O seguinte exemplo de código mostra como criar e iniciar uma execução de experiência e, em seguida, usá-la para obter informações sobre a sua experiência. Para eliminar a execução da experiência, obtenha uma referência à instância ExperimentRun e chame o respetivo método delete.

# 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 Vertex AI TensorBoard

O SDK Vertex AI para Python inclui classes para trabalhar com uma versão gerida do open source Vertex AI TensorBoard. O Vertex AI TensorBoard é uma ferramenta usada para monitorizar medições e visualizações durante o seu fluxo de trabalho de ML. Para mais informações, consulte o artigo Comece a usar o Vertex AI TensorBoard.

Para saber como usar o SDK Vertex AI para Python para trabalhar com o Vertex AI TensorBoard, experimente um dos seguintes tutoriais de blocos de notas:

Tensorboard

A classe Tensorboard representa um recurso gerido que armazena experiências do Vertex AI TensorBoard. Tem de criar uma instância do Tensorboard antes de poder visualizar as experiências. Pode criar mais do que uma instância doTensorboard num projeto do Google Cloud .

O seguinte exemplo de código mostra como criar uma instância de 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 elemento TensorboardExperiment representa um grupo de TensorboardRun objetos. Uma instância TensorboardRun representa os resultados de uma tarefa de preparação executada num TensorBoard.

TensorboardRun

Uma instância da classe TensorboardRun é mapeada para uma tarefa de preparação executada num 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 preparação.

O que se segue?