tabnet
v4.1.0
Esta es una implementación de Pytorch de Tabnet (Arik, So y Pfister, T. (2019). Tabnet: Atento aprendizaje tabular interpretable. ARXIV Preprint ARXIV: 1908.07442.) Https://arxiv.org/pdf/1908.07442.pdf. Tenga en cuenta que se han realizado algunas opciones extra para mejorar la biblioteca, lo que puede diferir del papel orginal.
¿Alguna pregunta? ¿Quieres contribuir? Para hablar con nosotros? Puedes unirte a nosotros en Slack
Puede instalar usando pip o conda de la siguiente manera.
con Pip
pip install pytorch-tabnetcon conda
conda install -c conda-forge pytorch-tabnetSi se reduce a usarlo localmente dentro de un contenedor Docker:
git clone [email protected]:dreamquark-ai/tabnet.git
cd tabnet para entrar en el repositorio
make start a construir y entrar en el contenedor make start-gpu se construya y entra en el contenedor de GPU poetry install para instalar todas las dependencias, incluido Jupyter
make notebook dentro del mismo terminal. Luego puede seguir el enlace a un cuaderno Jupyter con TabNet instalado.
grouped_features ). La atención ahora se realiza a nivel de grupo y no a nivel de características. Esto es especialmente útil si un conjunto de datos tiene muchas columnas provenientes de una sola fuente de datos (Exemple: una columna de texto transformada usando TD-IDF).Al contribuir al repositorio de TabNet, asegúrese de discutir primero el cambio que desea hacer a través de un problema nuevo o ya existente.
Nuestros compromisos siguen las reglas presentadas aquí.
TabNet ahora es compatible con Scikit, el entrenamiento de un Clasifier de TabNet o TabNetRegor es realmente fácil.
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 )o para TABNetMultTItaskClassifier:
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 ) Los objetivos en y_train/y_valid deben contener un tipo único (por ejemplo, todas deben ser cadenas o enteros).
Se implementan algunas métricas de evaluación clásica (ver más a continuación para las personalizadas):
Nota importante: 'RMSLE' recortará automáticamente las predicciones negativas a 0, porque el modelo puede predecir valores negativos. Para que coincida con los puntajes dados, debe usar np.clip(clf.predict(X_predict), a_min=0, a_max=None) al hacer predicciones.
Puede crear una métrica para su necesidad específica. Aquí hay un ejemplo para la puntuación de Gini (tenga en cuenta que debe especificar si esta métrica debe maximizarse o no):
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 ]
)Aquí está disponible un cuaderno de ejemplo de personalización específico: https://github.com/dreamquark-ai/tabnet/blob/develop/customizing_example.ipynb
Agregado más tarde al documento original de Tabnet, el pre-entrenamiento semi-supervisado ahora está disponible a través de la clase 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 función de pérdida se ha normalizado para ser independiente de pretraining_ratio , batch_size y el número de características en el problema. Una pérdida auto supervisada mayor que 1 significa que su modelo se está reconstruyendo peor que predecir la media para cada característica, una pérdida a continuación 1 significa que el modelo está mejor que predecir la media.
Se puede encontrar un ejemplo completo dentro del cuaderno pretraining_example.ipynb .
/. Bajar el batch_size podría facilitar el pretratamiento.
Ahora es posible aplicar la tubería de aumento de datos personalizados durante la capacitación. Las plantillas para clasificaciones se han agregado y regresiones se han agregado en pytorch-tabnet/augmentations.py y se pueden usar como está.
Es realmente fácil guardar y volver a cargar un modelo capacitado, esto hace que la producción de TabNet sea lista.
# 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)
Ancho de la capa de predicción de decisión. Los valores más grandes brindan más capacidad al modelo con el riesgo de sobreajustar. Los valores generalmente varían de 8 a 64.
n_a : int (predeterminado = 8)
Ancho de la atención incrustada para cada máscara. De acuerdo con el documento, N_D = N_A suele ser una buena opción. (predeterminado = 8)
n_steps : int (default = 3)
Número de pasos en la arquitectura (generalmente entre 3 y 10)
gamma : float (predeterminado = 1.3)
Este es el coeficiente para la reutilización de características en las máscaras. Un valor cercano a 1 hará que la selección de máscara se correlacione menos entre las capas. Los valores varían de 1.0 a 2.0.
cat_idxs : Lista de int (default = [] - obligatorio para incrustaciones)
Lista de índices de características categóricas.
cat_dims : Lista de int (default = [] - obligatorio para incrustaciones)
Lista de características categóricas Número de modalidades (número de valores únicos para una característica categórica) /! ! No se pueden predecir nuevas modalidades
cat_emb_dim : Lista de int (opcional)
Lista de tamaño de incrustaciones para cada características categóricas. (predeterminado = 1)
n_independent : int (default = 2)
Número de capas de unidades lineales cerradas independientes en cada paso. Los valores habituales varían de 1 a 5.
n_shared : int (default = 2)
Número de unidades lineales cerradas compartidas en cada paso Los valores habituales varían de 1 a 5
epsilon : Float (predeterminado 1E-15)
Debe dejarse intacto.
seed : int (predeterminado = 0)
Semilla aleatoria para la reproducibilidad
momentum : flotante
Momento para la normalización por lotes, generalmente varía de 0.01 a 0.4 (predeterminado = 0.02)
clip_value : Float (Ninguno predeterminado)
Si se le da un flotador, esto recortará el gradiente en clip_value.
lambda_sparse : float (default = 1e-3)
Este es el coeficiente de pérdida de dispersión adicional como se propuso en el documento original. Cuanto mayor sea este coeficiente, más escaso su modelo será en términos de selección de características. Dependiendo de la dificultad de su problema, reducir este valor podría ayudar.
optimizer_fn : Torch.optim (default = Torch.optim.adam)
Función de optimizador de pytorch
optimizer_params : dict (default = dict (lr = 2e-2))
Parámetros compatibles con Optimizer_FN utilizados Inicializar el optimizador. Como tenemos a Adam como nuestro optimizador predeterminado, usamos esto para definir la tasa de aprendizaje inicial utilizada para la capacitación. Como se mencionó en el documento original, una gran tasa de aprendizaje inicial de 0.02 con descomposición es una buena opción.
scheduler_fn : torch.optim.lr_scheduler (default = none)
Pytorch Scheduler cambiará las tasas de aprendizaje durante la capacitación.
scheduler_params : dict
DictionNary de parámetros para aplicar al Scheduler_FN. Ej: {"gamma": 0.95, "step_size": 10}
model_name : str (default = 'dreamquarktabnet')
Nombre del modelo utilizado para guardar en el disco, puede personalizarlo para recuperar y reutilizar fácilmente sus modelos capacitados.
verbose : int (predeterminado = 1)
Verbosidad para las tramas de cuadernos, establecido en 1 para ver cada época, 0 para obtener ninguna.
device_name : str (default = 'auto') 'CPU' para capacitación en CPU, 'GPU' para entrenamiento de GPU, 'Auto' para detectar automáticamente GPU.
mask_type: str (default = 'sparsemax') ya sea "Sparsemax" o "Entmax": esta es la función de enmascaramiento para usar para seleccionar características.
grouped_features: list of list of ints (default = None) Esto permite al modelo compartir su función de atención dentro de un mismo grupo. Esto puede ser especialmente útil cuando su preprocesamiento genera características correlacionadas o dependientes: como si usa un TF-IDF o un PCA en una columna de texto. Tenga en cuenta que la importancia de la característica será exactamente la misma entre las características en un mismo grupo. Tenga en cuenta también que los incrustaciones generados para una variable categórica siempre están dentro de un mismo grupo.
n_shared_decoder : int (default = 1)
Número de bloque GLU compartido en el decodificador, esto solo es útil para TabNetPretrainer .
n_indep_decoder : int (default = 1)
Número de bloque Glu Glu independiente en el decodificador, esto solo es útil para TabNetPretrainer .
X_train : np.array o scipy.sparse.csr_matrix
Características de entrenamiento
y_train : np.array
Objetivos de entrenamiento
eval_set : lista de tupla
Lista del conjunto de Tuple Eval (X, Y).
El último se usa para detener temprano
eval_name : lista de STR
Lista de nombres de configuración eval.
eval_metric : lista de STR
Lista de métricas de evaluación.
La última métrica se usa para detener temprano.
max_epochs : int (default = 200)
Número máximo de épocas para Trainng.
patience : int (predeterminado = 10)
Número de épocas consecutivas sin mejoras antes de realizar una parada temprana.
Si la paciencia se establece en 0, entonces no se realizará una parada temprana.
Tenga en cuenta que si la paciencia está habilitada, entonces los mejores pesos de la mejor época se cargarán automáticamente al final del fit .
weights : int o dict (predeterminado = 0)
/
loss_fn : torch.loss o lista de antorch.loss
Función de pérdida para el entrenamiento (predeterminado a MSE para la regresión y la entropía cruzada para la clasificación) Cuando se usa TABNetMultTaskClassifier, puede establecer una lista de la misma longitud que el número de tareas, a cada tarea se le asignará su propia función de pérdida
batch_size : int (default = 1024)
Número de ejemplos por lote. Se recomiendan grandes tamaños de lotes.
virtual_batch_size : int (default = 128)
Tamaño de los mini lotes utilizados para la "normalización de lotes de fantasmas". /! virtual_batch_size debería dividir batch_size
num_workers : int (default = 0)
Número o trabajadores utilizados en Torch.utils.data.dataloader
drop_last : bool (predeterminado = falso)
Si dejar caer el último lote si no está completo durante el entrenamiento
callbacks : lista de la función de devolución de llamada
Lista de devoluciones de llamada personalizadas
pretraining_ratio : flotante
/! 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) Para que coincida con la API Scikit-Learn, esto se establece en False. Permite caber el doble del mismo modelo y comenzar desde un comienzo cálido.
compute_importance : bool (default = true)
Si calcular la importancia de la característica
