Avalie e itere modelos de deteção de objetos de imagens da Plataforma AutoML

Esta página mostra como avaliar os modelos de deteção de objetos de imagens do AutoML para que possa 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 deteção de objetos de imagem em comparação com um modelo de classificaçã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/

• Limite de IoU: um valor limite de interseção sobre união que determina as inferências a devolver. Um modelo devolve inferências que estão neste valor ou superior. Quanto mais elevado for o limite, mais próximos têm de estar os valores da caixa delimitadora prevista dos valores da caixa delimitadora real.
• Precisão média média: também conhecida como a precisão média. Este valor varia entre zero e um, em que um valor mais elevado 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.
• Pontuação de F1: o meio harmónico de precisão e revocação. A F1 é uma métrica útil se estiver à procura de um equilíbrio entre a precisão e a revocação, e existir uma distribuição de classes desigual.
• Precisão média da caixa delimitadora: a métrica única para avaliações de caixas delimitadoras: a meanAveragePrecision com média em todos os boundingBoxMetrics.

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:

   

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.

Para a métrica de caixa delimitadora, o Vertex AI devolve uma matriz de valores de métricas em diferentes valores de limite de IoU (entre 0 e 1) e valores de limite de confiança (entre 0 e 1). Por exemplo, pode focar-se nas métricas de avaliação com um limite de IoU de 0,85 e um limite de confiança de 0,8228. Ao ver estes diferentes valores de limite, pode ver como afetam 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

Nota: O comando seguinte pressupõe que tem sessão iniciada na CLI gcloud com a sua conta de utilizador executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que inicia automaticamente sessão na CLI gcloud. Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

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

Nota: O comando seguinte pressupõe que iniciou sessão na CLI do Google Cloud com a sua conta de utilizador executando gcloud init ou gcloud auth login .gcloud Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

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:

Resposta

