Monitoramento

No Vertex AI Feature Store, você pode monitorar e definir alertas sobre featurestores e recursos. Por exemplo, uma equipe de operações pode monitorar um featurestore para rastrear a utilização da CPU. Os proprietários de recursos, como cientistas de dados, podem monitorar os valores dos recursos para detectar deslocamentos ao longo do tempo.

Os métodos para monitorar featurestores e recursos são descritos nas seções a seguir:

Monitoramento do featurestore

O Vertex AI Feature Store informa métricas sobre seu featurestore ao Cloud Monitoring, como carga de CPU, capacidade de armazenamento e latências de solicitação. A Vertex AI coleta e informa essas métricas automaticamente. Você não precisa configurar ou ativar o monitoramento do Featurestore.

Para configurar limites e notificações, use o Cloud Monitoring. Por exemplo, é possível definir um alerta se a carga média da CPU exceder 70%, o que pode exigir o aumento do número de nós do featurestore.

Também é possível ver as métricas do featurestore na seção "Vertex AI" do console do Google Cloud para ver as tendências ao longo do tempo. Para alguns gráficos, o console mostra valores agregados ou calculados para facilitar o consumo das informações. É sempre possível ver os dados brutos no Cloud Monitoring.

Para mais informações, consulte Métricas de monitoramento do Vertex AI Feature Store na página do Vertex AI Cloud Monitoring.

Monitoramento do valor do recurso

O monitoramento de valor do recurso permite rastrear o quanto a distribuição de valor de um recurso muda ao longo do tempo em um featurestore. Os seguintes tipos de monitoramento do valor do recurso são compatíveis:

  • Análise de snapshot: a Vertex AI Feature Store cria snapshots periódicos dos valores dos recursos. Com o passar do tempo, conforme você ingere mais dados, pode haver mudanças na distribuição dos valores de atributos. Essa alteração indica que pode ser necessário treinar novamente os modelos que usam esses recursos. É possível especificar um limite para que as anomalias sejam registradas no console do Cloud Logging sempre que o desvio de distribuição ultrapassar o limite.

    Para conjuntos de dados que ultrapassam 5 milhões de IDs de entidade, a Vertex AI Feature Store (legado) gera snapshots com base em 5 milhões de IDs selecionados aleatoriamente dentro da janela de tempo especificada como o número de dias de inatividade.

  • Análise de recursos de importação: cada operação ImportFeatureValues gera estatísticas de distribuição para os valores ingeridos na Feature Store do Vertex AI. É possível detectar anomalias ao comparar as estatísticas de distribuição com a distribuição do valor do recurso importado anteriormente ou, se ativada, com a distribuição do snapshot.

    Para conjuntos de dados com mais de 5 milhões de instâncias, a Vertex AI Feature Store (legado) gera snapshots com base em dados selecionados aleatoriamente, da seguinte maneira:

    • Se o número de instâncias no conjunto de dados ingerido for maior que 5 milhões, mas não exceder 50 milhões, o snapshot será gerado com base em 5 milhões de instâncias selecionadas aleatoriamente.
    • Se o número de instâncias no conjunto de dados ingerido exceder 50 milhões, o snapshot será gerado com base em 10% das instâncias, que serão selecionadas aleatoriamente.

Por exemplo, considere um recurso que coleta preços de casas vendidas recentemente e, em seguida, alimenta os valores em um modelo para prever o preço de uma casa. Os preços das casas vendidas recentemente podem variar significativamente ao longo do tempo, ou o lote de valores importados pode conter dados que diferem significativamente dos dados de treinamento. A Vertex AI Feature Store alerta sobre essa mudança. É possível treinar seu modelo novamente para usar as informações mais recentes.

Definir uma configuração de monitoramento

Para iniciar o monitoramento, você pode definir uma configuração de monitoramento em um tipo de entidade, o que permite o monitoramento de todos os recursos dos seguintes tipos:

  • BOOL
  • STRING
  • DOUBLE
  • INT64

É possível definir a configuração de monitoramento ao criar um tipo de entidade. Também é possível desativar o monitoramento de recursos específicos definindo a propriedade disableMonitoring. A configuração de monitoramento do tipo de entidade especifica o seguinte:

  • Se o monitoramento precisa ser ativado. O monitoramento fica desativado por padrão.
  • Limites usados para detectar anomalias. O limite padrão é 0,3.
  • Janela de lookback, além do intervalo entre snapshots (para análise de snapshots). O valor padrão é 21.
  • Se a análise de recursos de importação deve ser ativada. O padrão é desativado.

