Valutazione dei modelli

Dopo l'addestramento di un modello, il rilevamento di oggetti di AutoML Vision utilizza TEST impostato per valutare la qualità l'accuratezza del nuovo modello.

AutoML Vision Object Detection fornisce un set aggregato di metriche di valutazione (output del processo di valutazione) che indicano tutte le prestazioni del modello, oltre che le metriche di valutazione etichetta della categoria, che indica le prestazioni del modello per quell'etichetta.

Panoramica della valutazione

Input del processo di valutazione

• Soglia IoU : Intersezione su Unione, un valore utilizzato nel rilevamento degli oggetti per misurare la sovrapposizione di un intervallo riquadro di delimitazione effettivo di un oggetto. Più vicino è il riquadro di delimitazione previsto corrispondono ai valori effettivi del riquadro di delimitazione, maggiore è l'intersezione, e maggiore è il valore IoU.

• Soglia di punteggio: le metriche di output (di seguito) vengono calcolate partendo dal presupposto il modello non restituisce mai previsioni con un punteggio inferiore a questo valore.

Output del processo di valutazione

• AuPRC : area sotto la curva di precisione/richiamo, chiamata anche "precisione media". Di solito tra 0,5 e 1,0. Valori più alti indicano modelli più accurati.

• Curve di soglia di confidenza: mostrano in che modo le diverse soglie di confidenza inciderebbe sui tassi di precisione, richiamo, veri e falsi positivi. Informazioni la relazione precisione e richiamo.

• Punteggio F1: la media armonica di precisione e richiamo. F1 è un'informazione utile per trovare un equilibrio tra precisione e richiamo. F1 è utile anche quando la distribuzione in classe non è uniforme e i dati di Google Cloud.

Usa questi dati per valutare l'idoneità del modello. Confusione elevata, AUC bassa o punteggi bassi di precisione e richiamo possono indicare che il modello aggiuntivi o contiene etichette incoerenti. Un punteggio AUC molto alto e una precisione e un richiamo perfetti possono indicare che i dati sono troppo "facili" e può non generalizzare bene: un'AUC elevata può indicare che il modello è stato addestrato su dati idealizzati che non rappresentano bene le inferenze future.

Gestione delle valutazioni dei modelli

Elenco valutazioni modello

Una volta addestrato un modello, puoi elencare le relative metriche di valutazione.

Nota: puoi anche filtrare quando elenchi risorse, operazioni e metrics. Per informazioni sull'adattamento, consulta la sezione Applicazione di filtri quando dell'annuncio.

UI web

1. Apri l'interfaccia utente per il rilevamento di oggetti AutoML Vision e fai clic sulla scheda Modelli (con l'icona a forma di lampadina) nella barra di navigazione a sinistra. barra per visualizzare i modelli disponibili.

   Per visualizzare i modelli di un altro progetto, seleziona il progetto dal menu a discesa in alto a destra nella barra del titolo.

2. Fai clic sulla riga relativa al modello da valutare.

3. Se necessario, fai clic sulla scheda Valuta appena sotto la barra del titolo.

   Una volta completato l'addestramento del modello, AutoML Vision Object Detection mostra e le metriche di valutazione.

   

4. Per visualizzare le metriche per un'etichetta specifica, seleziona il nome dell'etichetta dall'elenco di etichette nella parte inferiore della pagina.

   

REST

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

• project-id: l'ID del tuo progetto Google Cloud.
• model-id: l'ID del modello, dalla quando hai creato il modello. L'ID è l'ultimo elemento del nome del modello. Ad esempio:
  • nome modello: projects/project-id/locations/location-id/models/IOD4412217016962778756
  • ID modello: IOD4412217016962778756

Metodo HTTP e URL:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti consente di accedere automaticamente all'interfaccia a riga di comando gcloud . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Esegui questo comando:

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

Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Esegui questo comando:

$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

Dovresti ricevere una risposta JSON simile all'esempio riportato di seguito. Specifico per il rilevamento di oggetti chiave campi sono in grassetto e la quantità variabile di boundingBoxMetricsEntries voci è mostrati per chiarezza:

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

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella Librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella Librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella Librerie client.

