Évaluer des modèles

Après avoir entraîné un modèle, la détection d'objets AutoML Vision évalue sa qualité et sa précision à l'aide des images de l'ensemble de TEST.

La détection d'objets AutoML Vision fournit un ensemble de métriques d'évaluation indiquant les performances globales du modèle. Il offre également des métriques pour chaque étiquette de catégorie, de façon à évaluer les performances du modèle pour une étiquette donnée.

Présentation de l'évaluation

Entrées du processus d'évaluation

• Seuil IoU : Intersection over Union (ratio entre l'aire d'intersection et l'aire d'union). Valeur utilisée dans la détection d'objets pour mesurer le chevauchement d'un cadre de sélection prévu par rapport au cadre réel d'un objet. Plus les valeurs du cadre de sélection prévu sont proches des valeurs réelles du cadre de sélection, plus l'intersection et la valeur d'IoU sont importantes.

• Seuil de score : Les métriques de sortie (ci-dessous) sont calculées en supposant que le modèle ne renvoie jamais de prédictions dont le score est inférieur à cette valeur.

Résultats du processus d'évaluation

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

• Courbes de seuil de confiance : elles 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.

• Score F1 : moyenne harmonique de précision et du rappel. F1 est une métrique utile si vous souhaitez équilibrer précision et rappel. Elle est également utile lorsque les classes sont réparties de façon inégale.

É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 étiquettes sont incohérentes. 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 se généraliser correctement : un score AUC élevé peut indiquer que le modèle a été entraîné avec des données idéalisées qui représentent mal les inférences futures.

Gérer les évaluations de modèle

Répertorier les évaluations de modèle

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

Remarque : Vous pouvez également utiliser un filtre pour répertorier des ressources, des opérations et des métriques. Pour en savoir plus sur les filtres, consultez la page Filtrer lors des opérations de filtrage.

UI Web

1. Ouvrez l'UI de AutoML Vision Object Detection et cliquez sur l'onglet Modèles (avec 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 l'entraînement du modèle est terminé, la détection d'objets AutoML Vision affiche ses métriques d'évaluation.

   

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.

   

REST

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

Méthode HTTP et URL :

GET https://automl.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/models/MODEL_ID/modelEvaluations

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

curl

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter gcloud auth list pour vérifier le compte actuellement actif.

Exécutez la commande suivante :

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "x-goog-user-project: project-id" \
     "https://automl.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/models/MODEL_ID/modelEvaluations"

PowerShell

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter gcloud auth list pour vérifier le compte actuellement actif.

Exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-id" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://automl.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/models/MODEL_ID/modelEvaluations" | 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 différentes entrées boundingBoxMetricsEntries sont affichées pour plus de clarté :

    {
  "modelEvaluation": [
    {
      "name": "projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-eval-id",
      "annotationSpecId": "6342510834593300480",
      "createTime": "2019-07-26T22:28:56.890727Z",
      "evaluatedExampleCount": 18,
      "imageObjectDetectionEvaluationMetrics": {
        "evaluatedBoundingBoxCount": 96,
        "boundingBoxMetricsEntries": [
          {
            "iouThreshold": 0.15,
            "meanAveragePrecision": 0.6317751,
            "confidenceMetricsEntries": [
              {
                "confidenceThreshold": 0.101631254,
                "recall": 0.84375,
                "precision": 0.2555205,
                "f1Score": 0.3922518
              },
              {
                "confidenceThreshold": 0.10180253,
                "recall": 0.8333333,
                "precision": 0.25316456,
                "f1Score": 0.3883495
              },
              ...
              {
                "confidenceThreshold": 0.8791167,
                "recall": 0.020833334,
                "precision": 1,
                "f1Score": 0.040816326
              },
              {
                "confidenceThreshold": 0.8804436,
                "recall": 0.010416667,
                "precision": 1,
                "f1Score": 0.020618558
              }
            ]
          },
          {
            "iouThreshold": 0.8,
            "meanAveragePrecision": 0.15461995,
            "confidenceMetricsEntries": [
              {
                "confidenceThreshold": 0.101631254,
                "recall": 0.22916667,
                "precision": 0.06940063,
                "f1Score": 0.10653753
              },
              ...
              {
                "confidenceThreshold": 0.8804436,
                "recall": 0.010416667,
                "precision": 1,
                "f1Score": 0.020618558
              }
            ]
          },
          {
            "iouThreshold": 0.4,
            "meanAveragePrecision": 0.56170964,
            "confidenceMetricsEntries": [
              {
                "confidenceThreshold": 0.101631254,
                "recall": 0.7604167,
                "precision": 0.23028392,
                "f1Score": 0.3535109
              },
              ...
              {
                "confidenceThreshold": 0.8804436,
                "recall": 0.010416667,
                "precision": 1,
                "f1Score": 0.020618558
              }
            ]
          },
          ...
        ],
        "boundingBoxMeanAveragePrecision": 0.4306387
      },
      "displayName": "Tomato"
    },
    {
      "name": "projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-eval-id",
      "annotationSpecId": "1730824816165912576",
      "createTime": "2019-07-26T22:28:56.890727Z",
      "evaluatedExampleCount": 9,
      "imageObjectDetectionEvaluationMetrics": {
        "evaluatedBoundingBoxCount": 51,
        "boundingBoxMetricsEntries": [
          {
            ...
          }
        ],
        "boundingBoxMeanAveragePrecision": 0.29565892
      },
      "displayName": "Cheese"
    },
    {
      "name": "projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-eval-id",
      "annotationSpecId": "7495432339200147456",
      "createTime": "2019-07-26T22:28:56.890727Z",
      "evaluatedExampleCount": 4,
      "imageObjectDetectionEvaluationMetrics": {
        "evaluatedBoundingBoxCount": 22,
        "boundingBoxMetricsEntries": [
          {
            "iouThreshold": 0.2,
            "meanAveragePrecision": 0.104004614,
            "confidenceMetricsEntries": [
              {
                "confidenceThreshold": 0.1008248,
                "recall": 0.36363637,
                "precision": 0.08888889,
                "f1Score": 0.14285715
              },
              ...
              {
                "confidenceThreshold": 0.47585258,
                "recall": 0.045454547,
                "precision": 1,
                "f1Score": 0.08695653
              }
            ]
          },
          ...
        ],
        "boundingBoxMeanAveragePrecision": 0.057070773
      },
      "displayName": "Seafood"
    }
  ]
}

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"
	"cloud.google.com/go/automl/apiv1/automlpb"
	"google.golang.org/api/iterator"
)

