Évaluer des modèles

Après avoir entraîné un modèle, AutoML Vision utilise des éléments de l'ensemble de TEST pour évaluer la qualité et la précision du nouveau modèle.

Présentation de l'évaluation

AutoML Vision fournit un ensemble de statistiques d'évaluation indiquant les performances globales du modèle, ainsi que pour chaque libellé de catégorie, de façon à évaluer les performances du modèle pour un libellé donné.

  • AuPRC : Area under Precision/Recall Curve (aire sous la courbe de précision/rappel), également appelée "précision moyenne". Cette valeur est généralement comprise entre 0,5 et 1. Plus les valeurs sont élevées, plus les modèles sont précis.

  • Les courbes de seuil de confiance montrent comment différents seuils de confiance peuvent influer sur la précision, le rappel, ainsi que les taux de vrais et faux positifs. Découvrez la relation qui existe entre la précision et le rappel.

  • Matrice de confusion : elle n'est disponible que pour les modèles avec un seul libellé par document. La matrice représente le pourcentage de fois où chaque libellé de l'ensemble d'entraînement a été prédit au cours de l'évaluation.

    Exemple de matrice de confusion

    Il est préférable de n'attribuer le libellé one qu'aux images classifiées dans la catégorie one, et ainsi de suite pour les autres libellés. La matrice idéale se présentera donc comme suit :

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

    Dans l'exemple ci-dessus, si une image est classifiée avec le libellé one alors que le modèle a prédit le libellé two, la première ligne se présente comme suit :

    99  1  0  0
    

    Pour en savoir plus sur ce sujet, effectuez une recherche sur les termes matrice de confusion machine learning.

    AutoML Vision crée la matrice de confusion pour 10 libellés au maximum. Si vous disposez d'un plus grand nombre de libellés, la matrice inclut les 10 libellés pour lesquels la confusion est la plus importante (prédictions incorrectes).

Évaluez l'état de préparation de votre modèle à l'aide de ces données. Une confusion importante, des scores AUC bas ou des valeurs de précision et de rappel faibles peuvent indiquer que votre modèle requiert des données d'entraînement supplémentaires ou que ses libellés sont incohérents. Si vous obtenez un score AUC très élevé et des valeurs de précision et de rappel parfaites, cela peut signifier que les données sont trop simples et risquent de ne pas être correctement généralisées.

Répertorier des évaluations de modèle

Une fois que vous avez entraîné un modèle, vous pouvez répertorier ses statistiques d'évaluation.

UI Web

  1. Ouvrez l'interface AutoML Vision, puis cliquez sur l'onglet Modèles (icône représentant une ampoule) dans la barre de navigation de gauche pour afficher les modèles disponibles.

    Pour afficher les modèles d'un autre projet, sélectionnez le projet dans la liste déroulante située en haut à droite de la barre de titre.

  2. Cliquez sur la ligne du modèle que vous souhaitez évaluer.

  3. Si nécessaire, cliquez sur l'onglet Évaluation situé juste en dessous de la barre de titre.

    Si le modèle a été entraîné, AutoML Vision affiche ses statistiques d'évaluation.

    Page d'évaluation du modèle

API REST et ligne de commande

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • project-id : ID de votre projet GCP.
  • model-id : ID de votre modèle, issu de la réponse obtenue lors de sa création. L'ID est le dernier élément du nom du modèle. Exemple :
    • Nom du modèle : projects/project-id/locations/location-id/models/IOD4412217016962778756
    • ID du modèle : IOD4412217016962778756
  • model-evaluation-id : ID d'évaluation du modèle. Vous pouvez obtenir les ID d'évaluation de modèle à partir de l'opération list des évaluations de modèle.

Méthode HTTP et URL :

GET https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-evaluation-id

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Exécutez la commande suivante :

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-evaluation-id

PowerShell

Exécutez la commande suivante :

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

