Monitorização

No Vertex AI Feature Store (antigo), pode monitorizar e definir alertas em featurestores e funcionalidades. Por exemplo, uma equipa de operações pode monitorizar um Feature Store para acompanhar a respetiva utilização da CPU. Os proprietários das funcionalidades, como os cientistas de dados, podem monitorizar os valores das funcionalidades para detetar a variação ao longo do tempo.

Os métodos de monitorização de featurestores e funcionalidades estão descritos nas secções seguintes:

Monitorização da Feature Store

O Vertex AI Feature Store (antigo) comunica métricas sobre o seu Feature Store ao Cloud Monitoring, como a carga da CPU, a capacidade de armazenamento, as latências de pedidos e a faturação. O Vertex AI recolhe e comunica estas métricas por si. Não precisa de configurar nem ativar a monitorização da Feature Store.

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

Também pode ver as métricas da Feature Store na secção do Vertex AI da Google Cloud consola para ver tendências ao longo do tempo. Para alguns gráficos, a consola mostra valores agregados ou calculados para facilitar o consumo das informações. Pode sempre ver os dados não processados no Cloud Monitoring.

Para mais informações, consulte as métricas de monitorização da Vertex AI Feature Store (antiga) na página do Cloud Monitoring da Vertex AI.

Monitorize a faturação de dados offline processados num repositório de funcionalidades

Use a Google Cloud consola para monitorizar os dados faturáveis processados offline pelos métodos featurestores.batchReadFeatureValues e entityTypes.exportFeatureValues. Pode ver os bytes faturáveis de cada Feature Store.

Pode monitorizar a métrica Bytes faturáveis para o Vertex AI Feature Store (antigo) no Explorador de métricas.

Consola

  1. Na Google Cloud consola, aceda ao Explorador de métricas:

    Aceda ao Explorador de métricas

  2. Na lista Métrica, selecione Vertex AI Feature Store > Featurestore > Bytes faturáveis.

  3. Clique em Aplicar. O gráfico apresenta os dados faturáveis offline das featurestores no seu projeto.

    Depois de gerar o gráfico, pode adicioná-lo ao seu painel de controlo personalizado. Para mais informações, consulte o artigo Guarde um gráfico para referência futura.

Monitorização do valor das funcionalidades

A monitorização do valor da caraterística permite-lhe acompanhar a forma como a distribuição do valor da caraterística muda num Feature Store. Os seguintes tipos de monitorização de valores de atributos são suportados:

  • Análise de instantâneos: o Vertex AI Feature Store (antigo) tira instantâneos periódicos dos valores das suas caraterísticas. Ao longo do tempo, à medida que carrega mais dados, pode reparar que a distribuição dos valores das funcionalidades muda. Esta alteração indica que os modelos que usam essas funcionalidades podem ter de ser novamente preparados. Pode especificar um limite para que as anomalias sejam registadas na consola do Cloud Logging sempre que o desvio da distribuição ultrapassar o limite.

    Para conjuntos de dados que excedam os 5 milhões de IDs de entidades, o Vertex AI Feature Store (antigo) gera capturas de ecrã com base em 5 milhões de IDs de entidades selecionados aleatoriamente no período especificado como o número de dias de desatualização.

  • Análise de caraterísticas de importação: cada operação ImportFeatureValues gera estatísticas de distribuição para os valores carregados no Vertex AI Feature Store (antigo). Pode optar por detetar anomalias comparando as estatísticas de distribuição com a distribuição de valores de atributos importada anteriormente ou, se estiver ativada, com a distribuição de instantâneos.

    Para conjuntos de dados que excedam 5 milhões de instâncias, o Vertex AI Feature Store (antigo) gera instantâneos com base em dados selecionados aleatoriamente, da seguinte forma:

    • Se o número de instâncias no conjunto de dados carregado exceder os 5 milhões, mas não exceder os 50 milhões, a imagem instantânea é gerada com base em 5 milhões de instâncias selecionadas aleatoriamente.
    • Se o número de instâncias no conjunto de dados carregado exceder os 50 milhões, a imagem instantânea é gerada com base em 10% das instâncias, selecionadas aleatoriamente.

Por exemplo, considere uma funcionalidade que recolhe os preços de casas vendidas recentemente e, em seguida, introduz os valores num 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 se desviam significativamente dos dados de preparação. O Vertex AI Feature Store (antigo) envia-lhe um alerta sobre esta alteração. Em seguida, pode voltar a preparar o modelo para usar as informações mais recentes.

Defina uma configuração de monitorização

