Avalie e itere modelos de classificação de imagens da AutoML

Esta página mostra como avaliar os modelos de classificação de imagens do AutoML para poder iterar no seu modelo.

O Vertex AI fornece métricas de avaliação de modelos para ajudar a determinar o desempenho dos seus modelos, como métricas de precisão e recall. O Vertex AI calcula as métricas de avaliação através do conjunto de testes.

Como usa as métricas de avaliação de modelos

As métricas de avaliação do modelo fornecem medições quantitativas do desempenho do modelo no conjunto de testes. A forma como interpreta e usa essas métricas depende das necessidades da sua empresa e do problema que o seu modelo foi preparado para resolver. Por exemplo, pode ter uma tolerância inferior a falsos positivos do que a falsos negativos ou vice-versa. Estes tipos de perguntas afetam as métricas nas quais se deve focar.

Para mais informações sobre a iteração no seu modelo para melhorar o respetivo desempenho, consulte o artigo Iterar no seu modelo.

Métricas de avaliação devolvidas pelo Vertex AI

O Vertex AI devolve várias métricas de avaliação diferentes, como precisão, recall e limites de confiança. As métricas que o Vertex AI devolve dependem do objetivo do seu modelo. Por exemplo, o Vertex AI fornece diferentes métricas de avaliação para um modelo de classificação de imagens em comparação com um modelo de deteção de objetos de imagem.

Um ficheiro de esquema, transferível a partir de uma localização do Cloud Storage, determina as métricas de avaliação que o Vertex AI fornece para cada objetivo. Os separadores seguintes fornecem links para os ficheiros de esquema e descrevem as métricas de avaliação para cada objetivo do modelo.

Pode ver e transferir ficheiros de esquemas a partir da seguinte localização do Cloud Storage:
gs://google-cloud-aiplatform/schema/modelevaluation/

  • AuPRC: a área sob a curva de precisão-revocação (PR), também denominada precisão média. Este valor varia entre zero e um, em que um valor mais elevado indica um modelo de qualidade superior.
  • Perda logarítmica: a entropia cruzada entre as inferências do modelo e os valores de destino. Este valor varia entre zero e infinito, sendo que um valor mais baixo indica um modelo de qualidade superior.
  • Limite de confiança: uma pontuação de confiança que determina as inferências a devolver. Um modelo devolve inferências que estão neste valor ou superior. Um limite de confiança mais elevado aumenta a precisão, mas diminui a revocação. A Vertex AI devolve métricas de confiança a diferentes valores de limite para mostrar como o limite afeta a precisão e a recolha.
  • Recall: a fração de inferências com esta classe que o modelo previu corretamente. Também denominada taxa de verdadeiros positivos.
  • Precisão: a fração de inferências de classificação produzidas pelo modelo que estavam corretas.
  • Matriz de confusão: uma matriz de confusão mostra a frequência com que um modelo previu corretamente um resultado. Para resultados previstos incorretamente, a matriz mostra o que o modelo previu em alternativa. A matriz de confusão ajuda a compreender onde o seu modelo está a "confundir" dois resultados.

Obter métricas de avaliação

Pode obter um conjunto agregado de métricas de avaliação para o seu modelo e, para alguns objetivos, métricas de avaliação para uma classe ou uma etiqueta específica. As métricas de avaliação de uma classe ou uma etiqueta específica também são conhecidas como uma divisão de avaliação. O conteúdo seguinte descreve como obter métricas de avaliação agregadas e divisões de avaliação através da Google Cloud consola ou da API.

