Modelle bewerten

Nach dem Training eines Modells bewertet die Objekterkennung von Cloud AutoML Vision die Qualität und Treffsicherheit des neuen Modells anhand von Bildern aus dem TEST-Dataset.

Die Objekterkennung von Cloud AutoML Vision bietet eine ganze Reihe von Bewertungsmesswerten (Bewertungsprozessausgaben), die angeben, wie gut das Modell insgesamt funktioniert. Auch für jedes Kategorielabel gibt es Bewertungsmesswerte. Sie geben an, wie gut das Modell für das jeweilige Label funktioniert.

Bewertungsübersicht

Bewertungsprozesseingaben

  • IoU-Schwellenwert: Überschneidung über Union, ein Messwert, mit dem im Objekt-Tracking die Überlappung eines vorhergesagten Begrenzungsrahmens gegenüber einem tatsächlichen Begrenzungsrahmen für ein Objekt gemessen wird. Je näher die Werte des vorhergesagten Begrenzungsrahmens an den Werten des tatsächlichen Begrenzungsrahmens liegen, desto größer ist die Überschneidung und desto größer der IoU-Wert.

  • Score-Schwellenwert: Ausgabemesswerte (unten) werden in der Annahme berechnet, dass das Modell keine Vorhersagen mit einem Score zurückgibt, der niedriger als dieser Wert ist.

Ausgabe des Bewertungsprozesses

  • AuPRC: Die Fläche unter der Genauigkeits-/Trefferquotenkurve, die auch als "durchschnittliche Genauigkeit" bezeichnet wird. Im Allgemeinen zwischen 0,5 und 1,0. Höhere Werte deuten auf genauere Modelle hin.

  • Konfidenzwertkurven: Diese zeigen, wie sich unterschiedliche Konfidenzwerte auf die Genauigkeit, die Trefferquote sowie die Rate richtig und falsch positiver Ergebnisse auswirken würden. Siehe auch die Beziehung von Genauigkeit und Trefferquote.

  • F1-Wert: der harmonische Mittelwert von Genauigkeit und Trefferquote. F1 ist ein nützlicher Messwert, wenn Sie ein Gleichgewicht zwischen Genauigkeit und Trefferquote erzielen möchten. F1 ist auch hilfreich, wenn Ihre Trainingsdaten eine ungleichmäßige Klassenverteilung haben.

Verwenden Sie diese Daten, um die Bereitschaft Ihres Modells zu bewerten. Hohe Konfusion, niedrige AUC-Werte oder niedrige Genauigkeits- und Trefferquotenwerte können darauf hinweisen, dass Ihr Modell zusätzliche Trainingsdaten benötigt oder inkonsistente Labels enthält. Ein sehr hoher AUC-Wert und eine perfekte Genauigkeit und Trefferquote können darauf hinweisen, dass die Daten zu einfach und nicht verallgemeinernd sind: Eine hoher AUC-Wert kann darauf hindeuten, dass das Modell mit idealisierten Daten trainiert wurde, die zukünftige Inferenzen nicht angemessen darstellen.

Modellbewertungen verwalten

Modellbewertungen auflisten

Nachdem Sie ein Modell trainiert haben, können Sie eine Liste von Bewertungsmesswerten für dieses Modell anlegen.

Web-UI

  1. Öffnen Sie die Cloud AutoML Vision-Benutzeroberfläche für die Objekterkennung und klicken Sie in der linken Navigationsleiste auf den Tab Modelle mit dem Glühbirnensymbol, um die verfügbaren Modelle aufzurufen.

    Wählen Sie zum Anzeigen der Modelle für ein anderes Projekt das Projekt in der Dropdown-Liste oben rechts in der Titelleiste aus.

  2. Klicken Sie auf die Zeile für das Modell, das Sie bewerten möchten.

  3. Klicken Sie ggf. unterhalb der Titelleiste auf den Tab Bewerten.

    Wenn das Training für das Modell abgeschlossen wurde, zeigt die Cloud AutoML Vision-Objekterkennung die Bewertungsmesswerte für das Modell an.

    Seite für Modellbewertung

  4. Wählen Sie unten auf der Seite in der Liste der Labels den Label-Namen aus, um Messwerte für ein bestimmtes Label anzeigen zu lassen.

    Spezifisches Label für die Seite mit der Modellbewertung

REST UND BEFEHLSZEILE

