Primeiros passos com o algoritmo integrado da TabNet no VertexAI.

Visão geral

TabNet é uma arquitetura de aprendizado profundo interpretável para dados tabulares (estruturados). Ela combina o melhor dos dois mundos: tem a explanabilidade de modelos baseados em árvores mais simples e atinge a alta precisão de modelos e conjuntos de caixa preta. Por isso, a TabNet é adequada para diversas tarefas de dados tabulares, como previsão de preços de ativos financeiros, detecção de fraudes/ataques cibernéticos/crimes, previsão de demanda no varejo, diagnósticos de registros médicos, recomendações de produtos e outras aplicações.

A TabNet emprega uma camada especialmente projetada na arquitetura: atenção sequencial, que seleciona quais atributos do modelo raciocinar em cada etapa do modelo. Esse mecanismo possibilita explicar como o modelo chega às previsões e ajuda a aprender modelos mais precisos. Graças a esse design, a TabNet não só supera outras redes neurais e árvores de decisão, mas também fornece atribuições de recursos interpretáveis.

Dados de entrada

A TabNet espera entradas tabulares em um dos seguintes formatos:

Dados de treinamento: dados de rótulo usados para treinar o modelo. Os formatos de arquivo a seguir são compatíveis:
- CSV
- BigQuery:
Esquema de entrada:
- Se a entrada for csv, a primeira coluna será a variável de destino.
- Se a entrada for BigQuery, especificará o parâmetro target_column.

Preparar arquivo CSV

Os dados de entrada podem estar em um arquivo CSV com codificação UTF-8. Se os dados de treinamento consistirem apenas em valores categóricos e numéricos, será possível usar o módulo de pré-processamento para preencher valores numéricos não encontrados, dividir o conjunto de dados e remover linhas com mais de 10% dos valores não encontrados. Do contrário, será possível gerar o treinamento sem pré-processamento automático ativado. No arquivo CSV, a primeira coluna é a variável de destino. Se o arquivo CSV tiver o cabeçalho, você precisará especificar o parâmetro has_header.

Preparar conjunto de dados do BigQuery

A entrada pode ser um conjunto de dados do BigQuery. Há vários métodos para carregar os dados de entrada no BigQuery.

Treinamento

Para realizar o treinamento de nó único com a TabNet, use o seguinte comando. Esse comando cria um recurso CustomJob que usa uma única máquina de CPU. Para informações sobre as sinalizações que podem ser usadas durante o treinamento, consulte a seção Sinalizações nesta página.

Treinamento com entrada CSV

Veja a seguir o exemplo do uso do CSV como formato de entrada. Depois de treinar o modelo, convém otimizar os hiperparâmetros usados durante o treinamento para melhorar a precisão e o desempenho do modelo. O notebook de tutorial fornece exemplos de jobs de treinamento de hiperparâmetros.

# URI of the TabNet Docker image.
LEARNER_IMAGE_URI='us-docker.pkg.dev/vertex-ai-restricted/builtin-algorithm/tab_net_v2'

# The region to run the job in.
REGION='us-central1'

# Your project.
PROJECT_ID="[your-project-id]"

# Set the training data
DATASET_NAME="petfinder"  # Change to your dataset name.
IMPORT_FILE="petfinder-tabular-classification-tabnet-with-header.csv"
MODEL_TYPE="classification"

# Give a unique name to your training job.
DATE="$(date '+%Y%m%d_%H%M%S')"

# Set a unique name for the job to run.
JOB_NAME="tab_net_cpu_${DATASET_NAME}_${DATE}"
echo $JOB_NAME

# Define your bucket.
YOUR_BUCKET_NAME="gs://[your-bucket-name]" # Replace by your bucket name

# Copy the csv to your bucket.
TRAINING_DATA_PATH="${YOUR_BUCKET_NAME}/data/${DATASET_NAME}/train.csv"
gsutil cp gs://cloud-samples-data/ai-platform-unified/datasets/tabular/${IMPORT_FILE} TRAINING_DATA_PATH

# Set a location for the output.
OUTPUT_DIR="${YOUR_BUCKET_NAME}/${JOB_NAME}/"

echo $OUTPUT_DIR
echo $JOB_NAME

