Valutazione dei modelli

Dopo aver addestrato un modello, AutoML Vision Object Detection utilizza le immagini del set di TEST per valutare la qualità e l'accuratezza del nuovo modello.

AutoML Vision Object Detection fornisce un set aggregato di metriche di valutazione (output del processo di valutazione) che indicano il livello di efficacia del modello in generale, nonché metriche di valutazione per ogni etichetta di categoria, che indicano le prestazioni del modello per quell'etichetta.

Panoramica della valutazione

Input del processo di valutazione

• Soglia IoU : Intersection over Union, un valore utilizzato nel rilevamento degli oggetti per misurare la sovrapposizione di un riquadro di delimitazione previsto rispetto a quello effettivo per un oggetto. Più vicini sono i valori previsti del riquadro di delimitazione 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 che il modello non restituisca mai previsioni con un punteggio inferiore a questo valore.

Output del processo di valutazione

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

• Curve della soglia di affidabilità: mostrano in che modo le diverse soglie di confidenza influirebbero sui tassi di precisione, richiamo, veri e falsi positivi. Scopri il rapporto tra precisione e richiamo.

• Punteggio F1: la media armonica di precisione e richiamo. F1 è una metrica utile per trovare un equilibrio tra precisione e richiamo. F1 è utile anche quando la distribuzione delle classi non è uniforme nei dati di addestramento.

Utilizza questi dati per valutare l'idoneità del modello. Un'elevata confusione, punteggi AUC bassi o punteggi di precisione e richiamo bassi possono indicare che il modello ha bisogno di dati di addestramento aggiuntivi o ha etichette incoerenti. Un punteggio AUC molto alto e una precisione e un richiamo perfetti possono indicare che i dati sono troppo "facili" e potrebbero non essere generalizzati bene: un valore AUC elevato potrebbe indicare che il modello è stato addestrato su dati idealizzati che non rappresentano bene le inferenze future.

Gestione delle valutazioni dei modelli

Elenco valutazioni modello

Dopo aver addestrato un modello, puoi elencare le relative metriche di valutazione.

Nota: puoi anche filtrare quando elenchi risorse, operazioni e metriche. Per informazioni sulla compatibilità, vedi Applicazione di filtri durante la creazione delle schede.

UI web

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

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

2. Fai clic sulla riga del modello da valutare.

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

   Se l'addestramento del modello è stato completato, AutoML Vision Object Detection mostra le proprie metriche di valutazione.

   

4. Per visualizzare le metriche relative a 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 risposta al momento della creazione del modello. L'ID è l'ultimo elemento del nome del modello. Ad esempio:
  • nome del 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:

arricciatura

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'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 di 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 all'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 seguente. I campi specifici per il rilevamento degli oggetti chiave sono in grassetto e vengono mostrate quantità variabili di voci boundingBoxMetricsEntries per maggiore 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 pagina 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 pagina 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 pagina 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 pagina 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 di configurazione di C# nella pagina delle librerie client e poi consulta la documentazione di riferimento di AutoML Vision Object Detection per .NET.

PHP: segui le istruzioni per la configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di AutoML Vision Object Detection per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di AutoML Vision Object Detection per Ruby.

Recupero valutazioni modello

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

UI web

Nell'interfaccia utente di AutoML Vision Object Detection, l'operazione equivalente è disponibile accedendo alla pagina Modelli e selezionando il modello. Dopo aver selezionato il modello, vai alla scheda Valuta e seleziona l'etichetta per visualizzare le 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 risposta al momento della creazione del modello. L'ID è l'ultimo elemento del nome del modello. Ad esempio:
  • nome del modello: projects/project-id/locations/location-id/models/IOD4412217016962778756
  • ID modello: IOD4412217016962778756
• model-evaluation-id: il valore ID della valutazione del modello. Puoi ottenere gli ID di valutazione del modello dall'operazione di valutazione del modello list.

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:

arricciatura

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'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 di 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 all'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 seguente. I campi specifici per il rilevamento degli oggetti chiave sono in grassetto e viene mostrata una versione abbreviata delle voci boundingBoxMetricsEntries per maggiore 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 pagina 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 pagina 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 pagina 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 pagina 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 di configurazione di C# nella pagina delle librerie client e poi consulta la documentazione di riferimento di AutoML Vision Object Detection per .NET.

PHP: segui le istruzioni per la configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di AutoML Vision Object Detection per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di AutoML Vision Object Detection 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 dei modelli, ovvero veri positivi (TP), falsi negativi (FN) e falsi positivi (FP) dei tuoi set di addestramento e convalida.

UI web

Puoi accedere alle visualizzazioni VP, FN e FP nell'interfaccia utente selezionando la scheda Valuta e quindi un'etichetta specifica.

La nostra UI fornisce categorie di correttezza (ad esempio TP, FP, FN) per ogni riquadro su ogni immagine. Ciò significa che una singola immagine potrebbe apparire in più righe dell'interfaccia utente, mostrando ogni volta un problema diverso. Inoltre, poiché ogni immagine può contenere un numero così elevato di riquadri, l'interfaccia utente mostrerà solo la singola coppia di riquadri previsti e basati 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 true positive sono caselle di convalida fornite al modello addestrato e il modello ha annotato correttamente:

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