Para iniciar a monitorização, pode definir uma configuração de monitorização num tipo de entidade, o que ativa a monitorização para todas as funcionalidades dos seguintes tipos:

  • BOOL
  • STRING
  • DOUBLE
  • INT64

Pode definir a configuração de monitorização quando cria um tipo de entidade. Também pode optar por desativar a monitorização de funcionalidades específicas definindo a propriedade disableMonitoring. A configuração de monitorização do tipo de entidade especifica o seguinte:

  • Ativar ou não a monitorização. A monitorização está desativada por predefinição.
  • Limiares usados para detetar anomalias. O limite predefinido é 0,3.
  • Período de análise, além do intervalo entre instantâneos (para análise de instantâneos). O valor predefinido é 21.
  • Ativar ou não a análise de funcionalidades de importação. A opção está desativada por predefinição.

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

Crie um tipo de entidade com a monitorização ativada

O exemplo seguinte cria um tipo de entidade em que a monitorização de funcionalidades está ativada:

IU da Web

Apenas a análise de instantâneos é suportada na IU.

  1. Na secção Vertex AI da Google Cloud consola, aceda à página Funcionalidades.

    Aceda à página Funcionalidades

  2. Selecione uma região na lista pendente Região.
  3. Clique em Criar tipo de entidade.
  4. Altere a secção Monitorização de funcionalidades para Ativado.
  5. Introduza o número de dias entre as capturas instantâneas no campo Intervalo de tempo de monitorização.
    A tarefa de monitorização de um tipo de entidade ou uma funcionalidade é executada na hora mais próxima após a hora do dia em que ativa a monitorização do tipo de entidade ou da funcionalidade. Por exemplo, se ativar a monitorização às 22:30 de segunda-feira e especificar dois dias como o intervalo de tempo de monitorização, a primeira tarefa de monitorização é executada às 23:00 de quarta-feira.
  6. Introduza o número de dias a analisar para cada captura instantânea no campo Período de análise da monitorização.
  7. Introduza o número do limite usado para detetar anomalias para caraterísticas numéricas no campo Limite de alerta numérico.
  8. Introduza o número do limite usado para detetar anomalias para caraterísticas categóricas neste EntityType no campo Limite de alerta categórico.
    Para mais informações sobre a deteção de anomalias de valores de caraterísticas, consulte o artigo Veja anomalias de valores de caraterísticas.
  9. Clique em Criar.
  10. Na tabela de funcionalidades, clique num tipo de entidade.
  11. Para adicionar novas funcionalidades à entidade, clique em Adicionar funcionalidades.
  12. Para desativar a monitorização de uma funcionalidade específica, desative a opção Ativar monitorização.

REST

Para criar um tipo de entidade, envie um pedido POST através do método entityTypes.create.

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

  • LOCATION_ID: região onde se encontra o Feature Store, como us-central1.
  • PROJECT_ID: o seu ID do projeto.
  • FEATURESTORE_ID: ID da Feature Store.
  • ENTITY_TYPE_ID: ID do tipo de entidade.
  • DURATION: a duração do intervalo entre capturas de ecrã em dias.
  • STALENESS_DAYS: o número de dias a considerar ao tirar instantâneos.
  • NUMERICAL_THRESHOLD_VALUE: o limite para detetar anomalias para caraterísticas numéricas deste tipo de entidade. O desvio estatístico é calculado pela divergência de Jenson-Shannon.
  • CATEGORICAL_THRESHOLD_VALUE: o limite para detetar anomalias para caraterísticas categóricas neste tipo de entidade. O desvio das estatísticas é calculado pela distância L-Infinity.
  • IMPORT_FEATURE_ANALYSIS_STATE: o estado que indica se a análise de funcionalidades de importação deve ser ativada.
  • IMPORT_FEATURE_ANALYSIS_BASELINE: a base para a análise da funcionalidade de importação, se estiver ativada.

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 do pedido: 

