Évaluer et itérer des modèles AutoML de classification d'images

Cette page explique comment évaluer vos modèles AutoML de classification d'images afin de pouvoir effectuer des itérations sur ceux-ci.

Vertex AI fournit des métriques d'évaluation de modèle pour vous aider à déterminer les performances de vos modèles, telles que les métriques de précision et de rappel. Vertex AI calcule les métriques d'évaluation à l'aide de l'ensemble de test.

Utiliser les métriques d'évaluation de modèle

Les métriques d'évaluation d'un modèle fournissent des mesures quantitatives sur les performances de votre modèle avec l'ensemble de test. La manière dont vous interprétez et utilisez ces métriques dépend des besoins de votre entreprise et du problème que votre modèle est entraîné à résoudre. Par exemple, vous pouvez obtenir une tolérance plus faible pour les faux positifs que pour les faux négatifs, ou inversement. Ces types de questions ont une incidence sur les métriques sur lesquelles vous devez vous concentrer.

Pour en savoir plus sur l'itération de votre modèle afin d'améliorer ses performances, consultez la section Itérer sur le modèle.

Métriques d'évaluation renvoyées par Vertex AI

Vertex AI renvoie plusieurs métriques d'évaluation différentes, telles que des seuils de précision, de rappel et de confiance. Les métriques renvoyées par Vertex AI dépendent de l'objectif de votre modèle. Par exemple, Vertex AI fournit des métriques d'évaluation différentes pour un modèle de classification d'images par rapport à un modèle de détection d'objets au sein des images.

Un fichier de schéma, téléchargeable à partir d'un emplacement Cloud Storage, détermine les métriques d'évaluation fournies par Vertex AI pour chaque objectif. Les onglets suivants fournissent des liens vers les fichiers de schéma et décrivent les métriques d'évaluation pour chaque objectif de modèle.

Vous pouvez afficher et télécharger des fichiers de schéma à partir de l'emplacement Cloud Storage suivant :
gs://google-cloud-aiplatform/schema/modelevaluation/

AuPRC : zone sous la courbe de précision/rappel, également appelée précision moyenne. Cette valeur est comprise entre zéro et un. Plus elle est élevée, plus le modèle est de bonne qualité.
Perte logistique : entropie croisée entre les prédictions du modèle et les valeurs cibles. Cette valeur varie de zéro à l'infini. Plus elle est faible, plus le modèle est de bonne qualité.
Seuil de confiance : score de confiance qui détermine les prédictions à renvoyer. Un modèle renvoie des prédictions d'une valeur égale ou supérieure. Un seuil de confiance élevé augmente la précision, mais diminue le rappel. Vertex AI renvoie des métriques de confiance à différentes valeurs de seuil pour montrer l'impact du seuil sur la précision et le rappel.
Rappel : fraction des prédictions comportant cette classe que le modèle a correctement prédites. Également appelé taux de vrais positifs.
Précision : fraction des prédictions de classification produites par le modèle qui étaient correctes.
Matrice de confusion : une matrice de confusion indique la fréquence à laquelle un modèle prédit correctement un résultat. Pour les résultats prédits de manière incorrecte, la matrice indique ce que le modèle a prédit à la place. La matrice de confusion vous permet de comprendre où votre modèle "confond" deux résultats.

Obtenir des métriques d'évaluation

Vous pouvez obtenir un ensemble agrégé de métriques d'évaluation pour votre modèle et, pour certains objectifs, des métriques d'évaluation pour une classe ou une étiquette donnée. Les métriques d'évaluation pour une classe ou une étiquette spécifique sont également appelées tranches d'évaluation. Le contenu suivant décrit comment obtenir des métriques d'évaluation agrégées et des tranches d'évaluation à l'aide de Google Cloud Console ou de l'API.

console Google Cloud

Accédez à la page Modèles de la console Google Cloud, dans la section Vertex AI.

