Como analisar o desvio do serviço de treinamento com o TensorFlow Data Validation

Este documento é o terceiro de uma série que mostra como monitorar modelos de aprendizado de máquina (ML) implantados no AI Platform Prediction para a detecção de desvio de dados. Este guia aborda os conceitos e métodos de implementação para detectar o desvio de dados de serviço de treinamento usando o TensorFlow Data Validation (TFDV).

Este guia é destinado a cientistas de dados e engenheiros de ML que querem monitorar como as informações de dados são alteradas ao longo do tempo e quem quer identificar desvios e anomalias de dados. Ele pressupõe que você tenha alguma experiência com o Google Cloud, com o BigQuery e com os notebooks do Jupyter.

A série inclui os guias a seguir:

• Como registrar solicitações de serviço usando o AI Platform Prediction
• Como analisar registros no BigQuery
• Como analisar o desvio do servidor de treinamento com o TensorFlow Data Validation (este documento)
• Como automatizar a detecção de desvios do servidor de treinamento
• Como identificar o desvio do servidor de treinamento com detecção de novidades

O código do processo descrito neste documento está incorporado aos notebooks do Jupyter. Os notebooks estão em um repositório do GitHub (em inglês).

Noções básicas sobre o deslocamento de dados e o deslocamento do conceito

O monitoramento do desempenho preditivo de um modelo de ML em produção surgiu como uma área crucial de MLOps. Duas causas comuns de redução no desempenho preditivo de um modelo ao longo do tempo são as seguintes:

• Um desvio cresce entre os dados de treinamento e os dados de serviço. Esse problema é conhecido como deslocamento de dados.
• A interpretação da relação entre as previsões de entrada e o recurso de destino evolui. Esse problema é conhecido como deslocamento de conceito.

No deslocamento de dados, os dados de produção que um modelo recebe para pontuação foram divididos no conjunto de dados usado para treinar, ajustar e avaliar o modelo. As discrepâncias entre os dados de treinamento e os dados de serviço geralmente podem ser classificadas como desvios de esquema ou desvios de distribuição:

• O desvio de esquema ocorre quando dados de treinamento e dados de serviço não estão em conformidade com o mesmo esquema. O desvio do esquema geralmente é causado por falhas ou alterações no processo ascendente que gera os dados de disponibilização. Os desvios de esquema entre dados de treinamento e serviço podem incluir o seguinte:

  • Recursos inconsistentes: por exemplo, um novo recurso é adicionado aos dados de serviço.
  • Tipos de recursos inconsistentes: por exemplo, um atributo numérico que era um número inteiro nos dados de treinamento é um número real nos dados de serviço
  • Domínios de recursos inconsistentes: por exemplo, um valor em um recurso categórico desaparece ou há uma alteração no intervalo de atributos numéricos.

• O desvio de distribuição ocorre quando a distribuição de valores de atributos para dados de treinamento é significativamente diferente dos dados de serviço. Esse desvio pode ser o resultado da escolha do conjunto de dados de treinamento errado para representar dados reais. Esse desvio também pode acontecer naturalmente, à medida que novas tendências e padrões surgem nos dados devido às alterações na dinâmica do ambiente. Por exemplo, alterações nos preços de imóveis ou uma alteração na popularidade de itens de moda.

O deslocamento de conceito significa que a interpretação dos dados mudou. Muitas vezes, o deslocamento de conceito implica que o mapeamento de recursos de entrada para rótulos usados durante o treinamento não é mais válido, ou que uma nova classe ou um intervalo de valores de rótulo apareceu. Geralmente, o deslocamento de conceito é resultado de uma alteração no processo que você está tentando modelar. Também pode ser uma evolução do seu conhecimento sobre esse processo.

O objetivo deste documento é descrever o cenário de deslocamento de dados, especificamente na detecção de desvios de esquema e desvios de distribuição de recursos entre os dados de treinamento e os dados de serviço.

Visão geral da arquitetura

No diagrama a seguir, mostramos o ambiente descrito neste documento.