Invoke-WebRequest `
-Method GET `
-Headers $headers `
-Uri "https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-evaluation-id" | Select-Object -Expand Content

Vous devriez recevoir une réponse JSON semblable à l'exemple ci-dessous. Les champs spécifiques de la détection des objets clés sont en gras et une version abrégée des entrées classificationEvaluationMetrics est affichée pour plus de clarté :

Go

Avant d'essayer l'exemple ci-dessous, suivez les instructions de configuration pour ce langage sur la page Bibliothèques clientes.

import (
	"context"
	"fmt"
	"io"

	automl "cloud.google.com/go/automl/apiv1"
	"google.golang.org/api/iterator"
	automlpb "google.golang.org/genproto/googleapis/cloud/automl/v1"
)

// listModelEvaluation lists existing model evaluations.
func listModelEvaluations(w io.Writer, projectID string, location string, modelID string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// modelID := "TRL123456789..."

	ctx := context.Background()
	client, err := automl.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %v", err)
	}
	defer client.Close()

	req := &automlpb.ListModelEvaluationsRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s/models/%s", projectID, location, modelID),
	}

	it := client.ListModelEvaluations(ctx, req)

	// Iterate over all results
	for {
		evaluation, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("ListModelEvaluations.Next: %v", err)
		}

		fmt.Fprintf(w, "Model evaluation name: %v\n", evaluation.GetName())
		fmt.Fprintf(w, "Model annotation spec id: %v\n", evaluation.GetAnnotationSpecId())
		fmt.Fprintf(w, "Create Time:\n")
		fmt.Fprintf(w, "\tseconds: %v\n", evaluation.GetCreateTime().GetSeconds())
		fmt.Fprintf(w, "\tnanos: %v\n", evaluation.GetCreateTime().GetNanos())
		fmt.Fprintf(w, "Evaluation example count: %v\n", evaluation.GetEvaluatedExampleCount())
		fmt.Fprintf(w, "Classification model evaluation metrics: %v\n", evaluation.GetClassificationEvaluationMetrics())
	}

	return nil
}

Java

Avant d'essayer l'exemple ci-dessous, suivez les instructions de configuration pour ce langage sur la page Bibliothèques clientes.


import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.ListModelEvaluationsRequest;
import com.google.cloud.automl.v1.ModelEvaluation;
import com.google.cloud.automl.v1.ModelName;
import java.io.IOException;

class ListModelEvaluations {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    listModelEvaluations(projectId, modelId);
  }

  // List model evaluations
  static void listModelEvaluations(String projectId, String modelId) throws IOException {
    // 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 (AutoMlClient client = AutoMlClient.create()) {
      // Get the full path of the model.
      ModelName modelFullId = ModelName.of(projectId, "us-central1", modelId);
      ListModelEvaluationsRequest modelEvaluationsrequest =
          ListModelEvaluationsRequest.newBuilder().setParent(modelFullId.toString()).build();

      // List all the model evaluations in the model by applying filter.
      System.out.println("List of model evaluations:");
      for (ModelEvaluation modelEvaluation :
          client.listModelEvaluations(modelEvaluationsrequest).iterateAll()) {

        System.out.format("Model Evaluation Name: %s\n", modelEvaluation.getName());
        System.out.format("Model Annotation Spec Id: %s", modelEvaluation.getAnnotationSpecId());
        System.out.println("Create Time:");
        System.out.format("\tseconds: %s\n", modelEvaluation.getCreateTime().getSeconds());
        System.out.format("\tnanos: %s", modelEvaluation.getCreateTime().getNanos() / 1e9);
        System.out.format(
            "Evalution Example Count: %d\n", modelEvaluation.getEvaluatedExampleCount());
        System.out.format(
            "Classification Model Evaluation Metrics: %s\n",
            modelEvaluation.getClassificationEvaluationMetrics());
      }
    }
  }
}

Node.js

Avant d'essayer l'exemple ci-dessous, suivez les instructions de configuration pour ce langage sur la page Bibliothèques clientes.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const modelId = 'YOUR_MODEL_ID';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function listModelEvaluations() {
  // Construct request
  const request = {
    parent: client.modelPath(projectId, location, modelId),
    filter: '',
  };

  const [response] = await client.listModelEvaluations(request);

  console.log('List of model evaluations:');
  for (const evaluation of response) {
    console.log(`Model evaluation name: ${evaluation.name}`);
    console.log(`Model annotation spec id: ${evaluation.annotationSpecId}`);
    console.log(`Model display name: ${evaluation.displayName}`);
    console.log('Model create time');
    console.log(`\tseconds ${evaluation.createTime.seconds}`);
    console.log(`\tnanos ${evaluation.createTime.nanos / 1e9}`);
    console.log(
      `Evaluation example count: ${evaluation.evaluatedExampleCount}`
    );
    console.log(
      `Classification model evaluation metrics: ${evaluation.classificationEvaluationMetrics}`
    );
  }
}

listModelEvaluations();

Python

Avant d'essayer l'exemple ci-dessous, suivez les instructions de configuration pour ce langage sur la page Bibliothèques clientes.

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# model_id = "YOUR_MODEL_ID"

client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = client.model_path(project_id, "us-central1", model_id)

print("List of model evaluations:")
for evaluation in client.list_model_evaluations(parent=model_full_id, filter=""):
    print("Model evaluation name: {}".format(evaluation.name))
    print("Model annotation spec id: {}".format(evaluation.annotation_spec_id))
    print("Create Time: {}".format(evaluation.create_time))
    print("Evaluation example count: {}".format(evaluation.evaluated_example_count))
    print(
        "Classification model evaluation metrics: {}".format(
            evaluation.classification_evaluation_metrics
        )
    )

Langues supplémentaires

C# : suivez les instructions de configuration C# sur la page des bibliothèques clientes, puis consultez le{ 10.1 Documentation de référence AutoML Vision pour .NET.

PHP : suivez les instructions de configuration PHP sur la page des bibliothèques clientes, puis consultez le{ 10.1 Documentation de référence AutoML Vision pour PHP.

Ruby : suivez les instructions de configuration de Ruby sur la page des bibliothèques clientes, puis accédez à la page { 10.1 Documentation de référence AutoML Vision pour Ruby.

Obtenir les valeurs d'évaluation du modèle

Vous pouvez également obtenir une évaluation de modèle spécifique pour un libellé (displayName) en utilisant un ID d'évaluation.

UI Web

  1. Accédez à Vision Dashboard, puis cliquez sur l'icône représentant une ampoule dans la barre de navigation de gauche pour afficher les modèles disponibles.

    Pour afficher les modèles d'un autre projet, sélectionnez le projet dans la liste déroulante située en haut à droite de la barre de titre.

  2. Cliquez sur la ligne du modèle que vous souhaitez évaluer.

  3. Si nécessaire, cliquez sur l'onglet Évaluation situé juste en dessous de la barre de titre.

    Si le modèle a été entraîné, AutoML Vision affiche ses statistiques d'évaluation.

    updated evaluate page
  4. Pour afficher les statistiques correspondant à un libellé spécifique, sélectionnez le nom du libellé dans la liste située dans la partie inférieure de la page.

    Libellé de la page d'évaluation du modèle

API REST et ligne de commande

Pour n'obtenir que les statistiques d'évaluation d'un libellé spécifique, ajoutez /{model-evaluation-id} à la requête ci-dessus, provenant d'une réponse à une opération.

Par exemple, vous pouvez trouver l'ID d'évaluation du modèle pour le libellé rose (displayName) dans le nom d'évaluation renvoyé par l'opération list :

  • "name": "projects/project-id/locations/us-central1/models/model-id/modelEvaluations/858136867710915695"

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • project-id : ID de votre projet GCP.
  • model-id : ID de votre modèle, issu de la réponse obtenue lors de sa création. L'ID est le dernier élément du nom du modèle. Exemple :
    • Nom du modèle : projects/project-id/locations/location-id/models/IOD4412217016962778756
    • ID du modèle : IOD4412217016962778756
  • model-evaluation-id : ID d'évaluation du modèle. Vous pouvez obtenir les ID d'évaluation de modèle à partir de l'opération list des évaluations de modèle.

Méthode HTTP et URL :

GET https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-evaluation-id

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Exécutez la commande suivante :

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-evaluation-id

PowerShell

Exécutez la commande suivante :

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

Invoke-WebRequest `
-Method GET `
-Headers $headers `
-Uri "https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-evaluation-id" | Select-Object -Expand Content

