Modelle bewerten

Nach dem Training eines Modells verwendet AutoML Vision Elemente aus dem TEST-Dataset, um die Qualität und Genauigkeit des neuen Modells zu bewerten.

Bewertungsübersicht

AutoML Vision bietet eine ganze Reihe von Bewertungsmesswerten, 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.

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

  • Die Konfidenzwertkurven zeigen, wie sich unterschiedliche Konfidenzwerte auf die Genauigkeit, die Trefferquote sowie die Richtig- und Falsch-Positiv-Raten auswirken würden. Siehe auch die Beziehung von Genauigkeit und Trefferquote.

  • Wahrheitsmatrix (auch Konfusionsmatrix genannt): Nur für Modelle mit einem Label pro Bild vorhanden. Stellt in Prozent dar, wie oft jedes Label während der Bewertung für jedes Label im Training-Dataset vorhergesagt wurde.

    Beispiel für eine Wahrheitsmatrix

    Idealerweise würde das one-Label nur Bildern zugewiesen werden, die alsone-Label usw. klassifiziert wurden, sodass eine perfekte Matrix so aussähe:

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

    Wenn im obigen Beispiel ein Bild als one klassifiziert wurde, das Modell jedoch two vorhergesagt hat, würde die erste Zeile stattdessen so aussehen:

    99  1  0  0
    

    Weitere Informationen erhalten Sie, wenn Sie nach Wahrheitsmatrix maschinelles Lernen suchen.

    AutoML Vision erstellt die Wahrheitsmatrix für bis zu zehn Labels. Wenn Sie mehr als zehn Labels haben, enthält die Matrix die zehn Labels mit der höchsten Konfusion (falsche Vorhersagen).

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. Ein sehr hoher AUC-Wert und eine perfekte Genauigkeit und Trefferquote zeigen unter Umständen an, dass die Daten zu einfach sind und sich möglicherweise nicht gut verallgemeinern lassen.

Modellbewertungen auflisten

Nachdem Sie ein Modell trainiert haben, können Sie Bewertungsmesswerte für dieses Modell auflisten.

Web-UI

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

    Sobald das Training für das Modell abgeschlossen ist, werden die entsprechenden Bewertungsmesswerte in AutoML Vision angezeigt.

    Screenshot: Seite für Modellbewertung

REST & CMD LINE

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 folgenden 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 classificationEvaluationMetrics-Einträgen angezeigt:

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

	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 com.google.protobuf.Timestamp;
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:");
        Timestamp createdTime = modelEvaluation.getCreateTime();
        System.out.format("\tseconds: %s%n", createdTime.getSeconds());
        System.out.format("\tnanos: %s", createdTime.getNanos() / 1e9);
        System.out.format(
            "Evalution Example Count: %d%n", modelEvaluation.getEvaluatedExampleCount());
        System.out.format(
            "Classification Model Evaluation Metrics: %s%n",
            modelEvaluation.getClassificationEvaluationMetrics());
      }
    }
  }
}

Node.js

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

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('Classification model evaluation metrics: %s' . PHP_EOL, $modelEvaluation->getTextSentimentEvaluationMetrics());
        }
    }
} 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(
        "Classification model evaluation metrics: {}".format(
            evaluation.classification_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.auto_ml

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

model_evaluations = client.list_model_evaluations parent: 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 "Classification model evaluation metrics: #{evaluation.classification_evaluation_metrics}"
end

Werte der Modellbewertung abrufen

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

Web-UI

  1. Öffnen Sie die Vision Dashboard und klicken Sie in der linken Navigationsleiste auf das 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.

    Sobald das Training für das Modell abgeschlossen ist, werden die entsprechenden Bewertungsmesswerte in AutoML Vision angezeigt.

    updated evaluate page
  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 & CMD LINE

Wenn Sie nur die Bewertungsmesswerte für ein bestimmtes Label erhalten möchten, fügen Sie /{model-evaluation-id} in die Anfrage oben aus der Antwort ein.

Beispiel: Sie finden die Modellbewertungs-ID für das Label rose (displayName) im Bewertungsnamen, der vom list-Vorgang zurückgegeben wird:

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

Ersetzen Sie diese Werte in den folgenden Anweisungen:

  • 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 folgenden 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 folgenden 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 in etwa folgende JSON-Antwort erhalten:

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

	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 com.google.protobuf.Timestamp;
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:");
      Timestamp createdTime = modelEvaluation.getCreateTime();
      System.out.format("\tseconds: %s%n", createdTime.getSeconds());
      System.out.format("\tnanos: %s", createdTime.getNanos() / 1e9);
      System.out.format(
          "Evalution Example Count: %d%n", modelEvaluation.getEvaluatedExampleCount());
      System.out.format(
          "Classification Model Evaluation Metrics: %s%n",
          modelEvaluation.getClassificationEvaluationMetrics());
    }
  }
}

Node.js

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

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->getTextSentimentEvaluationMetrics());
} 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(
    "Classification model evaluation metrics: {}".format(
        response.classification_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.auto_ml

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

# Get complete detail of the model evaluation.
model_evaluation = client.get_model_evaluation name: 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 "Classification model evaluation metrics: #{model_evaluation.classification_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

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

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.

Auf Grundlage der Trends in diesen Vorhersagen können Sie Ihr Trainings-Dataset ändern, um die Modellleistung zu verbessern.

Richtig positive Bilder sind Beispielbilder, die für das trainierte Modell bereitgestellt wurden und die das Modell korrekt annotiert hat:

Richtig positive Bilder

Falsch negative Bilder wurden dem trainierten Modell ebenfalls bereitgestellt, aber das Modell konnte die Bilder für das angegebene Label nicht richtig annotieren:

Falsch negative Bilder

Falsch positive Bilder sind solche Bilder, die dem trainierten Modell bereitgestellt und mit dem angegebenen Label annotiert wurden, aber nicht hätten annotiert werden sollen:

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 ein abstraktes Gemälde einer Rose als Rose betrachten oder nicht.

Bei wiederholten Label-, Trainings- und Bewertungsschleifen zeigt Ihr Modell weitere Unklarheiten dieser Art in Ihren Daten an.

Sie können den Punktzahl-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

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:

  • Mit AutoML Vision können Sie Bilder nach dem Wahrheitsgehalt des Modells sortieren, d. h. nach tatsächlichem und vorhergesagtem Label. Sehen Sie sich diese Bilder an und achten Sie darauf, dass sie mit den richtigen Labels versehen sind.
  • Erwägen Sie, allen Labels mit geringer Qualität weitere Bilder hinzuzufügen.
  • Möglicherweise müssen Sie verschiedene Arten von Bildern einfügen (z. B. mit größerem Winkel, höherer oder geringerer Auflösung, unterschiedlichen Blickpunkten).
  • Entfernen Sie Labels gegebenenfalls vollständig, wenn Sie nicht genügend Trainingsbilder haben.
  • Vergessen Sie nicht, dass Maschinen Labelnamen nicht lesen können. Für Maschinen stellen sie lediglich eine zufällige Aneinanderreihung von Buchstaben dar. Wenn Sie ein Label mit der Aufschrift "Tür" und ein anderes mit der Aufschrift "Tür_mit_Klinke" haben, kann die Maschine den feinen Unterschied nur erkennen, wenn Sie ihr 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 VALIDATION fest. Das Tool weist Bilder nach dem Zufallsprinzip zu, aber Beinahe-Duplikate können im Dataset TRAIN und VALIDATION landen, was zu einer Überanpassung und dann zu einer schlechten Leistung des Datasets TEST führen kann.

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