Bevor Sie die unten aufgeführten Anfragedaten verwenden, ersetzen Sie die folgenden Werte:

  • project-id: die ID Ihres GCP-Projekts.
  • model-id: die ID Ihres Modells aus der Antwort beim Erstellen des Modells. Sie ist das letzte Element des Modellnamens. Beispiel:
    • Modellname: projects/project-id/locations/location-id/models/IOD4412217016962778756
    • Modell-ID: IOD4412217016962778756

HTTP-Methode und URL:

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

Senden Sie die Anfrage mithilfe einer der folgenden Optionen:

curl

Führen Sie diesen Befehl aus:

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

PowerShell

Führen Sie diesen Befehl aus:

$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" | Select-Object -Expand Content

Sie sollten eine JSON-Antwort ähnlich der folgenden erhalten. Spezifische Felder für die Schlüsselobjekterkennung sind fett formatiert. Der Übersichtlichkeit halber variiert die Anzahl der angezeigten boundingBoxMetricsEntries-Einträge:



    {
  "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"
    }
  ]
}

C#

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für diese Sprache auf der Seite Clientbibliotheken.

/// <summary>
/// Demonstrates using the AutoML client to list model evaluations.
/// </summary>
/// <param name="projectId">GCP Project ID.</param>
/// <param name="modelId">the Id of the model.</param>
public static object ListModelEvaluations(string projectId = "YOUR-PROJECT-ID",
    string modelId = "YOUR-MODEL-ID")
{
    // Initialize the client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    AutoMlClient client = AutoMlClient.Create();

    // Get the full path of the model.
    string modelFullId = ModelName.Format(projectId, "us-central1", modelId);

    // Create list models request.
    ListModelEvaluationsRequest listModlesRequest = new ListModelEvaluationsRequest
    {
        Parent = modelFullId
    };

    // List all the model evaluations in the model by applying filter.
    Console.WriteLine("List of model evaluations:");
    foreach (ModelEvaluation modelEvaluation in client.ListModelEvaluations(listModlesRequest))
    {
        Console.WriteLine($"Model Evaluation Name: {modelEvaluation.Name}");
        Console.WriteLine($"Model Annotation Spec Id: {modelEvaluation.AnnotationSpecId}");
        Console.WriteLine("Create Time:");
        Console.WriteLine($"\tseconds: {modelEvaluation.CreateTime.Seconds}");
        Console.WriteLine($"\tnanos: {modelEvaluation.CreateTime.Nanos / 1e9}");
        Console.WriteLine(
            $"Evalution Example Count: {modelEvaluation.EvaluatedExampleCount}");
        Console.WriteLine(
            $"Object Detection Model Evaluation Metrics: {modelEvaluation.ImageObjectDetectionEvaluationMetrics}");
    }
    return 0;
}

Go

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für diese Sprache auf der Seite Clientbibliotheken.

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

	return nil
}

Java

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für diese Sprache auf der Seite Clientbibliotheken.


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

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für diese Sprache auf der Seite Clientbibliotheken.

/**
 * 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();

PHP

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für diese Sprache auf der Seite Clientbibliotheken.

use Google\Cloud\AutoMl\V1\AutoMlClient;

/** Uncomment and populate these variables in your code */
// $projectId = '[Google Cloud Project ID]';
// $location = 'us-central1';
// $modelId = 'my_model_id_123';

$client = new AutoMlClient();

try {
    // get full path of model
    $formattedParent = $client->modelName(
        $projectId,
        $location,
        $modelId
    );

    // list all model evaluations
    $filter = '';
    $pagedResponse = $client->listModelEvaluations($formattedParent, $filter);

    print('List of model evaluations' . PHP_EOL);
    foreach ($pagedResponse->iteratePages() as $page) {
        foreach ($page as $modelEvaluation) {
            // display model evaluation information
            $splitName = explode('/', $modelEvaluation->getName());
            printf('Model evaluation name: %s' . PHP_EOL, $modelEvaluation->getName());
            printf('Model evaluation id: %s' . PHP_EOL, end($splitName));
            printf('Model annotation spec id: %s' . PHP_EOL, $modelEvaluation->getAnnotationSpecId());
            printf('Create time' . PHP_EOL);
            printf('seconds: %d' . PHP_EOL, $modelEvaluation->getCreateTime()->getSeconds());
            printf('nanos : %d' . PHP_EOL, $modelEvaluation->getCreateTime()->getNanos());
            printf('Evaluation example count: %s' . PHP_EOL, $modelEvaluation->getEvaluatedExampleCount());
            printf('Object detection model evaluation metrics: %s' . PHP_EOL, $modelEvaluation->getImageObjectDetectionEvaluationMetrics());
        }
    }
} finally {
    $client->close();
}