Nesta arquitetura, o registro de solicitação/resposta do AI Platform Prediction registra uma amostra das solicitações on-line em uma tabela do BigQuery. Em seguida, é possível analisar esses dados, calcular estatísticas descritivas e visualizar a distorção e a variação dos dados usando os notebooks Vertex AI Workbench gerenciados pelo usuário e o TFDV.

Como capturar dados de serviço

Um documento anterior nesta série, Como gerar solicitações de serviço usando o AI Platform Prediction, mostra como usar o AI Platform Prediction para implantar um modelo Keras para previsão on-line. Ela também mostra como ativar o registro de solicitação/resposta , que registra uma amostra de solicitações e respostas de previsão on-line em uma tabela BigQuery.

As instâncias de solicitação registradas e as previsões de resposta são armazenadas em uma forma bruta. O documento anterior desta série mostra como analisar esses registros brutos e criar uma visualização estruturada para analisar atributos de entrada e previsões de saída. Neste documento, também descrevemos como usar o Google Data Studio para visualizar como alguns valores de recursos mudam ao longo do tempo. A visualização também ajuda a identificar alguns outliers nos dados que podem causar desvios na previsão.

Como detectar desvios de dados de serviço

Pode ser difícil identificar manualmente os possíveis desvios e anomalias nos dados simplesmente olhando a visualização. Isso é especialmente difícil se você tiver um grande número de recursos de entrada. Portanto, você precisa de uma abordagem escalonável e automatizada na produção para destacar proativamente possíveis problemas nos dados de disponibilização.

Este documento descreve como usar o TFDV para detectar, analisar e visualizar desvios de dados. O TFDV ajuda a analisar os registros de dados de serviço em relação ao esquema esperado e com as estatísticas geradas a partir dos dados de treinamento para identificar anomalias e detectar desvios no serviço de treinamento. Conforme mostrado no diagrama de arquitetura anterior, você usa notebooks gerenciados pelo usuário para utilizar as ferramentas do TFDV de maneira interativa.

Como usar o TFDV para detectar desvios no serviço de treinamento

O diagrama a seguir ilustra o fluxo de trabalho para usar o TFDV para detectar e analisar desvios em registros de serviço de solicitação/resposta no BigQuery.

O fluxo de trabalho consiste nas seguintes fases:

1. Como gerar estatísticas de valor de referência e um esquema de referência a partir dos dados de treinamento. É possível usar as estatísticas de referência e o esquema de referência para validar os dados de serviço.
2. Detecção do desvio de dados de serviço. Esse processo produz estatísticas de dados de serviço e identifica anomalias que são detectadas ao validar os dados de serviço no esquema de referência.
3. Como analisar e visualizar a saída de validação. As anomalias produzidas são então visualizadas e analisadas, e as estatísticas são visualizadas para mostrar os desvios da distribuição.

Objetivos

• Gere estatísticas de referência e um esquema de referência.
• Detecta o desvio do servidor.
• Analise e visualize as saídas de validação.

Custos

Neste tutorial, usamos os seguintes componentes faturáveis do Google Cloud:

• Notebooks do Vertex AI Workbench gerenciados pelo usuário
• BigQuery
• Previsão da AI Platform
• Cloud Storage

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Antes de começar

Antes de começar, conclua a primeira parte e a segunda parte desta série.

Após concluir essas partes, você terá o seguinte:

• Uma instância de notebooks gerenciados pelo usuário que usa o TensorFlow 2.3.
• Um clone do repositório do GitHub que tem o notebook do Jupyter necessário para este guia.
• Uma tabela do BigQuery que contém registros de solicitação/resposta e uma visualização que analisa os pontos de dados de solicitação e resposta brutos.

O notebook do Jupyter para este cenário

Um processo completo para esse fluxo de trabalho é codificado em um notebook do Jupyter no repositório do GitHub associado a este documento. As etapas no notebook são baseadas no conjunto de dados Covertype do UCI Machine Learning Repository, que é o mesmo conjunto de dados usado para dados de amostra nos documentos anteriores desta série.

