Como avaliar modelos

Depois de treinar um modelo, o AutoML Vision usa itens do conjunto TEST para avaliar a qualidade e a precisão desse modelo.

O AutoML Vision fornece um conjunto agregado de métricas de avaliação que indicam o desempenho geral do modelo, bem como as métricas de avaliação para cada rótulo de categoria, indicando o desempenho do modelo para esse rótulo.

  • AuPRC: área sob a curva de precisão/recall (AuPRC, na sigla em inglês) também conhecida como "precisão média". Geralmente, entre 0,5 e 1. Valores mais altos indicam modelos mais precisos.

  • As curvas de limite de confiança mostram como diferentes limites de confiança afetam a precisão, o recall e as taxas de resultados verdadeiros e falsos positivos. Leia sobre o relacionamento de precisão e recall.

  • Matriz de confusão: presente apenas para modelos de um único rótulo por imagem. Representa a porcentagem de vezes que cada rótulo foi previsto no conjunto de treinamento durante a avaliação. Idealmente, o rótulo one seria atribuído apenas às imagens classificadas com o rótulo one e assim por diante, de modo que uma matriz perfeita seria parecida com isto:

    100  0   0   0
     0  100  0   0
     0   0  100  0
     0   0   0  100
    

    No exemplo acima, se uma imagem fosse classificada como one, mas o modelo previsse two, a primeira linha teria esta aparência:

    99  1  0  0
    

    Para saber mais informações, pesquise por matriz de confusão de aprendizado de máquina.

    O AutoML Vision cria a matriz de confusão para até dez rótulos. Se você tiver mais do que isso, a matriz incluirá os dez rótulos com a maior confusão (previsões incorretas).

Use esses dados para avaliar a prontidão do seu modelo. Alta confusão, baixa pontuação de AUC ou baixas pontuações de precisão e recall podem indicar que o modelo precisa de dados de treinamento extras ou tem rótulos inconsistentes. Uma pontuação AUC muito alta e precisão e recall perfeitos podem indicar que os dados são fáceis demais e têm pouca capacidade de generalização.

Conseguir valores de avaliação do modelo

IU da Web

  1. Abra a IU do AutoML Vision e clique no ícone da lâmpada na barra de navegação à esquerda para exibir os modelos disponíveis.

    Para ver os modelos de outro projeto, selecione o projeto na lista suspensa na parte superior direita da barra de título.

  2. Clique na linha do modelo que você quer avaliar.

  3. Se necessário, clique na guia Avaliar abaixo da barra de título.

    Se o treinamento do modelo tiver sido concluído, o AutoML Vision mostrará as métricas de avaliação.

    Avaliar página

  4. Para visualizar as métricas de um rótulo específico, selecione o nome dele na lista na parte inferior da página.

Linha de comando

  • Substitua model-name pelo nome completo do modelo, com base na resposta de quando você criou o modelo. O nome completo tem o formato: projects/{project-id}/locations/us-central1/models/{model-id}
curl -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "Content-Type: application/json" \
  https://automl.googleapis.com/v1beta1/model-name/modelEvaluations

Na resposta, está incluso um recurso ModelEvaluation para cada rótulo identificado pelo annotationSpecId, além de outro para o modelo geral, identificado por um annotationSpecId vazio.

{
  "modelEvaluation": [
    {
      "name": "projects/434039606874/locations/us-central1/models/7537307368641647584/modelEvaluations/9009741181387603448",
      "annotationSpecId": "17040929661974749",
      "classificationMetrics": {
        "auPrc": 0.99772006,
        "baseAuPrc": 0.21706384,
        "evaluatedExamplesCount": 377,
        "confidenceMetricsEntry": [
          {
            "recall": 1,
            "precision": -1.3877788e-17,
            "f1Score": -2.7755576e-17,
            "recallAt1": 0.9761273,
            "precisionAt1": 0.9761273,
            "f1ScoreAt1": 0.9761273
          },
          {
            "confidenceThreshold": 0.05,
            "recall": 0.997,
            "precision": 0.867,
            "f1Score": 0.92746675,
            "recallAt1": 0.9761273,
            "precisionAt1": 0.9761273,
            "f1ScoreAt1": 0.9761273
          },
          {
            "confidenceThreshold": 0.1,
            "recall": 0.995,
            "precision": 0.905,
            "f1Score": 0.9478684,
            "recallAt1": 0.9761273,
            "precisionAt1": 0.9761273,
            "f1ScoreAt1": 0.9761273
          },
          {
            "confidenceThreshold": 0.15,
            "recall": 0.992,
            "precision": 0.932,
            "f1Score": 0.96106446,
            "recallAt1": 0.9761273,
            "precisionAt1": 0.9761273,
            "f1ScoreAt1": 0.9761273
          },
          {
            "confidenceThreshold": 0.2,
            "recall": 0.989,
            "precision": 0.951,
            "f1Score": 0.96962786,
            "recallAt1": 0.9761273,
            "precisionAt1": 0.9761273,
            "f1ScoreAt1": 0.9761273
          },
          {
            "confidenceThreshold": 0.25,
            "recall": 0.987,
            "precision": 0.957,
            "f1Score": 0.9717685,
            "recallAt1": 0.9761273,
            "precisionAt1": 0.9761273,
            "f1ScoreAt1": 0.9761273
          },
        ...
        ],
      },
      "createTime": "2018-04-30T23:06:14.746840Z"
    },
    {
      "name": "projects/434039606874/locations/us-central1/models/7537307368641647584/modelEvaluations/9009741181387603671",
      "annotationSpecId": "1258823357545045636",
      "classificationMetrics": {
        "auPrc": 0.9972302,
        "baseAuPrc": 0.1883289,
      ...
      },
      "createTime": "2018-04-30T23:06:14.649260Z"
    }
  ]
}