// 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: %w", 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: %w", 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, "Object detection model evaluation metrics: %v\n", evaluation.GetImageObjectDetectionEvaluationMetrics())
	}

	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(
            "Object Detection Model Evaluation Metrics: %s\n",
            modelEvaluation.getImageObjectDetectionEvaluationMetrics());
      }
    }
  }
}

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(
      `Object detection model evaluation metrics: ${evaluation.imageObjectDetectionEvaluationMetrics}`
    );
  }
}

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(f"Model evaluation name: {evaluation.name}")
    print(f"Model annotation spec id: {evaluation.annotation_spec_id}")
    print(f"Create Time: {evaluation.create_time}")
    print(f"Evaluation example count: {evaluation.evaluated_example_count}")
    print(
        "Object detection model evaluation metrics: {}\n\n".format(
            evaluation.image_object_detection_evaluation_metrics
        )
    )

Langages supplémentaires

C# : Veuillez suivre les Instructions de configuration pour C# sur la page des bibliothèques clientes, puis consultez la Documentation de référence sur la détection d'objets AutoML Vision pour .NET.

PHP : Veuillez suivre les Instructions de configuration pour PHP sur la page des bibliothèques clientes, puis consultez la Documentation de référence sur la détection d'objets AutoML Vision pour PHP.

Ruby : Veuillez suivre les Instructions de configuration de Ruby sur la page des bibliothèques clientes, puis consultez la Documentation de référence sur la détection d'objets AutoML Vision pour Ruby.

Obtenir des évaluations de modèle

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

UI Web

Dans l'UI de détection d'objets AutoML Vision, l'opération équivalente est disponible en accédant à la page Modèles, puis en sélectionnant votre modèle. Après avoir sélectionné votre modèle, accédez à l'onglet Évaluer, puis sélectionnez l'étiquette pour afficher les évaluations spécifiques qui lui sont associées.

REST

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

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter gcloud auth list pour vérifier le compte actuellement actif.

Exécutez la commande suivante :

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "x-goog-user-project: project-id" \
     "https://automl.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/models/MODEL_ID/modelEvaluations/MODEL_EVALUATION_ID"

PowerShell

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter gcloud auth list pour vérifier le compte actuellement actif.

Exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-id" }

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 boundingBoxMetricsEntries est affichée pour plus de clarté :

    {
  "name": "projects/project-id/locations/us-central1/models/model-id/modelEvaluations/model-evaluation-id",
  "annotationSpecId": "6342510834593300480",
  "createTime": "2019-07-26T22:28:56.890727Z",
  "evaluatedExampleCount": 18,
  "imageObjectDetectionEvaluationMetrics": {
    "evaluatedBoundingBoxCount": 96,
    "boundingBoxMetricsEntries": [
      {
        "iouThreshold": 0.15,
        "meanAveragePrecision": 0.6317751,
        "confidenceMetricsEntries": [
          {
            "confidenceThreshold": 0.101631254,
            "recall": 0.84375,
            "precision": 0.2555205,
            "f1Score": 0.3922518
          },
          ...
          {
            "confidenceThreshold": 0.8804436,
            "recall": 0.010416667,
            "precision": 1,
            "f1Score": 0.020618558
          }
        ]
      },
      {
        "iouThreshold": 0.8,
        "meanAveragePrecision": 0.15461995,
        "confidenceMetricsEntries": [
          {
            "confidenceThreshold": 0.101631254,
            "recall": 0.22916667,
            "precision": 0.06940063,
            "f1Score": 0.10653753
          },
          ...
          {
            "confidenceThreshold": 0.8804436,
            "recall": 0.010416667,
            "precision": 1,
            "f1Score": 0.020618558
          }
        ]
      },
      {
        "iouThreshold": 0.4,
        "meanAveragePrecision": 0.56170964,
        "confidenceMetricsEntries": [
          {
            "confidenceThreshold": 0.101631254,
            "recall": 0.7604167,
            "precision": 0.23028392,
            "f1Score": 0.3535109
          },
          ...
          {
            "confidenceThreshold": 0.8804436,
            "recall": 0.010416667,
            "precision": 1,
            "f1Score": 0.020618558
          }
        ]
      },
      ...
    ],
    "boundingBoxMeanAveragePrecision": 0.4306387
  },
  "displayName": "Tomato"
}

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"
	"cloud.google.com/go/automl/apiv1/automlpb"
)

// 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: %w", 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: %w", 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, "Object detection model evaluation metrics: %v\n", evaluation.GetImageObjectDetectionEvaluationMetrics())

	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(
          "Object Detection Model Evaluation Metrics: %s\n",
          modelEvaluation.getImageObjectDetectionEvaluationMetrics());
    }
  }
}

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(
    `Object detection model evaluation metrics: ${response.imageObjectDetectionEvaluationMetrics}`
  );
}

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(f"Model evaluation name: {response.name}")
print(f"Model annotation spec id: {response.annotation_spec_id}")
print(f"Create Time: {response.create_time}")
print(f"Evaluation example count: {response.evaluated_example_count}")
print(
    "Object detection model evaluation metrics: {}".format(
        response.image_object_detection_evaluation_metrics
    )
)

Langages supplémentaires

C# : Veuillez suivre les Instructions de configuration pour C# sur la page des bibliothèques clientes, puis consultez la Documentation de référence sur la détection d'objets AutoML Vision pour .NET.

PHP : Veuillez suivre les Instructions de configuration pour PHP sur la page des bibliothèques clientes, puis consultez la Documentation de référence sur la détection d'objets AutoML Vision pour PHP.

Ruby : Veuillez suivre les Instructions de configuration de Ruby sur la page des bibliothèques clientes, puis consultez la Documentation de référence sur la détection d'objets AutoML Vision pour Ruby.

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

Remarque : Cette fonctionnalité n'est disponible que dans l'interface utilisateur (UI).

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

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

Notre UI fournit des catégories d'exactitude (par exemple VP, FP, FN) pour chaque cadre de chaque image. Cela signifie qu'une image peut apparaître dans plusieurs lignes d'UI, à chaque fois qu'un problème est détecté. En outre, étant donné que chaque image ne peut avoir qu'un certain nombre de cadres, l'UI n'affiche que les deux cadres de prédiction et de vérité terrain démontrant ce comportement.

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 vraies positives sont des cadres de validation fournis au modèle entraîné qui ont été correctement annotés par le modèle :

Les images fausses négatives sont également fournies au modèle entraîné, mais le modèle n'est pas parvenu à annoter correctement une instance d'un objet :

Enfin, les images fausses positives sont celles fournies au modèle entraîné qui a annoté les instances d'un objet non annotées dans la zone spécifiée :

