Surveillance

Dans Vertex AI Feature Store (Ancien), vous pouvez surveiller et définir des alertes sur les magasins de caractéristiques et les caractéristiques. Par exemple, une équipe chargée des opérations peut surveiller un featurestore pour suivre l'utilisation de son processeur. Les propriétaires de caractéristiques, tels que les data scientists, peuvent surveiller les valeurs des caractéristiques pour détecter les écarts au fil du temps.

Les méthodes de surveillance des featurestores et des caractéristiques sont décrites dans les sections suivantes:

• Surveillance des featurestores
• Surveillance des caractéristiques

Surveillance des featurestores

Vertex AI Feature Store (Ancien) signale à Cloud Monitoring les métriques de votre magasin de caractéristiques telles que la charge du processeur, la capacité de stockage et la latence des requêtes. Vertex AI collecte et signale ces métriques pour vous. Vous n'avez pas besoin de configurer ni d'activer la surveillance du featurestore.

Pour configurer des seuils et des notifications, utilisez Cloud Monitoring. Par exemple, vous pouvez définir une alerte si la charge moyenne du processeur dépasse 70%, ce qui peut vous obliger à augmenter le nombre de nœuds de featurestores.

Vous pouvez également afficher les métriques du magasin de caractéristiques dans la section Vertex AI de la console Google Cloud pour voir les tendances au fil du temps. Pour certains graphiques, la console affiche des valeurs cumulées ou calculées pour faciliter la consommation des informations. Vous pouvez toujours afficher les données brutes dans Cloud Monitoring.

Pour en savoir plus, consultez les métriques de surveillance de Vertex AI Feature Store (Ancien) sur la page Cloud Monitoring de Vertex AI.

Surveillance de la valeur des caractéristiques

La surveillance des valeurs des caractéristiques vous permet de suivre l'évolution de la distribution des valeurs d'une caractéristique dans un featurestore. Les types de surveillance des valeurs des caractéristiques suivants sont compatibles :

• Analyse des instantanés : Vertex AI Feature Store (Ancien) prend des instantanés périodiques de vos valeurs de caractéristiques. Au fil du temps, à mesure que vous ingérez davantage de données, vous remarquerez peut-être que la distribution des valeurs de caractéristiques change. Cette modification indique que tout modèle utilisant ces caractéristiques devra peut-être être réentraîné. Vous pouvez spécifier un seuil afin que les anomalies soient consignées dans la console Cloud Logging chaque fois que l'écart de distribution dépasse le seuil.

  Pour les ensembles de données dépassant 5 millions d'ID d'entités, Vertex AI Feature Store (Ancien) génère des instantanés basés sur 5 millions d'ID d'entités sélectionnés de manière aléatoire dans la période spécifiée correspondant au nombre de jours d'obsolescence.

• Analyse des caractéristiques d'importation : chaque opération ImportFeatureValues génère des statistiques de distribution pour les valeurs ingérées dans Vertex AI Feature Store (Ancien). Vous pouvez choisir de détecter des anomalies en comparant vos statistiques de distribution avec la distribution des valeurs de caractéristiques précédemment importées ou, si elle est activée, la distribution des instantanés.

  Pour les ensembles de données dépassant 5 millions d'instances, Vertex AI Feature Store (Ancien) génère des instantanés basés sur des données sélectionnées de manière aléatoire, comme suit :

  • Si le nombre d'instances dans l'ensemble de données ingéré dépasse 5 millions, mais reste inférieur à 50 millions, l'instantané est généré sur la base de 5 millions d'instances sélectionnées de manière aléatoire.
  • Si le nombre d'instances dans l'ensemble de données ingéré dépasse 50 millions, l'instantané est généré en fonction de 10 % des instances, sélectionnées de manière aléatoire.

Par exemple, considérons une caractéristique qui collecte les prix des maisons récemment vendus, puis alimente les valeurs dans un modèle pour prédire le prix d'une maison. Les prix des maisons récemment vendues peuvent diminuer considérablement au fil du temps, ou le lot de valeurs importées peut contenir des données qui s'écartent considérablement des données d'entraînement. Vertex AI Feature Store (Ancien) vous avertit de ce changement. Vous pouvez ensuite réentraîner votre modèle pour utiliser les informations les plus récentes.