Google Cloud consola

  1. Na Google Cloud consola, na secção Vertex AI, aceda à página Modelos.

    Aceda à página Modelos

  2. No menu pendente Região, selecione a região onde o seu modelo está localizado.

  3. Na lista de modelos, clique no seu modelo, que abre o separador Avaliar do modelo.

    No separador Avaliar, pode ver as métricas de avaliação agregadas do modelo, como a Precisão média e a Relembrança.

    Se o objetivo do modelo tiver divisões de avaliação, a consola mostra uma lista de etiquetas. Pode clicar numa etiqueta para ver as métricas de avaliação dessa etiqueta, como mostrado no exemplo seguinte:

    seleção de etiquetas na consola

    (Pré-visualização) Para cada etiqueta, pode ver as imagens previstas agrupadas como verdadeiros positivos, falsos positivos e falsos negativos. Cada imagem tem uma métrica de distância L2 ao quadrado que mede a semelhança da imagem com as imagens de preparação. Uma imagem etiquetada com um emblema de Valor atípico é relativamente diferente de todas as imagens de preparação. Para melhorar o desempenho do modelo, deve ponderar adicionar mais imagens de preparação semelhantes aos valores atípicos.

API

Os pedidos da API para obter métricas de avaliação são iguais para cada tipo de dados e objetivo, mas os resultados são diferentes. Os exemplos seguintes mostram o mesmo pedido, mas respostas diferentes.

Obter métricas de avaliação de modelos agregadas

As métricas de avaliação do modelo agregado fornecem informações sobre o modelo como um todo. Para ver informações sobre uma fatia específica, liste as fatias de avaliação do modelo.

Para ver métricas de avaliação do modelo agregadas, use o método projects.locations.models.evaluations.get.

O Vertex AI devolve uma matriz de métricas de confiança. Cada elemento mostra métricas de avaliação a um valor confidenceThreshold diferente (a partir de 0 e até 1). Ao ver diferentes valores de limite, pode ver como o limite afeta outras métricas, como a precisão e a capacidade de memorização.

Selecione um separador que corresponda ao seu idioma ou ambiente:

REST

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

  • LOCATION: região onde o seu modelo está armazenado.
  • PROJECT: o seu ID do projeto.
  • MODEL_ID: o ID do recurso do modelo.
  • PROJECT_NUMBER: o número do projeto gerado automaticamente para o seu projeto.
  • EVALUATION_ID: ID da avaliação do modelo (aparece na resposta).

Método HTTP e URL: 

GET https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations

Para enviar o seu pedido, escolha uma destas opções:

curl

Execute o seguinte comando: 

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations"

PowerShell

Execute o seguinte comando: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations" | Select-Object -Expand Content

Deve receber uma resposta JSON semelhante à seguinte:

Java

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 


import com.google.cloud.aiplatform.v1.ModelEvaluation;
import com.google.cloud.aiplatform.v1.ModelEvaluationName;
import com.google.cloud.aiplatform.v1.ModelServiceClient;
import com.google.cloud.aiplatform.v1.ModelServiceSettings;
import java.io.IOException;

public class GetModelEvaluationImageClassificationSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // To obtain evaluationId run the code block below after setting modelServiceSettings.
    //
    // try (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings))
    // {
    //   String location = "us-central1";
    //   ModelName modelFullId = ModelName.of(project, location, modelId);
    //   ListModelEvaluationsRequest modelEvaluationsrequest =
    //   ListModelEvaluationsRequest.newBuilder().setParent(modelFullId.toString()).build();
    //   for (ModelEvaluation modelEvaluation :
    //     modelServiceClient.listModelEvaluations(modelEvaluationsrequest).iterateAll()) {
    //       System.out.format("Model Evaluation Name: %s%n", modelEvaluation.getName());
    //   }
    // }
    String project = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String evaluationId = "YOUR_EVALUATION_ID";
    getModelEvaluationImageClassificationSample(project, modelId, evaluationId);
  }

  static void getModelEvaluationImageClassificationSample(
      String project, String modelId, String evaluationId) throws IOException {
    ModelServiceSettings modelServiceSettings =
        ModelServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings)) {
      String location = "us-central1";
      ModelEvaluationName modelEvaluationName =
          ModelEvaluationName.of(project, location, modelId, evaluationId);

      ModelEvaluation modelEvaluation = modelServiceClient.getModelEvaluation(modelEvaluationName);

      System.out.println("Get Model Evaluation Image Classification Response");
      System.out.format("Model Name: %s\n", modelEvaluation.getName());
      System.out.format("Metrics Schema Uri: %s\n", modelEvaluation.getMetricsSchemaUri());
      System.out.format("Metrics: %s\n", modelEvaluation.getMetrics());
      System.out.format("Create Time: %s\n", modelEvaluation.getCreateTime());
      System.out.format("Slice Dimensions: %s\n", modelEvaluation.getSliceDimensionsList());
    }
  }
}