Le modèle sélectionne des cas intéressants, ce qui permet d'affiner les définitions et les étiquettes pour aider le modèle à comprendre les interprétations d'étiquette. Par exemple, une définition plus stricte peut aider le modèle à comprendre si vous considérez un poivron farci comme une "salade" ou non. Avec des boucles étiquette-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 :

Interpréter les métriques d'évaluation

Les modèles de détection d'objets affichent plusieurs cadres de délimitation pour une image d'entrée. Chaque cadre est fourni avec 1) une étiquette et 2) un score ou un niveau de confiance. Les métriques d'évaluation vous aideront à répondre à plusieurs questions clés sur la performance de votre modèle :

• Le nombre de cadres est-il correct ?
• Le modèle tend-il à attribuer des scores plus faibles aux cas marginaux ?
• Dans quelle mesure les cadres de prédiction correspondent-ils à mes cadres de vérité terrain ?

Notez que ces métriques, tout comme celles de la classification multi-étiquette, n'indiquent aucune confusion de classe autre que des scores généralement inférieurs.

Lors de l'examen des résultats du modèle par image, vous devez examiner deux cadres (le cadre de vérité terrain et celui de prédiction) et déterminer s'ils correspondent. Vous devez tenir compte des éléments suivants :

• Les deux cadres portent-ils le même libellé ?
• Dans quelle mesure les cadres se chevauchent-ils ?
• Dans quelle mesure le modèle a-t-il réussi à prédire la valeur du cadre ?

Pour répondre à la deuxième exigence, nous introduisons une nouvelle mesure appelée intersection-over-union, ou IoU (ratio entre l'aire d'intersection et l'aire d'union).

IoU et seuil IoU

L'IoU détermine à quel point deux cadres correspondent. Sa valeur varie de 0 (pas de chevauchement) à 1 (les cadres sont identiques) et elle est calculée en divisant l'aire commune entre les deux cadres par l'aire incluse dans au moins l'un des cadres. Le service AutoML vous permet d'examiner les performances de votre modèle à plusieurs seuils IoU.

Pourquoi modifier le seuil IoU ?

Prenons l'exemple du comptage des voitures dans un parking. Peu importe que les coordonnées du cadre soient très précises, ce qui compte est que vous ayez le bon nombre total de cadres. Dans ce cas, un seuil IoU bas est approprié.

Crédit image : Nacho, "Smart" (CC BY 2.0, cadres de délimitation et texte ajoutés).

Vous pouvez également essayer de mesurer la taille d'une tache sur du tissu. Dans ce cas, vous avez besoin de coordonnées très précises. Par conséquent, un seuil IoU beaucoup plus élevé est approprié.

Crédit image : Housing Works Thrift Shops, "Modern Sofa" (CC BY-SA 2.0, cadres de délimitation et texte ajoutés).

Vous n'avez pas besoin de ré-entraîner votre modèle si vous changez d'avis quant au seuil approprié pour votre cas d'utilisation : vous avez déjà accès aux métriques d'évaluation à différents seuils IoU.

Score et seuil de score

À l'instar des modèles de classification, les résultats des modèles de détection d'objets (désormais des cadres) sont accompagnés de scores. De même que pour la classification des images, vous pouvez définir un seuil de score après l'entraînement pour déterminer ce qu'est ou non une "bonne" correspondance. La modification du seuil de score vous permet d'ajuster le taux de faux positifs et de vrais positifs selon les besoins spécifiques de votre modèle. Un utilisateur qui souhaite un rappel élevé utilise généralement un seuil de score bas lors du traitement des résultats du modèle.

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 :

• Essayez d'ajouter d'autres images aux libellés du cadre de délimitation 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).
• Pensez à supprimer les libellés du cadre de délimitation si vous ne disposez pas d'assez d'images d'entraînement.
• Nos algorithmes d'entraînement n'utilisent pas les noms de vos libellés. Si vous avez une étiquette "porte" et une autre "porte_avec_poignée", l'algorithme n'a aucun moyen de déterminer la nuance, hormis les images que vous lui fournissez.
• 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 ENTRAÎNEMENT, TEST et VALIDATION. L'outil attribue des images au hasard, mais des quasi-doublons peuvent se retrouver dans les ensembles d'ENTRAÎNEMENT et de VALIDATION, ce qui peut entraîner un surapprentissage et nuire aux performances de l'ensemble de 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.