Vous devriez recevoir une réponse JSON de ce type :

Go

Avant d'essayer l'exemple ci-dessous, suivez les instructions de configuration pour ce langage sur la page Bibliothèques clientes.

import (
	"context"
	"fmt"
	"io"

	automl "cloud.google.com/go/automl/apiv1"
	automlpb "google.golang.org/genproto/googleapis/cloud/automl/v1"
)

// getModelEvaluation gets a model evaluation.
func getModelEvaluation(w io.Writer, projectID string, location string, modelID string, modelEvaluationID string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// modelID := "TRL123456789..."
	// modelEvaluationID := "123456789..."

	ctx := context.Background()
	client, err := automl.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %v", err)
	}
	defer client.Close()

	req := &automlpb.GetModelEvaluationRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/models/%s/modelEvaluations/%s", projectID, location, modelID, modelEvaluationID),
	}

	evaluation, err := client.GetModelEvaluation(ctx, req)
	if err != nil {
		return fmt.Errorf("GetModelEvaluation: %v", err)
	}

	fmt.Fprintf(w, "Model evaluation name: %v\n", evaluation.GetName())
	fmt.Fprintf(w, "Model annotation spec id: %v\n", evaluation.GetAnnotationSpecId())
	fmt.Fprintf(w, "Create Time:\n")
	fmt.Fprintf(w, "\tseconds: %v\n", evaluation.GetCreateTime().GetSeconds())
	fmt.Fprintf(w, "\tnanos: %v\n", evaluation.GetCreateTime().GetNanos())
	fmt.Fprintf(w, "Evaluation example count: %v\n", evaluation.GetEvaluatedExampleCount())
	fmt.Fprintf(w, "Classification model evaluation metrics: %v\n", evaluation.GetClassificationEvaluationMetrics())

	return nil
}