Para mais informações, consulte o tipo FeaturestoreMonitoringConfig na referência da API.

Criar um tipo de entidade com o monitoramento ativado

O exemplo a seguir cria um tipo de entidade, em que o monitoramento de recursos está ativado:

IU da Web

A análise de snapshots é compatível com a IU.

  1. Na seção "Vertex AI" do Console do Google Cloud, acesse a página Recursos.

    Acessar a página Recursos

  2. Selecione uma região na lista suspensa Região.
  3. Clique em Criar tipo de entidade.
  4. Mude a seção Monitoramento de recursos para Ativado.
  5. Digite o número de dias entre snapshots no campo Intervalo de tempo de monitoramento.
    O job de monitoramento para um tipo de entidade ou atributo é executado na hora completa mais próxima após a hora do dia em que você ativa o monitoramento para o tipo de entidade ou recurso. Por exemplo, se ativar o monitoramento às 22h30 na segunda-feira e especificar dois dias como o intervalo do tempo de monitoramento, o primeiro job de monitoramento será executado às 23h da quarta-feira.
  6. Digite o número de dias para cada período no campo Janela de lookback do Monitoring.
  7. Digite o número do limite usado para detectar anomalias em recursos numéricos no campo Limite numérico de alertas.
  8. Insira o número do limite usado para detectar anomalias em atributos categóricos neste EntityType no campo Limite de alerta categórico.
    Para mais informações sobre como detectar anomalias no valor do recurso, consulte Ver valor do recurso. anomalias.
  9. Clique em Criar.
  10. Na tabela de atributos, clique em um tipo de entidade.
  11. Para adicionar novos atributos à entidade, clique em Adicionar atributos.
  12. Para desativar o monitoramento de um recurso específico, desative a opção Ativar monitoramento.

REST

Para criar um tipo de entidade, envie uma solicitação POST usando o método featurestores.entityTypes.create.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • LOCATION_ID: região em que featurestore está localizada, como us-central1.
  • PROJECT_ID: o ID do projeto.
  • FEATURESTORE_ID: ID do featurestore.
  • ENTITY_TYPE_ID: ID do tipo de entidade.
  • DURATION: a duração do intervalo entre snapshots em dias.
  • STALENESS_DAYS: o número de dias para considerar ao tirar snapshots.
  • NUMERICAL_THRESHOLD_VALUE: o limite para detectar anomalias em recursos numéricos neste tipo de entidade. O desvio de estatísticas é calculado pela divergência de Jenson-Shannon.
  • CATEGORICAL_THRESHOLD_VALUE: o limite para detectar anomalias em recursos categóricos neste tipo de entidade. O desvio das estatísticas é calculado pela distância L-Infinito.
  • IMPORT_FEATURE_ANALYSIS_STATE: o estado que indica se a análise de recursos de importação será ativada.
  • IMPORT_FEATURE_ANALYSIS_BASELINE: o valor de referência para análise de recursos de importação, se ativado.

Método 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 da solicitação:

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

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

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

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

$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

Será exibido um código semelhante a este. Use OPERATION_ID na resposta para ver o status da operação.

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

Antes de testar esse exemplo, siga as instruções de configuração para Java no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Java.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 


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

Antes de testar essa amostra, siga as instruções de configuração para Node.js Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Node.js.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

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

Outras linguagens

Confira a instalação e o uso do SDK da Vertex AI para Python em Usar o SDK da Vertex AI para Python. Saiba mais na documentação de referência da API SDK da Vertex AI para Python.

Desativar o monitoramento de um novo recurso

O exemplo a seguir cria um novo recurso com o monitoramento desativado:

REST

Para criar um recurso, envie uma solicitação POST usando o método features.create.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • LOCATION_ID: região em que featurestore está localizada, como us-central1.
  • PROJECT_ID: o ID do projeto.
  • FEATURESTORE_ID: ID do featurestore.
  • ENTITY_TYPE_ID: ID do tipo de entidade.
  • FEATURE_ID: ID do recurso.
  • VALUE_TYPE: o tipo de valor do recurso.
  • DISABLE_MONITORING: defina como verdadeiro para desativar explicitamente o monitoramento.

Método 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 da solicitação:

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

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

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

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

$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

Será exibido um código semelhante a este. Use OPERATION_ID na resposta para ver o status da operação.

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

