tabnet
v4.1.0
Ceci est une implémentation Pytorch de Tabnet (Arik, So, & Pfister, T. (2019). Tabnet: Aménagement tabulaire interprétable attentif. ARXIV PRÉPRINT ARXIV: 1908.07442.) Https://arxiv.org/pdf/1908.0742.pdf. Veuillez noter que différents choix ont été faits des heures supplémentaires pour améliorer la bibliothèque qui peut différer du papier original.
Des questions? Vous voulez contribuer? Parler avec nous? Vous pouvez nous rejoindre sur Slack
Vous pouvez installer en utilisant pip ou conda comme suit.
avec pip
pip install pytorch-tabnetavec conda
conda install -c conda-forge pytorch-tabnetSi vous voulez l'utiliser localement dans un conteneur Docker:
git clone [email protected]:dreamquark-ai/tabnet.git
cd tabnet pour entrer dans le référentiel
make start à construire et à entrer dans le conteneur make start-gpu pour construire et pénétrer dans le conteneur GPU poetry install pour installer toutes les dépendances, y compris Jupyter
make notebook dans le même terminal. Vous pouvez ensuite suivre le lien vers un cahier Jupyter avec Tabnet installé.
grouped_features ). L'attention se fait maintenant au niveau du groupe et non au niveau des fonctionnalités. Ceci est particulièrement utile si un ensemble de données a de nombreuses colonnes provenant de la source unique de données (Exemple: une colonne de texte transformée à l'aide de TD-IDF).Lorsque vous contribuez au référentiel TABNET, assurez-vous d'abord de discuter de la modification que vous souhaitez apporter via un problème nouveau ou déjà existant.
Nos commits suivent les règles présentées ici.
Tabnet est désormais compatible SCIKIT, la formation d'un TabnetClassifier ou de TabNetRegressor est vraiment facile.
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 pour 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 ) Les cibles sur y_train/y_valid doivent contenir un type unique (par exemple, ils doivent tous être des chaînes ou des entiers).
Quelques métriques d'évaluation classiques sont mises en œuvre (voir plus loin pour les coutumes):
Remarque importante: «RMSLE» coupera automatiquement les prédictions négatives à 0, car le modèle peut prédire les valeurs négatives. Afin de faire correspondre les scores donnés, vous devez utiliser np.clip(clf.predict(X_predict), a_min=0, a_max=None) lors des prévisions.
Vous pouvez créer une métrique pour votre besoin spécifique. Voici un exemple de score Gini (notez que vous devez spécifier si cette métrique doit être maximisée ou non):
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 ]
)Un exemple de cahier de personnalisation spécifique est disponible ici: https://github.com/dreamquark-ai/tabnet/blob/develop/Customizing_example.ipynb
Ajouté plus tard sur le papier d'origine de Tabnet, la pré-formation semi-supervisée est désormais disponible via la 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
) La fonction de perte a été normalisée pour être indépendante de pretraining_ratio , batch_size et le nombre de fonctionnalités du problème. Une perte auto-supervisée supérieure à 1 signifie que votre modèle reconstruit pire que de prédire la moyenne pour chaque caractéristique, une perte Bellow 1 signifie que le modèle fait mieux que de prédire la moyenne.
Un exemple complet peut être trouvé dans le cahier pretraining_example.ipynb .
/! : L'implémentation actuelle essaie de reconstruire les entrées d'origine, mais la normalisation par lots applique une transformation aléatoire qui ne peut pas être déduite par une seule ligne, ce qui rend la reconstruction plus difficile. L'abaissement du batch_size pourrait faciliter la pré-entraînement.
Il est désormais possible d'appliquer le pipeline d'augmentation des données personnalisés pendant la formation. Des modèles de classificationsmote et de régressionsmote ont été ajoutés dans pytorch-tabnet/augmentations.py et peuvent être utilisés tels quels.
Il est vraiment facile d'économiser et de recharger un modèle formé, ce qui rend la production de Tabnet prête.
# 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 (par défaut = 8)
Largeur de la couche de prédiction de décision. Des valeurs plus grandes donnent plus de capacité au modèle avec le risque de sur-ajustement. Les valeurs vont généralement de 8 à 64.
n_a : int (par défaut = 8)
Largeur de l'attention incorporant pour chaque masque. Selon l'article n_d = n_a est généralement un bon choix. (par défaut = 8)
n_steps : int (par défaut = 3)
Nombre d'étapes dans l'architecture (généralement entre 3 et 10)
gamma : float (par défaut = 1,3)
Il s'agit du coefficient de réutilisation des fonctionnalités dans les masques. Une valeur proche de 1 rendra la sélection du masque la moins corrélée entre les couches. Les valeurs varient de 1,0 à 2,0.
cat_idxs : LISTE DE INT (Default = [] - Obligatoire pour les incorporations)
Liste des indices de fonctionnalités catégorielles.
cat_dims : LISTE DE INT (Default = [] - Obligatoire pour les incorporations)
Liste des fonctionnalités catégorielles Nombre de modalités (nombre de valeurs uniques pour une fonctionnalité catégorique) /! Aucune nouvelle modalité ne peut être prédite
cat_emb_dim : Liste d'int (facultatif)
Liste de la taille des intérêts pour chaque fonctionnalité catégorique. (par défaut = 1)
n_independent : int (par défaut = 2)
Nombre de couches d'unités linéaires fermées indépendantes à chaque étape. Les valeurs habituelles varient de 1 à 5.
n_shared : int (par défaut = 2)
Nombre d'unités linéaires fermées partagées à chaque étape Les valeurs habituelles varient de 1 à 5
epsilon : float (par défaut 1E-15)
Devrait être laissé intact.
seed : int (par défaut = 0)
Graines aléatoires pour la reproductibilité
momentum : flotter
L'élan pour la normalisation par lots, varie généralement de 0,01 à 0,4 (par défaut = 0,02)
clip_value : float (non par défaut)
Si un flotteur est donné, cela fera couper le gradient de clip_value.
lambda_sparse : float (default = 1e-3)
Il s'agit du coefficient de perte de rareté supplémentaire comme proposé dans le document d'origine. Plus ce coefficient est grand, plus votre modèle sera plus claire en termes de sélection des fonctionnalités. Selon la difficulté de votre problème, la réduction de cette valeur pourrait aider.
optimizer_fn : torch.optim (default = torch.optim.adam)
Fonction d'optimiseur Pytorch
optimizer_params : dict (default = dict (lr = 2e-2))
Paramètres compatibles avec Optimizer_FN utilisé Initialize l'optimiseur. Puisque nous avons Adam comme optimiseur par défaut, nous l'utilisons pour définir le taux d'apprentissage initial utilisé pour la formation. Comme mentionné dans l'article d'origine, un grand taux d'apprentissage initial de 0.02 avec désintégration est une bonne option.
scheduler_fn : torch.optim.lr_scheduler (default = Aucun)
Pytorch Scheduler pour modifier les taux d'apprentissage pendant la formation.
scheduler_params : dict
DictionNary of Paramètres à s'appliquer à la planificateur_fn. Ex: {"Gamma": 0,95, "Step_Size": 10}
model_name : str (default = 'dreamquarktabnet')
Nom du modèle utilisé pour enregistrer dans le disque, vous pouvez le personnaliser pour récupérer et réutiliser facilement vos modèles formés.
verbose : int (par défaut = 1)
Verbosité pour les tracés des cahiers, réglé sur 1 pour voir chaque époque, 0 pour n'en obtenir aucune.
device_name : str (default = 'auto') 'CPU' pour la formation CPU, 'GPU' pour la formation GPU, 'Auto' pour détecter automatiquement GPU.
mask_type: str (default = 'sparsemax') "SparsEMAX" ou "Entmax": il s'agit de la fonction de masquage à utiliser pour sélectionner des fonctionnalités.
grouped_features: list of list of ints (Default = None) Cela permet au modèle de partager sa fonction d'attention d'attention dans un même groupe. Cela peut être particulièrement utile lorsque votre prétraitement génère des fonctionnalités corrélées ou dépendantes: comme si vous utilisez un TF-IDF ou un PCA sur une colonne de texte. Notez que l'importance des fonctionnalités sera exactement la même entre les fonctionnalités d'un même groupe. Veuillez également noter que les intégres générés pour une variable catégorique sont toujours à l'intérieur d'un même groupe.
n_shared_decoder : int (par défaut = 1)
Nombre de blocs Glu partagés dans Decoder, ce n'est utile que pour TabNetPretrainer .
n_indep_decoder : int (par défaut = 1)
Nombre de blocs GLU indépendants dans le décodeur, cela n'est utile que pour TabNetPretrainer .
X_train : np.array ou scipy.sparse.csr_matrix
Caractéristiques de formation
y_train : np.array
Cibles de formation
eval_set : Liste des tuple
Liste de l'évaluation des Tuple (x, y).
Le dernier est utilisé pour l'arrêt anticipé
eval_name : LISTE DE STR
Liste des noms d'évaluation des évaluations.
eval_metric : LISTE DE STR
Liste des mesures d'évaluation.
La dernière métrique est utilisée pour l'arrêt anticipé.
max_epochs : int (par défaut = 200)
Nombre maximum d'époches pour le train.
patience : int (par défaut = 10)
Nombre d'époches consécutives sans amélioration avant d'effectuer un arrêt anticipé.
Si la patience est définie sur 0, aucun arrêt précoce ne sera effectué.
Notez que si la patience est activée, les meilleurs poids de la meilleure époque seront automatiquement chargés à la fin de fit .
weights : int ou dict (par défaut = 0)
/! Seulement pour tabnetclassifier le paramètre 0: pas d'échantillonnage 1: Échantillonnage automatisé avec des occurrences de classe inverse Dict: les clés sont des classes, les valeurs sont des poids pour chaque classe
loss_fn : torch.loss ou liste de torch.loss
Fonction de perte pour la formation (par défaut à MSE pour la régression et l'entropie croisée pour la classification) Lorsque vous utilisez tabnetMultitaskClassifier, vous pouvez définir une liste de la même longueur que le nombre de tâches, chaque tâche se verra attribuer sa propre fonction de perte
batch_size : int (par défaut = 1024)
Nombre d'exemples par lot. De grandes tailles de lots sont recommandées.
virtual_batch_size : int (default = 128)
Taille des mini lots utilisés pour la "normalisation des lots fantômes". /! virtual_batch_size devrait diviser batch_size
num_workers : int (par défaut = 0)
Numéro ou travailleurs utilisés dans torch.utils.data.dataloader
drop_last : bool (default = false)
S'il faut tomber le dernier lot s'il n'est pas terminé pendant l'entraînement
callbacks : liste de la fonction de rappel
Liste des rappels personnalisés
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 (default = false) Afin de faire correspondre l'API Scikit-Learn, ceci est défini sur false. Il permet d'adapter deux fois par le même modèle et de commencer à partir d'un démarrage chaud.
compute_importance : bool (default = true)
S'il faut calculer l'importance des fonctionnalités