Définir une configuration de surveillance

Pour lancer la surveillance, vous pouvez définir une configuration de surveillance sur un type d'entité, ce qui active la surveillance de toutes les caractéristiques des types suivants :

• BOOL
• STRING
• DOUBLE
• INT64

Vous pouvez définir la configuration de la surveillance lorsque vous créez un type d'entité. Vous pouvez également choisir de désactiver la surveillance de caractéristiques spécifiques en définissant la propriété disableMonitoring. La configuration de la surveillance du type d'entité spécifie les éléments suivants :

• Indique si la surveillance doit être activée. La surveillance est désactivée par défaut.
• Seuils utilisés pour détecter les anomalies. Le seuil par défaut est 0.3.
• Période d'analyse en plus de l'intervalle entre les instantanés (pour l'analyse d'instantanés). La valeur par défaut est 21.
• Permet d'activer ou non l'analyse des caractéristiques d'importation. La valeur par défaut est désactivée.

Pour en savoir plus, reportez-vous au type FeaturestoreMonitoringConfig dans la documentation de référence de l'API.

Créer un type d'entité avec la surveillance activée

L'exemple suivant crée un type d'entité, où la surveillance des caractéristiques est activée :

POST http://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes?entityTypeId=ENTITY_TYPE_ID

{
  "monitoringConfig": {
    "snapshotAnalysis": {
      "monitoringIntervalDays": "DURATION"
      "stalenessDays": "STALENESS_DAYS"
    }
  },
 "numericalThresholdConfig": {
    "value": "NUMERICAL_THRESHOLD_VALUE"
  },
  "categoricalThresholdConfig": {
    "value": "CATEGORICAL_THRESHOLD_VALUE"
  },
  "importFeatureAnalysis": {
    "state": "IMPORT_FEATURE_ANALYSIS_STATE",
    "anomalyDetectionBaseline": "IMPORT_FEATURE_ANALYSIS_BASELINE"
  }
}

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "http://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes?entityTypeId=ENTITY_TYPE_ID"

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

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "http://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes?entityTypeId=ENTITY_TYPE_ID" | Select-Object -Expand Content