Atualizar configuração de monitoramento

É possível definir a configuração de monitoramento ao atualizar um tipo de entidade. Também é possível desativar o monitoramento de recursos específicos definindo a propriedade disableMonitoring.

Atualizar configuração de monitoramento para recursos e tipo de entidade

O exemplo a seguir atualiza a configuração de monitoramento para um tipo de entidade existente e recursos específicos para esse tipo de entidade:

IU da Web

A análise de snapshots é compatível com a IU.

  1. Na seção "Vertex AI" do Console do Google Cloud, acesse a página Recursos.
  2. Selecione uma região na lista suspensa Região.
  3. Na tabela de atributos, veja a coluna Tipo de entidade para encontrar o tipo da entidade a ser atualizada.
  4. Clique no nome do tipo de entidade para ver a página de detalhes dela.
  5. Na barra de ação, clique em Editar informações.
  6. Em Intervalo de tempo do Monitoring, insira o número de dias entre snapshots.
    O job de monitoramento para um tipo de entidade ou atributo é executado na hora completa mais próxima após a hora do dia em que você ativa o monitoramento para o tipo de entidade ou recurso. Por exemplo, se ativar o monitoramento às 22h30 na segunda-feira e especificar dois dias como o intervalo do tempo de monitoramento, o primeiro job de monitoramento será executado às 23h da quarta-feira.
  7. Clique em Atualizar.
  8. Da mesma forma, na tabela de recursos, acesse a coluna Recursos para encontrar o item que será atualizado.
  9. Clique no nome do elemento para ver a página de detalhes.
  10. Na barra de ação, clique em Editar informações.
  11. Para desativar o monitoramento de um recurso específico, desative a opção Monitoramento ativado.

REST

Para atualizar um tipo de entidade, envie uma solicitação PATCH usando o método entityTypes.patch.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • LOCATION_ID: região em que featurestore está localizada, como us-central1.
  • PROJECT_ID: o ID do projeto.
  • FEATURESTORE_ID: ID do featurestore.
  • ENTITY_TYPE_ID: ID do tipo de entidade.
  • DURATION_IN_DAYS: a duração do intervalo entre snapshots em dias.
  • STALENESS_DAYS: o número de dias para considerar ao tirar snapshots.
  • NUMERICAL_THRESHOLD_VALUE: o limite para detectar anomalias em recursos numéricos neste tipo de entidade. O desvio de estatísticas é calculado pela divergência de Jenson-Shannon.
  • CATEGORICAL_THRESHOLD_VALUE: o limite para detectar anomalias em recursos categóricos neste tipo de entidade. O desvio das estatísticas é calculado pela distância L-Infinito.
  • IMPORT_FEATURE_ANALYSIS_STATE: o estado que indica se a análise de recursos de importação será ativada.
  • IMPORT_FEATURE_ANALYSIS_BASELINE: o valor de referência que indica ????

Método 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 da solicitação:

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

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

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

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

$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

Você receberá uma resposta JSON semelhante a esta:

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

Antes de testar esse exemplo, siga as instruções de configuração para Java no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Java.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 


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

Antes de testar essa amostra, siga as instruções de configuração para Node.js Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Node.js.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

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

Desativar o monitoramento de um recurso

O exemplo a seguir desativa o monitoramento de um recurso atual:

REST

Para atualizar um recurso, envie uma solicitação PATCH usando o método featurestores.patch.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • LOCATION_ID: região em que featurestore está localizada, como us-central1.
  • PROJECT_ID: o ID do projeto.
  • FEATURESTORE_ID: ID do featurestore.
  • ENTITY_TYPE_ID: ID do tipo de entidade.
  • FEATURE_ID: código do recurso a ser atualizado.
  • DISABLE_MONITORING: defina como verdadeiro para desativar explicitamente o monitoramento.

Método 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 da solicitação:

{
  "disableMonitoring": "DISABLE_MONITORING"
}

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

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

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

$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

Você receberá uma resposta JSON semelhante a esta:

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

Ver distribuições de valor do recurso

Use o Console do Cloud para ver a distribuição dos valores de recurso ao longo do tempo.