gcloud ai custom-jobs create \
  --region=${REGION} \
  --display-name=${JOB_NAME} \
  --worker-pool-spec=machine-type=n1-standard-8,replica-count=1,container-image-uri=${LEARNER_IMAGE_URI} \
  --args=--preprocess \
  --args=--model_type=${MODEL_TYPE} \
  --args=--data_has_header \
  --args=--training_data_path=${TRAINING_DATA_PATH} \
  --args=--job-dir=${OUTPUT_DIR} \
  --args=--max_steps=2000 \
  --args=--batch_size=4096 \
  --args=--learning_rate=0.01

Como treinar com a entrada do BigQuery

Veja o exemplo de como usar o BigQuery como entrada.

# URI of the TabNet Docker image.
LEARNER_IMAGE_URI='us-docker.pkg.dev/vertex-ai-restricted/builtin-algorithm/tab_net_v2'

# The region to run the job in.
REGION='us-central1'

# Your project.
PROJECT_ID="[your-project-id]"

# Set the training data
DATASET_NAME="petfinder"  # Change to your dataset name.
IMPORT_FILE="petfinder-tabular-classification-tabnet-with-header.csv"

# Give a unique name to your training job.
DATE="$(date '+%Y%m%d_%H%M%S')"

# Set a unique name for the job to run.
JOB_NAME="tab_net_cpu_${DATASET_NAME}_${DATE}"
echo $JOB_NAME

# Define your bucket.
YOUR_BUCKET_NAME="gs://[your-bucket-name]" # Replace by your bucket name

# Copy the csv to your bucket.
TRAINING_DATA_PATH="${YOUR_BUCKET_NAME}/data/${DATASET_NAME}/train.csv"
gsutil cp gs://cloud-samples-data/ai-platform-unified/datasets/tabular/${IMPORT_FILE} TRAINING_DATA_PATH

# Create BigQuery dataset.
bq --location=${REGION} mk --dataset ${PROJECT_ID}:${DATASET_NAME}

# Create BigQuery table using CSV file.
TABLE_NAME="train"
bq --location=${REGION} load --source_format=CSV --autodetect ${PROJECT_ID}:${DATASET_NAME}.${TABLE_NAME} ${YOUR_BUCKET_NAME}/data/petfinder/train.csv

# Set a location for the output.
OUTPUT_DIR="${YOUR_BUCKET_NAME}/${JOB_NAME}/"
echo $OUTPUT_DIR
echo $JOB_NAME

gcloud ai custom-jobs create \
  --region=${REGION} \
  --display-name=${JOB_NAME} \
  --worker-pool-spec=machine-type=n1-standard-8,replica-count=1,container-image-uri=${LEARNER_IMAGE_URI} \
  --args=--preprocess \
  --args=--input_type=bigquery \
  --args=--model_type=classification \
  --args=--stream_inputs \
  --args=--bq_project=${PROJECT_ID} \
  --args=--dataset_name=${DATASET_NAME} \
  --args=--table_name=${TABLE_NAME} \
  --args=--target_column=Adopted \
  --args=--num_parallel_reads=2 \
  --args=--optimizer_type=adam \
  --args=--data_cache=disk \
  --args=--deterministic_data=False \
  --args=--loss_function_type=weighted_cross_entropy \
  --args=--replace_transformed_features=True \
  --args=--apply_quantile_transform=True \
  --args=--apply_log_transform=True \
  --args=--max_steps=2000 \
  --args=--batch_size=4096 \
  --args=--learning_rate=0.01 \
  --args=--job-dir=${OUTPUT_DIR}

Compreender o diretório do job

Após a conclusão de um job de treinamento, o treinamento da TabNet cria um modelo treinado no bucket do Cloud Storage com alguns outros artefatos. Você verá a estrutura de diretório a seguir no seu JOB_DIR:

artifacts/
- metadata.json
model/ (um diretório SavedModel do TensorFlow que também contém um arquivo deployment_config.yaml)
- saved_model.pb
- deployment_config.yaml
processed_data/
- test.csv
- training.csv
- validation.csv

O diretório do job também contém vários arquivos de checkpoint do modelo em um diretório "experiment". É possível usar o TensorBoard para visualizar as métricas. As métricas finais também são incluídas em deployment_config.yaml.

Confirme se a estrutura de diretórios no JOB_DIR corresponde a:

