def test_fit_methods(
X_wide,
X_deep,
target,
method,
X_wide_test,
X_deep_test,
X_test,
pred_dim,
probs_dim,
):
wide = Wide(np.unique(X_wide).shape[0], pred_dim)
deepdense = DeepDense(
hidden_layers=[32, 16],
dropout=[0.5, 0.5],
deep_column_idx=deep_column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
model = WideDeep(wide=wide, deepdense=deepdense, pred_dim=pred_dim)
model.compile(method=method, verbose=0)
model.fit(X_wide=X_wide, X_deep=X_deep, target=target)
preds = model.predict(X_wide=X_wide, X_deep=X_deep, X_test=X_test)
if method == "binary":
pass
else:
probs = model.predict_proba(X_wide=X_wide,
X_deep=X_deep,
X_test=X_test)
assert preds.shape[0] == 100, probs.shape[1] == probs_dim
def test_initializers_with_pattern():
wide = Wide(100, 1)
deeptabular = TabMlp(
mlp_hidden_dims=[32, 16],
mlp_dropout=[0.5, 0.5],
column_idx=column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
deeptext = DeepText(vocab_size=vocab_size, embed_dim=32, padding_idx=0)
model = WideDeep(wide=wide,
deeptabular=deeptabular,
deeptext=deeptext,
pred_dim=1)
cmodel = c(model)
org_word_embed = []
for n, p in cmodel.named_parameters():
if "word_embed" in n:
org_word_embed.append(p)
trainer = Trainer(model,
objective="binary",
verbose=0,
initializers=initializers_2)
init_word_embed = []
for n, p in trainer.model.named_parameters():
if "word_embed" in n:
init_word_embed.append(p)
assert torch.all(org_word_embed[0] == init_word_embed[0].cpu())
def test_initializers_with_pattern():
wide = Wide(100, 1)
deepdense = DeepDense(
hidden_layers=[32, 16],
dropout=[0.5, 0.5],
deep_column_idx=deep_column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
deeptext = DeepText(vocab_size=vocab_size, embed_dim=32, padding_idx=0)
model = WideDeep(wide=wide,
deepdense=deepdense,
deeptext=deeptext,
pred_dim=1)
cmodel = c(model)
org_word_embed = []
for n, p in cmodel.named_parameters():
if "word_embed" in n:
org_word_embed.append(p)
model.compile(method="binary", verbose=0, initializers=initializers_2)
init_word_embed = []
for n, p in model.named_parameters():
if "word_embed" in n:
init_word_embed.append(p)
assert torch.all(org_word_embed[0] == init_word_embed[0].cpu())
def test_model_checkpoint(save_best_only, max_save, n_files):
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(
mlp_hidden_dims=[32, 16],
mlp_dropout=[0.5, 0.5],
column_idx=column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
model = WideDeep(wide=wide, deeptabular=deeptabular)
trainer = Trainer(
model=model,
objective="binary",
callbacks=[
ModelCheckpoint(
"tests/test_model_functioning/weights/test_weights",
save_best_only=save_best_only,
max_save=max_save,
)
],
verbose=0,
)
trainer.fit(X_wide=X_wide, X_tab=X_tab, target=target, n_epochs=5, val_split=0.2)
n_saved = len(os.listdir("tests/test_model_functioning/weights/"))
shutil.rmtree("tests/test_model_functioning/weights/")
assert n_saved <= n_files
def test_basic_run_with_metrics_multiclass():
wide = Wide(np.unique(X_wide).shape[0], 3)
deeptabular = TabMlp(
mlp_hidden_dims=[32, 16],
mlp_dropout=[0.5, 0.5],
column_idx={k: v
for v, k in enumerate(colnames)},
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
model = WideDeep(wide=wide, deeptabular=deeptabular, pred_dim=3)
trainer = Trainer(model,
objective="multiclass",
metrics=[Accuracy],
verbose=False)
trainer.fit(
X_wide=X_wide,
X_tab=X_tab,
target=target_multi,
n_epochs=1,
batch_size=16,
val_split=0.2,
)
assert ("train_loss" in trainer.history.keys()
and "train_acc" in trainer.history.keys())
def test_fit_objectives(
X_wide,
X_tab,
target,
objective,
X_wide_test,
X_tab_test,
X_test,
pred_dim,
probs_dim,
):
wide = Wide(np.unique(X_wide).shape[0], pred_dim)
deeptabular = TabMlp(
mlp_hidden_dims=[32, 16],
mlp_dropout=[0.5, 0.5],
column_idx=column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
model = WideDeep(wide=wide, deeptabular=deeptabular, pred_dim=pred_dim)
trainer = Trainer(model, objective=objective, verbose=0)
trainer.fit(X_wide=X_wide, X_tab=X_tab, target=target, batch_size=16)
preds = trainer.predict(X_wide=X_wide, X_tab=X_tab, X_test=X_test)
if objective == "binary":
pass
else:
probs = trainer.predict_proba(X_wide=X_wide,
X_tab=X_tab,
X_test=X_test)
assert preds.shape[0] == 32, probs.shape[1] == probs_dim
def test_save_and_load_dict():
wide = Wide(np.unique(X_wide).shape[0], 1)
tabmlp = TabMlp(
mlp_hidden_dims=[32, 16],
column_idx={k: v
for v, k in enumerate(colnames)},
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
model1 = WideDeep(wide=deepcopy(wide), deeptabular=deepcopy(tabmlp))
trainer1 = Trainer(model1, objective="binary", verbose=0)
trainer1.fit(
X_wide=X_wide,
X_tab=X_tab,
X_text=X_text,
X_img=X_img,
target=target,
batch_size=16,
)
wide_weights = model1.wide.wide_linear.weight.data
trainer1.save_model_state_dict(
"tests/test_model_functioning/model_dir/model_d.t")
model2 = WideDeep(wide=wide, deeptabular=tabmlp)
trainer2 = Trainer(model2, objective="binary", verbose=0)
trainer2.load_model_state_dict(
"tests/test_model_functioning/model_dir/model_d.t")
n_wide_weights = trainer2.model.wide.wide_linear.weight.data
shutil.rmtree("tests/test_model_functioning/model_dir/")
assert torch.allclose(wide_weights, n_wide_weights)
def test_early_stop():
wide = Wide(100, 1)
deepdense = DeepDense(
hidden_layers=[32, 16],
dropout=[0.5, 0.5],
deep_column_idx=deep_column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
model = WideDeep(wide=wide, deepdense=deepdense)
model.compile(
method="binary",
callbacks=[
EarlyStopping(min_delta=0.1,
patience=3,
restore_best_weights=True,
verbose=1)
],
verbose=1,
)
model.fit(X_wide=X_wide,
X_deep=X_deep,
target=target,
val_split=0.2,
n_epochs=5)
# length of history = patience+1
assert len(model.history._history["train_loss"]) == 3 + 1
def test_fit_objectives_tab_transformer(
X_wide,
X_tab,
target,
objective,
X_wide_test,
X_tab_test,
X_test,
pred_dim,
probs_dim,
):
wide = Wide(np.unique(X_wide).shape[0], pred_dim)
tab_transformer = TabTransformer(
column_idx={k: v
for v, k in enumerate(colnames)},
embed_input=embed_input_tt,
continuous_cols=colnames[5:],
)
model = WideDeep(wide=wide, deeptabular=tab_transformer, pred_dim=pred_dim)
trainer = Trainer(model, objective=objective, verbose=0)
trainer.fit(X_wide=X_wide, X_tab=X_tab, target=target, batch_size=16)
preds = trainer.predict(X_wide=X_wide, X_tab=X_tab, X_test=X_test)
if objective == "binary":
pass
else:
probs = trainer.predict_proba(X_wide=X_wide,
X_tab=X_tab,
X_test=X_test)
assert preds.shape[0] == 32, probs.shape[1] == probs_dim
def test_model_checkpoint(save_best_only, max_save, n_files):
wide = Wide(100, 1)
deepdense = DeepDense(
hidden_layers=[32, 16],
dropout=[0.5, 0.5],
deep_column_idx=deep_column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
model = WideDeep(wide=wide, deepdense=deepdense)
model.compile(
method="binary",
callbacks=[
ModelCheckpoint("weights/test_weights",
save_best_only=save_best_only,
max_save=max_save)
],
verbose=0,
)
model.fit(X_wide=X_wide,
X_deep=X_deep,
target=target,
n_epochs=5,
val_split=0.2)
n_saved = len(os.listdir("weights/"))
for f in os.listdir("weights/"):
os.remove("weights/" + f)
assert n_saved <= n_files
def test_focal_loss(X_wide, X_deep, target, method, output_dim, probs_dim):
wide = Wide(100, output_dim)
deepdense = model3 = DeepDense(hidden_layers=[32, 16],
dropout=[0.5, 0.5],
deep_column_idx=deep_column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:])
model = WideDeep(wide=wide, deepdense=deepdense, output_dim=output_dim)
model.compile(method=method, verbose=0, with_focal_loss=True)
model.fit(X_wide=X_wide, X_deep=X_deep, target=target)
probs = model.predict_proba(X_wide=X_wide, X_deep=X_deep)
assert probs.shape[1] == probs_dim
def test_filepath_error():
wide = Wide(np.unique(X_wide).shape[0], 1)
deepdense = DeepDense(
hidden_layers=[16, 4],
deep_column_idx=deep_column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
model = WideDeep(wide=wide, deepdense=deepdense)
with pytest.raises(ValueError):
model.compile(
method="binary",
callbacks=[ModelCheckpoint(filepath="wrong_file_path")],
verbose=0,
)
def test_filepath_error():
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(
mlp_hidden_dims=[16, 4],
column_idx=column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
model = WideDeep(wide=wide, deeptabular=deeptabular)
with pytest.raises(ValueError):
trainer = Trainer( # noqa: F841
model=model,
objective="binary",
callbacks=[ModelCheckpoint(filepath="wrong_file_path")],
verbose=0,
)
def test_aliases():
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(
mlp_hidden_dims=[32, 16],
mlp_dropout=[0.5, 0.5],
column_idx=column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
model = WideDeep(wide=wide, deeptabular=deeptabular, pred_dim=1)
trainer = Trainer(model, loss="regression", verbose=0)
trainer.fit(X_wide=X_wide,
X_tab=X_tab,
target=target_regres,
batch_size=16,
warmup=True)
assert ("train_loss" in trainer.history.keys()
and trainer.__wd_aliases_used["objective"] == "loss"
and trainer.__wd_aliases_used["finetune"] == "warmup")
def test_fit_with_regression_and_metric():
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(
mlp_hidden_dims=[32, 16],
mlp_dropout=[0.5, 0.5],
column_idx=column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
model = WideDeep(wide=wide, deeptabular=deeptabular, pred_dim=1)
trainer = Trainer(model,
objective="regression",
metrics=[R2Score],
verbose=0)
trainer.fit(X_wide=X_wide,
X_tab=X_tab,
target=target_regres,
batch_size=16)
assert "train_r2" in trainer.history.keys()
def test_initializers_1(): wide = Wide(100, 1) deepdense = DeepDense(hidden_layers=[32,16], dropout=[0.5, 0.5], deep_column_idx=deep_column_idx, embed_input=embed_input, continuous_cols=colnames[-5:]) deeptext = DeepText( vocab_size=vocab_size, embed_dim=32, padding_idx=0) deepimage=DeepImage(pretrained=True) model = WideDeep(wide=wide, deepdense=deepdense, deeptext=deeptext, deepimage=deepimage, output_dim=1) cmodel = c(model) org_weights = [] for n,p in cmodel.named_parameters(): if n in test_layers_1: org_weights.append(p) model.compile(method='binary', verbose=0, initializers=initializers_1) init_weights = [] for n,p in model.named_parameters(): if n in test_layers_1: init_weights.append(p) res = all([torch.all((1-(a==b).int()).bool()) for a,b in zip(org_weights, init_weights)]) assert res
def test_warning_when_missing_initializer():
wide = Wide(100, 1)
deeptabular = TabMlp(
mlp_hidden_dims=[32, 16],
mlp_dropout=[0.5, 0.5],
column_idx=column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
deeptext = DeepText(vocab_size=vocab_size, embed_dim=32, padding_idx=0)
model = WideDeep(wide=wide,
deeptabular=deeptabular,
deeptext=deeptext,
pred_dim=1)
with pytest.warns(UserWarning):
trainer = Trainer( # noqa: F841
model,
objective="binary",
verbose=True,
initializers=initializers_3)
def test_fit_with_deephead():
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(
mlp_hidden_dims=[32, 16],
column_idx=column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
deephead = nn.Sequential(nn.Linear(16, 8), nn.Linear(8, 4))
model = WideDeep(wide=wide,
deeptabular=deeptabular,
pred_dim=1,
deephead=deephead)
trainer = Trainer(model, objective="binary", verbose=0)
trainer.fit(X_wide=X_wide,
X_tab=X_tab,
target=target_binary,
batch_size=16)
preds = trainer.predict(X_wide=X_wide, X_tab=X_tab, X_test=X_test)
probs = trainer.predict_proba(X_wide=X_wide, X_tab=X_tab, X_test=X_test)
assert preds.shape[0] == 32, probs.shape[1] == 2
def test_fit_with_deephead():
wide = Wide(np.unique(X_wide).shape[0], 1)
deepdense = DeepDense(
hidden_layers=[32, 16],
deep_column_idx=deep_column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
deephead = nn.Sequential(nn.Linear(16, 8), nn.Linear(8, 4))
model = WideDeep(wide=wide,
deepdense=deepdense,
pred_dim=1,
deephead=deephead)
model.compile(method="binary", verbose=0)
model.fit(X_wide=X_wide,
X_deep=X_deep,
target=target_binary,
batch_size=16)
preds = model.predict(X_wide=X_wide, X_deep=X_deep, X_test=X_test)
probs = model.predict_proba(X_wide=X_wide, X_deep=X_deep, X_test=X_test)
assert preds.shape[0] == 32, probs.shape[1] == 2
def test_initializers_1(initializers, test_layers):
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(
mlp_hidden_dims=[32, 16],
mlp_dropout=[0.5, 0.5],
column_idx=column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
deeptext = DeepText(vocab_size=vocab_size, embed_dim=32, padding_idx=0)
deepimage = DeepImage(pretrained=True)
model = WideDeep(
wide=wide,
deeptabular=deeptabular,
deeptext=deeptext,
deepimage=deepimage,
pred_dim=1,
)
cmodel = c(model)
org_weights = []
for n, p in cmodel.named_parameters():
if n in test_layers:
org_weights.append(p)
trainer = Trainer(model,
objective="binary",
verbose=0,
initializers=initializers)
init_weights = []
for n, p in trainer.model.named_parameters():
if n in test_layers:
init_weights.append(p)
res = all([
torch.all((1 - (a == b).int()).bool())
for a, b in zip(org_weights, init_weights)
])
assert res
def test_basic_run_with_metrics_multiclass():
wide = Wide(np.unique(X_wide).shape[0], 3)
deepdense = DeepDense(
hidden_layers=[32, 16],
dropout=[0.5, 0.5],
deep_column_idx={k: v
for v, k in enumerate(colnames)},
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
model = WideDeep(wide=wide, deepdense=deepdense, pred_dim=3)
model.compile(method="multiclass", metrics=[Accuracy], verbose=False)
model.fit(
X_wide=X_wide,
X_deep=X_deep,
target=target_multi,
n_epochs=1,
batch_size=16,
val_split=0.2,
)
assert ("train_loss" in model.history._history.keys()
and "train_acc" in model.history._history.keys())
def test_early_stop():
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(
mlp_hidden_dims=[32, 16],
mlp_dropout=[0.5, 0.5],
column_idx=column_idx,
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
model = WideDeep(wide=wide, deeptabular=deeptabular)
trainer = Trainer(
model=model,
objective="binary",
callbacks=[
EarlyStopping(
min_delta=5.0, patience=3, restore_best_weights=True, verbose=1
)
],
verbose=1,
)
trainer.fit(X_wide=X_wide, X_tab=X_tab, target=target, val_split=0.2, n_epochs=5)
# length of history = patience+1
assert len(trainer.history["train_loss"]) == 3 + 1
cont_cols = [np.random.rand(100) for _ in range(5)]
deep_column_idx={k:v for v,k in enumerate(colnames)}
X_deep = np.vstack(embed_cols+cont_cols).transpose()
# Text Array
padded_sequences = np.random.choice(np.arange(1,100), (100, 48))
vocab_size = 1000
X_text = np.hstack((np.repeat(np.array([[0,0]]), 100, axis=0), padded_sequences))
# target
target = np.random.choice(2, 100)
###############################################################################
# Test that history saves the information adequately
###############################################################################
wide = Wide(100, 1)
deepdense = DeepDense(hidden_layers=[32,16], dropout=[0.5, 0.5], deep_column_idx=deep_column_idx,
embed_input=embed_input, continuous_cols=colnames[-5:])
model = WideDeep(wide=wide, deepdense=deepdense)
wide_opt_1 = torch.optim.Adam(model.wide.parameters())
deep_opt_1 = torch.optim.Adam(model.deepdense.parameters())
wide_sch_1 = StepLR(wide_opt_1, step_size=4)
deep_sch_1 = CyclicLR(deep_opt_1, base_lr=0.001, max_lr=0.01, step_size_up=10, cycle_momentum=False)
optimizers_1 = {'wide': wide_opt_1, 'deepdense': deep_opt_1}
lr_schedulers_1 = {'wide': wide_sch_1, 'deepdense': deep_sch_1}
wide_opt_2 = torch.optim.Adam(model.wide.parameters())
deep_opt_2 = RAdam(model.deepdense.parameters())
wide_sch_2 = StepLR(wide_opt_2, step_size=4)
deep_sch_2 = StepLR(deep_opt_2, step_size=4)
tab_preprocessor = TabPreprocessor(
embed_cols=cat_embed_cols, # type: ignore[arg-type]
continuous_cols=continuous_cols,
already_standard=already_standard,
)
X_tab = tab_preprocessor.fit_transform(df)
text_processor = TextPreprocessor(word_vectors_path=word_vectors_path,
text_col=text_col)
X_text = text_processor.fit_transform(df)
image_processor = ImagePreprocessor(img_col=img_col, img_path=img_path)
X_images = image_processor.fit_transform(df)
wide = Wide(wide_dim=np.unique(X_wide).shape[0], pred_dim=1)
deepdense = TabMlp(
mlp_hidden_dims=[64, 32],
mlp_dropout=[0.2, 0.2],
column_idx=tab_preprocessor.column_idx,
embed_input=tab_preprocessor.embeddings_input,
continuous_cols=continuous_cols,
)
# # To use TabResnet as the deepdense component simply:
# deepdense = TabResnet(
# blocks_dims=[64, 32],
# dropout=0.2,
# column_idx=tab_preprocessor.column_idx,
# embed_input=tab_preprocessor.embeddings_input,
# continuous_cols=continuous_cols,
# )
already_standard = ["latitude", "longitude"]
df["yield_cat"] = pd.cut(df["yield"],
bins=[0.2, 65, 163, 600],
labels=[0, 1, 2])
df.drop("yield", axis=1, inplace=True)
target = "yield_cat"
target = np.array(df[target].values)
prepare_wide = WidePreprocessor(wide_cols=wide_cols,
crossed_cols=crossed_cols)
X_wide = prepare_wide.fit_transform(df)
prepare_deep = DensePreprocessor(embed_cols=cat_embed_cols,
continuous_cols=continuous_cols)
X_deep = prepare_deep.fit_transform(df)
wide = Wide(wide_dim=X_wide.shape[1], pred_dim=3)
deepdense = DeepDense(
hidden_layers=[64, 32],
dropout=[0.2, 0.2],
deep_column_idx=prepare_deep.deep_column_idx,
embed_input=prepare_deep.embeddings_input,
continuous_cols=continuous_cols,
)
model = WideDeep(wide=wide, deepdense=deepdense, pred_dim=3)
model.compile(method="multiclass", metrics=[Accuracy, F1Score])
model.fit(
X_wide=X_wide,
X_deep=X_deep,
target=target,
n_epochs=1,
]
crossed_cols = [('education', 'occupation'),
('native_country', 'occupation')]
cat_embed_cols = [('education', 10), ('relationship', 8),
('workclass', 10), ('occupation', 10),
('native_country', 10)]
continuous_cols = ["age", "hours_per_week"]
target = 'income_label'
target = df[target].values
prepare_wide = WidePreprocessor(wide_cols=wide_cols,
crossed_cols=crossed_cols)
X_wide = prepare_wide.fit_transform(df)
prepare_deep = DeepPreprocessor(embed_cols=cat_embed_cols,
continuous_cols=continuous_cols)
X_deep = prepare_deep.fit_transform(df)
wide = Wide(wide_dim=X_wide.shape[1], output_dim=1)
deepdense = DeepDense(hidden_layers=[64, 32],
dropout=[0.2, 0.2],
deep_column_idx=prepare_deep.deep_column_idx,
embed_input=prepare_deep.embeddings_input,
continuous_cols=continuous_cols)
model = WideDeep(wide=wide, deepdense=deepdense)
wide_opt = torch.optim.Adam(model.wide.parameters())
deep_opt = RAdam(model.deepdense.parameters())
wide_sch = torch.optim.lr_scheduler.StepLR(wide_opt, step_size=3)
deep_sch = torch.optim.lr_scheduler.StepLR(deep_opt, step_size=5)
optimizers = {'wide': wide_opt, 'deepdense': deep_opt}
schedulers = {'wide': wide_sch, 'deepdense': deep_sch}
initializers = {'wide': KaimingNormal, 'deepdense': XavierNormal}
embed_input = [(u, i, j) for u, i, j in zip(colnames[:5], [5] * 5, [16] * 5)]
deep_column_idx = {k: v for v, k in enumerate(colnames[:10])}
continuous_cols = colnames[-5:]
X_deep = torch.from_numpy(np.vstack(embed_cols + cont_cols).transpose())
# text
X_text = torch.cat((torch.zeros([100, 1]), torch.empty(100, 4).random_(1, 4)),
axis=1)
# image
X_image = torch.rand(100, 3, 28, 28)
# Define the model components
# wide
wide = Wide(10, 1)
if use_cuda:
wide.cuda()
# deep
deepdense = DeepDense(
hidden_layers=[16, 8],
dropout=[0.5, 0.2],
deep_column_idx=deep_column_idx,
embed_input=embed_input,
continuous_cols=continuous_cols,
)
deepdense = nn.Sequential(deepdense, nn.Linear(8, 1))
if use_cuda:
deepdense.cuda()
# train/validation split
(
X_wide_tr,
X_wide_val,
X_deep_tr,
X_deep_val,
X_text_tr,
X_text_val,
X_img_tr,
X_img_val,
y_train,
y_val,
) = train_test_split(X_wide, X_deep, X_text, X_img, target)
# build model components
wide = Wide(np.unique(X_wide).shape[0], 1)
deepdense = DeepDense(
hidden_layers=[32, 16],
dropout=[0.5, 0.5],
deep_column_idx={k: v
for v, k in enumerate(colnames)},
embed_input=embed_input,
continuous_cols=colnames[-5:],
)
deeptext = DeepText(vocab_size=vocab_size, embed_dim=32, padding_idx=0)
deepimage = DeepImage(pretrained=True)
# transforms
mean = [0.406, 0.456, 0.485] # BGR
std = [0.225, 0.224, 0.229] # BGR
transforms1 = [ToTensor, Normalize(mean=mean, std=std)]
import pytest
from torch import nn
from pytorch_widedeep.models import (
Wide,
DeepText,
WideDeep,
DeepDense,
DeepImage,
)
embed_input = [(u, i, j)
for u, i, j in zip(["a", "b", "c"][:4], [4] * 3, [8] * 3)]
deep_column_idx = {k: v for v, k in enumerate(["a", "b", "c"])}
wide = Wide(10, 1)
deepdense = DeepDense(hidden_layers=[16, 8],
deep_column_idx=deep_column_idx,
embed_input=embed_input)
deeptext = DeepText(vocab_size=100, embed_dim=8)
deepimage = DeepImage(pretrained=False)
###############################################################################
# test raising 'output dim errors'
###############################################################################
@pytest.mark.parametrize(
"deepcomponent, component_name",
[
(None, "dense"),
cont_cols = [np.random.rand(100) for _ in range(5)]
embed_input = [(u, i, j) for u, i, j in zip(colnames[:5], [5] * 5, [16] * 5)]
column_idx = {k: v for v, k in enumerate(colnames[:10])}
continuous_cols = colnames[-5:]
X_tab = torch.from_numpy(np.vstack(embed_cols + cont_cols).transpose())
# text
X_text = torch.cat((torch.zeros([100, 1]), torch.empty(100, 4).random_(1, 4)), axis=1) # type: ignore[call-overload]
# image
X_image = torch.rand(100, 3, 28, 28)
# Define the model components
# wide
wide = Wide(X_wide.unique().size(0), 1)
if use_cuda:
wide.cuda()
# deep
deeptabular = TabMlp(
mlp_hidden_dims=[32, 16, 8],
mlp_dropout=0.2,
column_idx=column_idx,
embed_input=embed_input,
continuous_cols=continuous_cols,
)
deeptabular = nn.Sequential(deeptabular, nn.Linear(8, 1)) # type: ignore[assignment]
if use_cuda:
deeptabular.cuda()
