Modelle bewerten

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

Die Objekterkennung von 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 Precision/Recall, 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 Precison und Recall.

• F1-Wert: der harmonische Mittelwert von Precision und Recall. 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.

Hinweis: Beim Auflisten von Ressourcen, Vorgängen und Messwerten können Sie auch filtern. Informationen zum Filtern finden Sie unter Beim Auflisten filtern.

Web-UI

1. Öffnen Sie die 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.

   Wenn Sie die Modelle für ein anderes Projekt ansehen möchten, wählen Sie das Projekt in der Drop-down-Liste rechts oben 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 AutoML Vision-Objekterkennung die Bewertungsmesswerte für das Modell an.

   

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.

   

REST

Ersetzen Sie dabei folgende Werte für die Anfragedaten:

• 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

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto in der gcloud CLI angemeldet haben. Dazu haben Sie gcloud init oder gcloud auth login ausgeführt oder die Cloud Shell genutzt, die Sie automatisch in der gcloud CLI anmeldet. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

Führen Sie folgenden Befehl aus:

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

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto in der gcloud-Befehlszeile angemeldet haben. Dazu führen Sie gcloud init oder gcloud auth login aus. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

Führen Sie folgenden Befehl aus:

$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

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

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

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

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(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
        )
    )

Weitere Sprachen

C#: Folgen Sie der Anleitung zur Einrichtung von C# auf der Seite der Clientbibliotheken und rufen Sie dann die AutoML Vision Object Detection-Referenzdokumentation für .NET auf.

PHP: Folgen Sie der Anleitung zur Einrichtung von PHP auf der Seite der Clientbibliotheken und rufen Sie dann die AutoML Vision Object Detection-Referenzdokumentation für PHP auf.

Ruby: Folgen Sie der Anleitung zur Einrichtung von Ruby auf der Seite der Clientbibliotheken und rufen Sie dann die AutoML Vision Object Detection-Referenzdokumentation für Ruby auf.

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

REST

Ersetzen Sie dabei folgende Werte für die Anfragedaten:

• 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

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto in der gcloud CLI angemeldet haben. Dazu haben Sie gcloud init oder gcloud auth login ausgeführt oder die Cloud Shell genutzt, die Sie automatisch in der gcloud CLI anmeldet. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

Führen Sie folgenden Befehl aus:

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

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto in der gcloud-Befehlszeile angemeldet haben. Dazu führen Sie gcloud init oder gcloud auth login aus. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

Führen Sie folgenden Befehl aus:

$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

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

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

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

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_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
    )
)

Weitere Sprachen

C#: Folgen Sie der Anleitung zur Einrichtung von C# auf der Seite der Clientbibliotheken und rufen Sie dann die AutoML Vision Object Detection-Referenzdokumentation für .NET auf.

PHP: Folgen Sie der Anleitung zur Einrichtung von PHP auf der Seite der Clientbibliotheken und rufen Sie dann die AutoML Vision Object Detection-Referenzdokumentation für PHP auf.

Ruby: Folgen Sie der Anleitung zur Einrichtung von Ruby auf der Seite der Clientbibliotheken und rufen Sie dann die AutoML Vision Object Detection-Referenzdokumentation für Ruby auf.

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

Hinweis: Diese Funktion ist nur in der Benutzeroberfläche (UI) verfügbar.

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.

Die Benutzeroberfläche enthält Korrektheitskategorien (z. B. richtig positiv, falsch positiv, falsch negativ) für jeden Begrenzungsrahmen auf jedem Bild. Das bedeutet, dass ein einzelnes Bild in mehreren UI-Zeilen enthalten sein kann und jedes Mal auf ein anderes Problem hinweist. Da es in jedem Bild viele Rahmen geben kann, zeigt die Benutzeroberfläche nur ein einziges Paar aus vorhergesagtem Begrenzungsrahmen und Ground-Truth-Rahmen an, das diesem Verhalten entspricht.

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 sind Begrenzungsrahmen, die dem trainierten Modell ähnlich bereitgestellt wurden, doch das Modell konnte keine Instanzen eines Objekts richtig annotieren:

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:

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:

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

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.

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.

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.