{
  "modelEvaluations": [
    {
      "name": "projects/PROJECT_NUMBER/locations/LOCATION/models/MODEL_ID/evaluations/EVALUATION_ID",
      "metricsSchemaUri": "gs://google-cloud-aiplatform/schema/modelevaluation/image_object_detection_metrics_1.0.0.yaml",
      "metrics": {
        "evaluatedBoundingBoxCount": 190,
        "boundingBoxMetrics": [
          {
            "iouThreshold": 0.85,
            "meanAveragePrecision": 0.0818413,
            "confidenceMetrics": [
              {
                "confidenceThreshold": 7.7341465e-06,
                "recall": 0.22105263,
                "precision": 0.045652173,
                "f1Score": 0.075675674
              },
              {
                "confidenceThreshold": 0.017749911,
                "recall": 0.21578947,
                "precision": 0.078998074,
                "f1Score": 0.11565586
              },
              {
                "confidenceThreshold": 0.022688486,
                "recall": 0.21052632,
                "precision": 0.08583691,
                "f1Score": 0.121951215
              },
              ...
        ],
        "boundingBoxMeanAveragePrecision": 0.3128878
      },
      "createTime": "2020-10-09T23:35:43.325822Z",
      "sliceDimensions": [
        "annotationSpec"
      ]
    }
  ]
}

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 GetModelEvaluationImageObjectDetectionSample {

  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";
    getModelEvaluationImageObjectDetectionSample(project, modelId, evaluationId);
  }

  static void getModelEvaluationImageObjectDetectionSample(
      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 Object Detection Response");
      System.out.format("\tName: %s\n", modelEvaluation.getName());
      System.out.format("\tMetrics Schema Uri: %s\n", modelEvaluation.getMetricsSchemaUri());
      System.out.format("\tMetrics: %s\n", modelEvaluation.getMetrics());
      System.out.format("\tCreate Time: %s\n", modelEvaluation.getCreateTime());
      System.out.format("\tSlice 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 getModelEvaluationImageObjectDetection() {
  // 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 object detection response');
  console.log(`\tName : ${response.name}`);
  console.log(`\tMetrics schema uri : ${response.metricsSchemaUri}`);
  console.log(`\tCreate time : ${JSON.stringify(response.createTime)}`);
  console.log(`\tSlice dimensions : ${response.sliceDimensions}`);

  const modelExplanation = response.modelExplanation;
  console.log('\tModel explanation');
  if (modelExplanation === null) {
    console.log('\t\t{}');
  } else {
    const meanAttributions = modelExplanation.meanAttributions;
    if (meanAttributions === null) {
      console.log('\t\t\t []');
    } else {
      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 : \
            ${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}`
        );
      }
    }
  }
}
getModelEvaluationImageObjectDetection();

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_object_detection_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.

Para a métrica de caixa delimitadora, o Vertex AI devolve uma matriz de valores de métricas em diferentes valores de limite de IoU (entre 0 e 1) e valores de limite de confiança (entre 0 e 1). Por exemplo, pode focar-se nas métricas de avaliação com um limite de IoU de 0,85 e um limite de confiança de 0,8228. Ao ver estes diferentes valores de limite, pode ver como afetam 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

Nota: O comando seguinte pressupõe que tem sessão iniciada na CLI gcloud com a sua conta de utilizador executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que inicia automaticamente sessão na CLI gcloud. Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

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

Nota: O comando seguinte pressupõe que iniciou sessão na CLI do Google Cloud com a sua conta de utilizador executando gcloud init ou gcloud auth login .gcloud Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

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:

Resposta

{
  "modelEvaluationSlices": [
    {
      "name": "projects/693884908213/locations/us-central1/models/9199094820113481728/evaluations/3223746102406676480/slices/466270444805616887",
      "slice": {
        "dimension": "annotationSpec",
        "value": "Tomato"
      },
      "metricsSchemaUri": "gs://google-cloud-aiplatform/schema/modelevaluation/image_object_detection_metrics_1.0.0.yaml",
      "metrics": {
        "evaluatedBoundingBoxCount": 98,
        "boundingBoxMetrics": [
          {
            "iouThreshold": 0.75,
            "meanAveragePrecision": 0.22579378,
            "confidenceMetrics": [
              {
                "confidenceThreshold": 8.980461e-06,
                "recall": 0.3469388,
                "precision": 0.15525115,
                "f1Score": 0.21451104
              },
              {
                "confidenceThreshold": 0.10109353,
                "recall": 0.33673468,
                "precision": 0.35106382,
                "f1Score": 0.34374997
              },
              {
                "confidenceThreshold": 0.112416565,
                "recall": 0.3265306,
                "precision": 0.35555556,
                "f1Score": 0.34042552
              },
              ...
            ]
          },
          {
            "iouThreshold": 0.8,
            "meanAveragePrecision": 0.14461963,
            "confidenceMetrics": [
              {
                "confidenceThreshold": 8.980461e-06,
                "recall": 0.25510204,
                "precision": 0.11415525,
                "f1Score": 0.15772872
              },
              {
                "confidenceThreshold": 0.11577999,
                "recall": 0.24489796,
                "precision": 0.27272728,
                "f1Score": 0.25806454
              },
              {
                "confidenceThreshold": 0.1570652,
                "recall": 0.23469388,
                "precision": 0.28395063,
                "f1Score": 0.25698322
              },
              ...
            ]
          }
        ],
        "boundingBoxMeanAveragePrecision": 0.35238627
      },
      "createTime": "2020-10-09T23:35:43.654861Z"
    },
    {
      "name": "projects/693884908213/locations/us-central1/models/9199094820113481728/evaluations/3223746102406676480/slices/2285744162687356072",
      "slice": {
        "dimension": "annotationSpec",
        "value": "Cheese"
      },
      "metricsSchemaUri": "gs://google-cloud-aiplatform/schema/modelevaluation/image_object_detection_metrics_1.0.0.yaml",
      "metrics": {
        "evaluatedBoundingBoxCount": 46,
        "boundingBoxMetrics": [
          {
            "iouThreshold": 0.85,
            "meanAveragePrecision": 0.0110351965,
            "confidenceMetrics": [
              {
                "confidenceThreshold": 1.1757337e-05,
                "recall": 0.08695652,
                "precision": 0.019607844,
                "f1Score": 0.032
              },
              {
                "confidenceThreshold": 0.32720456,
                "recall": 0.06521739,
                "precision": 0.125,
                "f1Score": 0.08571429
              },
              {
                "confidenceThreshold": 0.4676356,
                "recall": 0.04347826,
                "precision": 0.1,
                "f1Score": 0.060606066
              },
              ...
            ]
          }
        ],
        "boundingBoxMeanAveragePrecision": 0.3591522
      },
      "createTime": "2020-10-09T23:35:43.661512Z"
    }
  ]
}

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

Nota: O comando seguinte pressupõe que tem sessão iniciada na CLI gcloud com a sua conta de utilizador executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que inicia automaticamente sessão na CLI gcloud. Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

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

Nota: O comando seguinte pressupõe que iniciou sessão na CLI do Google Cloud com a sua conta de utilizador executando gcloud init ou gcloud auth login .gcloud Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

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:

Resposta

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/models/MODEL_ID/evaluations/EVALUATION_ID/slices/SLICE_ID",
  "slice": {
    "dimension": "annotationSpec",
    "value": "a particular class or label"
  },
  "metricsSchemaUri": "gs://google-cloud-aiplatform/schema/modelevaluation/EVALUATION_METRIC_SCHEMA_FILE_NAME.yaml",
  "metrics": {
    evaluation metrics for the slice
  },
  "createTime": "2020-10-08T23:35:54.770876Z"
}

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 a deteção de objetos ou os modelos de 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 deteção de objetos de imagem, 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).