Accéder à la page des modèles
Dans la liste déroulante Région, sélectionnez la région dans laquelle se trouve votre modèle.
Dans la liste des modèles, cliquez sur votre modèle pour ouvrir l'onglet Évaluation correspondant.

Dans l'onglet Évaluation, vous pouvez afficher les métriques d'évaluation agrégées de votre modèle, telles que la précision moyenne et le rappel.

Si l'objectif du modèle comporte des tranches d'évaluation, la console affiche une liste d'étiquettes. Vous pouvez cliquer sur une étiquette pour afficher les métriques d'évaluation correspondantes, comme illustré dans l'exemple suivant :

(Preview) Pour chaque étiquette, vous pouvez afficher les images prédites regroupées en tant que vrais positifs, faux positifs et faux négatifs. Chaque image possède une métrique de distance L2 au carré qui mesure la similitude de l'image avec les images d'entraînement. Une image étiquetée avec un badge Outlier est relativement différente de toutes les images d'entraînement. Pour améliorer les performances du modèle, vous devez envisager d'ajouter plus d'images d'entraînement similaires aux anomalies.

API

Les requêtes API permettant d'obtenir des métriques d'évaluation sont identiques pour chaque type de données et objectif, mais les résultats sont différents. Les exemples suivants montrent la même requête, mais des réponses différentes.

Obtenir des métriques d'évaluation de modèle agrégées

Les métriques d'évaluation de modèle agrégées fournissent des informations sur le modèle dans son ensemble. Pour afficher des informations sur une tranche spécifique, répertoriez les tranches d'évaluation du modèle.

Pour afficher les métriques d'évaluation de modèle agrégées, utilisez la méthode projects.locations.models.evaluations.get.

Vertex AI renvoie un tableau de métriques de confiance. Chaque élément affiche les métriques d'évaluation avec une valeur confidenceThreshold différente (comprise entre 0 et 1). En affichant différentes valeurs de seuil, vous pouvez voir comment le seuil affecte d'autres métriques, telles que la précision et le rappel.

Sélectionnez un onglet correspondant à votre langue ou à votre environnement :

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

LOCATION : région où votre modèle est stocké.
PROJECT : l'ID de votre projet.
MODEL_ID : ID de la ressource de modèle.
PROJECT_NUMBER : numéro de projet généré automatiquement pour votre projet.
EVALUATION_ID : ID de l'évaluation du modèle (affiché dans la réponse).

Méthode HTTP et URL :

GET https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Exécutez la commande suivante :

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations"

PowerShell

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations" | Select-Object -Expand Content

Vous devriez recevoir une réponse JSON de ce type :

Réponse

{
  "modelEvaluations": [
    {
      "name": "projects/PROJECT_NUMBER/locations/LOCATION/models/MODEL_ID/evaluations/EVALUATION_ID",
      "metricsSchemaUri": "gs://google-cloud-aiplatform/schema/modelevaluation/classification_metrics_1.0.0.yaml",
      "metrics": {
        "auPrc": 0.9946683,
        "logLoss": 0.043421753,
        "confidenceMetrics": [
          {
            "recall": 1,
            "precision": 0.2
          },
          {
            "confidenceThreshold": 0.05,
            "recall": 0.98637605,
            "precision": 0.8960396
          },
          {
            "confidenceThreshold": 0.1,
            "recall": 0.98637605,
            "precision": 0.92346936
          },
          {
            "confidenceThreshold": 0.15,
            "recall": 0.9782016,
            "precision": 0.93979055
          },
          ...
        ],
        "confusionMatrix": {
          "annotationSpecs": [
            {
              "id": "216348703974227968",
              "displayName": "tulips"
            },
            {
              "id": "1369270208581074944",
              "displayName": "dandelion"
            },
            {
              "id": "2522191713187921920",
              "displayName": "sunflowers"
            },
            {
              "id": "4828034722401615872",
              "displayName": "daisy"
            },
            {
              "id": "7133877731615309824",
              "displayName": "roses"
            }
          ],
          "rows": [
            [
              78,
              0,
              0,
              0,
              2
            ],
            [
              0,
              89,
              0,
              1,
              0
            ],
            [
              1,
              0,
              67,
              1,
              1
            ],
            [
              0,
              1,
              0,
              61,
              1
            ],
            [
              6,
              0,
              0,
              0,
              58
            ]
          ]
        }
      },
      "createTime": "2020-10-08T23:35:54.559702Z",
      "sliceDimensions": [
        "annotationSpec"
      ]
    }
  ]
}