{
  "name": "projects/PROJECT_ID/locations/LOCATION_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.ui.CreateEntityTypeOperationMetadata",
    "genericMetadata": {
      "createTime": "2022-04-29T20:29:05.206525Z",
      "updateTime": "2022-04-29T20:29:05.206525Z"
    }
  }
}

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.CreateEntityTypeOperationMetadata;
import com.google.cloud.aiplatform.v1.CreateEntityTypeRequest;
import com.google.cloud.aiplatform.v1.EntityType;
import com.google.cloud.aiplatform.v1.FeaturestoreMonitoringConfig;
import com.google.cloud.aiplatform.v1.FeaturestoreMonitoringConfig.SnapshotAnalysis;
import com.google.cloud.aiplatform.v1.FeaturestoreName;
import com.google.cloud.aiplatform.v1.FeaturestoreServiceClient;
import com.google.cloud.aiplatform.v1.FeaturestoreServiceSettings;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateEntityTypeMonitoringSample {

  public static void main(String[] args)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String featurestoreId = "YOUR_FEATURESTORE_ID";
    String entityTypeId = "YOUR_ENTITY_TYPE_ID";
    String description = "YOUR_ENTITY_TYPE_DESCRIPTION";
    int monitoringIntervalDays = 1;
    String location = "us-central1";
    String endpoint = "us-central1-aiplatform.googleapis.com:443";
    int timeout = 300;
    createEntityTypeMonitoringSample(
        project,
        featurestoreId,
        entityTypeId,
        description,
        monitoringIntervalDays,
        location,
        endpoint,
        timeout);
  }

  static void createEntityTypeMonitoringSample(
      String project,
      String featurestoreId,
      String entityTypeId,
      String description,
      int monitoringIntervalDays,
      String location,
      String endpoint,
      int timeout)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {

    FeaturestoreServiceSettings featurestoreServiceSettings =
        FeaturestoreServiceSettings.newBuilder().setEndpoint(endpoint).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 (FeaturestoreServiceClient featurestoreServiceClient =
        FeaturestoreServiceClient.create(featurestoreServiceSettings)) {

      FeaturestoreMonitoringConfig featurestoreMonitoringConfig =
          FeaturestoreMonitoringConfig.newBuilder()
              .setSnapshotAnalysis(
                  SnapshotAnalysis.newBuilder().setMonitoringIntervalDays(monitoringIntervalDays))
              .build();

      EntityType entityType =
          EntityType.newBuilder()
              .setDescription(description)
              .setMonitoringConfig(featurestoreMonitoringConfig)
              .build();

      CreateEntityTypeRequest createEntityTypeRequest =
          CreateEntityTypeRequest.newBuilder()
              .setParent(FeaturestoreName.of(project, location, featurestoreId).toString())
              .setEntityType(entityType)
              .setEntityTypeId(entityTypeId)
              .build();

      OperationFuture<EntityType, CreateEntityTypeOperationMetadata> entityTypeFuture =
          featurestoreServiceClient.createEntityTypeAsync(createEntityTypeRequest);
      System.out.format(
          "Operation name: %s%n", entityTypeFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      EntityType entityTypeResponse = entityTypeFuture.get(timeout, TimeUnit.SECONDS);
      System.out.println("Create Entity Type Monitoring Response");
      System.out.format("Name: %s%n", entityTypeResponse.getName());
    }
  }
}

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const project = 'YOUR_PROJECT_ID';
// const featurestoreId = 'YOUR_FEATURESTORE_ID';
// const entityTypeId = 'YOUR_ENTITY_TYPE_ID';
// const description = 'YOUR_ENTITY_TYPE_DESCRIPTION';
// const duration = <MONITORING_INTERVAL_IN_SECONDS>;
// const location = 'YOUR_PROJECT_LOCATION';
// const apiEndpoint = 'YOUR_API_ENDPOINT';
// const timeout = <TIMEOUT_IN_MILLI_SECONDS>;

// Imports the Google Cloud Featurestore Service Client library
const {FeaturestoreServiceClient} =
  require('@google-cloud/aiplatform').v1beta1;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: apiEndpoint,
};

// Instantiates a client
const featurestoreServiceClient = new FeaturestoreServiceClient(
  clientOptions
);

async function createEntityTypeMonitoring() {
  // Configure the parent resource
  const parent = `projects/${project}/locations/${location}/featurestores/${featurestoreId}`;

  const entityType = {
    description: description,
    monitoringConfig: {
      snapshotAnalysis: {
        monitoringInterval: {
          seconds: Number(duration),
        },
      },
    },
  };

  const request = {
    parent: parent,
    entityTypeId: entityTypeId,
    entityType: entityType,
  };

  // Create EntityType request
  const [operation] = await featurestoreServiceClient.createEntityType(
    request,
    {timeout: Number(timeout)}
  );
  const [response] = await operation.promise();

  console.log('Create entity type monitoring response');
  console.log(`Name : ${response.name}`);
  console.log('Raw response:');
  console.log(JSON.stringify(response, null, 2));
}
createEntityTypeMonitoring();

Désactiver la surveillance d'une nouvelle caractéristique

L'exemple suivant crée une fonctionnalité avec la surveillance désactivée :

POST http://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes/ENTITY_TYPE_ID?featureId=/FEATURE_ID

{
  "disableMonitoring": "DISABLE_MONITORING",
  "valueType": "VALUE_TYPE"
}

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "http://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes/ENTITY_TYPE_ID?featureId=/FEATURE_ID"

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

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "http://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes/ENTITY_TYPE_ID?featureId=/FEATURE_ID" | Select-Object -Expand Content

{
  "name": "projects/PROJECT_ID/locations/LOCATION_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.ui.CreateFeatureOperationMetadata",
    "genericMetadata": {
      "createTime": "2022-04-29T20:29:05.206525Z",
      "updateTime": "2022-04-29T20:29:05.206525Z"
    }
  }
}

Mettre à jour la configuration de la surveillance