Python

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für diese Sprache auf der Seite Clientbibliotheken.

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(model_full_id, ""):
    print("Model evaluation name: {}".format(evaluation.name))
    print(
        "Model annotation spec id: {}".format(
            evaluation.annotation_spec_id
        )
    )
    print("Create Time:")
    print("\tseconds: {}".format(evaluation.create_time.seconds))
    print("\tnanos: {}".format(evaluation.create_time.nanos / 1e9))
    print(
        "Evaluation example count: {}".format(
            evaluation.evaluated_example_count
        )
    )
    print(
        "Object detection model evaluation metrics: {}\n\n".format(
            evaluation.image_object_detection_evaluation_metrics
        )
    )

Ruby

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für diese Sprache auf der Seite Clientbibliotheken.

require "google/cloud/automl"

project_id = "YOUR_PROJECT_ID"
model_id = "YOUR_MODEL_ID"

client = Google::Cloud::AutoML::AutoML.new

# Get the full path of the model.
model_full_id = client.class.model_path project_id, "us-central1", model_id

model_evaluations = client.list_model_evaluations model_full_id

puts "List of model evaluations:"

model_evaluations.each do |evaluation|
  puts "Model evaluation name: #{evaluation.name}"
  puts "Model annotation spec id: #{evaluation.annotation_spec_id}"
  puts "Create Time: #{evaluation.create_time.to_time}"
  puts "Evaluation example count: #{evaluation.evaluated_example_count}"
  puts "Object detection model evaluation metrics: #{evaluation.image_object_detection_evaluation_metrics}"
end

Modellbewertungen abrufen

Sie können auch eine spezifische Modellbewertung für ein Label (displayName) anhand der Bewertungs-ID abrufen.

Web-UI

Öffnen Sie in der Cloud AutoML Vision-Benutzeroberfläche für die Objekterkennung die Seite Modelle und wählen Sie Ihr Modell aus. Nachdem Sie das Modell ausgewählt haben, wechseln Sie zum Tab Bewerten und wählen Sie das Label aus, um die labelspezifischen Bewertungen anzusehen.

Spezifisches Label für die Seite mit der Modellbewertung

REST UND BEFEHLSZEILE

Bevor Sie die unten aufgeführten Anfragedaten verwenden, ersetzen Sie die folgenden Werte:

  • project-id: die ID Ihres GCP-Projekts.
  • model-id: die ID Ihres Modells aus der Antwort beim Erstellen des Modells. Sie ist das letzte Element des Modellnamens. Beispiel:
    • Modellname: projects/project-id/locations/location-id/models/IOD4412217016962778756
    • Modell-ID: IOD4412217016962778756
  • model-evaluation-id: der ID-Wert der Modellbewertung. Sie können Modellbewertungs-IDs aus dem list-Modellbewertungsvorgang abrufen.

HTTP-Methode und URL:

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

Senden Sie die Anfrage mithilfe einer der folgenden Optionen:

curl

Führen Sie diesen Befehl aus:

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

Führen Sie diesen Befehl aus:

$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

Sie sollten eine JSON-Antwort ähnlich der folgenden erhalten. Spezifische Felder für die Schlüsselobjekterkennung sind fett formatiert. Der Übersichtlichkeit halber wird eine verkürzte Version von boundingBoxMetricsEntries-Einträgen angezeigt:



    {
  "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"
}

C#

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für diese Sprache auf der Seite Clientbibliotheken.