Para receber apenas as métricas de avaliação de um rótulo específico, adicione /{modelEvaluation-name} à solicitação acima, usando o valor completo de "name" da resposta.

Python

Antes de executar este código de exemplo, você precisa instalar as bibliotecas de cliente do Python.

  • O parâmetro model_id é o código do modelo. O código é o último elemento do nome do modelo. Por exemplo, se o nome do modelo for projects/434039606874/locations/us-central1/models/3745331181667467569, o código dele será 3745331181667467569.
# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_id = 'MODEL_ID_HERE'
# filter_ = 'filter expression here'

from google.cloud import automl_v1beta1 as automl

client = automl.AutoMlClient()

# Get the full path of the model.
model_full_id = client.model_path(project_id, compute_region, model_id)

# List all the model evaluations in the model by applying filter.
response = client.list_model_evaluations(model_full_id, filter_)

print("List of model evaluations:")
for element in response:
    print(element)

Java

/**
 * Demonstrates using the AutoML client to display model evaluation.
 *
 * @param projectId the Id of the project.
 * @param computeRegion the Region name.
 * @param modelId the Id of the model.
 * @param filter the filter expression.
 * @throws IOException on Input/Output errors.
 */
public static void displayEvaluation(
    String projectId, String computeRegion, String modelId, String filter) throws IOException {
  AutoMlClient client = AutoMlClient.create();

  // Get the full path of the model.
  ModelName modelFullId = ModelName.of(projectId, computeRegion, modelId);

  // List all the model evaluations in the model by applying filter.
  ListModelEvaluationsRequest modelEvaluationsrequest =
      ListModelEvaluationsRequest.newBuilder()
          .setParent(modelFullId.toString())
          .setFilter(filter)
          .build();

  // Iterate through the results.
  String modelEvaluationId = "";
  for (ModelEvaluation element :
      client.listModelEvaluations(modelEvaluationsrequest).iterateAll()) {
    if (element.getAnnotationSpecId() != null) {
      modelEvaluationId = element.getName().split("/")[element.getName().split("/").length - 1];
    }
  }

  // Resource name for the model evaluation.
  ModelEvaluationName modelEvaluationFullId =
      ModelEvaluationName.of(projectId, computeRegion, modelId, modelEvaluationId);

  // Get a model evaluation.
  ModelEvaluation modelEvaluation = client.getModelEvaluation(modelEvaluationFullId);

  ClassificationEvaluationMetrics classMetrics =
      modelEvaluation.getClassificationEvaluationMetrics();
  List<ConfidenceMetricsEntry> confidenceMetricsEntries =
      classMetrics.getConfidenceMetricsEntryList();

  // Showing model score based on threshold of 0.5
  for (ConfidenceMetricsEntry confidenceMetricsEntry : confidenceMetricsEntries) {
    if (confidenceMetricsEntry.getConfidenceThreshold() == 0.5) {
      System.out.println("Precision and recall are based on a score threshold of 0.5");
      System.out.println(
          String.format("Model Precision: %.2f ", confidenceMetricsEntry.getPrecision() * 100)
              + '%');
      System.out.println(
          String.format("Model Recall: %.2f ", confidenceMetricsEntry.getRecall() * 100) + '%');
      System.out.println(
          String.format("Model F1 score: %.2f ", confidenceMetricsEntry.getF1Score() * 100)
              + '%');
      System.out.println(
          String.format(
                  "Model Precision@1: %.2f ", confidenceMetricsEntry.getPrecisionAt1() * 100)
              + '%');
      System.out.println(
          String.format("Model Recall@1: %.2f ", confidenceMetricsEntry.getRecallAt1() * 100)
              + '%');
      System.out.println(
          String.format("Model F1 score@1: %.2f ", confidenceMetricsEntry.getF1ScoreAt1() * 100)
              + '%');
    }
  }
}