Java

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Java.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.


import com.google.cloud.aiplatform.v1.ModelEvaluation;
import com.google.cloud.aiplatform.v1.ModelEvaluationName;
import com.google.cloud.aiplatform.v1.ModelServiceClient;
import com.google.cloud.aiplatform.v1.ModelServiceSettings;
import java.io.IOException;

public class GetModelEvaluationImageClassificationSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // To obtain evaluationId run the code block below after setting modelServiceSettings.
    //
    // try (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings))
    // {
    //   String location = "us-central1";
    //   ModelName modelFullId = ModelName.of(project, location, modelId);
    //   ListModelEvaluationsRequest modelEvaluationsrequest =
    //   ListModelEvaluationsRequest.newBuilder().setParent(modelFullId.toString()).build();
    //   for (ModelEvaluation modelEvaluation :
    //     modelServiceClient.listModelEvaluations(modelEvaluationsrequest).iterateAll()) {
    //       System.out.format("Model Evaluation Name: %s%n", modelEvaluation.getName());
    //   }
    // }
    String project = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String evaluationId = "YOUR_EVALUATION_ID";
    getModelEvaluationImageClassificationSample(project, modelId, evaluationId);
  }

  static void getModelEvaluationImageClassificationSample(
      String project, String modelId, String evaluationId) throws IOException {
    ModelServiceSettings modelServiceSettings =
        ModelServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // 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 (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings)) {
      String location = "us-central1";
      ModelEvaluationName modelEvaluationName =
          ModelEvaluationName.of(project, location, modelId, evaluationId);

      ModelEvaluation modelEvaluation = modelServiceClient.getModelEvaluation(modelEvaluationName);

      System.out.println("Get Model Evaluation Image Classification Response");
      System.out.format("Model Name: %s\n", modelEvaluation.getName());
      System.out.format("Metrics Schema Uri: %s\n", modelEvaluation.getMetricsSchemaUri());
      System.out.format("Metrics: %s\n", modelEvaluation.getMetrics());
      System.out.format("Create Time: %s\n", modelEvaluation.getCreateTime());
      System.out.format("Slice Dimensions: %s\n", modelEvaluation.getSliceDimensionsList());
    }
  }
}

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Node.js.

/**
 * TODO(developer): Uncomment these variables before running the sample
 * (not necessary if passing values as arguments). To obtain evaluationId,
 * instantiate the client and run the following the commands.
 */
// const parentName = `projects/${project}/locations/${location}/models/${modelId}`;
// const evalRequest = {
//   parent: parentName
// };
// const [evalResponse] = await modelServiceClient.listModelEvaluations(evalRequest);
// console.log(evalResponse);