Infine, i falsi positivi sono quelle fornite al modello addestrato che annotava le istanze di un oggetto che non erano annotate nell'area specificata:

Il modello seleziona casi interessanti, il che offre l'opportunità di perfezionare le definizioni e le etichette per aiutarlo a comprendere le interpretazioni delle etichette. Ad esempio, una definizione più restrittiva aiuterebbe il modello a capire se si considera un peperoncino ripieno un'"insalata" o meno. Nel caso di loop ripetuti di etichette, addestramento e valutazione, il modello mostrerà altre ambiguità nei dati.

Puoi anche regolare la soglia di punteggio in questa visualizzazione nell'interfaccia utente e le immagini TP, FN e FP visualizzate rispecchieranno la variazione della soglia:

Interpretazione delle metriche di valutazione

I modelli di rilevamento degli oggetti producono molti riquadri di delimitazione per un'immagine di input; ogni riquadro include 1) un'etichetta e 2) un punteggio o confidenza. Le metriche di valutazione ti aiuteranno a rispondere a diverse domande chiave sulle prestazioni del tuo modello:

• Ho ricevuto il numero giusto di scatole?
• Il modello tende a fornire punteggi più bassi ai casi marginali?
• Quanto corrispondono le caselle previste con le mie caselle di dati empirici reali?

Tieni presente che queste metriche, come quelle per la classificazione con più etichette, non evidenziano alcuna confusione delle classi se non con punteggi generalmente più bassi.

Quando esamini l'output del modello per immagine, devi trovare un modo per esaminare una coppia di caselle (il riquadro basato su dati empirici reali e il riquadro previsto) e determinare il loro valore sulla corrispondenza. Devi prendere in considerazione aspetti quali:

• Entrambe le caselle hanno la stessa etichetta?
• Qual è il livello di sovrapposizione delle caselle?
• Con quanta sicurezza il modello ha previsto il modello?

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

IoU e soglia di IoU

L'intersezione sull'unione determina la corrispondenza tra due caselle. Il valore IoU è compreso tra 0 (nessuna sovrapposizione) e 1 (le caselle sono identiche) e viene calcolato dividendo l'area in comune tra i due riquadri per l'area inclusa in almeno uno dei riquadri. Il servizio AutoML consente di esaminare le prestazioni del modello in base a diverse soglie IoU.

Perché potrebbe essere utile modificare la soglia di IoU?

Considera il caso d'uso di contare le auto in un parcheggio. Se le coordinate dei riquadri sono molto precise, non ti importa di avere il giusto numero totale di caselle. In questo caso, è appropriata una soglia IoU bassa.

Credito immagine: Nacho, "Smart" (CC BY 2.0, riquadri di delimitazione e testo aggiunti).

In alternativa, prova a misurare le dimensioni di una macchia di tessuto. In questo caso sono necessarie coordinate molto precise e, di conseguenza, una soglia di IoU molto più alta è appropriata.

Credito immagine: Housing Works Thrift Shops, "Modern Sofa" (CC BY-SA 2.0, riquadro di delimitazione e testo aggiunti).

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

Punteggio e soglia di punteggio

Analogamente ai modelli di classificazione, gli output del modello di rilevamento degli oggetti (ora riquadri) sono comprensivi di punteggi. Come per la classificazione delle immagini, esiste una soglia di punteggio che puoi specificare dopo l'addestramento per determinare qual è (o meno) una corrispondenza "buona". Modificando la soglia di punteggio puoi ottimizzare le percentuali di falsi positivi e veri positivi in base alle esigenze specifiche del tuo modello. Un utente che vuole un richiamo molto elevato utilizza in genere una soglia di punteggio più bassa nell'elaborazione dell'output del modello.

Esegui l'iterazione sul modello

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

• Potresti aggiungere altre immagini alle etichette del riquadro di delimitazione di bassa qualità.
• Potresti dover aggiungere diversi tipi di immagini (ad es. un'angolazione più ampia, una risoluzione superiore o inferiore, punti di vista diversi).
• Valuta la possibilità di rimuovere del tutto le etichette del riquadro di delimitazione se non disponi di un numero sufficiente di immagini di addestramento.
• I nostri algoritmi di addestramento non utilizzano i nomi delle etichette. Se hai un'etichetta che dice "porta" e un'altra "porta_con_manopola", l'algoritmo non ha modo di capire le sfumature diverse dalle immagini fornite da te.
• Arricchisci i tuoi dati con più esempi di veri positivi e negativi. Gli esempi particolarmente importanti sono quelli vicini ai confini decisionali (che potrebbero generare confusione, ma che comunque sono etichettati correttamente).
• Specifica la tua suddivisione per addestramento, test e convalida. Lo strumento assegna le immagini in modo casuale, ma i quasi duplicati potrebbero finire in TRAIN e VALIDATE, il che potrebbe portare a un overfitting e quindi a prestazioni scadenti sul set di TEST.

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