Classes de previsão

O SDK da Vertex AI inclui as seguintes classes de previsão. Uma classe destina-se a previsões em lote. As outras estão relacionadas com previsões online ou previsões de pesquisa vetorial. Para mais informações, consulte a Vista geral da obtenção de previsões no Vertex AI.

Classe de previsão em lote

Uma previsão em lote é um grupo de pedidos de previsão assíncronos. Pede previsões em lote do recurso do modelo sem ter de implementar o modelo num ponto final. As previsões em lote são adequadas quando não precisa de uma resposta imediata e quer processar dados com um único pedido. BatchPredictionJob é a única classe no SDK do Vertex AI que é específica das previsões em lote.

BatchPredictionJob

A classe BatchPredictionJob representa um grupo de pedidos de previsão assíncronos. Existem duas formas de criar uma tarefa de previsão em lote:

  1. A forma preferencial de criar uma tarefa de previsão em lote é usar o método batch_predict no seu Model preparado. Este método requer os seguintes parâmetros:

    • instances_format: o formato do ficheiro de pedido de previsão em lote: jsonl, csv, bigquery, tf-record, tf-record-gzip ou file-list.
    • prediction_format: O formato do ficheiro de resposta da previsão em lote: jsonl, csv, bigquery, tf-record, tf-record-gzip ou file-list.
    • gcs_source: Uma lista de um ou mais caminhos do Cloud Storage para os seus pedidos de previsão em lote.
    • gcs_destination_prefix: o caminho do Cloud Storage para o qual o Vertex AI escreve as previsões.

    O código seguinte é um exemplo de como pode chamar Model.batch_predict:

    batch_prediction_job = model.batch_predict(
    instances_format="jsonl",
    predictions_format="jsonl",
    job_display_name="your_job_display_name_string",
    gcs_source=['gs://path/to/my/dataset.csv'],
    gcs_destination_prefix='gs://path/to/my/destination',
    model_parameters=None,
    starting_replica_count=1,
    max_replica_count=5,
    machine_type="n1-standard-4",
    sync=True
)

  2. A segunda forma de criar uma tarefa de previsão em lote é chamar o método BatchPredictionJob.create. O método BatchPredictionJob.create requer quatro parâmetros:

    • job_display_name: um nome que atribui à tarefa de previsão em lote. Tenha em atenção que, embora job_display_name seja obrigatório para BatchPredictionJob.create, é opcional para Model.batch_predict.
    • model_name: o nome totalmente qualificado ou o ID do Model preparado que usa para a tarefa de previsão em lote.
    • instances_format: o formato do ficheiro de pedido de previsão em lote: jsonl, csv, bigquery, tf-record, tf-record-gzip ou file-list.
    • predictions_format: O formato do ficheiro de resposta da previsão em lote: jsonl, csv, bigquery, tf-record, tf-record-gzip ou file-list.

Aulas de previsão online

As previsões online são pedidos síncronos feitos a um ponto final do modelo. Tem de implementar o modelo num ponto final antes de poder fazer um pedido de previsão online. Use previsões online quando quiser previsões geradas com base na entrada da aplicação ou quando precisar de uma resposta de previsão rápida.

Endpoint

Antes de poder receber previsões online do seu modelo, tem de implementar o modelo num ponto final. Quando implementa um modelo num ponto final, associa os recursos da máquina física ao modelo para que possa publicar previsões online.

Pode implementar mais do que um modelo num único ponto final. Também pode implementar um modelo em mais de um ponto final. Para mais informações, consulte o artigo Considerações para a implementação de modelos.

Para criar um recurso Endpoint, implemente o seu modelo. Quando chama o método Model.deploy, cria e devolve um Endpoint.

Segue-se um exemplo de fragmento do código que mostra como criar uma tarefa de preparação personalizada, criar e preparar um modelo e, em seguida, implementar o modelo num ponto final.

# Create your custom training job

job = aiplatform.CustomTrainingJob(
    display_name="my_custom_training_job",
    script_path="task.py",
    container_uri="us-docker.pkg.dev/vertex-ai/training/tf-cpu.2-8:latest",
    requirements=["google-cloud-bigquery>=2.20.0", "db-dtypes"],
    model_serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-8:latest"
)

# Start the training and create your model
model = job.run(
    dataset=dataset,
    model_display_name="my_model_name",
    bigquery_destination=f"bq://{project_id}"
)

# Create an endpoint and deploy your model to that endpoint
endpoint = model.deploy(deployed_model_display_name="my_deployed_model")

# Get predictions using test data in a DataFrame named 'df_my_test_data'
predictions = endpoint.predict(instances=df_my_test_data)

PrivateEndpoint