{
  "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 o seu pedido, escolha uma destas opções:

curl

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte 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

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte 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

Deverá ver uma saída semelhante à seguinte. Pode usar o elemento OPERATION_ID na resposta para obter o estado 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 experimentar este exemplo, siga as Javainstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Node.js Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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();

Idiomas adicionais

Para saber como instalar e usar o SDK Vertex AI para Python, consulte o artigo Use o SDK Vertex AI para Python. Para mais informações, consulte a documentação de referência da API do SDK Vertex AI para Python.

Desative a monitorização de uma nova funcionalidade

O exemplo seguinte cria uma nova funcionalidade com a monitorização desativada:

REST

Para criar uma funcionalidade, envie um pedido POST através do método features.create.

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

  • LOCATION_ID: região onde o Feature Store está localizado, como us-central1.
  • PROJECT_ID: .
  • FEATURESTORE_ID: ID da Feature Store.
  • ENTITY_TYPE_ID: ID do tipo de entidade.
  • FEATURE_ID: ID da funcionalidade.
  • VALUE_TYPE: o tipo de valor da funcionalidade.
  • DISABLE_MONITORING: defina como verdadeiro para desativar explicitamente a monitorização.

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 do pedido: 

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

Para enviar o seu pedido, escolha uma destas opções:

curl

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte 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

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte 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

Deverá ver uma saída semelhante à seguinte. Pode usar o elemento OPERATION_ID na resposta para obter o estado 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"
    }
  }
}

Atualize a configuração da monitorização

Pode definir a configuração de monitorização quando atualiza um tipo de entidade. Também pode optar por desativar a monitorização de funcionalidades específicas definindo a propriedade disableMonitoring.

Atualize a configuração de monitorização para o tipo de entidade e as funcionalidades

O exemplo seguinte atualiza a configuração de monitorização de um tipo de entidade existente e funcionalidades específicas desse tipo de entidade:

IU da Web

Apenas a análise de instantâneos é suportada na IU.

  1. Na secção do Vertex AI da Google Cloud consola, aceda à página Funcionalidades.
  2. Selecione uma região na lista pendente Região.
  3. Na tabela de funcionalidades, veja a coluna Tipo de entidade para encontrar o tipo de entidade a atualizar.
  4. Clique no nome do tipo de entidade para ver a página de detalhes da entidade.
  5. Na barra de ações, clique em Editar informações.
  6. Em Intervalo de tempo de monitorização, introduza o número de dias entre as capturas de ecrã.
    A tarefa de monitorização de um tipo de entidade ou uma funcionalidade é executada na hora mais próxima após a hora do dia em que ativa a monitorização do tipo de entidade ou da funcionalidade. Por exemplo, se ativar a monitorização às 22:30 de segunda-feira e especificar dois dias como o intervalo de tempo de monitorização, a primeira tarefa de monitorização é executada às 23:00 de quarta-feira.
  7. Clique em Atualizar.
  8. Da mesma forma, na tabela de funcionalidades, veja a coluna Funcionalidades para encontrar a funcionalidade a atualizar.
  9. Clique no nome da funcionalidade para ver a página de detalhes.
  10. Na barra de ações, clique em Editar informações.
  11. Para desativar a monitorização de uma funcionalidade específica, desative a opção Monitorização ativada.

REST

Para atualizar um tipo de entidade, envie um pedido PATCH através do método entityTypes.patch.

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

  • LOCATION_ID: região onde se encontra o Feature Store, como us-central1.
  • PROJECT_ID: .
  • FEATURESTORE_ID: ID da Feature Store.
  • ENTITY_TYPE_ID: ID do tipo de entidade.
  • DURATION_IN_DAYS: a duração do intervalo entre capturas de ecrã em dias.
  • STALENESS_DAYS: o número de dias a considerar ao tirar instantâneos.
  • NUMERICAL_THRESHOLD_VALUE: o limite para detetar anomalias para caraterísticas numéricas deste tipo de entidade. O desvio estatístico é calculado pela divergência de Jenson-Shannon.
  • CATEGORICAL_THRESHOLD_VALUE: o limite para detetar anomalias para caraterísticas categóricas neste tipo de entidade. O desvio das estatísticas é calculado pela distância L-Infinity.
  • IMPORT_FEATURE_ANALYSIS_STATE: o estado que indica se a análise de funcionalidades de importação deve ser ativada.
  • IMPORT_FEATURE_ANALYSIS_BASELINE: a base 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 do pedido: 

