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:

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.

Arquitetura do fluxo criado nesta série de tutoriais.

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. Também é possível analisar esses dados, calcular estatísticas descritivas e visualizar o desvio e o deslocamento de dados usando o Notebooks 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, use o Notebooks para usar as ferramentas do TFDV de forma 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.

Fluxo de trabalho para detectar desvios de servidor de treinamento.

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:

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 ser 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 do Notebooks 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 do Notebooks do parte um aberta no Console do Cloud, faça o seguinte:

    1. Acesse a página "Notebooks".

      Acessar a página "Notebooks"

    2. Na lista de instâncias do Notebooks, 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:

Listagem do esquema gerado.

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.

Gráficos que mostram anomalias para elevação e aspecto.

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.

Visualização da área selvagem.

Visualização do tipo de capa.

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.

Listagem de anomalias encontradas pelo método "display_anomalies".

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:

Gráfico de valores médios para elevação.

Gráfico de valores médios para o aspecto.

Gráfico de valores médios para inclinação.

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:

Gráficos de barras que mostram a distribuição de valor dos recursos ao longo do 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

  1. No Console do Cloud, 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