gsutil ls -a $JOB_DIR/*

Notebook do tutorial

Há um notebook de exemplo no Colab para iniciar a TabNet. Este notebook também mostra como usar:

Treinamento com a entrada do BigQuery.
Treinamento distribuído com GPUs.
Fazer ajuste de hiperparâmetros.

Sinalizações

Use as seguintes sinalizações de treinamento genéricas e específicas da TabNet ao treinar um modelo.

Sinalizações de treinamento genéricas

As sinalizações de treinamento personalizadas a seguir são usadas com mais frequência. Para mais informações, consulte Criar jobs de treinamento personalizados.

worker-pool-spec: a configuração do pool de workers usada pelo job personalizado. Para criar um job personalizado com vários pools de workers, especifique várias configurações de worker-pool-spec.

Um worker-pool-spec pode conter os seguintes campos listados com os campos correspondentes na mensagem da API WorkerPoolSpec.
- machine-type: o tipo de máquina para o pool. Para ver uma lista de máquinas compatíveis, consulte Tipos de máquina.
- replica-count: o número de réplicas da máquina no pool.
- container-image-uri: a imagem do Docker a ser executada em cada worker. Para usar o algoritmo integrado da TabNet, a imagem do Docker precisa ser definida como us-docker.pkg.dev/vertex-ai-restricted/builtin-algorithm/tab_net_v2:latest.
display-name: o nome do job.
region: a região em que você quer que o job seja executado.

Sinalizações de treinamento específicas da TabNet

A tabela a seguir mostra os parâmetros do ambiente de execução que podem ser definidos no job de treinamento da TabNet:

Parâmetro	Tipo de dado	Descrição	Obrigatório
`preprocess`	argumento booleano	Especifique para ativar o pré-processamento automático.	Não
`job_dir`	string	O diretório do Cloud Storage em que os arquivos de saída do modelo serão armazenados.	Sim
`input_metadata_path`	string	O caminho do Cloud Storage para os metadados específicos da TabNet para o conjunto de dados de treinamento. Veja acima como criar os metadados.	Não
`training_data_path`	string	Padrão do Cloud Storage em que os dados de treinamento são armazenados.	Sim
`validation_data_path`	string	Padrão do Cloud Storage em que os dados de avaliação são armazenados.	Não
`test_data_path`	string	Padrão do Cloud Storage em que os dados de teste são armazenados.	Sim
`input_type`	string	"bigquery" ou "csv": tipo dos dados tabulares de entrada. Se CSV for mencionado, a primeira coluna será tratada como destino. Se os arquivos CSV tiverem um cabeçalho, transmita também a sinalização "data_has_header". Se "bigquery" for usado, pode fornecer caminhos de treinamento/validação de dados ou fornecer nomes de projetos, conjuntos de dados e tabelas do BigQuery para pré-processamento e produzir conjuntos de dados de treinamento e validação.	Não. O padrão é "csv".
`model_type`	string	A tarefa de aprendizado, como classificação ou regressão.	Sim
`split_column`	string	O nome da coluna usado para criar as divisões de treinamento, validação e teste. Os valores das colunas (também conhecida como "tabela_"[column]") precisam ser "TRAIN", "VALIDATE" ou "TEST". "TEST" é opcional. Aplicável apenas para entradas do BigQuery.	Não
`train_batch_size`	int	Tamanho do lote para treinamento.	Não. O padrão é 1024.
`eval_split`	float	Fração de divisão a ser usada para o conjunto de dados de avaliação, se `validation_data_path` não for fornecido.	Não. O padrão é 0.2
`learning_rate`	float	Taxa de aprendizado do treinamento.	Não: o padrão é a taxa de aprendizado padrão do otimizador especificado.
`eval_frequency_secs`	int	Frequência com que a avaliação e o checkpoint ocorrem. O padrão é 600.	Não
`num_parallel_reads`	int	Número de linhas de execução usadas para ler os arquivos de entrada. Sugerimos que ele seja igual ou um pouco menor que o número de CPUs da máquina para um desempenho máximo na maioria dos casos. Por exemplo, 6 por GPU é uma boa opção padrão.	Sim
`data_cache`	string	Escolha armazenar os dados em cache como "memory", "disk" ou "no_cache". Para conjuntos de dados grandes, armazenar em cache os dados na memória provocaria erros de falta de memória. Portanto, sugerimos escolher "disk". É possível especificar o tamanho do disco no arquivo de configuração (conforme o exemplo abaixo). Certifique-se de solicitar um disco suficientemente grande (por exemplo, tamanho TB) para gravar os dados de conjuntos de dados grandes (escala B).	Não: o padrão é "memória".
`bq_project`	string	O nome do projeto do BigQuery. Se input_type=bigquery e usar a sinalização – pré-processamento, isso será obrigatório. Essa é uma alternativa à especificação de caminhos de dados de treinamento, validação e teste.	Não
`dataset_name`	string	O nome do conjunto de dados do BigQuery. Se input_type=bigquery e usar a sinalização – pré-processamento, isso será obrigatório. Essa é uma alternativa à especificação de caminhos de dados de treinamento, validação e teste.	Não
`table_name`	string	O nome da tabela do BigQuery. Se input_type=bigquery e usar a sinalização – pré-processamento, isso será obrigatório. Essa é uma alternativa à especificação de caminhos de dados de treinamento, validação e teste.	Não
`loss_function_type`	string	Existem vários tipos de função de perda na TabNet. Para regressão: mse/mae são incluídos. Para classificação: cross_entropy/weighted_cross_entropy/focal_loss estão incluídos.	Não: padrão, "mse" para regressão e "cross_entropy" para classificação.
`deterministic_data`	argumento booleano	Determinismo da leitura de dados a partir de dados tabulares. O padrão é definido como Falso. Ao definir como "Verdadeiro", o experimento é determinista. Para treinamento rápido em conjuntos de dados grandes, sugerimos a configuração deterministic_data=False, ainda que haja aleatoriedade nos resultados (o que se torna insignificante em grandes conjuntos de dados). O determinismo ainda não é garantido com o treinamento distribuído, já que a redução de mapas causa aleatoriedade devido à ordem das operações algébricas com precisão finita. No entanto, isso é insignificante na prática, especialmente em conjuntos de dados grandes. Para os casos em que 100% de determinismo é o desejado, além da configuração deterministic_data=True, sugerimos o treinamento com uma única GPU (por exemplo, com MACHINE_TYPE="n1-highmem-8).	Não. O padrão é Falso.
`stream_inputs`	argumento booleano	Faça streaming de dados de entrada no Cloud Storage em vez de fazer o download localmente. Essa opção é sugerida para agilizar o tempo de execução.	Não
`large_category_dim`	int	Dimensionalidade da incorporação: se o número de categorias distintas para uma coluna categórica for maior que a arge_category_thresh, usamos uma incorporação dimensional large_category_dim, em vez da incorporação 1-D. O padrão é 1. Sugerimos aumentá-lo (por exemplo, para aproximadamente 5, na maioria dos casos e até para mais ou menos 10 se o número de categorias normalmente for muito grande no conjunto de dados), se a precisão for o objetivo principal, em vez da eficiência computacional e explicabilidade.	Não. O padrão é 1.
`large_category_thresh`	int	Limite para cardinalidade de coluna categórica: se o número de categorias distintas para uma coluna categórica for maior que o large_category_thresh, usaremos uma incorporação dimensional large_category_dim, em vez da incorporação 1-D. O padrão é 300. Sugerimos diminuí-la (por exemplo, para aproximadamente 10), se a meta for a precisão, em vez da eficiência computacional e explicabilidade.	Não. O padrão é 300.
`yeo_johnson_transform`	argumento booleano	Ativa a transformação de potência treinável Yeo-Johnson (o padrão é desativado). Acesse este link: https://www.stat.umn.edu/arc/yjpower.pdf para mais informações sobre a transformação de potência Yeo-Johnson. Com nossa implementação, os parâmetros de transformação podem ser aprendidos com a TabNet, treinados de ponta a ponta.	Não
`apply_log_transform`	argumento booleano	Se as estatísticas de transformação de registro estiverem nos metadados e essa sinalização for verdadeira, os recursos de entrada serão transformados. Use "falso" para não usar a transformação e "verdadeiro" (o padrão) para usá-la. Especialmente para conjuntos de dados com distribuições numéricas distorcidas, as transformações de registro podem ser muito úteis.	Não
`apply_quantile_transform`	argumento booleano	Se as estatísticas de quantil estiverem contidas nos metadados e essa sinalização for verdadeira, os atributos de entrada serão transformados em quantil. Use "falso" para não usar a transformação e "verdadeiro" (o padrão) para usá-la. Especialmente para conjuntos de dados com distribuições numéricas distorcidas, as transformações de quantil podem ser muito úteis. Compatível com input_type do BigQuery.	Não

A seguir

Veja o notebook no GitHub.
Saiba mais sobre a TabNet