Node.js

Antes de experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Node.js Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 

/**
 * TODO(developer): Uncomment these variables before running the sample
 * (not necessary if passing values as arguments). To obtain evaluationId,
 * instantiate the client and run the following the commands.
 */
// const parentName = `projects/${project}/locations/${location}/models/${modelId}`;
// const evalRequest = {
//   parent: parentName
// };
// const [evalResponse] = await modelServiceClient.listModelEvaluations(evalRequest);
// console.log(evalResponse);

// const modelId = 'YOUR_MODEL_ID';
// const evaluationId = 'YOUR_EVALUATION_ID';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Model Service Client library
const {ModelServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const modelServiceClient = new ModelServiceClient(clientOptions);

async function getModelEvaluationImageClassification() {
  // Configure the name resources
  const name = `projects/${project}/locations/${location}/models/${modelId}/evaluations/${evaluationId}`;
  const request = {
    name,
  };

  // Create get model evaluation request
  const [response] = await modelServiceClient.getModelEvaluation(request);

  console.log('Get model evaluation image classification response');
  console.log(`\tName : ${response.name}`);
  console.log(`\tMetrics schema uri : ${response.metricsSchemaUri}`);
  console.log(`\tMetrics : ${JSON.stringify(response.metrics)}`);
  console.log(`\tCreate time : ${JSON.stringify(response.createTime)}`);
  console.log(`\tSlice dimensions : ${response.sliceDimensions}`);

  const modelExplanation = response.modelExplanation;
  if (modelExplanation === null) {
    console.log(`\tModel explanation: ${JSON.stringify(modelExplanation)}`);
  } else {
    const meanAttributions = modelExplanation.meanAttributions;
    for (const meanAttribution of meanAttributions) {
      console.log('\t\tMean attribution');
      console.log(
        `\t\t\tBaseline output value : \
           ${meanAttribution.baselineOutputValue}`
      );
      console.log(
        `\t\t\tInstance output value : \
           ${meanAttribution.instanceOutputValue}`
      );
      console.log(
        `\t\t\tFeature attributions : \
           ${JSON.stringify(meanAttribution.featureAttributions)}`
      );
      console.log(`\t\t\tOutput index : ${meanAttribution.outputIndex}`);
      console.log(
        `\t\t\tOutput display name : \
           ${meanAttribution.outputDisplayName}`
      );
      console.log(
        `\t\t\tApproximation error : \
           ${meanAttribution.approximationError}`
      );
    }
  }
}
getModelEvaluationImageClassification();

Python

Para saber como instalar ou atualizar o SDK Vertex AI para Python, consulte o artigo Instale o SDK Vertex AI para Python. Para mais informações, consulte a Python documentação de referência da API. 

from google.cloud import aiplatform


def get_model_evaluation_image_classification_sample(
    project: str,
    model_id: str,
    evaluation_id: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    """
    To obtain evaluation_id run the following commands where LOCATION
    is the region where the model is stored, PROJECT is the project ID,
    and MODEL_ID is the ID of your model.

    model_client = aiplatform.gapic.ModelServiceClient(
        client_options={
            'api_endpoint':'LOCATION-aiplatform.googleapis.com'
            }
        )
    evaluations = model_client.list_model_evaluations(parent='projects/PROJECT/locations/LOCATION/models/MODEL_ID')
    print("evaluations:", evaluations)
    """
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.ModelServiceClient(client_options=client_options)
    name = client.model_evaluation_path(
        project=project, location=location, model=model_id, evaluation=evaluation_id
    )
    response = client.get_model_evaluation(name=name)
    print("response:", response)

Listar todas as divisões de avaliação

O método projects.locations.models.evaluations.slices.list apresenta todas as divisões de avaliação do seu modelo. Tem de ter o ID de avaliação do modelo, que pode obter quando vê as métricas de avaliação agregadas.

Pode usar as divisões da avaliação do modelo para determinar o desempenho do modelo numa etiqueta específica. O campo value indica a etiqueta a que as métricas se referem.

O Vertex AI devolve uma matriz de métricas de confiança. Cada elemento mostra métricas de avaliação a um valor confidenceThreshold diferente (a partir de 0 e até 1). Ao ver diferentes valores de limite, pode ver como o limite afeta outras métricas, como a precisão e a capacidade de memorização.

REST

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

  • LOCATION: região onde o modelo está localizado. Por exemplo, us-central1.
  • PROJECT: .
  • MODEL_ID: o ID do seu modelo.
  • EVALUATION_ID: ID da avaliação do modelo que contém as divisões de avaliação a apresentar.

Método HTTP e URL: 

GET https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations/EVALUATION_ID/slices

Para enviar o seu pedido, escolha uma destas opções:

curl

Execute o seguinte comando: 

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations/EVALUATION_ID/slices"

PowerShell

Execute o seguinte comando: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations/EVALUATION_ID/slices" | Select-Object -Expand Content

Deve receber uma resposta JSON semelhante à seguinte:

Java

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 


import com.google.cloud.aiplatform.v1.ModelEvaluationName;
import com.google.cloud.aiplatform.v1.ModelEvaluationSlice;
import com.google.cloud.aiplatform.v1.ModelEvaluationSlice.Slice;
import com.google.cloud.aiplatform.v1.ModelServiceClient;
import com.google.cloud.aiplatform.v1.ModelServiceSettings;
import java.io.IOException;

public class ListModelEvaluationSliceSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // To obtain evaluationId run the code block below after setting modelServiceSettings.
    //
    // try (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings))
    // {
    //   String location = "us-central1";
    //   ModelName modelFullId = ModelName.of(project, location, modelId);
    //   ListModelEvaluationsRequest modelEvaluationsrequest =
    //   ListModelEvaluationsRequest.newBuilder().setParent(modelFullId.toString()).build();
    //   for (ModelEvaluation modelEvaluation :
    //     modelServiceClient.listModelEvaluations(modelEvaluationsrequest).iterateAll()) {
    //       System.out.format("Model Evaluation Name: %s%n", modelEvaluation.getName());
    //   }
    // }
    String project = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String evaluationId = "YOUR_EVALUATION_ID";
    listModelEvaluationSliceSample(project, modelId, evaluationId);
  }

  static void listModelEvaluationSliceSample(String project, String modelId, String evaluationId)
      throws IOException {
    ModelServiceSettings modelServiceSettings =
        ModelServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings)) {
      String location = "us-central1";
      ModelEvaluationName modelEvaluationName =
          ModelEvaluationName.of(project, location, modelId, evaluationId);

      for (ModelEvaluationSlice modelEvaluationSlice :
          modelServiceClient.listModelEvaluationSlices(modelEvaluationName).iterateAll()) {
        System.out.format("Model Evaluation Slice Name: %s\n", modelEvaluationSlice.getName());
        System.out.format("Metrics Schema Uri: %s\n", modelEvaluationSlice.getMetricsSchemaUri());
        System.out.format("Metrics: %s\n", modelEvaluationSlice.getMetrics());
        System.out.format("Create Time: %s\n", modelEvaluationSlice.getCreateTime());

        Slice slice = modelEvaluationSlice.getSlice();
        System.out.format("Slice Dimensions: %s\n", slice.getDimension());
        System.out.format("Slice Value: %s\n\n", slice.getValue());
      }
    }
  }
}

