tabnet
v4.1.0
Dies ist eine Pytorch -Implementierung von Tabnet (Arik, SO, & Pfister, T. (2019). Tabnet: aufmerksam interpretierbares tabellarisches Lernen. Arxiv Preprint Arxiv: 1908.07442.) Https://arxiv.org/pdf/1908.074442.pdf. Bitte beachten Sie, dass einige verschiedene Auswahlmöglichkeiten über die Zeit getroffen wurden, um die Bibliothek zu verbessern, die sich vom Orginalpapier unterscheiden können.
Irgendwelche Fragen? Willst du einen Beitrag leisten? Mit uns sprechen? Sie können sich uns auf Slack anschließen
Sie können wie folgt mit pip oder conda installieren.
mit Pip
pip install pytorch-tabnetmit Conda
conda install -c conda-forge pytorch-tabnetWenn Sie es lokal in einem Docker -Container verwenden möchten:
git clone [email protected]:dreamquark-ai/tabnet.git
cd tabnet , um im Repository zu gelangen
make start zu bauen und in den Behälter zu gelangen make start-gpu um den GPU-Container zu bauen und in den GPU-Container zu gelangen poetry install , um alle Abhängigkeiten, einschließlich Jupyter, zu installieren
make notebook im selben Terminal. Sie können dann den Link zu einem Jupyter -Notizbuch mit installiertem Tabnet folgen.
grouped_features ). Die Aufmerksamkeit erfolgt nun auf Gruppenebene und nicht auf Feature -Level. Dies ist besonders nützlich, wenn ein Datensatz viele Spalten enthält, die von einer einzelnen Datenquelle stammen (Exempl: Eine Textspalte, die mit TD-IDF transformiert wird).Wenn Sie zum Tabnet -Repository beitragen, besprechen Sie bitte zunächst die Änderung, die Sie über ein neues oder bereits vorhandenes Problem vornehmen möchten.
Unsere Commits folgen den hier vorgestellten Regeln.
TABNET ist jetzt scikit-kompatibel, trainiert ein tabNetClassifier oder tabNetRegressor wirklich einfach.
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 )oder für 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 ) Die Ziele auf y_train/y_valid sollten einen eindeutigen Typ enthalten (z. B. müssen sie alle Saiten oder Ganzzahlen sein).
Es werden einige klassische Bewertungsmetriken implementiert (siehe weiter unten für benutzerdefinierte):
Wichtiger Hinweis: 'RMSLE' wird negative Vorhersagen automatisch auf 0 übertragen, da das Modell negative Werte vorhersagen kann. Um die angegebenen Bewertungen abzustimmen, müssen Sie bei Vorhersagen np.clip(clf.predict(X_predict), a_min=0, a_max=None) verwenden.
Sie können eine Metrik für Ihr spezifisches Bedürfnis erstellen. Hier ist ein Beispiel für Gini -Score (beachten Sie, dass Sie angeben müssen, ob diese Metrik maximiert werden sollte oder nicht):
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 ]
)Ein spezifisches Anpassungsbeispiel-Notizbuch ist hier verfügbar: https://github.com/dreamquark-ai/tabnet/blob/develop/customizing_example.ipynb
Später zum Originalpapier von tabNet fügte sich die halbüberwachende Vorausbildung über den Unterrichtsklassen TabNetPretrainer zur Verfügung:
# 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
) Die Verlustfunktion wurde so normalisiert, dass sie unabhängig von pretraining_ratio , batch_size und der Anzahl der Merkmale im Problem ist. Ein selbst beaufsichtigter Verlust von mehr als 1 bedeutet, dass Ihr Modell schlechter rekonstruiert, als den Mittelwert für jedes Merkmal vorherzusagen. Ein Verlust brüll 1 bedeutet, dass das Modell besser abschneidet, als den Mittelwert vorherzusagen.
Ein vollständiges Beispiel finden Sie in der Notebook pretraining_example.ipynb .
/! Durch das Absenken der batch_size kann die Vorabstreichung erleichtert werden.
Während des Trainings ist es jetzt möglich, benutzerdefinierte Datenvergrößerungspipeline anzuwenden. Vorlagen für Klassifizierungenmote und Regressionsmote wurden in pytorch-tabnet/augmentations.py hinzugefügt und können so verwendet werden.
Es ist wirklich einfach, ein geschultes Modell zu speichern und neu zu laden. Dadurch wird die Tabnet-Produktion bereit.
# 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 (default = 8)
Breite der Entscheidungsvorhersageschicht. Größere Werte verleihen dem Modell mit dem Risiko einer Überanpassung mehr Kapazität. Die Werte reichen typischerweise zwischen 8 und 64.
n_a : int (default = 8)
Breite der Aufmerksamkeit, die für jede Maske einbettet. Nach dem Papier ist n_d = n_a normalerweise eine gute Wahl. (Standard = 8)
n_steps : int (default = 3)
Anzahl der Schritte in der Architektur (normalerweise zwischen 3 und 10)
gamma : float (Standard = 1,3)
Dies ist der Koeffizient für die Merkmalsreusage in den Masken. Ein Wert in der Nähe von 1 wird die Maskenauswahl zwischen den Schichten am wenigsten korrelieren. Die Werte reichen von 1,0 bis 2,0.
cat_idxs : Liste von int (default = [] - obligatorisch für Einbettungen)
Liste der kategorialen Merkmale.
cat_dims : Liste von int (default = [] - obligatorisch für Einbettungen)
Liste der kategorialen Merkmale Anzahl der Modalitäten (Anzahl der eindeutigen Werte für eine kategoriale Funktion) /! Können keine neuen Modalitäten vorhergesagt werden
cat_emb_dim : Liste von int (optional)
Liste der Einbettungsgröße für jede kategoriale Merkmale. (Standard = 1)
n_independent : int (default = 2)
Anzahl der unabhängigen schenkten linearen Einheiten in jedem Schritt. Die üblichen Werte reichen von 1 bis 5.
n_shared : int (default = 2)
Die Anzahl der gemeinsam genutzten linearen Einheiten in jedem Schritt Die üblichen Werte reichen von 1 bis 5
epsilon : Float (Standard 1E-15)
Sollte unberührt bleiben.
seed : int (default = 0)
Zufälliger Samen für die Reproduzierbarkeit
momentum : Float
Impuls für die Batch -Normalisierung reicht typischerweise zwischen 0,01 und 0,4 (Standard = 0,02)
clip_value : float (Standard keine)
Wenn ein Float angegeben wird, wird der Gradient bei clip_value abgeschnitten.
lambda_sparse : float (default = 1e-3)
Dies ist der im Originalpapier vorgeschlagene zusätzliche Sparsity -Verlustkoeffizient. Je größer dieser Koeffizient ist, desto sparsamer ist Ihr Modell in Bezug auf die Feature -Auswahl. Abhängig von der Schwierigkeit Ihres Problems kann es helfen, diesen Wert zu verringern.
optimizer_fn : fackel.optim (default = t Torch.optim.adam)
Pytorch -Optimiererfunktion
optimizer_params : dict (default = dict (LR = 2E-2))
Mit optimizer_fn kompatibel Parameter initialisieren Sie den Optimierer. Da wir Adam als Standard -Optimierer haben, verwenden wir dies, um die anfängliche Lernrate für das Training zu definieren. Wie im Originalpapier erwähnt, ist eine große anfängliche Lernrate von 0.02 mit Zerfall eine gute Option.
scheduler_fn : Torch.optim.lr_scheduler (default = none)
Pytorch -Scheduler, um die Lernraten während des Trainings zu ändern.
scheduler_params : Diktat
DictionNary of Parameters für den Scheduler_FN. Ex: {"Gamma": 0,95, "Step_size": 10}
model_name : str (default = 'DreamQugtabnet')
Name des Modells zum Speichern in der Festplatte können Sie dies anpassen, um Ihre geschulten Modelle problemlos abzurufen und wiederzuverwenden.
verbose : int (default = 1)
Ausführlichkeit für Notizbücher -Diagramme, auf 1 gesetzt, um jede Epoche zu sehen, 0, um keine zu bekommen.
device_name : STR (default = 'auto') 'CPU' für CPU -Training, 'GPU' für GPU -Training, automatisch, um GPU automatisch zu erkennen.
mask_type: str (default = 'sparsemax') entweder "sparsemax" oder "entmax": Dies ist die Maskierungsfunktion für die Auswahl von Funktionen.
grouped_features: list of list of ints (Standard = None) Auf diese Weise kann das Modell die Aufmerksamkeitsbeschaffungsfunktion in einer gleichen Gruppe teilen. Dies kann besonders nützlich sein, wenn Ihre Vorverarbeitung korrelierte oder abhängige Funktionen erzeugt: wie bei Verwendung eines TF-IDF oder einer PCA in einer Textspalte. Beachten Sie, dass die Wichtigkeit der Funktionen zwischen den Funktionen derselben Gruppe genau gleich ist. Bitte beachten Sie auch, dass die für eine kategorialen Variablen generierten Einbettungsdings immer in derselben Gruppe befinden.
n_shared_decoder : int (default = 1)
Anzahl der gemeinsam genutzten Glu -Blocks im Decoder. Dies ist nur für TabNetPretrainer nützlich.
n_indep_decoder : int (default = 1)
Anzahl der unabhängigen Glu -Blocks im Decoder. Dies ist nur für TabNetPretrainer nützlich.
X_train : np.array oder scipy.sparse.csr_matrix
Trainingsmerkmale
y_train : np.Array
Trainingsziele
eval_set : Liste der Tupel
Liste des Eval -Tupel -Satzes (x, y).
Der letzte wird zum frühen Stopp verwendet
eval_name : Liste von str
Liste der Bewertungsnamen.
eval_metric : Liste von str
Liste der Bewertungsmetriken.
Die letzte Metrik wird zum frühen Stopp verwendet.
max_epochs : int (default = 200)
Maximale Anzahl von Epochen für Training.
patience : int (Standard = 10)
Anzahl der aufeinanderfolgenden Epochen ohne Verbesserung, bevor Sie frühzeitig anhalten.
Wenn die Geduld auf 0 eingestellt ist, wird kein frühes Stoppen durchgeführt.
Beachten Sie, dass die besten Gewichte von der besten Epoche am Ende der fit automatisch geladen werden, wenn die Geduld aktiviert ist.
weights : int oder dict (default = 0)
/! Nur für tabNetClassifier -Sampling -Parameter 0: Keine Abtastung 1: Automatisierte Abtastung mit inversen Klassenvorkommen DICT: Tasten sind Klassen, Werte sind Gewichte für jede Klasse
loss_fn : TORCH.USS ODER LISTE VON TORCH.LOSS
Verlustfunktion für das Training (standardmäßig für Regression und Kreuzentropie für die Klassifizierung) Bei Verwendung von TabNetMultitaskClassifier können Sie eine Liste derselben Länge wie die Anzahl der Aufgaben festlegen. Jede Aufgabe wird ihre eigene Verlustfunktion zugewiesen
batch_size : int (default = 1024)
Anzahl der Beispiele pro Charge. Es werden große Chargengrößen empfohlen.
virtual_batch_size : int (default = 128)
Größe der Mini -Chargen, die für die Normalisierung der Ghost -Stapel verwendet werden. /! virtual_batch_size sollte batch_size teilen
num_workers : int (default = 0)
Nummer oder Arbeiter, die in Torch.utils.data.Dataloader verwendet werden
drop_last : bool (default = false)
Ob Sie die letzte Stapel fallen lassen, wenn Sie während des Trainings nicht abgeschlossen sind
callbacks : Liste der Rückruffunktion
Liste der benutzerdefinierten Rückrufe
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) Um die Scikit-Learn-API zu übereinstimmen, ist dies auf false festgelegt. Es ermöglicht das zweimals gleiche Modell und startet von einem warmen Start.
compute_importance : bool (default = true)
Ob die Merkmals Bedeutung berechnet werden soll