{
  "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 o seu pedido, escolha uma destas opções:

curl

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte 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

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte 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

Deve receber uma resposta JSON semelhante à seguinte:

{
  "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 experimentar este exemplo, siga as Javainstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Node.js Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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();

Desative a monitorização de uma funcionalidade

O exemplo seguinte desativa a monitorização de uma funcionalidade existente:

REST

Para atualizar uma funcionalidade, envie um pedido PATCH através do método features.patch.

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

  • LOCATION_ID: região onde o Feature Store está localizado, como us-central1.
  • PROJECT_ID: .
  • FEATURESTORE_ID: ID da Feature Store.
  • ENTITY_TYPE_ID: ID do tipo de entidade.
  • FEATURE_ID: ID da funcionalidade a atualizar.
  • DISABLE_MONITORING: defina como verdadeiro para desativar explicitamente a monitorização.

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 do pedido: 

{
  "disableMonitoring": "DISABLE_MONITORING"
}

Para enviar o seu pedido, escolha uma destas opções:

curl

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte 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

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte 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

Deve receber uma resposta JSON semelhante à seguinte:

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

Veja as distribuições de valores das funcionalidades

Use a Google Cloud consola para ver a distribuição dos valores das caraterísticas ao longo do tempo.

IU da Web

  1. Na secção do Vertex AI da Google Cloud consola, aceda à página Funcionalidades.

    Aceda à página Funcionalidades

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

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

  4. Para ver as métricas de distribuição de valores de atributos de um atributo:

    1. Na coluna Funcionalidade, clique na funcionalidade.

    2. Clique no separador Métricas para ver as métricas de distribuição de valores de atributos.

Veja anomalias de valores de atributos

Se a distribuição do valor da funcionalidade se desviar além do limite especificado num pipeline de monitorização, é considerada uma anomalia. Existem dois tipos de anomalias: a discrepância entre a preparação e a publicação, e a deriva. Para calcular o desvio, o Vertex AI compara os valores das funcionalidades mais recentes em produção com uma base.

  • Para detetar a distorção entre a preparação e a publicação, o Vertex AI compara os valores das funcionalidades mais recentes em produção com a distribuição estatística dos valores das funcionalidades nos dados de preparação. Neste caso, a distribuição estatística dos valores das funcionalidades nos dados de preparação é considerada a distribuição de base. Saiba mais sobre a discrepância entre a preparação e a publicação.

  • Para detetar a deriva, o Vertex AI compara os valores das funcionalidades mais recentes em produção com a distribuição estatística dos valores das funcionalidades da execução de monitorização mais recente que ocorreu há, pelo menos, uma hora. Neste caso, a distribuição estatística dos valores das caraterísticas da execução de monitorização mais recente é considerada a distribuição de base. Saiba mais acerca da variação.

Em ambos os casos, a distribuição de base é comparada com os valores das funcionalidades mais recentes em produção para calcular uma pontuação de distância.

  • Para as caraterísticas categóricas, a pontuação de distância é calculada através da distância L-infinity. Neste caso, se a pontuação de distância exceder o limite especificado no campo Limite de alertas categóricos, é identificada como uma anomalia.

  • Para as caraterísticas numéricas, a pontuação de distância é calculada através da divergência de Jensen-Shannon. Neste caso, se a pontuação de distância exceder o limite especificado no campo Limite de alerta numérico, é identificada como uma anomalia.

Em qualquer dos casos, a anomalia pode ser uma discrepância entre a preparação e a publicação ou uma deriva, consoante a distribuição de base usada para calcular a pontuação de distância. É escrito um registo de anomalias no Cloud Logging com o nome do registo featurestore_log. Pode sincronizar os registos com qualquer serviço a jusante suportado pelo Cloud Logging, como o Pub/Sub.

Para mais informações sobre a definição dos limites de alerta, consulte o artigo Crie um tipo de entidade com a monitorização ativada.

Exemplo de consulta para todas as anomalias geradas para uma determinada Feature Store

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 registo de 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"
}

Monitorize erros de gravação de armazenamento offline para o carregamento por streaming

Use a Google Cloud consola para monitorizar erros de gravação no armazenamento offline durante o carregamento de streams.

Veja métricas de carregamento de streaming para armazenamento offline

Pode monitorizar a métrica Gravação de armazenamento offline para gravação de streaming para o Vertex AI Feature Store (antigo) no Explorador de métricas.

IU da Web

  1. Na Google Cloud consola, aceda ao Explorador de métricas:

    Aceda ao Explorador de métricas

  2. Especifique os dados a apresentar no gráfico:

    • Recurso e métrica: selecione a métrica Vertex AI Feature Store > Gravação de armazenamento offline para gravação de streaming.

    • Filtrar: selecione error_code.

  3. Clique em Aplicar. O gráfico apresenta os erros de gravação do armazenamento offline para os vários códigos de erro.

    Depois de gerar o gráfico, pode adicioná-lo ao seu painel de controlo personalizado. Para mais informações, consulte o artigo Guarde um gráfico para referência futura.

Veja os registos do Vertex AI Feature Store (antigo)

Pode ver as entradas de registo da sua Feature Store, incluindo registos gerados durante erros de gravação da loja offline, no Explorador de registos.

IU da Web

  1. Na Google Cloud consola, aceda ao Explorador de registos:

    Aceda ao Explorador de registos

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

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