Java

Avant d'essayer l'exemple ci-dessous, suivez les instructions de configuration pour ce langage sur la page Bibliothèques clientes.


import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.ModelEvaluation;
import com.google.cloud.automl.v1.ModelEvaluationName;
import java.io.IOException;

class GetModelEvaluation {

  static void getModelEvaluation() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String modelEvaluationId = "YOUR_MODEL_EVALUATION_ID";
    getModelEvaluation(projectId, modelId, modelEvaluationId);
  }

  // Get a model evaluation
  static void getModelEvaluation(String projectId, String modelId, String modelEvaluationId)
      throws IOException {
    // 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 (AutoMlClient client = AutoMlClient.create()) {
      // Get the full path of the model evaluation.
      ModelEvaluationName modelEvaluationFullId =
          ModelEvaluationName.of(projectId, "us-central1", modelId, modelEvaluationId);

      // Get complete detail of the model evaluation.
      ModelEvaluation modelEvaluation = client.getModelEvaluation(modelEvaluationFullId);

      System.out.format("Model Evaluation Name: %s\n", modelEvaluation.getName());
      System.out.format("Model Annotation Spec Id: %s", modelEvaluation.getAnnotationSpecId());
      System.out.println("Create Time:");
      System.out.format("\tseconds: %s\n", modelEvaluation.getCreateTime().getSeconds());
      System.out.format("\tnanos: %s", modelEvaluation.getCreateTime().getNanos() / 1e9);
      System.out.format(
          "Evalution Example Count: %d\n", modelEvaluation.getEvaluatedExampleCount());
      System.out.format(
          "Classification Model Evaluation Metrics: %s\n",
          modelEvaluation.getClassificationEvaluationMetrics());
    }
  }
}

Node.js

Avant d'essayer l'exemple ci-dessous, suivez les instructions de configuration pour ce langage sur la page Bibliothèques clientes.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const modelId = 'YOUR_MODEL_ID';
// const modelEvaluationId = 'YOUR_MODEL_EVALUATION_ID';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function getModelEvaluation() {
  // Construct request
  const request = {
    name: client.modelEvaluationPath(
      projectId,
      location,
      modelId,
      modelEvaluationId
    ),
  };

  const [response] = await client.getModelEvaluation(request);

  console.log(`Model evaluation name: ${response.name}`);
  console.log(`Model annotation spec id: ${response.annotationSpecId}`);
  console.log(`Model display name: ${response.displayName}`);
  console.log('Model create time');
  console.log(`\tseconds ${response.createTime.seconds}`);
  console.log(`\tnanos ${response.createTime.nanos / 1e9}`);
  console.log(`Evaluation example count: ${response.evaluatedExampleCount}`);
  console.log(
    `Classification model evaluation metrics: ${response.classificationEvaluationMetrics}`
  );
}

getModelEvaluation();

Python

Avant d'essayer l'exemple ci-dessous, suivez les instructions de configuration pour ce langage sur la page Bibliothèques clientes.

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# model_id = "YOUR_MODEL_ID"
# model_evaluation_id = "YOUR_MODEL_EVALUATION_ID"