/// <summary>
/// Demonstrates using the AutoML client to get model evaluations.
/// </summary>
/// <param name="projectId">GCP Project ID.</param>
/// <param name="modelId">the Id of the model.</param>
/// <param name="modelEvaluationId">the Id of your model evaluation.</param>
public static object GetModelEvaluation(string projectId = "YOUR-PROJECT-ID",
    string modelId = "YOUR-MODEL-ID",
    string modelEvaluationId = " YOUR-MODEL-EVAL-ID")
{
    // Initialize the client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    AutoMlClient client = AutoMlClient.Create();

    // Get the full path of the model evaluation.
    string modelEvaluationFullId =
        ModelEvaluationName.Format(projectId, "us-central1", modelId, modelEvaluationId);

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

    Console.WriteLine($"Model Evaluation Name: {modelEvaluation.Name}");
    Console.WriteLine($"Model Annotation Spec Id: {modelEvaluation.AnnotationSpecId}");
    Console.WriteLine("Create Time:");
    Console.WriteLine($"\tseconds: {modelEvaluation.CreateTime.Seconds}");
    Console.WriteLine($"\tnanos: {modelEvaluation.CreateTime.Nanos / 1e9}");
    Console.WriteLine(
        $"Evalution Example Count: {modelEvaluation.EvaluatedExampleCount}");

    Console.WriteLine(
        $"Object Detection Model Evaluation Metrics: {modelEvaluation.ImageObjectDetectionEvaluationMetrics}");
    return 0;
}

Go

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für diese Sprache auf der Seite Clientbibliotheken.

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

	return nil
}

Java

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für diese Sprache auf der Seite Clientbibliotheken.


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

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für diese Sprache auf der Seite Clientbibliotheken.

/**
 * 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();

PHP

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für diese Sprache auf der Seite Clientbibliotheken.

use Google\Cloud\AutoMl\V1\AutoMlClient;

/** Uncomment and populate these variables in your code */
// $projectId = '[Google Cloud Project ID]';
// $location = 'us-central1';
// $modelId = 'my_model_id_123';
// $modeEvaluationId = 'my_model_evaluation_id_123';

$client = new AutoMlClient();

try {
    // get full path of the model evaluation
    $formattedName = $client->modelEvaluationName(
        $projectId,
        $location,
        $modelId,
        $modelEvaluationId
    );

    $modelEvaluation = $client->getModelEvaluation($formattedName);

    // display model evaluation information
    $splitName = explode('/', $modelEvaluation->getName());
    printf('Model evaluation name: %s' . PHP_EOL, $modelEvaluation->getName());
    printf('Model evaluation id: %s' . PHP_EOL, end($splitName));
    printf('Model annotation spec id: %s' . PHP_EOL, $modelEvaluation->getAnnotationSpecId());
    printf('Create time' . PHP_EOL);
    printf('seconds: %d' . PHP_EOL, $modelEvaluation->getCreateTime()->getSeconds());
    printf('nanos : %d' . PHP_EOL, $modelEvaluation->getCreateTime()->getNanos());
    printf('Evaluation example count: %s' . PHP_EOL, $modelEvaluation->getEvaluatedExampleCount());
    printf('Model evaluation metrics: %s' . PHP_EOL, $modelEvaluation->getImageObjectDetectionEvaluationMetrics());

} finally {
    $client->close();
}

Python

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für diese Sprache auf der Seite Clientbibliotheken.

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_evaluation_full_id = client.model_evaluation_path(
    project_id, "us-central1", model_id, model_evaluation_id
)

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

print("Model evaluation name: {}".format(response.name))
print("Model annotation spec id: {}".format(response.annotation_spec_id))
print("Create Time:")
print("\tseconds: {}".format(response.create_time.seconds))
print("\tnanos: {}".format(response.create_time.nanos / 1e9))
print(
    "Evaluation example count: {}".format(response.evaluated_example_count)
)
print(
    "Object detection model evaluation metrics: {}".format(
        response.image_object_detection_evaluation_metrics
    )
)

Ruby

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Einrichtungsanleitung für diese Sprache auf der Seite Clientbibliotheken.

require "google/cloud/automl"

project_id = "YOUR_PROJECT_ID"
model_id = "YOUR_MODEL_ID"
model_evaluation_id = "YOUR_MODEL_EVALUATION_ID"

client = Google::Cloud::AutoML::AutoML.new

# Get the full path of the model evaluation.
model_evaluation_full_id = client.class.model_evaluation_path project_id, "us-central1", model_id, model_evaluation_id

# Get complete detail of the model evaluation.
model_evaluation = client.get_model_evaluation model_evaluation_full_id

puts "Model evaluation name: #{model_evaluation.name}"
puts "Model annotation spec id: #{model_evaluation.annotation_spec_id}"
puts "Create Time: #{model_evaluation.create_time.to_time}"
puts "Evaluation example count: #{model_evaluation.evaluated_example_count}"
puts "Object detection model evaluation metrics: #{model_evaluation.image_object_detection_evaluation_metrics}"