IU da Web

  1. Na seção "Vertex AI" do Console do Google Cloud, acesse a página Recursos.

    Acessar a página Recursos

  2. Selecione uma região na lista suspensa Região.

  3. Para ver as distribuições de valor de todos os atributos de um tipo de entidade, na coluna Tipo de entidade, clique no tipo.

  4. Para ver as métricas de distribuição de valor de um atributo, faça o seguinte:

    1. Na coluna Atributo, clique na opção.

    2. Clique em Métricas para ver as métricas de distribuição de valor do recurso.

Ver anomalias no valor do recurso

Se a distribuição do valor do recurso desvia do limite especificado em um pipeline de monitoramento, ela é considerada uma anomalia. Há dois tipos de anomalias: desvio de treinamento/exibição e deslocamento. Para calcular o desvio, a Vertex AI compara os últimos valores de atributos na produção com um valor de referência.

  • Para detectar o desvio de treinamento/exibição, a Vertex AI compara os valores mais recentes de atributo na produção com a distribuição estatística dos valores de atributo nos dados de treinamento. Nesse caso, a distribuição estatística dos valores dos atributos nos dados de treinamento é considerada a distribuição do valor de referência. Saiba mais sobre o desvio de treinamento/exibição.

  • Para detectar deslocamentos, a Vertex AI compara os últimos valores de atributos na produção com a distribuição estatística dos valores de atributos da execução de monitoramento mais recente que ocorreu há pelo menos uma hora. Nesse caso, a distribuição estatística dos valores de atributos da execução de monitoramento mais recente é considerada como a distribuição de referência. Saiba mais sobre deslocamentos.

Em ambos os casos, a distribuição do valor de referência é comparada aos valores de recurso mais recentes em produção para calcular uma pontuação de distância.

  • Para recursos categóricos, a pontuação de distância é calculada usando a distância de L-infinito. Nesse caso, se a pontuação de distância exceder o limite especificado no campo Limite de alertas categóricos, ela será identificada como uma anomalia.

  • Para atributos numéricos, a pontuação de distância é calculada usando a divergência de Jensen-Shannon. Nesse caso, se a pontuação de distância exceder o limite especificado no campo Limite numérico de alertas, ela será identificada como uma anomalia.

Em ambos os casos, a anomalia pode ser um desvio de treinamento/exibição ou um deslocamento, dependendo da distribuição de referência usada para calcular a pontuação de distância. Um registro de anomalias é gravado no Cloud Logging com o nome de registro featurestore_log. É possível sincronizar os registros com qualquer serviço downstream compatível com o Cloud Logging, como o Pub/Sub.

Para mais informações sobre como definir os limites de alerta, consulte Criar um tipo de entidade com o monitoramento ativado.

Exemplo de consulta de todas as anomalias geradas para um determinado featurestore

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

Exemplo de uma entrada de registro de anomalias

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

Monitorar erros de gravação no armazenamento off-line para ingestão de streaming

Usar o console do Google Cloud para monitorar erros de gravação no armazenamento off-line durante a ingestão de streaming.

Conferir métricas de ingestão de streaming para armazenamento off-line

Você pode monitorar a métrica Gravação de armazenamento off-line para gravação de streaming na Feature Store da Vertex AI no Metrics Explorer.

IU da Web

  1. No console do Google Cloud, acesse Metrics Explorer.

    Acessar o Metrics Explorer

  2. Na barra de ferramentas, selecione a guia Explorer.

  3. Na guia Configuração, especifique os dados que aparecerão no gráfico:

    • Recurso e métrica: selecione a métrica Feature Store da Vertex AI - gravação de armazenamento off-line para gravação em streaming.

    • Agrupar por: selecione error_code.

    • Período de alinhamento mínimo: especifica o intervalo de tempo mínimo para alinhar os dados no gráfico.

  4. Depois de atualizar esses campos, o gráfico exibe os erros de gravação do armazenamento off-line para os vários códigos de erro.

    Depois de gerar o gráfico, você poderá adicioná-lo ao seu painel personalizado. Confira mais informações em Salvar um gráfico para referência futura.

Conferir registros do Feature Store da Vertex AI

É possível ver as entradas de registro do seu featurestore, incluindo registros gerados durante erros de gravação no armazenamento off-line, no Explorador de registros.

IU da Web

  1. No console do Google Cloud, acesse a página do Explorador de registros:

    Acesse o Explorador de registros

  2. No Criador de consultas, adicione os seguintes parâmetros de consulta e clique em Executar consulta:

    • Recurso: selecione Feature Store da Vertex AI.
    • Nome do registro: em API Vertex AI, selecione aiplatform.googlapis.com/featurestore_log.