Vous pouvez définir la configuration de la surveillance lors de la mise à jour d'un type d'entité. Vous pouvez également choisir de désactiver la surveillance de caractéristiques spécifiques en définissant la propriété disableMonitoring.

Mettre à jour la configuration de la surveillance pour le type d'entité et les caractéristiques

L'exemple suivant met à jour la configuration de la surveillance pour un type d'entité existant et des fonctionnalités spécifiques pour ce type d'entité :

PATCH http://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes/ENTITY_TYPE_ID

{
  "monitoringConfig": {
    "snapshotAnalysis": {
      "monitoringIntervalDays": "DURATION_IN_DAYS",
      "stalenessDays": "STALENESS_DAYS"
    }
  },
  "numericalThresholdConfig": {
    "value": "NUMERICAL_THRESHOLD_VALUE"
  },
  "categoricalThresholdConfig": {
    "value": "CATEGORICAL_THRESHOLD_VALUE"
  },
  "importFeatureAnalysis": {
    "state": "IMPORT_FEATURE_ANALYSIS_STATE",
    "anomalyDetectionBaseline": "IMPORT_FEATURE_ANALYSIS_BASELINE"
  }
}

curl -X PATCH \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "http://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes/ENTITY_TYPE_ID"

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

Invoke-WebRequest `
    -Method PATCH `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "http://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes/ENTITY_TYPE_ID" | Select-Object -Expand Content

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes/ENTITY_TYPE_ID",
  "createTime": "2021-07-22T23:18:31.339972Z",
  "updateTime": "2021-07-29T22:24:40.221821Z",
  "etag": "AMEw9yPGDpwUwHx39gIDIg5mTQz65GMhnYHRzRslVPonm1g8xTnsTC5YUibmWo2MIuI=",
  "monitoringConfig": {
    "snapshotAnalysis": {
      "monitoringIntervalDays": "DURATION_IN_DAYS",
      "stalenessDays": "STALENESS_DAYS"
    }
  },
  "numericalThresholdConfig": {
    "value": "NUMERICAL_THRESHOLD_VALUE"
  },
  "categoricalThresholdConfig": {
    "value": "CATEGORICAL_THRESHOLD_VALUE"
  },
  "importFeatureAnalysis": {
    "state": "IMPORT_FEATURE_ANALYSIS_STATE",
    "anomalyDetectionBaseline": "IMPORT_FEATURE_ANALYSIS_BASELINE"
  }
}

import com.google.cloud.aiplatform.v1.EntityType;
import com.google.cloud.aiplatform.v1.EntityTypeName;
import com.google.cloud.aiplatform.v1.FeaturestoreMonitoringConfig;
import com.google.cloud.aiplatform.v1.FeaturestoreMonitoringConfig.SnapshotAnalysis;
import com.google.cloud.aiplatform.v1.FeaturestoreServiceClient;
import com.google.cloud.aiplatform.v1.FeaturestoreServiceSettings;
import com.google.cloud.aiplatform.v1.UpdateEntityTypeRequest;
import java.io.IOException;

public class UpdateEntityTypeMonitoringSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String featurestoreId = "YOUR_FEATURESTORE_ID";
    String entityTypeId = "YOUR_ENTITY_TYPE_ID";
    int monitoringIntervalDays = 1;
    String location = "us-central1";
    String endpoint = "us-central1-aiplatform.googleapis.com:443";
    updateEntityTypeMonitoringSample(
        project, featurestoreId, entityTypeId, monitoringIntervalDays, location, endpoint);
  }

  static void updateEntityTypeMonitoringSample(
      String project,
      String featurestoreId,
      String entityTypeId,
      int monitoringIntervalDays,
      String location,
      String endpoint)
      throws IOException {

    FeaturestoreServiceSettings featurestoreServiceSettings =
        FeaturestoreServiceSettings.newBuilder().setEndpoint(endpoint).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 (FeaturestoreServiceClient featurestoreServiceClient =
        FeaturestoreServiceClient.create(featurestoreServiceSettings)) {
      FeaturestoreMonitoringConfig featurestoreMonitoringConfig =
          FeaturestoreMonitoringConfig.newBuilder()
              .setSnapshotAnalysis(
                  SnapshotAnalysis.newBuilder().setMonitoringIntervalDays(monitoringIntervalDays))
              .build();
      EntityType entityType =
          EntityType.newBuilder()
              .setName(
                  EntityTypeName.of(project, location, featurestoreId, entityTypeId).toString())
              .setMonitoringConfig(featurestoreMonitoringConfig)
              .build();

      UpdateEntityTypeRequest updateEntityTypeRequest =
          UpdateEntityTypeRequest.newBuilder().setEntityType(entityType).build();
      EntityType entityTypeResponse =
          featurestoreServiceClient.updateEntityType(updateEntityTypeRequest);
      System.out.println("Update Entity Type Monitoring Response");
      System.out.println(entityTypeResponse);
    }
  }
}

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const project = 'YOUR_PROJECT_ID';
// const featurestoreId = 'YOUR_FEATURESTORE_ID';
// const entityTypeId = 'YOUR_ENTITY_TYPE_ID';
// const duration = <MONITORING_INTERVAL_IN_SECONDS>;
// const location = 'YOUR_PROJECT_LOCATION';
// const apiEndpoint = 'YOUR_API_ENDPOINT';
// const timeout = <TIMEOUT_IN_MILLI_SECONDS>;

// Imports the Google Cloud Featurestore Service Client library
const {FeaturestoreServiceClient} =
  require('@google-cloud/aiplatform').v1beta1;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: apiEndpoint,
};

// Instantiates a client
const featurestoreServiceClient = new FeaturestoreServiceClient(
  clientOptions
);

async function updateEntityTypeMonitoring() {
  // Configure the name resource
  const name = `projects/${project}/locations/${location}/featurestores/${featurestoreId}/entityTypes/${entityTypeId}`;

  // Constructing the monitoring configuration
  const monitoringConfig = {
    snapshotAnalysis: {
      monitoringInterval: {
        seconds: Number(duration),
      },
    },
  };

  // Constructing the entityType
  const entityType = {
    name: name,
    monitoringConfig: monitoringConfig,
  };

  const request = {
    entityType: entityType,
  };

  // Update EntityType request
  const [response] = await featurestoreServiceClient.updateEntityType(
    request,
    {timeout: Number(timeout)}
  );

  console.log('Update entity type monitoring response');
  console.log(`Name : ${response.name}`);
  console.log('Raw response:');
  console.log(JSON.stringify(response, null, 2));
}
updateEntityTypeMonitoring();

Désactiver la surveillance d'une caractéristique

Dans l'exemple suivant, la surveillance d'une fonctionnalité existante est désactivée :

PATCH http://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes/ENTITY_TYPE_ID/features/FEATURE_ID

{
  "disableMonitoring": "DISABLE_MONITORING"
}

curl -X PATCH \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "http://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes/ENTITY_TYPE_ID/features/FEATURE_ID"

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

Invoke-WebRequest `
    -Method PATCH `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "http://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes/ENTITY_TYPE_ID/features/FEATURE_ID" | Select-Object -Expand Content

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes/ENTITY_TYPE_ID/features/FEATURE_ID",
  "valueType": "FEATURE_VALUE_TYPE",
  "createTime": "2021-07-22T23:18:31.339972Z",
  "updateTime": "2021-07-29T22:24:40.221821Z",
  "etag": "AMEw9yPGDpwUwHx39gIDIg5mTQz65GMhnYHRzRslVPonm1g8xTnsTC5YUibmWo2MIuI=",
  "disableMonitoring": "DISABLE_MONITORING"
}

Afficher la répartition des valeurs des caractéristiques

Utilisez la console Google Cloud pour afficher la distribution des valeurs des caractéristiques au fil du temps.

Afficher les anomalies liées aux valeurs des caractéristiques

Si la distribution des valeurs de caractéristiques dévie au-delà du seuil spécifié dans un pipeline de surveillance, elle est considérée comme une anomalie. Il existe deux types d'anomalies : le décalage entraînement/diffusion et la dérive. Pour calculer l'écart, Vertex AI compare les dernières valeurs de caractéristique en production à une référence.

