tabnet
v4.1.0
Esta é uma implementação de Pytorch do Tabnet (Arik, So & Pfister, T. (2019). Tabnet: aprendizado tabular interpretável atencioso. Arxiv pré -impressão arxiv: 1908.07442.) Https://arxiv.org/pdf/1908.0742.pdf. Observe que algumas opções diferentes foram feitas horas extras para melhorar a biblioteca que podem diferir do papel orginal.
Alguma dúvida? Quer contribuir? Para falar conosco? Você pode se juntar a nós no Slack
Você pode instalar usando pip ou conda da seguinte maneira.
com pip
pip install pytorch-tabnetcom conda
conda install -c conda-forge pytorch-tabnetSe você Wan para usá -lo localmente dentro de um recipiente do Docker:
git clone [email protected]:dreamquark-ai/tabnet.git
cd tabnet para entrar no repositório
make start a construir e entrar no recipiente make start-gpu para construir e entrar no contêiner da GPU poetry install para instalar todas as dependências, incluindo Jupyter
make notebook dentro do mesmo terminal. Você pode seguir o link para um notebook Jupyter com o TabNet instalado.
grouped_features ). Atenção agora é feita no nível do grupo e não é o nível de recurso. Isso é especialmente útil se um conjunto de dados tiver muitas colunas provenientes de uma única fonte de dados (Exemple: uma coluna de texto transformada usando TD-IDF).Ao contribuir para o repositório do Tabnet, não se esqueça de discutir a alteração que você deseja fazer por meio de um problema novo ou já existente.
Nossos compromissos seguem as regras apresentadas aqui.
A TabNet agora é compatível com o Scikit, é realmente fácil treinar um TabNetClassifier ou TabNetRegressor.
from pytorch_tabnet . tab_model import TabNetClassifier , TabNetRegressor
clf = TabNetClassifier () #TabNetRegressor()
clf . fit (
X_train , Y_train ,
eval_set = [( X_valid , y_valid )]
)
preds = clf . predict ( X_test )ou para TabNetMultiTaskClassifier:
from pytorch_tabnet . multitask import TabNetMultiTaskClassifier
clf = TabNetMultiTaskClassifier ()
clf . fit (
X_train , Y_train ,
eval_set = [( X_valid , y_valid )]
)
preds = clf . predict ( X_test ) Os alvos no y_train/y_valid devem conter um tipo exclusivo (por exemplo, todos devem ser strings ou números inteiros).
Algumas métricas de avaliação clássica são implementadas (veja mais abaixo para as personalizadas):
NOTA IMPORTANTE: 'RMSLE' prenderá automaticamente previsões negativas a 0, porque o modelo pode prever valores negativos. Para corresponder às pontuações fornecidas, você precisa usar np.clip(clf.predict(X_predict), a_min=0, a_max=None) ao fazer previsões.
Você pode criar uma métrica para sua necessidade específica. Aqui está um exemplo para a pontuação do Gini (observe que você precisa especificar se essa métrica deve ser maximizada ou não):
from pytorch_tabnet . metrics import Metric
from sklearn . metrics import roc_auc_score
class Gini ( Metric ):
def __init__ ( self ):
self . _name = "gini"
self . _maximize = True
def __call__ ( self , y_true , y_score ):
auc = roc_auc_score ( y_true , y_score [:, 1 ])
return max ( 2 * auc - 1 , 0. )
clf = TabNetClassifier ()
clf . fit (
X_train , Y_train ,
eval_set = [( X_valid , y_valid )],
eval_metric = [ Gini ]
)Um notebook de exemplo de personalização específico está disponível aqui: https://github.com/dreamquark-ai/tabnet/blob/devell/customizing_example.ipynb
Adicionado posteriormente ao artigo original da Tabnet, o pré-treinamento semi-supervisionado já está disponível através da classe TabNetPretrainer :
# TabNetPretrainer
unsupervised_model = TabNetPretrainer (
optimizer_fn = torch . optim . Adam ,
optimizer_params = dict ( lr = 2e-2 ),
mask_type = 'entmax' # "sparsemax"
)
unsupervised_model . fit (
X_train = X_train ,
eval_set = [ X_valid ],
pretraining_ratio = 0.8 ,
)
clf = TabNetClassifier (
optimizer_fn = torch . optim . Adam ,
optimizer_params = dict ( lr = 2e-2 ),
scheduler_params = { "step_size" : 10 , # how to use learning rate scheduler
"gamma" : 0.9 },
scheduler_fn = torch . optim . lr_scheduler . StepLR ,
mask_type = 'sparsemax' # This will be overwritten if using pretrain model
)
clf . fit (
X_train = X_train , y_train = y_train ,
eval_set = [( X_train , y_train ), ( X_valid , y_valid )],
eval_name = [ 'train' , 'valid' ],
eval_metric = [ 'auc' ],
from_unsupervised = unsupervised_model
) A função de perda foi normalizada para ser independente de pretraining_ratio , batch_size e o número de recursos no problema. Uma perda auto -supervisionada maior que 1 significa que seu modelo está reconstruindo pior do que prever a média para cada recurso, uma perda abaixo de 1 significa que o modelo está se saindo melhor do que prever a média.
Um exemplo completo pode ser encontrado dentro do notebook pretraining_example.ipynb .
/! : A implementação atual está tentando reconstruir as entradas originais, mas a normalização do lote aplica uma transformação aleatória que não pode ser deduzida por uma única linha, dificultando a reconstrução. Abaixar o batch_size pode facilitar o pré -treinamento.
Agora é possível aplicar o pipeline de aumento de dados personalizado durante o treinamento. Modelos para classificações e regressões foram adicionados no pytorch-tabnet/augmentations.py e podem ser usados como estão.
É realmente fácil salvar e rearretar um modelo treinado, isso torna a produção da Tabnet pronta.
# save tabnet model
saving_path_name = "./tabnet_model_test_1"
saved_filepath = clf.save_model(saving_path_name)
# define new model with basic parameters and load state dict weights
loaded_clf = TabNetClassifier()
loaded_clf.load_model(saved_filepath)
n_d : int (padrão = 8)
Largura da camada de previsão de decisão. Valores maiores fornecem mais capacidade ao modelo com o risco de excesso de ajuste. Os valores geralmente variam de 8 a 64.
n_a : int (padrão = 8)
Largura da atenção incorporada para cada máscara. De acordo com o papel n_d = n_a, geralmente é uma boa escolha. (padrão = 8)
n_steps : int (padrão = 3)
Número de etapas na arquitetura (geralmente entre 3 e 10)
gamma : flutuação (padrão = 1,3)
Este é o coeficiente para a reutilização de recursos nas máscaras. Um valor próximo a 1 tornará a seleção de máscara menos correlacionada entre as camadas. Os valores variam de 1,0 a 2.0.
cat_idxs : Lista de int (padrão = [] - obrigatório para incorporação)
Lista de índices de recursos categóricos.
cat_dims : Lista de int (padrão = [] - obrigatório para incorporação)
Lista de recursos categóricos Número de modalidades (número de valores exclusivos para um recurso categórico) /! Nenhuma nova modalidade pode ser prevista
cat_emb_dim : lista de int (opcional)
Lista de tamanho de incorporação para cada recurso categórico. (padrão = 1)
n_independent : int (padrão = 2)
Número de camadas independentes de unidades lineares fechadas em cada etapa. Os valores usuais variam de 1 a 5.
n_shared : int (padrão = 2)
Número de unidades lineares fechadas compartilhadas em cada etapa, os valores usuais variam de 1 a 5
epsilon : Float (padrão 1E-15)
Deve ser deixado intocado.
seed : int (padrão = 0)
Semente aleatória para reprodutibilidade
momentum : flutuar
Momentum para normalização do lote, normalmente varia de 0,01 a 0,4 (padrão = 0,02)
clip_value : float (padrão nenhum)
Se um flutuador for dado, isso prenderá o gradiente em clip_value.
lambda_sparse : float (padrão = 1e-3)
Este é o coeficiente de perda de escassez extra, conforme proposto no artigo original. Quanto maior esse coeficiente, mais escasso será o seu modelo em termos de seleção de recursos. Dependendo da dificuldade do seu problema, reduzir esse valor pode ajudar.
optimizer_fn : Torch.Optim (default = Torch.optim.adam)
Função do otimizador Pytorch
optimizer_params : dict (padrão = dict (lr = 2e-2))
Parâmetros compatíveis com otimizer_fn usados inicialize o otimizador. Como temos Adam como nosso otimizador padrão, usamos isso para definir a taxa de aprendizado inicial usada para o treinamento. Conforme mencionado no artigo original, uma grande taxa de aprendizado inicial de 0.02 com decaimento é uma boa opção.
scheduler_fn : Torch.optim.lr_scheduler (default = nenhum)
Pytorch Scheduler para alterar as taxas de aprendizado durante o treinamento.
scheduler_params : ditado
DictionNary dos parâmetros para se aplicar ao Scheduler_FN. Ex: {"gama": 0,95, "step_size": 10}
model_name : str (default = 'dreamquarktabnet')
Nome do modelo usado para salvar no disco, você pode personalizá -lo para recuperar e reutilizar facilmente seus modelos treinados.
verbose : int (padrão = 1)
Verbosidade para cadernos de notebooks, definido como 1 para ver cada época, 0 para obter nenhum.
device_name : str (padrão = 'Auto') 'CPU' para treinamento da CPU, 'GPU' para treinamento da GPU, 'Auto' para detectar automaticamente a GPU.
mask_type: str (padrão = 'Sparsemax'), "Sparsemax" ou "Entmax": esta é a função de mascaramento a ser usada para selecionar recursos.
grouped_features: list of list of ints (padrão = nenhum) Isso permite que o modelo compartilhe seu recurso de atenção dentro de um mesmo grupo. Isso pode ser especialmente útil quando o seu pré-processamento gera recursos correlacionados ou dependentes: como se você usar um TF-IDF ou um PCA em uma coluna de texto. Observe que a importância do recurso será exatamente a mesma entre os recursos do mesmo grupo. Observe também que as incorporações geradas para uma variável categórica estão sempre dentro de um mesmo grupo.
n_shared_decoder : int (default = 1)
Número de blocos de Glu compartilhados no decodificador, isso é útil apenas para TabNetPretrainer .
n_indep_decoder : int (default = 1)
Número de bloco GLU independente no decodificador, isso é útil apenas para TabNetPretrainer .
X_train : np.array ou scipy.sparse.csr_matrix
Recursos de treinamento
y_train : np.array
Metas de treinamento
eval_set : Lista de Tupla
Lista do conjunto de tupla de avaliação (x, y).
O último é usado para parar cedo
eval_name : Lista de STR
Lista de nomes de conjunto de avaliação.
eval_metric : Lista de STR
Lista de métricas de avaliação.
A última métrica é usada para parar cedo.
max_epochs : int (default = 200)
Número máximo de épocas para o trem.
patience : int (padrão = 10)
Número de épocas consecutivas sem melhorias antes de realizar a parada precoce.
Se a paciência estiver definida como 0, nenhuma parada precoce será realizada.
Observe que, se a paciência estiver ativada, os melhores pesos da melhor época serão carregados automaticamente no final do fit .
weights : int ou dict (padrão = 0)
/! Somente para o parâmetro de amostragem TabNetClassifier 0: Nenhuma amostragem 1: Amostragem automatizada com ocorrências de classe inversa Dicta: as chaves são classes, os valores são pesos para cada classe
loss_fn : Torch.loss ou lista de tocha.loss
Função de perda para treinamento (padrão para MSE para regressão e entropia cruzada para classificação) Ao usar o TabNetMultitaSkClassifier Você pode definir uma lista do mesmo comprimento que o número de tarefas, cada tarefa será atribuída sua própria função de perda
batch_size : int (padrão = 1024)
Número de exemplos por lote. Recomenda -se grandes tamanhos de lote.
virtual_batch_size : int (padrão = 128)
Tamanho dos mini lotes usados para "normalização do lote fantasma". /! virtual_batch_size deve dividir batch_size
num_workers : int (padrão = 0)
Número ou trabalhadores usados em Torch.utils.data.dataloader
drop_last : bool (padrão = false)
Se deve soltar o último lote se não for concluído durante o treinamento
callbacks : Lista de função de retorno de chamada
Lista de retornos de chamada personalizados
pretraining_ratio : Float
/! TabNetPretrainer Only : Percentage of input features to mask during pretraining.
Should be between 0 and 1. The bigger the harder the reconstruction task is.
warm_start : bool (padrão = false) para corresponder à API Scikit-Learn, isso é definido como false. Ele permite caber duas vezes no mesmo modelo e iniciar a partir de um começo quente.
compute_importance : bool (default = true)
Se deve calcular a importância do recurso