Richtig positive (true positive, TP), falsch negative (false negative, FN) und falsch positive (false positive, FP) Ergebnisse (nur UI)

In der UI können Sie sich bestimmte Beispiele für die Modellleistung ansehen, nämlich: richtig positive, falsch negative und falsch positive Instanzen aus den Trainings- und Validierungs-Datasets.

Web-UI

Sie können auf die Ansicht für richtig positive, falsch negative und falsch positive Instanzen in der UI zugreifen. Dazu rufen Sie den Tab Bewerten auf und wählen ein bestimmtes Label aus.

Anhand der Trends, die Sie in diesen Vorhersagen erkennen, können Sie Ihr Trainings-Dataset so ändern, dass die Modellleistung verbessert wird.

Richtig positive Bilder sind Begrenzungsrahmen zur Validierung, die dem trainierten Modell bereitgestellt wurden und vom Modell korrekt annotiert wurden:

Richtig positive Bilder

Richtig positive Bilder sind Begrenzungsrahmen, die dem trainierten Modell ähnlich bereitgestellt wurden, doch das Modell konnte keine Instanzen eines Objekts richtig annotieren:

Falsch negative Bilder

Falsch positive Bilder sind Bilder, die dem trainierten Modell zwar bereitgestellt wurden, doch das Modell hat Instanzen eines Objekts annotiert, die in keinem der angegebenen Bereiche annotiert waren:

Falsch positive Bilder

Das Modell wählt interessante Grenzfälle aus, sodass Sie die Möglichkeit haben, Ihre Definitionen und Labels zu verfeinern, damit das Modell Ihre Labelinterpretationen besser nachvollziehen kann. Mit einer strikteren Definition könnte das Modell beispielsweise besser verstehen, ob Sie eine gefüllte Paprikaschote als "Salat" betrachten (oder nicht). Bei wiederholten Label-, Trainings- und Bewertungsschleifen zeigt Ihr Modell weitere Unklarheiten dieser Art in Ihren Daten an.

Sie können den Score-Schwellenwert in dieser Ansicht der Benutzeroberfläche auch anpassen. Die angezeigten richtig positiven, falsch negativen und falsch positiven Bilder entsprechen der Schwellenwertänderung:

Richtig positive Bilder mit aktualisiertem Schwellenwert

Bewertungsmesswerte interpretieren

Objekterkennungsmodelle geben viele Begrenzungsrahmen für ein Eingabebild aus. Jeder Rahmen enthält 1) ein Label und 2) eine Score oder einen Konfidenzwert. Mit den Bewertungsmesswerten können Sie mehrere wichtige Leistungsfragen zu Ihrem Modell beantworten:

  • Erhalte ich die richtige Anzahl an Begrenzungsrahmen?
  • Gibt das Modell tendenziell Grenzfällen niedrigere Scores?
  • Wie genau stimmen die vorhergesagten Begrenzungsrahmen mit dem Ground-Truth-Begrenzungsrahmen überein?

Beachten Sie, dass diese Messwerte genau wie bei der Klassifizierung mehrerer Labels nur Hinweis auf allgemeine niedrigere Punktzahlen geben, nicht jedoch auf eine andere Art von Klassenkonfusion.

Bei der Untersuchung der Modellausgabe pro Bild müssen Sie zwei Begrenzungsrahmen (Ground-Truth-Begrenzungsrahmen und vorhergesagter Begrenzungsrahmen) untersuchen und ermitteln können, wie gut sie miteinander übereinstimmen. Sie müssen Folgendes berücksichtigen:

  • Haben beide Begrenzungsrahmen dasselbe Label?
  • Wie gut überlappen sich die Begrenzungsrahmen?
  • Wie zuversichtlich wurde der Begrenzungsrahmen vom Modell vorhergesagt?

Um die zweite Anforderung zu erfüllen, führen Sie eine neue Messung namens intersection-over-union bzw. IoU aus.

IoU und IoU-Schwellenwert

Darstellung der IoU von Begrenzungsrahmen

Anhand des IoU-Werts wird bestimmt, wie genau zwei Begrenzungsrahmen übereinstimmen. Der IoU-Wert reicht von 0 (keine Überschneidung) bis 1 (die Rahmen sind identisch). Zur Berechnung dieses Werts wird die gemeinsame Fläche zweier Rahmen durch die Fläche in mindestens einem der Rahmen geteilt. Mit dem AutoML-Dienst können Sie die Leistung Ihres Modells bei mehreren IoU-Schwellenwerten untersuchen.