• Pour détecter des écarts entraînement/diffusion, Vertex AI compare les dernières valeurs de caractéristique en production à la distribution statistique des valeurs de caractéristiques dans les données d'entraînement. Dans ce cas, la distribution statistique des valeurs de caractéristiques dans les données d'entraînement est considérée comme la distribution de référence. En savoir plus sur le décalage entraînement/diffusion.

• Pour détecter la dérive, Vertex AI compare les dernières valeurs de caractéristique en production à la distribution statistique des valeurs des caractéristiques de l'exécution de surveillance la plus récente, qui a eu lieu au moins une heure auparavant. Dans ce cas, la distribution statistique des valeurs de caractéristiques de l'exécution de surveillance la plus récente est considérée comme la distribution de référence. En savoir plus sur la dérive.

Dans les deux cas, la distribution de référence est comparée aux dernières valeurs de caractéristiques en production pour calculer un score de distance.

• Pour les caractéristiques de type catégorique, le score de distance est calculé à l'aide de la distance L-infini. Dans ce cas, si le score à distance dépasse le seuil que vous avez spécifié dans le champ Seuil d'alerte catégoriel, il est identifié comme une anomalie.

• Pour les caractéristiques numériques, le score de distance est calculé à l'aide de la divergence Jensen-Shannon. Dans ce cas, si le score à distance dépasse le seuil que vous avez spécifié dans le champ Seuil d'alerte numérique, il est identifié comme une anomalie.

Dans les deux cas, l'anomalie peut être un décalage entraînement/diffusion ou une dérive, selon la distribution de référence utilisée pour calculer le score de distance. Un journal d'anomalies est écrit dans Cloud Logging avec le nom de journal featurestore_log. Vous pouvez synchroniser les journaux avec n'importe quel service en aval compatible avec Cloud Logging, tel que Pub/Sub.

Pour en savoir plus sur la définition des seuils d'alerte, consultez la section Créer un type d'entité avec la surveillance activée.

Exemple de requête pour toutes les anomalies générées pour un magasin de caractéristiques particulier

logName="projects/model-monitoring-demo/logs/aiplatform.googleapis.com%2FFfeaturestore_log"
resource.labels.resource_container=<project_number>
resource.labels.featurestore_id=<featurestore_id>

Exemple d'entrée de journal d'anomalies

{
  "insertId": "ktbx5jf7vdn7b",
  "jsonPayload": {
    "threshold": 0.001,
    "featureName": "projects/<project_number>/locations/us-central1/featurestores/<featurestore_id>/entityTypes/<entity_type_id>/features/<feature_id>",
    "deviation": 1,
    "@type": "type.googleapis.com/google.cloud.aiplatform.logging.FeatureAnomalyLogEntry",
    "objective": "Featurestore Monitoring Snapshot Drift Anomaly"
  },
  "resource": {
    "type": "aiplatform.googleapis.com/Featurestore",
    "labels": {
      "resource_container": "<project_number>",
      "location": "us-central1",
      "featurestore_id": "<featurestore_id>"
    }
  },
  "timestamp": "2022-02-06T00:54:06.455501Z",
  "severity": "WARNING",
  "logName": "projects/model-monitoring-demo/logs/aiplatform.googleapis.com%2Ffeaturestore_log",
  "receiveTimestamp": "2022-02-06T00:54:06.476107155Z"
}

Surveiller les erreurs d'écriture dans le stockage hors connexion pour l'ingestion en flux continu

Utilisez la console Google Cloud pour surveiller les erreurs d'écriture dans le stockage hors connexion lors de l'ingestion en flux continu.

Afficher les métriques concernant l'ingestion en flux continu vers le stockage hors connexion

Vous pouvez surveiller la métrique Offline storage write for streaming write (écriture dans le stockage hors connexion pour l'écriture en flux) pour Vertex AI Feature Store (Ancien) dans l'explorateur de métriques.

Afficher les journaux de Vertex AI Feature Store (Ancien)

Vous pouvez afficher les entrées de journal correspondant à votre magasin de caractéristiques, y compris les journaux générés lors des erreurs d'écriture dans le stockage hors connexion, dans l'explorateur de journaux.