client = automl.AutoMlClient()
# Get the full path of the model evaluation.
model_path = client.model_path(project_id, "us-central1", model_id)
model_evaluation_full_id = f"{model_path}/modelEvaluations/{model_evaluation_id}"

# Get complete detail of the model evaluation.
response = client.get_model_evaluation(name=model_evaluation_full_id)

print("Model evaluation name: {}".format(response.name))
print("Model annotation spec id: {}".format(response.annotation_spec_id))
print("Create Time: {}".format(response.create_time))
print("Evaluation example count: {}".format(response.evaluated_example_count))
print(
    "Classification model evaluation metrics: {}".format(
        response.classification_evaluation_metrics
    )
)

Vrais positifs, faux négatifs et faux positifs (UI uniquement)

Dans l'interface utilisateur, vous pouvez observer des exemples spécifiques de performances du modèle, à savoir les vrais positifs (VP), faux négatifs (FN)et faux positifs (FP) de vos ensembles d'ENTRAÎNEMENT et de VALIDATION.

UI Web

Avant d'essayer l'exemple ci-dessous, suivez les instructions de configuration pour ce langage sur la page Bibliothèques clientes.

Pour accéder aux vues "VP", "FN", et "FP" dans l'UI, sélectionnez l'onglet Évaluer, puis sélectionnez un libellé spécifique.

En affichant les tendances de ces prédictions, vous pouvez modifier votre ensemble d'entraînement pour améliorer les performances du modèle.

Les images de la catégorie True positives (Vrais positifs) sont des exemples d'images fournis au modèle entraîné et annotés correctement par le modèle :

vrais positifs affichés

Les images de la catégorie False negatives (Faux négatifs) sont également fournies au modèle entraîné, mais le modèle n'a pas correctement annoté l'image pour le libellé donné :

faux négatifs affichés

Enfin, les images de la catégorie False positives (Faux positifs) sont celles fournies au modèle entraîné qui étaient annotées avec le libellé donné, alors qu'elles n'auraient pas dû être annotées :

faux positifs affichés

Le modèle sélectionne des cas intéressants, ce qui permet d'affiner les définitions et les libellés pour aider le modèle à comprendre les interprétations de libellés. Par exemple, une définition plus stricte peut aider le modèle à comprendre si vous considérez une peinture abstraite d'une rose comme une rose ou non.

Avec des boucles libellé-entraînement-évaluation répétées, votre modèle dégage d'autres ambiguïtés de vos données.

Vous pouvez également ajuster le seuil de score dans cette vue de l'interface utilisateur. Les images VP, FN et FP affichées reflètent le changement de seuil :

vrais positifs avec seuil mis à jour

Itérer sur le modèle

Si vous n'êtes pas satisfait des niveaux de qualité, vous pouvez revenir aux étapes précédentes pour les améliorer en suivant les consignes ci-après :

  • AutoML Vision vous permet de trier les images en fonction du degré de "confusion" du modèle, du libellé réel et du libellé prédit. Examinez ces images et assurez-vous que le libellé approprié leur a été attribué.
  • Essayez d'ajouter plus d'images aux libellés de faible qualité.
  • Vous devrez peut-être ajouter d'autres types d'images (par exemple, un angle plus large, une résolution supérieure ou inférieure, des points de vue différents).
  • Supprimez totalement les libellés si vous ne disposez pas d'images d'entraînement en quantité suffisante.
  • N'oubliez pas que les machines ne peuvent pas lire le nom de votre libellé : pour elles, il s'agit seulement d'une chaîne de lettres aléatoire. Si vous avez un libellé "porte" et un autre libellé "porte_avec_poignée", la machine ne peut se baser que sur les images que fournissez pour déterminer la nuance.
  • Enrichissez vos données avec davantage d'exemples de vrais positifs et négatifs. Les exemples particulièrement importants sont ceux qui sont proches de la frontière de décision, c'est-à-dire susceptibles de créer une confusion alors que leur libellé est approprié.
  • Spécifiez votre propre répartition des ensembles ENTRAÎNEMENT, TEST et VALIDATION. L'outil attribue des images au hasard, mais des quasi-doublons peuvent se retrouver dans ENTRAÎNEMENT et VALIDATION, ce qui peut entraîner un surapprentissage et nuire aux performances de l'ensemble TEST.

Une fois les modifications apportées, entraînez et évaluez un nouveau modèle jusqu'à ce que vous ayez atteint un niveau de qualité suffisant.