Como definir as configurações do notebook

Nesta seção, você prepara o ambiente Python e define as variáveis necessárias para executar o código do cenário.

1. Se você ainda não tiver a instância de notebooks gerenciada pelo usuário da parte um aberta, faça o seguinte:

   1. No Console do Cloud, acesse a página Notebooks.

      Acesse o Notebooks

   2. Na guia Notebooks gerenciados pelo usuário, selecione o notebook e clique em Abrir o JupyterLab. O ambiente do JupyterLab é aberto no navegador.

   3. No navegador de arquivos, abra o arquivo mlops-on-gcp e navegue até o diretório skew-detection.

2. Abra o notebook 03-covertype-drift-detection_tfdv.ipynb.

3. No notebook, em Configuração, execute a célula Instalar pacotes e dependências para instalar os pacotes Python necessários e configurar as variáveis de ambiente.

4. Em Definir configurações do ambiente do Google Cloud, defina as seguintes variáveis:

   • PROJECT_ID: o ID do projeto do Google Cloud em que o conjunto de dados do BigQuery para os dados da solicitação/resposta é registrado.
   • BUCKET: o nome do bucket do Cloud Storage em que os artefatos produzidos são armazenados.
   • BQ_DATASET_NAME: o nome do conjunto de dados do BigQuery em que os registros de solicitação/resposta são armazenados.
   • BQ_VIEW_NAME: o nome da visualização do BigQuery criada na segunda parte da série.
   • MODEL_NAME: o nome do modelo implantado no AI Platform Prediction.
   • VERSION_NAME: o nome da versão do modelo implantado no AI Platform Prediction. A versão está no formato vN. por exemplo, v1.

5. Execute as células restantes em Configuração para concluir a configuração do ambiente:

   1. Autenticar a conta do GCP
   2. Importar bibliotecas
   3. Crie um espaço de trabalho local

Como gerar estatísticas de referência e um esquema de referência

Execute as tarefas na primeira seção do notebook para que os dados de treinamento gerem estatísticas de referência e esquema de referência. Faça o download dos dados como arquivos CSV e use o método tfdv.generate_statistics_from_csv para calcular as estatísticas de valor de referência e colocá-las na variável baseline_stats. O código usa o método tfdv.infer_schema para inferir o esquema de referência dos dados de treinamento e colocá-lo na variável reference_schema.

Você pode modificar o esquema inferido, como mostrado no snippet de código a seguir:

baseline_stats = tfdv.generate_statistics_from_csv(
   data_location=TRAIN_DATA,
   stats_options=tfdv.StatsOptions(schema=reference_schema,
       sample_count=10000))

reference_schema = tfdv.infer_schema(baseline_stats)

# Set Soil_Type to be categorical
tfdv.set_domain(reference_schema, 'Soil_Type', schema_pb2.IntDomain(
   name='Soil_Type', is_categorical=True))

# Set Cover_Type to be categorical
tfdv.set_domain(reference_schema, 'Cover_Type', schema_pb2.IntDomain(
   name='Cover_Type', is_categorical=True))

# Set max and min values for Elevation
tfdv.set_domain(reference_schema,
   'Elevation',
   tfdv.utils.schema_util.schema_pb2.IntDomain(min=1000, max=5000))

# Allow no missing values
tfdv.get_feature(reference_schema,
   'Slope').presence.min_fraction = 1.0

# Set distribution skew detector for Wilderness_Area
tfdv.get_feature(reference_schema,
   'Wilderness_Area').skew_comparator.infinity_norm.threshold = 0.05

Exiba o esquema de referência gerado usando o método tfdv.display_schema. Ao fazer isso, você verá uma lista semelhante a esta:

Como detectar o desvio de dados de serviço

Na próxima seção, você executará tarefas para detectar desvios de dados de serviço. O processo consiste nas etapas a seguir:

