Valutazione dei modelli

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

AutoML Vision Object Detection fornisce un insieme aggregato di metriche di valutazione (output del processo di valutazione) che indicano le prestazioni complessive del modello, nonché metriche di valutazione per ogni etichetta di categoria, indicando 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ù i valori del riquadro di delimitazione previsti sono vicini 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 presupponendo 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, 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 soglie di confidenza diverse incidono 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 hai una distribuzione non uniforme delle classi nei dati di addestramento.

Usa questi dati per valutare l'idoneità del modello. Una confusione elevata, punteggi AUC bassi o punteggi di precisione e richiamo bassi possono indicare che il modello ha bisogno di dati di addestramento aggiuntivi o contiene etichette incoerenti. Un punteggio AUC molto elevato e una precisione e un richiamo perfetti possono indicare che i dati sono troppo "facili" e potrebbero non essere generalizzati: un'AUC elevata può indicare che il modello è stato addestrato su dati idealizzati che non rappresenterebbero 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 metriche. Per informazioni sull'adattamento, consulta la sezione Applicazione di filtri nella scheda.

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 per visualizzare i modelli disponibili.

   Per visualizzare i modelli di un progetto diverso, seleziona il progetto dall'elenco a discesa in alto a destra della 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 Rilevamento di oggetti mostra 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 risposta al momento della creazione del 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 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 fa 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 di 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. 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 la lingua in questione 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 la lingua in questione 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 la lingua in questione 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 la lingua in questione 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 visita la documentazione di riferimento sul rilevamento di oggetti AutoML Vision per .NET.

PHP: segui le istruzioni per la configurazione di PHP nella pagina delle librerie client e poi consulta la documentazione di riferimento sul rilevamento di oggetti AutoML Vision 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 per il rilevamento di oggetti 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 un'operazione equivalente accedendo alla pagina Modelli e selezionando il tuo modello. Dopo aver selezionato il modello, vai alla 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 risposta al momento della creazione del 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 della valutazione del modello. Puoi ottenere gli ID 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:

curl

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 fa 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 di 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. 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 la lingua in questione 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 la lingua in questione 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 la lingua in questione 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 la lingua in questione 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 visita la documentazione di riferimento sul rilevamento di oggetti AutoML Vision per .NET.

PHP: segui le istruzioni per la configurazione di PHP nella pagina delle librerie client e poi consulta la documentazione di riferimento sul rilevamento di oggetti AutoML Vision 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 per il rilevamento di oggetti 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 istanze di veri positivi (TP), falsi negativi (FN) e falsi positivi (FP) dai tuoi set di addestramento e convalida.

UI web

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

La nostra UI fornisce categorie di correttezza (ad es. TP, FP, FN) per ogni casella su ogni immagine. Ciò significa che una singola immagine potrebbe apparire in più righe dell'interfaccia utente, ogni volta che mostra un problema diverso. Inoltre, dato che ogni immagine può contenere un numero elevato di caselle, la UI mostrerà 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 veri positivi sono caselle di convalida fornite al modello addestrato che il modello ha annotato correttamente:

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

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

Il modello sta selezionando richieste d'angolo interessanti, il che presenta l'opportunità di perfezionare le definizioni e le etichette per aiutare il modello a comprendere le tue interpretazioni delle etichette. Ad esempio, una definizione più rigorosa aiuterebbe il modello a capire se consideriamo un peperone ripieno un'"insalata" (o meno). Con loop di etichetta, addestramento e valutazione ripetuti, il modello mostrerà altre ambiguità di questo tipo nei dati.

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

Interpretazione delle metriche di valutazione

I modelli di rilevamento degli oggetti eseguono l'output di molti riquadri di delimitazione per un'immagine di input; ognuno dei quali include 1) un'etichetta e 2) un punteggio o una confidenza. Le metriche di valutazione ti aiuteranno a rispondere a diverse domande chiave sulle prestazioni del tuo 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, proprio come quelle nella classificazione con più etichette, non indicano la confusione delle classi oltre ai punteggi generalmente più bassi.

Quando esamini l'output del modello per immagine, devi trovare un modo per esaminare una coppia di scatole (ovvero la casella basata su dati di fatto e la 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 denominata intersection-over-union o IoU.

IoU e soglia IoU

L'intersezione sull'unione determina il grado di corrispondenza tra due scatole. Il valore IoU va da 0 (senza sovrapposizione) a 1 (le scatole sono identiche) e viene calcolato dividendo l'area in comune tra i due scatole per l'area inclusa in almeno uno dei riquadri. 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 è importante che le coordinate dei riquadri siano molto precise, è sufficiente che tu abbia il numero totale corretto di riquadri. In questo caso, è appropriata una soglia di IoU bassa.

Credito per le immagini: Nacho, "Smart" (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, pertanto una soglia di IoU molto più elevata è appropriata.

Immagine concessa: Housing Works Thrift Shops, "Modern Sofa" (CC BY-SA 2.0, riquadro di delimitazione e testo aggiunto).

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

Punteggio e soglia di punteggio

Analogamente ai modelli di classificazione, gli output dei modelli per il rilevamento degli oggetti (ora scatole) hanno un punteggio. Come per la classificazione delle immagini, esiste una soglia di punteggio che puoi specificare dopo l'addestramento per determinare se una corrispondenza è buona o meno. La modifica della soglia del punteggio consente di ottimizzare i tassi di falsi positivi e veri positivi in base alle esigenze specifiche del tuo modello. Un utente che punta a un richiamo molto alto in genere utilizza una soglia di punteggio inferiore 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à.
• Potresti dover aggiungere diversi tipi di immagini (ad es. un angolo più ampio, una risoluzione superiore o inferiore, diversi punti di vista).
• Valuta la possibilità di rimuovere completamente 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 tue etichette. Se hai un'etichetta con la dicitura "door" e un'altra con la dicitura "door_with_knob", l'algoritmo non ha modo di comprendere le sfumature diverse dalle immagini che gli fornisci.
• Arricchisci i tuoi dati con un maggior numero di esempi di veri positivi e negativi. Gli esempi particolarmente importanti sono quelli vicini al confine decisionale (ovvero che possono generare confusione, ma che sono comunque etichettati correttamente).
• Specifica la tua suddivisione TRAIN, TEST e VALIDATE. Lo strumento assegna le immagini in modo casuale, ma dei duplicati potrebbero terminare in TRAIN e VALIDATE, il che potrebbe portare a un overfitting e a prestazioni scarse per il set di TEST.

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