Warum kann eine Änderung des IoU-Schwellenwerts sinnvoll sein?

Stellen Sie sich vor, Sie möchten die Fahrzeuge auf einem Parkplatz zählen. Hier kommt es Ihnen nicht darauf an, ob die Rahmenkoordinaten besonders korrekt sind. Sie möchten lediglich die Gesamtzahl der Begrenzungsrahmen ermitteln. In diesem Fall ist ein niedriger IoU-Schwellenwert angemessen.

Darstellung von Begrenzungsrahmen mit niedrigen Schwellenwerten um Fahrzeuge
Bildnachweis: Nacho, "Smart" (CC BY 2.0, Begrenzungsrahmen und Text hinzugefügt).

Alternativ können Sie versuchen, die Größe eines Stoffflecks zu messen. In diesem Fall benötigen Sie sehr genaue Koordinaten. Daher ist ein viel höherer IoU-Schwellenwert angemessen.

Visuelle Darstellung eines Rahmens um Stoffflecken mit hohem Schwellenwert
Bildnachweis: Housing Works Thrift Shops, "Modern Sofa" (CC BY-SA 2.0, Begrenzungsrahmen und Text hinzugefügt).

Beachten Sie, dass Ihr Modell nicht neu trainiert werden muss, wenn Sie den richtigen Grenzwert für Ihren Anwendungsfall ändern möchten. Sie haben bereits Zugriff auf Bewertungsmesswerte bei verschiedenen IoU-Schwellenwerten.

Score und Score-Schwellenwert

Ähnlich wie bei Klassifikationsmodellen enthalten Ausgaben von Objekterkennungsmodellen (jetzt Begrenzungsrahmen) ebenfalls Scores. Ebenso wie bei der Bildklassifizierung gibt es einen Score-Schwellenwert, den Sie nach dem Training festlegen können, um zu bestimmen, was eine "gute" Übereinstimmung ist und was nicht. Wenn Sie den Score-Schwellenwert ändern, können Sie die Rate falsch positiver und richtig positiver Ergebnisse auf Ihre spezifischen Modellanforderungen abstimmen. Ein Nutzer, der eine sehr hohe Trefferquote wünscht, würde bei der Verarbeitung der Modellausgabe normalerweise einen niedrigeren Score-Schwellenwert verwenden.

Modell durchlaufen

Wenn Sie mit dem Qualitätsniveau nicht zufrieden sind, können Sie zu den vorherigen Schritten zurückkehren, um die Qualität zu verbessern:

  • Überlegen Sie, ob es sinnvoll wäre, bei den Begrenzungsrahmen-Labels mit niedriger Qualität noch mehr Bilder hinzuzufügen.
  • Möglicherweise müssen Sie verschiedene Arten von Bildern einfügen (z. B. mit größerem Bildwinkel, höherer oder niedrigerer Auflösung, aus unterschiedlichen Perspektiven).
  • Wenn Sie nicht genügend Trainingsbilder haben, können Sie die Labels von Begrenzungsrahmen auch vollständig entfernen.
  • Unsere Trainingsalgorithmen verwenden keine Labelnamen. Wenn Sie ein Label mit der Aufschrift "Tür" und ein anderes mit der Aufschrift "Tür_mit_Türknauf" haben, kann der Algorithmus den feinen Unterschied nur erkennen, wenn Sie ihm entsprechende Bilder bieten.
  • Erweitern Sie Ihre Daten um mehr echt positive und negative Beispiele. Besonders wichtige Beispiele sind jene, die nahe an der Entscheidungsgrenze liegen, also solche, die wahrscheinlich zu Fehlern führen, aber trotzdem das richtige Label haben.
  • Legen Sie Ihre eigenen Aufteilungen für TRAIN, TEST und VALIDATE fest. Das Tool weist Bilder nach dem Zufallsprinzip zu, aber Beinahe-Duplikate können im TRAIN- und VALIDATE-Dataset landen, was zu einer Überanpassung und dann zu einer schlechten Leistung des TEST-Datasets führen kann.

Nachdem Sie Änderungen vorgenommen haben, trainieren und bewerten Sie ein neues Modell, bis Sie ein ausreichend hohes Qualitätsniveau erreicht haben.