def apply_test_data():
data, test_data, cat_col_names, num_col_names = data_load()
bsize = 2500 * 3 * 2 * 2
data_config = DataConfig(target=["target"],
continuous_cols=num_col_names,
categorical_cols=cat_col_names,
num_workers=4)
trainer_config = TrainerConfig(auto_lr_find=True,
batch_size=bsize,
max_epochs=100,
gpus=1)
optimizer_config = OptimizerConfig()
model_config = TabNetModelConfig(task="classification",
learning_rate=1e-3 * bsize / 1024,
n_d=24,
n_a=24,
n_steps=5,
gamma=1.3)
tabular_mode = TabularModel(data_config=data_config,
optimizer_config=optimizer_config,
model_config=model_config,
trainer_config=trainer_config)
for i in range(10):
diri = f"Analysis/basic_tabnet_rep{i}"
tabular_mode.load_from_checkpoint(dir=diri)
def test_save_load(
regression_data,
model_config_class,
continuous_cols,
categorical_cols,
custom_metrics,
custom_loss,
custom_optimizer,
tmpdir,
):
(train, test, target) = regression_data
data_config = DataConfig(
target=target,
continuous_cols=continuous_cols,
categorical_cols=categorical_cols,
)
model_config_class, model_config_params = model_config_class
model_config_params["task"] = "regression"
model_config = model_config_class(**model_config_params)
trainer_config = TrainerConfig(
max_epochs=3,
checkpoints=None,
early_stopping=None,
gpus=None,
fast_dev_run=True,
)
optimizer_config = OptimizerConfig()
tabular_model = TabularModel(
data_config=data_config,
model_config=model_config,
optimizer_config=optimizer_config,
trainer_config=trainer_config,
)
tabular_model.fit(
train=train,
test=test,
metrics=custom_metrics,
loss=custom_loss,
optimizer=custom_optimizer,
optimizer_params={},
)
result_1 = tabular_model.evaluate(test)
# sv_dir = tmpdir/"save_model"
# sv_dir.mkdir(exist_ok=True, parents=True)
sv_dir = tmpdir.mkdir("saved_model")
tabular_model.save_model(str(sv_dir))
new_mdl = TabularModel.load_from_checkpoint(str(sv_dir))
result_2 = new_mdl.evaluate(test)
assert (result_1[0][f"test_{tabular_model.model.hparams.metrics[0]}"] ==
result_2[0][f"test_{new_mdl.model.hparams.metrics[0]}"])
def load_model(path=""):
global model, session
import cloudpickle as pickle
model0 = pickle.load(open(path + '/model/model.pkl', mode='rb'))
model = Model() # Empty model
model.model_pars = model0.model_pars
model.compute_pars = model0.compute_pars
model.data_pars = model0.data_pars
### Custom part
# model.model = TabularModel.load_from_checkpoint( "ztmp/data/output/torch_tabular/torch_checkpoint")
model.model = TabularModel.load_from_checkpoint( path +"/model/torch_checkpoint")
session = None
return model, session
], #target should always be a list. Multi-targets are only supported for regression. Multi-Task Classification is not implemented
continuous_cols=num_col_names,
categorical_cols=cat_col_names,
)
trainer_config = TrainerConfig(
auto_lr_find=
True, # Runs the LRFinder to automatically derive a learning rate
batch_size=1024,
max_epochs=100,
gpus=1, #index of the GPU to use. 0, means CPU
)
optimizer_config = OptimizerConfig()
model_config = CategoryEmbeddingModelConfig(
task="classification",
layers="1024-512-512", # Number of nodes in each layer
activation="LeakyReLU", # Activation between each layers
learning_rate=1e-3)
tabular_model = TabularModel(
data_config=data_config,
model_config=model_config,
optimizer_config=optimizer_config,
trainer_config=trainer_config,
)
tabular_model.fit(train=train, validation=val)
result = tabular_model.evaluate(test)
pred_df = tabular_model.predict(test)
tabular_model.save_model("Analysis/basic")
loaded_model = TabularModel.load_from_checkpoint("Analysis/basic")
def test_pretrained_backbone(
regression_data,
model_config_class,
continuous_cols,
categorical_cols,
custom_metrics,
custom_loss,
custom_optimizer,
tmpdir,
):
(train, test, target) = regression_data
data_config = DataConfig(
target=target,
continuous_cols=continuous_cols,
categorical_cols=categorical_cols,
)
model_config_class, model_config_params = model_config_class
model_config_params["task"] = "ssl"
model_config_params["ssl_task"] = "Denoising"
model_config_params["aug_task"] = "cutmix"
model_config = model_config_class(**model_config_params)
trainer_config = TrainerConfig(
max_epochs=3,
checkpoints=None,
early_stopping=None,
gpus=None,
fast_dev_run=True,
)
optimizer_config = OptimizerConfig()
tabular_model = TabularModel(
data_config=data_config,
model_config=model_config,
optimizer_config=optimizer_config,
trainer_config=trainer_config,
)
tabular_model.fit(
train=train,
test=test,
metrics=custom_metrics,
loss=custom_loss,
optimizer=custom_optimizer,
optimizer_params={},
)
result_1 = tabular_model.evaluate(test)
with pytest.raises(AssertionError):
tabular_model.predict(test)
assert "test_mean_squared_error" in result_1[0].keys()
sv_dir = tmpdir.mkdir("saved_model")
tabular_model.save_model(str(sv_dir))
old_mdl = TabularModel.load_from_checkpoint(str(sv_dir))
model_config_params["task"] = "regression"
model_config_params["ssl_task"] = None
model_config_params["aug_task"] = None
model_config = model_config_class(**model_config_params)
trainer_config = TrainerConfig(
max_epochs=1,
checkpoints=None,
early_stopping=None,
gpus=None,
fast_dev_run=True,
)
tabular_model = TabularModel(
data_config=data_config,
model_config=model_config,
optimizer_config=optimizer_config,
trainer_config=trainer_config,
)
tabular_model.fit(
train=train,
test=test,
metrics=custom_metrics,
loss=custom_loss,
optimizer=custom_optimizer,
optimizer_params={},
trained_backbone=old_mdl.model.backbone,
)
result_2 = tabular_model.evaluate(test)
assert "test_mean_squared_error" in result_2[0].keys()
