Monitoraggio

In Vertex AI Feature Store (legacy), puoi monitorare e impostare avvisi su featurestore e funzionalità. Ad esempio, un team operativo potrebbe monitorare un archivio di caratteristiche per tracciare l'utilizzo della CPU. I proprietari delle funzionalità, come i data scientist, potrebbero monitorarne i valori per rilevare variazioni nel tempo.

I metodi per monitorare gli archivi di caratteristiche e le funzionalità sono descritti nelle sezioni seguenti:

Monitoraggio dell'archivio di caratteristiche

Vertex AI Feature Store (legacy) segnala a Cloud Monitoring le metriche relative al tuo archivio di caratteristiche, come il carico della CPU, la capacità di archiviazione e le latenze delle richieste. Vertex AI raccoglie e segnala queste metriche per te. Non è necessario configurare o abilitare il monitoraggio dell'archivio di caratteristiche.

Per configurare soglie e notifiche, utilizza Cloud Monitoring. Ad esempio, puoi impostare un avviso se il carico medio della CPU supera il 70%, il che potrebbe richiedere un aumento del numero di nodi dell'archivio di caratteristiche.

Puoi anche visualizzare le metriche dell'archivio di caratteristiche nella sezione Vertex AI della console Google Cloud per controllare le tendenze nel tempo. Per alcuni grafici, la console mostra valori aggregati o calcolati per semplificare l'utilizzo delle informazioni. Puoi sempre visualizzare i dati non elaborati in Cloud Monitoring.

Per ulteriori informazioni, consulta Metriche di monitoraggio di Vertex AI Feature Store (legacy) nella pagina Cloud Monitoring di Vertex AI.

Monitoraggio del valore delle funzionalità

Il monitoraggio dei valori delle caratteristiche consente di tenere traccia di quanto cambia la distribuzione dei valori di una funzionalità in un archivio di caratteristiche. Sono supportati i seguenti tipi di monitoraggio del valore delle caratteristiche:

  • Analisi snapshot: Vertex AI Feature Store (legacy) acquisisce istantanee periodiche dei valori delle funzionalità. Nel tempo, man mano che importi più dati, potresti notare che la distribuzione dei valori delle caratteristiche cambia. Questa modifica indica che potrebbe essere necessario riaddestrare tutti i modelli che utilizzano queste funzionalità. Puoi specificare una soglia in modo che le anomalie vengano registrate nella console di Cloud Logging ogni volta che la deviazione di distribuzione supera la soglia.

    Per set di dati che superano i 5 milioni di ID entità, Vertex AI Feature Store (Legacy) genera snapshot in base a 5 milioni di ID entità selezionati casualmente nella finestra temporale specificata come numero di giorni di inattività.

  • Importa analisi delle caratteristiche: ogni operazione ImportFeatureValues genera statistiche di distribuzione per i valori importati in Vertex AI Feature Store (legacy). Puoi scegliere di rilevare le anomalie confrontando le statistiche di distribuzione con la distribuzione dei valori delle funzionalità importate in precedenza o, se abilitata, con la distribuzione degli snapshot.

    Per set di dati che superano i 5 milioni di istanze, Vertex AI Feature Store (Legacy) genera snapshot in base a dati selezionati casualmente, come segue:

    • Se il numero di istanze all'interno del set di dati importato supera 5 milioni, ma non supera i 50 milioni, lo snapshot viene generato in base a 5 milioni di istanze selezionate casualmente.
    • Se il numero di istanze all'interno del set di dati importato supera i 50 milioni, lo snapshot viene generato in base al 10% delle istanze, selezionate in modo casuale.

Prendi ad esempio una funzionalità che raccoglie i prezzi delle case vendute di recente e li inserisce in un modello per prevedere il prezzo di un'abitazione. I prezzi delle case vendute di recente potrebbero subire variazioni significative nel tempo oppure il gruppo di valori importati potrebbe contenere dati che differiscono in modo significativo da quelli di addestramento. Vertex AI Feature Store (legacy) ti avvisa di questa modifica. Puoi quindi riaddestrare il modello per utilizzare le informazioni più recenti.