Node.js

Antes de experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Node.js Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 

/**
 * TODO(developer): Uncomment these variables before running the sample
 * (not necessary if passing values as arguments). To obtain evaluationId,
 * instantiate the client and run the following the commands.
 */
// const parentName = `projects/${project}/locations/${location}/models/${modelId}`;
// const evalRequest = {
//   parent: parentName
// };
// const [evalResponse] = await modelServiceClient.listModelEvaluations(evalRequest);
// console.log(evalResponse);

// const modelId = 'YOUR_MODEL_ID';
// const evaluationId = 'YOUR_EVALUATION_ID';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Model Service Client library
const {ModelServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const modelServiceClient = new ModelServiceClient(clientOptions);

async function listModelEvaluationSlices() {
  // Configure the parent resources
  const parent = `projects/${project}/locations/${location}/models/${modelId}/evaluations/${evaluationId}`;
  const request = {
    parent,
  };

  // Get and print out a list of all the evaluation slices for this resource
  const [response] =
    await modelServiceClient.listModelEvaluationSlices(request);
  console.log('List model evaluation response', response);
  console.log(response);
}
listModelEvaluationSlices();

Python

Para saber como instalar ou atualizar o SDK Vertex AI para Python, consulte o artigo Instale o SDK Vertex AI para Python. Para mais informações, consulte a Python documentação de referência da API. 

from google.cloud import aiplatform


def list_model_evaluation_slices_sample(
    project: str,
    model_id: str,
    evaluation_id: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    """
    To obtain evaluation_id run the following commands where LOCATION
    is the region where the model is stored, PROJECT is the project ID,
    and MODEL_ID is the ID of your model.

    model_client = aiplatform.gapic.ModelServiceClient(
        client_options={
            'api_endpoint':'LOCATION-aiplatform.googleapis.com'
            }
        )
    evaluations = model_client.list_model_evaluations(parent='projects/PROJECT/locations/LOCATION/models/MODEL_ID')
    print("evaluations:", evaluations)
    """
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.ModelServiceClient(client_options=client_options)
    parent = client.model_evaluation_path(
        project=project, location=location, model=model_id, evaluation=evaluation_id
    )
    response = client.list_model_evaluation_slices(parent=parent)
    for model_evaluation_slice in response:
        print("model_evaluation_slice:", model_evaluation_slice)

Obter métricas para uma única fatia

Para ver as métricas de avaliação de uma única fatia, use o método projects.locations.models.evaluations.slices.get. Tem de ter o ID da fatia, que é fornecido quando lista todas as fatias. O exemplo seguinte aplica-se a todos os tipos de dados e objetivos.

REST

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

  • LOCATION: região onde o modelo está localizado. Por exemplo: us-central1.
  • PROJECT: .
  • MODEL_ID: o ID do seu modelo.
  • EVALUATION_ID: ID da avaliação do modelo que contém a fatia de avaliação a obter.
  • SLICE_ID: ID de uma fatia de avaliação a obter.
  • PROJECT_NUMBER: o número do projeto gerado automaticamente para o seu projeto.
  • EVALUATION_METRIC_SCHEMA_FILE_NAME: o nome de um ficheiro de esquema que define as métricas de avaliação a devolver, como classification_metrics_1.0.0.

Método HTTP e URL: 

GET https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations/EVALUATION_ID/slices/SLICE_ID

Para enviar o seu pedido, escolha uma destas opções:

curl

Execute o seguinte comando: 

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations/EVALUATION_ID/slices/SLICE_ID"

PowerShell

Execute o seguinte comando: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations/EVALUATION_ID/slices/SLICE_ID" | Select-Object -Expand Content

Deve receber uma resposta JSON semelhante à seguinte:

Java

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 


import com.google.cloud.aiplatform.v1.ModelEvaluationSlice;
import com.google.cloud.aiplatform.v1.ModelEvaluationSlice.Slice;
import com.google.cloud.aiplatform.v1.ModelEvaluationSliceName;
import com.google.cloud.aiplatform.v1.ModelServiceClient;
import com.google.cloud.aiplatform.v1.ModelServiceSettings;
import java.io.IOException;

public class GetModelEvaluationSliceSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // To obtain evaluationId run the code block below after setting modelServiceSettings.
    //
    // try (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings))
    // {
    //   String location = "us-central1";
    //   ModelName modelFullId = ModelName.of(project, location, modelId);
    //   ListModelEvaluationsRequest modelEvaluationsrequest =
    //   ListModelEvaluationsRequest.newBuilder().setParent(modelFullId.toString()).build();
    //   for (ModelEvaluation modelEvaluation :
    //     modelServiceClient.listModelEvaluations(modelEvaluationsrequest).iterateAll()) {
    //       System.out.format("Model Evaluation Name: %s%n", modelEvaluation.getName());
    //   }
    // }
    String project = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String evaluationId = "YOUR_EVALUATION_ID";
    String sliceId = "YOUR_SLICE_ID";
    getModelEvaluationSliceSample(project, modelId, evaluationId, sliceId);
  }

  static void getModelEvaluationSliceSample(
      String project, String modelId, String evaluationId, String sliceId) throws IOException {
    ModelServiceSettings modelServiceSettings =
        ModelServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings)) {
      String location = "us-central1";
      ModelEvaluationSliceName modelEvaluationSliceName =
          ModelEvaluationSliceName.of(project, location, modelId, evaluationId, sliceId);

      ModelEvaluationSlice modelEvaluationSlice =
          modelServiceClient.getModelEvaluationSlice(modelEvaluationSliceName);

      System.out.println("Get Model Evaluation Slice Response");
      System.out.format("Model Evaluation Slice Name: %s\n", modelEvaluationSlice.getName());
      System.out.format("Metrics Schema Uri: %s\n", modelEvaluationSlice.getMetricsSchemaUri());
      System.out.format("Metrics: %s\n", modelEvaluationSlice.getMetrics());
      System.out.format("Create Time: %s\n", modelEvaluationSlice.getCreateTime());

      Slice slice = modelEvaluationSlice.getSlice();
      System.out.format("Slice Dimensions: %s\n", slice.getDimension());
      System.out.format("Slice Value: %s\n", slice.getValue());
    }
  }
}