// const modelId = 'YOUR_MODEL_ID';
// const evaluationId = 'YOUR_EVALUATION_ID';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Model Service Client library
const {ModelServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const modelServiceClient = new ModelServiceClient(clientOptions);

async function getModelEvaluationImageClassification() {
  // Configure the name resources
  const name = `projects/${project}/locations/${location}/models/${modelId}/evaluations/${evaluationId}`;
  const request = {
    name,
  };

  // Create get model evaluation request
  const [response] = await modelServiceClient.getModelEvaluation(request);

  console.log('Get model evaluation image classification response');
  console.log(`\tName : ${response.name}`);
  console.log(`\tMetrics schema uri : ${response.metricsSchemaUri}`);
  console.log(`\tMetrics : ${JSON.stringify(response.metrics)}`);
  console.log(`\tCreate time : ${JSON.stringify(response.createTime)}`);
  console.log(`\tSlice dimensions : ${response.sliceDimensions}`);

  const modelExplanation = response.modelExplanation;
  if (modelExplanation === null) {
    console.log(`\tModel explanation: ${JSON.stringify(modelExplanation)}`);
  } else {
    const meanAttributions = modelExplanation.meanAttributions;
    for (const meanAttribution of meanAttributions) {
      console.log('\t\tMean attribution');
      console.log(
        `\t\t\tBaseline output value : \
           ${meanAttribution.baselineOutputValue}`
      );
      console.log(
        `\t\t\tInstance output value : \
           ${meanAttribution.instanceOutputValue}`
      );
      console.log(
        `\t\t\tFeature attributions : \
           ${JSON.stringify(meanAttribution.featureAttributions)}`
      );
      console.log(`\t\t\tOutput index : ${meanAttribution.outputIndex}`);
      console.log(
        `\t\t\tOutput display name : \
           ${meanAttribution.outputDisplayName}`
      );
      console.log(
        `\t\t\tApproximation error : \
           ${meanAttribution.approximationError}`
      );
    }
  }
}
getModelEvaluationImageClassification();

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API Python.

from google.cloud import aiplatform


def get_model_evaluation_image_classification_sample(
    project: str,
    model_id: str,
    evaluation_id: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    """
    To obtain evaluation_id run the following commands where LOCATION
    is the region where the model is stored, PROJECT is the project ID,
    and MODEL_ID is the ID of your model.

    model_client = aiplatform.gapic.ModelServiceClient(
        client_options={
            'api_endpoint':'LOCATION-aiplatform.googleapis.com'
            }
        )
    evaluations = model_client.list_model_evaluations(parent='projects/PROJECT/locations/LOCATION/models/MODEL_ID')
    print("evaluations:", evaluations)
    """
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.ModelServiceClient(client_options=client_options)
    name = client.model_evaluation_path(
        project=project, location=location, model=model_id, evaluation=evaluation_id
    )
    response = client.get_model_evaluation(name=name)
    print("response:", response)

Répertorier toutes les tranches d'évaluation

La méthode projects.locations.models.evaluations.slices.list répertorie toutes les tranches d'évaluation de votre modèle. Vous devez disposer de l'ID d'évaluation du modèle, que vous pouvez obtenir lorsque vous affichez les métriques d'évaluation agrégées.

Les tranches d'évaluation d'un modèle permettent de déterminer les performances du modèle sur une étiquette spécifique. Le champ value vous indique à quelle étiquette les métriques sont destinées.

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

LOCATION : région où se trouve le modèle. Exemple : us-central1.
PROJECT : l'ID de votre projet.
MODEL_ID : ID de votre modèle.
EVALUATION_ID : ID de l'évaluation du modèle qui contient les tranches d'évaluation à répertorier.

Méthode HTTP et URL :

GET https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations/EVALUATION_ID/slices

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Exécutez la commande suivante :

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations/EVALUATION_ID/slices"

PowerShell

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations/EVALUATION_ID/slices" | Select-Object -Expand Content

Vous devriez recevoir une réponse JSON de ce type :

Réponse

{
  "modelEvaluationSlices": [
    {
      "name": "projects/123456789012/locations/us-central1/models/1232584574060974976/evaluations/1234057709820346880/slices/123455414369100579",
      "slice": {
        "dimension": "annotationSpec",
        "value": "daisy"
      },
      "metricsSchemaUri": "gs://google-cloud-aiplatform/schema/modelevaluation/classification_metrics_1.0.0.yaml",
      "metrics": {
        "auPrc": 0.99713016,
        "auRoc": 0.99942565,
        "logLoss": 0.025896452,
        "confidenceMetrics": [
          {
            "recall": 1,
            "precision": 0.17166212
          },
          {
            "confidenceThreshold": 0.05,
            "recall": 1,
            "precision": 0.9402985
          },
          {
            "confidenceThreshold": 0.1,
            "recall": 1,
            "precision": 0.95454544
          },
          ...
      },
      "createTime": "2020-10-08T23:35:54.770876Z"
    },
    {
      "name": "projects/123456789012/locations/us-central1/models/1232584574060974976/evaluations/1234057709820346880/slices/123455414369101230",
      "slice": {
        "dimension": "annotationSpec",
        "value": "sunflowers"
      },
      "metricsSchemaUri": "gs://google-cloud-aiplatform/schema/modelevaluation/classification_metrics_1.0.0.yaml",
      "metrics": {
        "auPrc": 0.99369764,
        "auRoc": 0.9978355,
        "logLoss": 0.049820196,
        "confidenceMetrics": [
          {
            "recall": 1,
            "precision": 0.1907357
          },
          {
            "confidenceThreshold": 0.05,
            "recall": 0.95714283,
            "precision": 0.9852941
          },
          {
            "confidenceThreshold": 0.1,
            "recall": 0.95714283,
            "precision": 0.9852941
          },
          ...
      },
      "createTime": "2020-10-08T23:35:54.770876Z"
    }
  ]
}

Java


import com.google.cloud.aiplatform.v1.ModelEvaluationName;
import com.google.cloud.aiplatform.v1.ModelEvaluationSlice;
import com.google.cloud.aiplatform.v1.ModelEvaluationSlice.Slice;
import com.google.cloud.aiplatform.v1.ModelServiceClient;
import com.google.cloud.aiplatform.v1.ModelServiceSettings;
import java.io.IOException;

public class ListModelEvaluationSliceSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // To obtain evaluationId run the code block below after setting modelServiceSettings.
    //
    // try (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings))
    // {
    //   String location = "us-central1";
    //   ModelName modelFullId = ModelName.of(project, location, modelId);
    //   ListModelEvaluationsRequest modelEvaluationsrequest =
    //   ListModelEvaluationsRequest.newBuilder().setParent(modelFullId.toString()).build();
    //   for (ModelEvaluation modelEvaluation :
    //     modelServiceClient.listModelEvaluations(modelEvaluationsrequest).iterateAll()) {
    //       System.out.format("Model Evaluation Name: %s%n", modelEvaluation.getName());
    //   }
    // }
    String project = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String evaluationId = "YOUR_EVALUATION_ID";
    listModelEvaluationSliceSample(project, modelId, evaluationId);
  }

  static void listModelEvaluationSliceSample(String project, String modelId, String evaluationId)
      throws IOException {
    ModelServiceSettings modelServiceSettings =
        ModelServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // 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 (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings)) {
      String location = "us-central1";
      ModelEvaluationName modelEvaluationName =
          ModelEvaluationName.of(project, location, modelId, evaluationId);

      for (ModelEvaluationSlice modelEvaluationSlice :
          modelServiceClient.listModelEvaluationSlices(modelEvaluationName).iterateAll()) {
        System.out.format("Model Evaluation Slice Name: %s\n", modelEvaluationSlice.getName());
        System.out.format("Metrics Schema Uri: %s\n", modelEvaluationSlice.getMetricsSchemaUri());
        System.out.format("Metrics: %s\n", modelEvaluationSlice.getMetrics());
        System.out.format("Create Time: %s\n", modelEvaluationSlice.getCreateTime());

        Slice slice = modelEvaluationSlice.getSlice();
        System.out.format("Slice Dimensions: %s\n", slice.getDimension());
        System.out.format("Slice Value: %s\n\n", slice.getValue());
      }
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample
 * (not necessary if passing values as arguments). To obtain evaluationId,
 * instantiate the client and run the following the commands.
 */
// const parentName = `projects/${project}/locations/${location}/models/${modelId}`;
// const evalRequest = {
//   parent: parentName
// };
// const [evalResponse] = await modelServiceClient.listModelEvaluations(evalRequest);
// console.log(evalResponse);

// const modelId = 'YOUR_MODEL_ID';
// const evaluationId = 'YOUR_EVALUATION_ID';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Model Service Client library
const {ModelServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const modelServiceClient = new ModelServiceClient(clientOptions);

async function listModelEvaluationSlices() {
  // Configure the parent resources
  const parent = `projects/${project}/locations/${location}/models/${modelId}/evaluations/${evaluationId}`;
  const request = {
    parent,
  };

  // Get and print out a list of all the evaluation slices for this resource
  const [response] =
    await modelServiceClient.listModelEvaluationSlices(request);
  console.log('List model evaluation response', response);
  console.log(response);
}
listModelEvaluationSlices();

Python

from google.cloud import aiplatform


def list_model_evaluation_slices_sample(
    project: str,
    model_id: str,
    evaluation_id: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    """
    To obtain evaluation_id run the following commands where LOCATION
    is the region where the model is stored, PROJECT is the project ID,
    and MODEL_ID is the ID of your model.

    model_client = aiplatform.gapic.ModelServiceClient(
        client_options={
            'api_endpoint':'LOCATION-aiplatform.googleapis.com'
            }
        )
    evaluations = model_client.list_model_evaluations(parent='projects/PROJECT/locations/LOCATION/models/MODEL_ID')
    print("evaluations:", evaluations)
    """
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.ModelServiceClient(client_options=client_options)
    parent = client.model_evaluation_path(
        project=project, location=location, model=model_id, evaluation=evaluation_id
    )
    response = client.list_model_evaluation_slices(parent=parent)
    for model_evaluation_slice in response:
        print("model_evaluation_slice:", model_evaluation_slice)

Obtenir des métriques pour une seule tranche

Pour afficher les métriques d'évaluation d'une tranche, utilisez la méthode projects.locations.models.evaluations.slices.get. Vous devez disposer de l'ID de tranche, qui est fourni lorsque vous répertoriez toutes les tranches. L'exemple suivant s'applique à tous les types de données et objectifs.

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

LOCATION : région où se trouve le modèle. Exemple : us-central1.
PROJECT : l'ID de votre projet.
MODEL_ID : ID de votre modèle.
EVALUATION_ID : ID de l'évaluation du modèle qui contient la tranche d'évaluation à récupérer.
SLICE_ID : ID d'une tranche d'évaluation à obtenir.
PROJECT_NUMBER : numéro de projet généré automatiquement pour votre projet.
EVALUATION_METRIC_SCHEMA_FILE_NAME : nom d'un fichier de schéma qui définit les métriques d'évaluation à renvoyer, telles que classification_metrics_1.0.0.

Méthode HTTP et URL :

GET https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations/EVALUATION_ID/slices/SLICE_ID

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Exécutez la commande suivante :

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations/EVALUATION_ID/slices/SLICE_ID"

PowerShell

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID/evaluations/EVALUATION_ID/slices/SLICE_ID" | Select-Object -Expand Content

Vous devriez recevoir une réponse JSON de ce type :

Réponse

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/models/MODEL_ID/evaluations/EVALUATION_ID/slices/SLICE_ID",
  "slice": {
    "dimension": "annotationSpec",
    "value": "a particular class or label"
  },
  "metricsSchemaUri": "gs://google-cloud-aiplatform/schema/modelevaluation/EVALUATION_METRIC_SCHEMA_FILE_NAME.yaml",
  "metrics": {
    evaluation metrics for the slice
  },
  "createTime": "2020-10-08T23:35:54.770876Z"
}

Java


import com.google.cloud.aiplatform.v1.ModelEvaluationSlice;
import com.google.cloud.aiplatform.v1.ModelEvaluationSlice.Slice;
import com.google.cloud.aiplatform.v1.ModelEvaluationSliceName;
import com.google.cloud.aiplatform.v1.ModelServiceClient;
import com.google.cloud.aiplatform.v1.ModelServiceSettings;
import java.io.IOException;

public class GetModelEvaluationSliceSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // To obtain evaluationId run the code block below after setting modelServiceSettings.
    //
    // try (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings))
    // {
    //   String location = "us-central1";
    //   ModelName modelFullId = ModelName.of(project, location, modelId);
    //   ListModelEvaluationsRequest modelEvaluationsrequest =
    //   ListModelEvaluationsRequest.newBuilder().setParent(modelFullId.toString()).build();
    //   for (ModelEvaluation modelEvaluation :
    //     modelServiceClient.listModelEvaluations(modelEvaluationsrequest).iterateAll()) {
    //       System.out.format("Model Evaluation Name: %s%n", modelEvaluation.getName());
    //   }
    // }
    String project = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String evaluationId = "YOUR_EVALUATION_ID";
    String sliceId = "YOUR_SLICE_ID";
    getModelEvaluationSliceSample(project, modelId, evaluationId, sliceId);
  }

  static void getModelEvaluationSliceSample(
      String project, String modelId, String evaluationId, String sliceId) throws IOException {
    ModelServiceSettings modelServiceSettings =
        ModelServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // 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 (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings)) {
      String location = "us-central1";
      ModelEvaluationSliceName modelEvaluationSliceName =
          ModelEvaluationSliceName.of(project, location, modelId, evaluationId, sliceId);

      ModelEvaluationSlice modelEvaluationSlice =
          modelServiceClient.getModelEvaluationSlice(modelEvaluationSliceName);

      System.out.println("Get Model Evaluation Slice Response");
      System.out.format("Model Evaluation Slice Name: %s\n", modelEvaluationSlice.getName());
      System.out.format("Metrics Schema Uri: %s\n", modelEvaluationSlice.getMetricsSchemaUri());
      System.out.format("Metrics: %s\n", modelEvaluationSlice.getMetrics());
      System.out.format("Create Time: %s\n", modelEvaluationSlice.getCreateTime());

      Slice slice = modelEvaluationSlice.getSlice();
      System.out.format("Slice Dimensions: %s\n", slice.getDimension());
      System.out.format("Slice Value: %s\n", slice.getValue());
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample
 * (not necessary if passing values as arguments). To obtain evaluationId,
 * instantiate the client and run the following the commands.
 */
// const parentName = `projects/${project}/locations/${location}/models/${modelId}`;
// const evalRequest = {
//   parent: parentName
// };
// const [evalResponse] = await modelServiceClient.listModelEvaluations(evalRequest);
// console.log(evalResponse);

// const modelId = 'YOUR_MODEL_ID';
// const evaluationId = 'YOUR_EVALUATION_ID';
// const sliceId = 'YOUR_SLICE_ID';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Model Service client library
const {ModelServiceClient} = require('@google-cloud/aiplatform');
// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};
// Specifies the location of the api endpoint
const modelServiceClient = new ModelServiceClient(clientOptions);

async function getModelEvaluationSlice() {
  // Configure the parent resource
  const name = `projects/${project}/locations/${location}/models/${modelId}/evaluations/${evaluationId}/slices/${sliceId}`;
  const request = {
    name,
  };

  // Get and print out a list of all the endpoints for this resource
  const [response] =
    await modelServiceClient.getModelEvaluationSlice(request);

  console.log('Get model evaluation slice');
  console.log(`\tName : ${response.name}`);
  console.log(`\tMetrics_Schema_Uri : ${response.metricsSchemaUri}`);
  console.log(`\tMetrics : ${JSON.stringify(response.metrics)}`);
  console.log(`\tCreate time : ${JSON.stringify(response.createTime)}`);

  console.log('Slice');
  const slice = response.slice;
  console.log(`\tDimension :${slice.dimension}`);
  console.log(`\tValue :${slice.value}`);
}
getModelEvaluationSlice();

Python

from google.cloud import aiplatform


def get_model_evaluation_slice_sample(
    project: str,
    model_id: str,
    evaluation_id: str,
    slice_id: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    """
    To obtain evaluation_id run the following commands where LOCATION
    is the region where the model is stored, PROJECT is the project ID,
    and MODEL_ID is the ID of your model.

    model_client = aiplatform.gapic.ModelServiceClient(
        client_options={
            'api_endpoint':'LOCATION-aiplatform.googleapis.com'
            }
        )
    evaluations = model_client.list_model_evaluations(parent='projects/PROJECT/locations/LOCATION/models/MODEL_ID')
    print("evaluations:", evaluations)
    """
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.ModelServiceClient(client_options=client_options)
    name = client.model_evaluation_slice_path(
        project=project,
        location=location,
        model=model_id,
        evaluation=evaluation_id,
        slice=slice_id,
    )
    response = client.get_model_evaluation_slice(name=name)
    print("response:", response)

Itérer sur le modèle

Les métriques d'évaluation du modèle constituent un point de départ pour déboguer le modèle lorsqu'il ne répond pas à vos attentes. Par exemple, des scores de précision et de rappel faibles peuvent indiquer que votre modèle requiert des données d'entraînement supplémentaires ou que ses étiquettes sont incohérentes. Un score de précision et de rappel parfait peut indiquer que les données de test sont trop faciles à prédire et risquent de ne pas se généraliser correctement.

Vous pouvez effectuer l'itération sur vos données d'entraînement et créer un modèle. Après avoir créé un modèle, vous pouvez comparer les métriques d'évaluation entre le modèle existant et le nouveau modèle.

Les suggestions suivantes peuvent vous aider à améliorer les modèles qui ajoutent des étiquettes aux éléments, tels que les modèles de classification ou de détection :

Envisagez d'ajouter d'autres exemples ou une gamme plus large d'exemples dans vos données d'entraînement. Par exemple, pour un modèle de classification d'images, vous pouvez inclure des images plus larges, des images de résolution supérieure ou inférieure, ou des points de vue différents. Pour obtenir plus de conseils, consultez la section Préparer des données.
Envisagez de supprimer des classes ou des étiquettes ne comportant pas beaucoup d'exemples. Des exemples insuffisants empêchent le modèle de réaliser des prédictions fiables et cohérentes sur ces classes ou étiquettes.
Les machines ne peuvent pas interpréter le nom de vos classes ou étiquettes et ne comprennent pas les nuances entre elles, comme "porte" et "porte_avec_poignée". Vous devez fournir des données pour aider les machines à reconnaître de telles nuances.
Augmentez vos données à l'aide d'autres exemples de vrais positifs et de vrais négatifs, en particulier ceux qui sont proches d'une frontière de décision pour atténuer la confusion du modèle.
Spécifiez votre propre répartition des données (entraînement, validation et test). Vertex AI attribue des éléments au hasard à chaque ensemble. Par conséquent, des quasi-doublons peuvent se retrouver dans les ensembles d'entraînement et de validation, ce qui peut entraîner un surapprentissage et nuire aux performances de l'ensemble de test. Pour en savoir plus sur la définition de votre propre répartition des données, consultez la page À propos de la répartition des données pour les modèles AutoML.
Si les métriques d'évaluation de votre modèle incluent une matrice de confusion, vous pouvez voir si le modèle confond deux étiquettes et prédit une étiquette particulière beaucoup plus que l'étiquette réelle. Examinez vos données et assurez-vous que les exemples sont correctement étiquetés.
Si vous avez eu un court entraînement (faible nombre de nœuds-heures), vous pouvez obtenir un modèle de meilleure qualité en l'autorisant à s'entraîner sur une période plus longue (nombre maximal d'heures de nœuds-heures supérieur).

Entraîner le modèle

Get predictions