Node.js

  const automl = require(`@google-cloud/automl`).v1beta1;
  const math = require(`mathjs`);

  const client = new automl.AutoMlClient();

  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const projectId = `The GCLOUD_PROJECT string, e.g. "my-gcloud-project"`;
  // const computeRegion = `region-name, e.g. "us-central1"`;
  // const modelId = `id of the model, e.g. “ICN12345”`;
  // const filter = `filter expressions, must specify field, e.g. “imageClassificationModelMetadata:*”`;

  // Get the full path of the model.
  const modelFullId = client.modelPath(projectId, computeRegion, modelId);

  // List all the model evaluations in the model by applying filter.
  const [response] = await client.listModelEvaluations({
    parent: modelFullId,
    filter: filter,
  });

  response.forEach(async element => {
    // There is evaluation for each class in a model and for overall model.
    // Get only the evaluation of overall model.
    if (!element.annotationSpecId) {
      const modelEvaluationId = element.name.split(`/`).pop(-1);

      // Resource name for the model evaluation.
      const modelEvaluationFullId = client.modelEvaluationPath(
        projectId,
        computeRegion,
        modelId,
        modelEvaluationId
      );

      const [modelEvaluation] = await client.getModelEvaluation({
        name: modelEvaluationFullId,
      });
      const classMetrics = modelEvaluation.classificationEvaluationMetrics;
      const confidenceMetricsEntries = classMetrics.confidenceMetricsEntry;

      // Showing model score based on threshold of 0.5
      confidenceMetricsEntries.forEach(confidenceMetricsEntry => {
        if (confidenceMetricsEntry.confidenceThreshold === 0.5) {
          console.log(
            `Precision and recall are based on a score threshold of 0.5`
          );
          console.log(
            `Model Precision: %`,
            math.round(confidenceMetricsEntry.precision * 100, 2)
          );
          console.log(
            `Model Recall: %`,
            math.round(confidenceMetricsEntry.recall * 100, 2)
          );
          console.log(
            `Model F1 score: %`,
            math.round(confidenceMetricsEntry.f1Score * 100, 2)
          );
          console.log(
            `Model Precision@1: %`,
            math.round(confidenceMetricsEntry.precisionAt1 * 100, 2)
          );
          console.log(
            `Model Recall@1: %`,
            math.round(confidenceMetricsEntry.recallAt1 * 100, 2)
          );
          console.log(
            `Model F1 score@1: %`,
            math.round(confidenceMetricsEntry.f1ScoreAt1 * 100, 2)
          );
        }
      });
    }
  });

Iterar o modelo

Se você não estiver satisfeito com os níveis de qualidade, poderá voltar às etapas anteriores para melhorar a qualidade:

  • Com o AutoML Vision, você pode classificar as imagens de acordo com o grau de confusão do modelo, pelo rótulo verdadeiro e pelo rótulo previsto correspondente. Analise essas imagens e verifique se elas estão rotuladas corretamente.
  • Pense em incluir mais documentos a qualquer rótulo com baixa qualidade.
  • Talvez seja necessário adicionar diferentes tipos de imagens (por exemplo, ângulo amplo, resolução maior ou menor, pontos de vista diferentes).
  • Pense em remover rótulos completamente se não houver imagens de treinamento suficientes.
  • Lembre-se de que a máquina não consegue ler o nome do rótulo. É apenas uma string aleatória de letras para ela. Se você tem um rótulo que diz "porta" e outro que diz "porta_com_maçaneta", a máquina não tem como descobrir a nuance além das imagens fornecidas.
  • Aumente seus dados com mais exemplos de positivos e negativos verdadeiros. Exemplos especialmente importantes são aqueles que estão próximos do limite de decisão (isto é, que provavelmente produzem confusão, mas ainda assim rotulados corretamente).
  • Especifique sua própria divisão TRAIN, TEST, VALIDATION. A ferramenta atribui aleatoriamente imagens, mas quase duplicatas podem acabar em TRAIN e VALIDATION, o que poderia levar a um sobreajuste e, em seguida, a um baixo desempenho no conjunto TEST.

Depois de fazer as alterações, treine e avalie um novo modelo até atingir um nível de qualidade alto o suficiente.

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Cloud AutoML Vision
Precisa de ajuda? Acesse nossa página de suporte.