Node.js

Antes de experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Node.js Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 

/**
 * TODO(developer): Uncomment these variables before running the sample
 * (not necessary if passing values as arguments). To obtain evaluationId,
 * instantiate the client and run the following the commands.
 */
// const parentName = `projects/${project}/locations/${location}/models/${modelId}`;
// const evalRequest = {
//   parent: parentName
// };
// const [evalResponse] = await modelServiceClient.listModelEvaluations(evalRequest);
// console.log(evalResponse);

// const modelId = 'YOUR_MODEL_ID';
// const evaluationId = 'YOUR_EVALUATION_ID';
// const sliceId = 'YOUR_SLICE_ID';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Model Service client library
const {ModelServiceClient} = require('@google-cloud/aiplatform');
// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};
// Specifies the location of the api endpoint
const modelServiceClient = new ModelServiceClient(clientOptions);

async function getModelEvaluationSlice() {
  // Configure the parent resource
  const name = `projects/${project}/locations/${location}/models/${modelId}/evaluations/${evaluationId}/slices/${sliceId}`;
  const request = {
    name,
  };

  // Get and print out a list of all the endpoints for this resource
  const [response] =
    await modelServiceClient.getModelEvaluationSlice(request);

  console.log('Get model evaluation slice');
  console.log(`\tName : ${response.name}`);
  console.log(`\tMetrics_Schema_Uri : ${response.metricsSchemaUri}`);
  console.log(`\tMetrics : ${JSON.stringify(response.metrics)}`);
  console.log(`\tCreate time : ${JSON.stringify(response.createTime)}`);

  console.log('Slice');
  const slice = response.slice;
  console.log(`\tDimension :${slice.dimension}`);
  console.log(`\tValue :${slice.value}`);
}
getModelEvaluationSlice();