Imposta una configurazione di monitoraggio

Per avviare il monitoraggio, puoi definire una configurazione di monitoraggio su un tipo di entità, che abilita il monitoraggio per tutte le funzionalità dei seguenti tipi:

  • BOOL
  • STRING
  • DOUBLE
  • INT64

Puoi impostare la configurazione del monitoraggio quando crei un tipo di entità. Puoi anche scegliere di disattivare il monitoraggio di funzionalità specifiche impostando la proprietà disableMonitoring. La configurazione del monitoraggio del tipo di entità specifica quanto segue:

  • Se abilitare il monitoraggio. Il monitoraggio è disabilitato per impostazione predefinita.
  • Soglie utilizzate per rilevare le anomalie. La soglia predefinita è 0,3.
  • Finestra temporale oltre all'intervallo tra gli snapshot (per l'analisi degli snapshot). Il valore predefinito è 21.
  • Se abilitare l'analisi delle caratteristiche di importazione. L'impostazione predefinita è disabilitata.

Per ulteriori informazioni, consulta il tipo FeaturestoreMonitoringConfig nel riferimento API.

Crea un tipo di entità con il monitoraggio abilitato

L'esempio seguente crea un tipo di entità in cui è abilitato il monitoraggio delle funzionalità:

UI web

Dalla UI è supportata solo l'analisi snapshot.

  1. Nella sezione Vertex AI della console Google Cloud, vai alla pagina Funzionalità.

    Vai alla pagina Funzionalità

  2. Seleziona una regione dall'elenco a discesa Regione.
  3. Fai clic su Crea tipo di entità.
  4. Imposta la sezione Monitoraggio delle funzionalità su Abilitato.
  5. Inserisci il numero di giorni tra gli snapshot nel campo Intervallo di tempo del monitoraggio.
    Il job di monitoraggio per un tipo di entità o una funzionalità viene eseguito all'ora rotonda più vicina dopo l'ora del giorno in cui abiliti il monitoraggio per il tipo o la funzionalità di entità. Ad esempio, se abiliti il monitoraggio alle 22:30 di lunedì e specifichi due giorni come intervallo di tempo, il primo job di monitoraggio viene eseguito alle 23:00 di mercoledì.
  6. Inserisci il numero di giorni da cercare per ogni snapshot nel campo Finestra temporale di Monitoring.
  7. Inserisci il numero per la soglia utilizzata per rilevare le anomalie delle caratteristiche numeriche nel campo Soglia di avviso numerica.
  8. Inserisci il numero per la soglia utilizzata per rilevare le anomalie relative alle caratteristiche categoriche in questo EntityType nel campo Soglia di avviso categoriale.
    Per saperne di più sul rilevamento delle anomalie dei valori delle funzionalità, consulta Visualizzare le anomalie nei valori delle funzionalità.
  9. Fai clic su Crea.
  10. Nella tabella delle funzionalità, fai clic su un tipo di entità.
  11. Per aggiungere nuove funzionalità all'entità, fai clic su Aggiungi funzionalità.
  12. Per disattivare il monitoraggio di una funzionalità specifica, disattiva l'opzione Abilita il monitoraggio.

REST

Per creare un tipo di entità, invia una richiesta POST utilizzando il metodo entityTypes.create.

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

  • LOCATION_ID: regione in cui si trova l'archivio di caratteristiche, ad esempio us-central1.
  • PROJECT_ID: il tuo ID progetto.
  • FEATURESTORE_ID: ID dell'archivio di caratteristiche.
  • ENTITY_TYPE_ID: ID del tipo di entità.
  • DURATION: la durata dell'intervallo tra gli snapshot in giorni.
  • STALENESS_DAYS: il numero di giorni da prendere in considerazione quando si scattano le istantanee.
  • NUMERICAL_THRESHOLD_VALUE: la soglia per rilevare anomalie per le caratteristiche numeriche in questo tipo di entità. La deviazione delle statistiche viene calcolata dalla divergenza di Jenson-Shannon.
  • CATEGORICAL_THRESHOLD_VALUE: la soglia per rilevare anomalie per le funzionalità categoriche in questo tipo di entità. La deviazione delle statistiche viene calcolata dalla distanza L-Infinity.
  • IMPORT_FEATURE_ANALYSIS_STATE: lo stato che indica se attivare l'analisi delle funzionalità di importazione.
  • IMPORT_FEATURE_ANALYSIS_BASELINE: la base di riferimento per l'analisi delle caratteristiche di importazione, se abilitata.

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando: 

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