1. Os dados de serviço da solicitação/resposta são lidos na visualização vw_covertype_classifier_logs_v1 no BigQuery. A visualização apresenta valores de recurso analisados e previsões que são registrados na tabela covertype_classifier_logs. A tabela contém solicitações de instâncias brutas e respostas de previsão do modelo covertype_classifier que foi implantado anteriormente no AI Platform Prediction.
2. Os dados de serviço registrados são salvos em um arquivo CSV para uso do TFDV.

3. O TFDV calcula as estatísticas de serviço do arquivo de dados CSV para diferentes partes dos dados de serviço usando o método tfdv.experimental_get_feature_value_slicer, conforme mostrado no snippet de código a seguir:

   slice_fn = tfdv.experimental_get_feature_value_slicer(features={'time': None})
   
   serving_stats_list = tfdv.generate_statistics_from_csv(
   data_location=serving_data_file,
   stats_options=tfdv.StatsOptions(
       slice_functions=[slice_fn],
       schema=reference_schema))
   

4. O TFDV valida cada fração serving_stats em relação ao esquema de referência (na variável reference_schema) usando o método tfdv.validate_statistics (em inglês). Esse processo gera anomalias, como mostrado no snippet de código a seguir:

   anomalies_list = []
   
   for slice_key in slice_keys[1:]:
     serving_stats = tfdv.get_slice_stats(serving_stats_list, slice_key)
     anomalies = tfdv.validate_statistics(
          serving_stats, schema=reference_schema,
          previous_statistics=baseline_stats)
     anomalies_list.append(anomalies)
   

O TFDV verifica se há anomalias ao comparar um esquema e o buffer do protocolo de estatísticas. Para mais informações sobre os tipos de anomalias que o TFDV pode detectar, consulte a Referência de anomalias do TensorFlow Data Validation. Os campos de esquema e de estatísticas são usados para detectar cada tipo de anomalia e as condições em que cada tipo de anomalia é detectado.

Como analisar e visualizar saídas de validação

Na terceira seção do notebook, você visualiza anomalias. O código usa o método tfdv.visualize_statistics (em inglês) para visualizar uma fração de serving_stats com as estatísticas de valor de referência dos dados de treinamento para destacar os desvios de distribuição.

A captura de tela a seguir mostra um exemplo de visualização para distribuições para os recursos numéricos Elevation e Aspect.

As capturas de tela a seguir mostram exemplos de visualizações para os recursos categóricos Wildness_Area e Cover_Type. Observe que, na visualização de recursos categóricos, Cover_Type é o recurso de destino e que a distribuição mostra o desvio da previsão.

Para inspecionar as anomalias geradas em cada fração serving_stats, chame o método tfdv.display_anomalies. A lista a seguir mostra um exemplo das anomalias detectadas.

Além de criar visualizações usando a API de visualização TFDV, você pode usar uma biblioteca de plotagem em Python para visualizar as estatísticas em seu notebook.

Veja nos gráficos a seguir como os valores médios do recurso numérico nas estatísticas de serviço se espalham em frações de tempo e como o deslocamento se compara aos valores médios nas estatísticas de valor de referência:

O gráfico a seguir mostra como a distribuição de valor do recurso categórico nas estatísticas de serviço se desloca entre frações de tempo:

Limpeza

Se você pretende continuar com o restante desta série, mantenha os recursos que já foram criados. Caso contrário, exclua o projeto que contém os recursos ou mantenha o projeto e exclua os recursos individuais.

Exclua o projeto

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto atual para seguir este tutorial, a exclusão dele incluirá quaisquer outras ações feitas no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja explorar vários tutoriais e guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

1. No console, acesse a página Gerenciar recursos.

   Acessar "Gerenciar recursos"

2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

A seguir

• Leia o guia Como automatizar a detecção de desvio do serviço de treinamento no AI Platform Prediction.
• Leia o guia Como identificar o desvio do servidor de treinamento com detecção de novidade.
• Saiba mais sobre MLOps e pipelines de entrega contínua e automação no machine learning.
• Conheça arquiteturas de referência, diagramas, tutoriais e práticas recomendadas do Google Cloud. Confira o Centro de arquitetura do Cloud.