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()