/**
 * 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

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella Librerie client.

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

Linguaggi aggiuntivi

C#: Segui le Istruzioni per la configurazione di C# Nella pagina delle librerie client e poi visita Documentazione di riferimento per il rilevamento di oggetti di AutoML Vision per .NET.

PHP Segui le Istruzioni per la configurazione dei file PHP Nella pagina delle librerie client e poi visita Documentazione di riferimento per il rilevamento di oggetti di AutoML Vision per PHP.

Rubino: Segui le Istruzioni per la configurazione di Ruby Nella pagina delle librerie client e poi visita Documentazione di riferimento per il rilevamento di oggetti di AutoML Vision per Ruby.

Recupero valutazioni modello

Puoi anche ottenere una valutazione specifica del modello per un'etichetta (displayName) utilizzando un ID valutazione.

UI web

Nella UI per il rilevamento di oggetti di AutoML Vision è disponibile l'operazione equivalente andando al alla pagina Modelli, per poi selezionare il tuo modello. Dopo aver selezionato vai alla sezione Scheda Valuta e seleziona l'etichetta per visualizzare valutazioni specifiche per l'etichetta.

REST

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

• project-id: l'ID del tuo progetto Google Cloud.
• model-id: l'ID del modello, dalla quando hai creato il modello. L'ID è l'ultimo elemento del nome del modello. Ad esempio:
  • nome modello: projects/project-id/locations/location-id/models/IOD4412217016962778756
  • ID modello: IOD4412217016962778756
• model-evaluation-id: il valore ID del modello la valutazione delle prestazioni. Puoi ottenere gli ID valutazione del modello da list valutazione del modello operativa.

Metodo HTTP e URL:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti consente di accedere automaticamente all'interfaccia a riga di comando gcloud . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Esegui questo comando:

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

Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Esegui questo comando:

$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

Dovresti ricevere una risposta JSON simile all'esempio riportato di seguito. Specifico per il rilevamento di oggetti chiave i campi sono in grassetto e una versione abbreviata delle voci boundingBoxMetricsEntries sono mostrati per chiarezza:

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

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella Librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella Librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella Librerie client.

/**
 * 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

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella Librerie client.

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

Linguaggi aggiuntivi

C#: Segui le Istruzioni per la configurazione di C# Nella pagina delle librerie client e poi visita Documentazione di riferimento per il rilevamento di oggetti di AutoML Vision per .NET.

PHP Segui le Istruzioni per la configurazione dei file PHP Nella pagina delle librerie client e poi visita Documentazione di riferimento per il rilevamento di oggetti di AutoML Vision per PHP.

Rubino: Segui le Istruzioni per la configurazione di Ruby Nella pagina delle librerie client e poi visita Documentazione di riferimento per il rilevamento di oggetti di AutoML Vision per Ruby.

Veri positivi, falsi negativi e falsi positivi (solo UI)

Nota: questa funzionalità è disponibile solo nell'interfaccia utente (UI).

Nell'interfaccia utente puoi osservare esempi specifici di prestazioni del modello, ovvero veri positivi (TP), falsi negativi (FN) e falsi positivi (FP) dalle tue istanze Set di TRAINING e VALIDATION.

UI web

Puoi accedere alla vista TP, FN e FP nell'interfaccia utente selezionando la scheda Valuta e poi scegliendo un'etichetta specifica.

La nostra UI fornisce categorie di correttezza (ad es. VP, FP, FN) per ogni riquadro su ogni immagine. Ciò significa che una singola immagine potrebbe in più righe dell'interfaccia utente, ogni volta che mostra un problema diverso. Inoltre, dato che ogni immagine può contenere moltissime caselle, l'interfaccia utente mostrano solo la singola coppia di caselle previste e basate su dati empirici reali che dimostrano questo comportamento.

Visualizzando le tendenze in queste previsioni, puoi modificare il set di addestramento per migliorare le prestazioni del modello.

Le immagini vere positive sono caselle di convalida fornite al modello addestrato che annotato in modo corretto:

Le immagini falsi negativi sono fornite in modo simile al modello addestrato, ma il modello non è stato possibile annotare correttamente un'istanza di un oggetto:

Infine, le immagini falsi positivi sono quelle fornite al modello addestrato che con annotazioni di un oggetto che non sono state annotate nell'area specificata:

Il modello seleziona casi d'angolo interessanti, il che presenta un l'opportunità di perfezionare le definizioni e le etichette per aiutare il modello a comprendere le interpretazioni delle etichette. Ad esempio, una definizione più rigorosa aiuterebbe un modello capisce se consideri un peperone ripieno un "insalata" (o meno). Con ripetuti etichetta, addestra e valuta i loop, il modello mostrerà altri ambiguità nei dati.

Puoi anche modificare la soglia del punteggio in questa visualizzazione nell'interfaccia utente, e le immagini TP, FN e FP visualizzate riflettono la modifica della soglia:

Interpretazione delle metriche di valutazione

I modelli di rilevamento degli oggetti restituiscono molti riquadri di delimitazione per un'immagine di input; ogni casella include 1) un'etichetta e 2) un punteggio o una confidenza. La valutazione consente di rispondere a diverse domande chiave sulle prestazioni del modello:

• Il numero di scatole è quello giusto?
• Il modello tende a dare punteggi più bassi ai casi marginali?
• Quanto si avvicinano le caselle previste con quelle dei dati di fatto?

Tieni presente che queste metriche, esattamente come quelle della classificazione con più etichette, non segnalino confusione in classe, se non in modo generico punteggi più bassi.

Quando esamini l'output del modello per immagine, devi trovare un modo per esaminare una coppia di caselle (dati empirici reali e casella prevista) e determinare l'efficacia di una corrispondenza. Devi considerare, ad esempio:

• Entrambe le scatole hanno la stessa etichetta?
• Quanto si sovrappongono i riquadri?
• Con quale affidabilità il modello ha previsto la scatola?

Per soddisfare il secondo requisito, introduciamo una nuova misurazione chiamata intersection-over-union o IoU.

IoU e soglia IoU

L'intersezione sull'unione determina il grado di corrispondenza tra due scatole. L'IoU è compreso tra 0 (senza sovrapposizione) a 1 (le caselle sono identiche) calcolato dividendo l'area in comune tra i due riquadri per l'area inclusi in almeno una delle scatole. Il servizio AutoML ti consente di esaminare le prestazioni del modello con diverse soglie IoU.

Perché potrebbe essere utile modificare la soglia di IoU?

Considera il caso d'uso di contare le auto in un parcheggio. Non ti importa se le coordinate dei riquadri sono molto precise, è importante che tu abbia il giusto il numero totale di scatole. In questo caso, è appropriata una soglia di IoU bassa.

. Credito per l'immagine: Nacho, "Intelligente" (CC BY 2.0, riquadro di delimitazione e testo aggiunto).

In alternativa, valuta la possibilità di misurare le dimensioni di una macchia di tessuto. In questo caso sono necessarie coordinate molto precise e quindi un valore IoU molto più elevato soglia è appropriata.

. Credito per l'immagine: Negozi di articoli usati per abitazioni "Divano moderno" (CC BY-SA 2.0, riquadro di delimitazione e testo aggiunto).

Tieni presente che non è necessario riaddestrare il modello se cambi idea sulla soglia giusta per il tuo caso d'uso; già hanno accesso alle metriche di valutazione a varie soglie di IoU.

Punteggio e soglia di punteggio

Analogamente ai modelli di classificazione, gli output del modello per il rilevamento degli oggetti (ora caselle) con i punteggi. Come per la classificazione delle immagini, c'è soglia che puoi specificare dopo l'addestramento per determinare cosa è (o non è) un "buon" corrispondono. Modificare la soglia del punteggio consente di correggere false tassi positivi e veri positivi alle esigenze specifiche del tuo modello. Un utente che punta a un richiamo molto alto di solito impiegherà un punteggio più basso nell'elaborazione dell'output del modello.

Esegui l'iterazione sul modello

Se i livelli qualitativi non sono soddisfacenti, puoi tornare ai passaggi precedenti per migliorare la qualità:

• Valuta la possibilità di aggiungere altre immagini alle etichette riquadro di delimitazione di bassa qualità.
• Potrebbe essere necessario aggiungere diversi tipi di immagini (ad es. angolo più ampio, più alto risoluzione più bassa, punti di vista diversi).
• Valuta la possibilità di rimuovere completamente le etichette dei riquadro di delimitazione se non disponi di un numero sufficiente di immagini di addestramento.
• I nostri algoritmi di addestramento non utilizzano i nomi delle tue etichette. Se è presente un'etichetta con la dicitura "porta" e un'altra che dice "porta_con_manopola" l'algoritmo non ha modo di comprenderne le sfumature rispetto alle immagini da te fornite.
• Arricchisci i tuoi dati con un maggior numero di esempi di veri positivi e negativi. Gli esempi particolarmente importanti sono quelli correlati alla decisione confine (ovvero che è in grado di generare confusione, ma che è comunque etichettato correttamente).
• Specifica la tua suddivisione TRAIN, TEST e VALIDATE. Lo strumento assegna in modo casuale ma le immagini quasi duplicate potrebbero finire in TRAIN e VALIDATE, causare un overfitting con conseguenti prestazioni scadenti del set di TEST.

Dopo aver apportato le modifiche, addestra e valuta un nuovo modello fino a raggiungere un livello qualitativo sufficientemente alto.