Python

Para saber como instalar ou atualizar o SDK Vertex AI para Python, consulte o artigo Instale o SDK Vertex AI para Python. Para mais informações, consulte a Python documentação de referência da API. 

from google.cloud import aiplatform


def get_model_evaluation_slice_sample(
    project: str,
    model_id: str,
    evaluation_id: str,
    slice_id: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    """
    To obtain evaluation_id run the following commands where LOCATION
    is the region where the model is stored, PROJECT is the project ID,
    and MODEL_ID is the ID of your model.

    model_client = aiplatform.gapic.ModelServiceClient(
        client_options={
            'api_endpoint':'LOCATION-aiplatform.googleapis.com'
            }
        )
    evaluations = model_client.list_model_evaluations(parent='projects/PROJECT/locations/LOCATION/models/MODEL_ID')
    print("evaluations:", evaluations)
    """
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.ModelServiceClient(client_options=client_options)
    name = client.model_evaluation_slice_path(
        project=project,
        location=location,
        model=model_id,
        evaluation=evaluation_id,
        slice=slice_id,
    )
    response = client.get_model_evaluation_slice(name=name)
    print("response:", response)

Itere no seu modelo

As métricas de avaliação do modelo oferecem um ponto de partida para depurar o modelo quando este não cumpre as suas expectativas. Por exemplo, as pontuações de precisão e recall baixas podem indicar que o seu modelo precisa de dados de preparação adicionais ou tem etiquetas inconsistentes. A precisão e a revocação perfeitas podem indicar que os dados de teste são demasiado fáceis de prever e podem não ser generalizados bem.

Pode iterar os dados de treino e criar um novo modelo. Depois de criar um novo modelo, pode comparar as métricas de avaliação entre o modelo existente e o novo modelo.

As seguintes sugestões podem ajudar a melhorar os modelos que etiquetam itens, como modelos de classificação ou deteção:

  • Pondere adicionar mais exemplos ou uma gama mais ampla de exemplos nos seus dados de preparação. Por exemplo, para um modelo de classificação de imagens, pode incluir imagens com um ângulo mais amplo, imagens com uma resolução mais alta ou mais baixa, ou diferentes pontos de vista. Para mais orientações, consulte o artigo Preparar dados.
  • Considere remover classes ou etiquetas que não tenham muitos exemplos. Os exemplos insuficientes impedem que o modelo faça previsões sobre essas classes ou etiquetas de forma consistente e com confiança.
  • As máquinas não conseguem interpretar o nome das suas classes ou etiquetas e não compreendem as nuances entre elas, como "porta" e "porta_com_puxador". Tem de fornecer dados para ajudar as máquinas a reconhecerem essas nuances.
  • Aumente os seus dados com mais exemplos de verdadeiros positivos e verdadeiros negativos, especialmente exemplos próximos de um limite de decisão, para mitigar a confusão do modelo.
  • Especifique a sua própria divisão de dados (preparação, validação e teste). O Vertex AI atribui aleatoriamente itens a cada conjunto. Por conseguinte, os quase duplicados podem ser atribuídos aos conjuntos de preparação e validação, o que pode levar a um sobreajuste e, em seguida, a um desempenho fraco no conjunto de testes. Para mais informações sobre como definir a sua própria divisão de dados, consulte o artigo Acerca das divisões de dados para modelos do AutoML.
  • Se as métricas de avaliação do seu modelo incluírem uma matriz de confusão, pode ver se o modelo está a confundir duas etiquetas, em que o modelo está a prever uma etiqueta específica significativamente mais do que a etiqueta verdadeira. Reveja os seus dados e certifique-se de que os exemplos estão etiquetados corretamente.
  • Se teve um tempo de preparação curto (número máximo de horas de nós baixo), pode obter um modelo de qualidade superior permitindo que seja preparado durante um período mais longo (número máximo de horas de nós mais elevado).
Anterior
Prepare o modelo
Avançar
Obtenha previsões