Um ponto final privado é como um recurso Endpoint, exceto que as previsões são enviadas através de uma rede segura para o serviço de previsão online do Vertex AI. Use um ponto final privado se a sua organização quiser manter todo o tráfego privado.

Para usar um ponto final privado, tem de configurar a Vertex AI para estabelecer uma relação de interligação com uma nuvem privada virtual (VPC). É necessária uma VPC para que o ponto final de previsão privado se ligue diretamente ao Vertex AI. Para mais informações, consulte Configure o peering de redes VPC e Use pontos finais privados para a previsão online.

ModelDeploymentMonitoringJob

Use o recurso ModelDeploymentMonitoringJob para monitorizar o seu modelo e receber alertas se este se desviar de uma forma que possa afetar a qualidade das previsões do modelo.

Quando os dados de entrada se desviam dos dados usados para preparar o modelo, o desempenho do modelo pode deteriorar-se, mesmo que o modelo não tenha sido alterado. A monitorização de modelos analisa a data de entrada para a distribuição assimétrica e a deriva de funcionalidades:

  • A Skew ocorre quando a distribuição de dados de caraterísticas de produção se desvia dos dados de caraterísticas usados para preparar o modelo.
  • A deriva ocorre quando os dados das funcionalidades de produção mudam significativamente ao longo do tempo.

Para mais informações, consulte o artigo Introdução à monitorização de modelos do Vertex AI. Para ver um exemplo de como implementar a monitorização da Vertex AI com o SDK Vertex AI, consulte o bloco de notas Vertex AI model monitoring with explainable AI feature attributions no GitHub.

Classes de previsão do Vector Search

A pesquisa vetorial é um serviço gerido que cria índices de semelhança ou vetores para realizar a correspondência de semelhanças. Existem dois passos de alto nível para realizar a correspondência por semelhança:

  1. Crie uma representação vetorial dos seus dados. Os dados podem ser texto, imagens, vídeo, áudio ou dados tabulares.

  2. O Vector Search usa os pontos finais dos vetores que cria para realizar uma pesquisa de alta escala e baixa latência de vetores semelhantes.

Para mais informações, consulte a vista geral da pesquisa vetorial e o bloco de notas Crie um índice de pesquisa vetorial no GitHub.

MatchingEngineIndex

A classe MatchingEngineIndex representa os índices ou os vetores que cria e que o Vector Search usa para realizar a respetiva pesquisa de similaridade.

Existem dois algoritmos de pesquisa que pode usar para o seu índice:

  1. O TreeAhConfig usa um algoritmo de árvore AH superficial (árvore superficial com hash assimétrico). Use MatchingEngineIndex.create_tree_ah_index para criar um índice que use o algoritmo tree-AH.
  2. BruteForceConfig usa uma pesquisa linear padrão) Use MatchingEngineIndex.create_brute_force_index para criar um índice que usa uma pesquisa linear padrão.

Para mais informações sobre como pode configurar os seus índices, consulte o artigo Configure os índices.

O código seguinte é um exemplo de criação de um índice que usa o algoritmo tree-AH:

my_tree_ah_index = aiplatform.Index.create_tree_ah_index(
    display_name="my_display_name",
    contents_delta_uri="gs://my_bucket/embeddings",
    dimensions=1,
    approximate_neighbors_count=150,
    distance_measure_type="SQUARED_L2_DISTANCE",
    leaf_node_embedding_count=100,
    leaf_nodes_to_search_percent=50,
    description="my description",
    labels={ "label_name": "label_value" }
)

O código seguinte é um exemplo de criação de um índice que usa o algoritmo de força bruta:

my_brute_force_index = aiplatform.Index.create_brute_force_index(
    display_name="my_display_name",
    contents_delta_uri="gs://my_bucket/embeddings",
    dimensions=1,
    approximate_neighbors_count=150,
    distance_measure_type="SQUARED_L2_DISTANCE",
    description="my description",
    labels={ "label_name": "label_value" }
)

MatchingEngineIndexEndpoint

Use a classe MatchingEngineIndexEndpoint para criar e obter um ponto final. Depois de implementar um modelo no seu ponto final, recebe um endereço IP que usa para executar as suas consultas.

O código seguinte é um exemplo de criação de um ponto final do índice do motor de correspondência e, em seguida, de implementação de um índice do motor de correspondência no mesmo:

my_index_endpoint = aiplatform.MatchingEngineIndexEndpoint.create(
    display_name="sample_index_endpoint",
    description="index endpoint description",
    network="projects/123456789123/global/networks/my_vpc"
)

my_index_endpoint = my_index_endpoint.deploy_index(
    index=my_tree_ah_index, deployed_index_id="my_matching_engine_index_id"
)

O que se segue?