PowerShell

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando: 

$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 "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes?entityTypeId=ENTITY_TYPE_ID" | Select-Object -Expand Content

Dovresti vedere un output simile al seguente. Puoi utilizzare OPERATION_ID nella risposta per recuperare lo stato dell'operazione.

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

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Node.js Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

/**
 * 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();

Linguaggi aggiuntivi

Per scoprire come installare e utilizzare l'SDK Vertex AI per Python, consulta Utilizzare l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'SDK Vertex AI per l'API Python.

Disattivare il monitoraggio per una nuova funzionalità

Nell'esempio seguente viene creata una nuova funzionalità con il monitoraggio disattivato:

REST

Per creare una funzionalità, invia una richiesta POST utilizzando il metodo features.create.

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

  • LOCATION_ID: regione in cui si trova l'archivio di caratteristiche, ad esempio us-central1.
  • PROJECT_ID: il tuo ID progetto.
  • FEATURESTORE_ID: ID dell'archivio di caratteristiche.
  • ENTITY_TYPE_ID: ID del tipo di entità.
  • FEATURE_ID: ID dell'elemento.
  • VALUE_TYPE: il tipo di valore della caratteristica.
  • DISABLE_MONITORING: imposta il valore su true per disattivare esplicitamente il monitoraggio.

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando: 

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

PowerShell

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando: 

$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 "https://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

Dovresti vedere un output simile al seguente. Puoi utilizzare OPERATION_ID nella risposta per recuperare lo stato dell'operazione.

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

Aggiorna configurazione di monitoraggio

Puoi impostare la configurazione del monitoraggio quando aggiorni un tipo di entità. Puoi anche scegliere di disattivare il monitoraggio di funzionalità specifiche impostando la proprietà disableMonitoring.

Aggiorna la configurazione del monitoraggio per il tipo di entità e le funzionalità

L'esempio seguente aggiorna la configurazione del monitoraggio per un tipo di entità esistente e le funzionalità specifiche per quel tipo di entità:

UI web

Dalla UI è supportata solo l'analisi snapshot.

  1. Nella sezione Vertex AI della console Google Cloud, vai alla pagina Funzionalità.
  2. Seleziona una regione dall'elenco a discesa Regione.
  3. Nella tabella delle funzionalità, visualizza la colonna Tipo di entità per trovare il tipo di entità da aggiornare.
  4. Fai clic sul nome del tipo di entità per visualizzare la pagina dei dettagli dell'entità.
  5. Nella barra delle azioni, fai clic su Modifica informazioni.
  6. In Intervallo di tempo del monitoraggio, inserisci il numero di giorni tra gli snapshot.
    Il job di monitoraggio per un tipo di entità o una funzionalità viene eseguito all'ora rotonda più vicina dopo l'ora del giorno in cui abiliti il monitoraggio per il tipo o la funzionalità di entità. Ad esempio, se abiliti il monitoraggio alle 22:30 di lunedì e specifichi due giorni come intervallo di tempo, il primo job di monitoraggio viene eseguito alle 23:00 di mercoledì.
  7. Fai clic su Update (Aggiorna).
  8. Allo stesso modo, nella tabella delle funzionalità, visualizza la colonna Funzionalità per trovare quella da aggiornare.
  9. Fai clic sul nome dell'elemento per visualizzare la pagina dei dettagli.
  10. Nella barra delle azioni, fai clic su Modifica informazioni.
  11. Per disattivare il monitoraggio di una funzionalità specifica, disattiva Monitoraggio abilitato.

REST

Per aggiornare un tipo di entità, invia una richiesta PATCH utilizzando il metodo entityTypes.patch.

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

  • LOCATION_ID: regione in cui si trova l'archivio di caratteristiche, ad esempio us-central1.
  • PROJECT_ID: il tuo ID progetto.
  • FEATURESTORE_ID: ID dell'archivio di caratteristiche.
  • ENTITY_TYPE_ID: ID del tipo di entità.
  • DURATION_IN_DAYS: la durata dell'intervallo tra gli snapshot in giorni.
  • STALENESS_DAYS: il numero di giorni da prendere in considerazione quando si scattano le istantanee.
  • NUMERICAL_THRESHOLD_VALUE: la soglia per rilevare anomalie per le caratteristiche numeriche in questo tipo di entità. La deviazione delle statistiche viene calcolata dalla divergenza di Jenson-Shannon.
  • CATEGORICAL_THRESHOLD_VALUE: la soglia per rilevare anomalie per le funzionalità categoriche in questo tipo di entità. La deviazione delle statistiche viene calcolata dalla distanza L-Infinity.
  • IMPORT_FEATURE_ANALYSIS_STATE: lo stato che indica se attivare l'analisi delle funzionalità di importazione.
  • IMPORT_FEATURE_ANALYSIS_BASELINE: il riferimento che indica ????

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando: 

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

PowerShell

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando: 

$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 "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/featurestores/FEATURESTORE_ID/entityTypes/ENTITY_TYPE_ID" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente:

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

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Node.js Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

/**
 * 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();

Disattivare il monitoraggio di una funzionalità

Nell'esempio seguente viene disattivato il monitoraggio di una funzionalità esistente:

REST

Per aggiornare una funzionalità, invia una richiesta PATCH usando il metodo features.patch.

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

  • LOCATION_ID: regione in cui si trova l'archivio di caratteristiche, ad esempio us-central1.
  • PROJECT_ID: il tuo ID progetto.
  • FEATURESTORE_ID: ID dell'archivio di caratteristiche.
  • ENTITY_TYPE_ID: ID del tipo di entità.
  • FEATURE_ID: ID della funzionalità da aggiornare.
  • DISABLE_MONITORING: imposta il valore su true per disattivare esplicitamente il monitoraggio.

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

{
  "disableMonitoring": "DISABLE_MONITORING"
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando: 

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

PowerShell

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando: 

$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 "https://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

Dovresti ricevere una risposta JSON simile alla seguente:

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

Visualizza distribuzioni dei valori delle caratteristiche

Utilizza la console Google Cloud per visualizzare la distribuzione dei valori delle funzionalità nel tempo.

UI web

  1. Nella sezione Vertex AI della console Google Cloud, vai alla pagina Funzionalità.

    Vai alla pagina Funzionalità

  2. Seleziona una regione dall'elenco a discesa Regione.

  3. Per visualizzare le distribuzioni dei valori delle caratteristiche per tutte le funzionalità di un tipo di entità, fai clic sul tipo di entità nella colonna Tipo di entità.

  4. Per visualizzare le metriche di distribuzione dei valori delle caratteristiche per una caratteristica:

    1. Nella colonna Funzionalità, fai clic sulla funzionalità.

    2. Fai clic sulla scheda Metriche per visualizzare le metriche di distribuzione dei valori delle caratteristiche.

Visualizza le anomalie dei valori delle funzionalità

Se la distribuzione dei valori delle caratteristiche devia oltre la soglia specificata in una pipeline di monitoraggio, viene considerata un'anomalia. Esistono due tipi di anomalie: disallineamento addestramento/produzione e deviazione. Per calcolare la deviazione, Vertex AI confronta gli ultimi valori delle caratteristiche in produzione con una base di riferimento.

  • Per rilevare il disallineamento addestramento/produzione, Vertex AI confronta i valori delle caratteristiche più recenti in produzione con la distribuzione statistica dei valori delle caratteristiche nei dati di addestramento. In questo caso, la distribuzione statistica dei valori delle caratteristiche nei dati di addestramento è considerata come la distribuzione di riferimento. Scopri di più sul disallineamento addestramento/produzione.

  • Per rilevare le deviazioni, Vertex AI confronta i valori delle funzionalità più recenti in produzione con la distribuzione statistica dei valori delle caratteristiche dell'esecuzione di monitoraggio più recente che si è verificata almeno un'ora fa. In questo caso, la distribuzione statistica dei valori delle caratteristiche dell'esecuzione del monitoraggio più recente è considerata come la distribuzione di riferimento. Scopri di più sulla deriva.

In entrambi i casi, la distribuzione di riferimento viene confrontata con i valori delle funzionalità più recenti in produzione per calcolare il punteggio sulla distanza.

  • Per gli elementi categorici, il punteggio di distanza viene calcolato utilizzando la distanza L'infinito. In questo caso, se il punteggio di distanza supera la soglia specificata nel campo Soglia di avviso per categoria, viene identificata come anomalia.

  • Per gli elementi numerici, il punteggio della distanza viene calcolato utilizzando la divergenza di Jeensen-Shannon. In questo caso, se il punteggio della distanza supera la soglia specificata nel campo Soglia di avviso numerica, viene identificata come anomalia.

In entrambi i casi, l'anomalia potrebbe essere un disallineamento addestramento/produzione o una deviazione, a seconda della distribuzione di riferimento usata per calcolare il punteggio della distanza. In Cloud Logging viene scritto un log relativo alle anomalie con il nome log featurestore_log. Puoi sincronizzare i log con qualsiasi servizio downstream supportato da Cloud Logging, come Pub/Sub.

Per saperne di più sull'impostazione delle soglie di avviso, consulta Creare un tipo di entità con il monitoraggio abilitato.

Query di esempio per tutte le anomalie generate per un determinato archivio di caratteristiche

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

Esempio di voce di log di un'anomalia

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

Monitora gli errori di scrittura nello spazio di archiviazione offline per l'importazione di flussi di dati

Utilizza la console Google Cloud per monitorare gli errori di scrittura nello spazio di archiviazione offline durante limportazione di flussi di dati dati.

Visualizza metriche per l'importazione di flussi di dati nello spazio di archiviazione offline

Puoi monitorare la metrica Scrittura nello spazio di archiviazione offline per la scrittura di flussi di dati per Vertex AI Feature Store (legacy) in Metrics Explorer.

UI web

  1. Nella console Google Cloud, vai a Metrics Explorer:

    Vai a Metrics Explorer

  2. Nella barra degli strumenti, seleziona la scheda Explorer.

  3. Nella scheda Configurazione, specifica i dati da visualizzare nel grafico:

    • Risorsa e metrica: seleziona la metrica Vertex AI Feature Store - Scrittura offline per la scrittura di flussi di dati.

    • Raggruppa per: seleziona error_code.

    • Periodo di allineamento minimo: specifica l'intervallo di tempo minimo per l'allineamento dei dati nel grafico.

  4. Dopo aver aggiornato questi campi, il grafico mostra gli errori di scrittura nello spazio di archiviazione offline relativi ai vari codici di errore.

    Dopo aver generato il grafico, puoi aggiungerlo alla dashboard personalizzata. Per ulteriori informazioni, vedi Salvare un grafico per riferimento futuro.

Visualizza i log di Vertex AI Feature Store (legacy)

In Esplora log puoi visualizzare le voci di log per l'archivio di caratteristiche, inclusi i log generati durante gli errori di scrittura dell'archivio offline.

UI web

  1. Nella console Google Cloud, vai a Esplora log:

    Vai a Esplora log

  2. In Query Builder, aggiungi i seguenti parametri di ricerca e fai clic su Esegui query:

    • Risorsa: seleziona Vertex AI Feature Store.
    • Nome log: in API Vertex AI, seleziona aiplatform.googlapis.com/featurestore_log.