code stringlengths 17 6.64M |
|---|
def test_notfittederror():
processor = WidePreprocessor(wide_cols, cross_cols)
with pytest.raises(NotFittedError):
processor.transform(df_letters)
|
def test_rules():
assert (fix_html('Some HTML text<br />') == 'Some HTML& text\n')
assert (replace_rep("I'm so excited!!!!!!!!") == "I'm so excited xxrep 8 ! ")
assert (replace_wrep("I've never ever ever ever ever ever ever ever done this.") == "I've never xxwrep 7 ever done this.")
assert (rm_... |
def test_tokenize():
texts = ['one two three four', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.', "I'm suddenly SHOUTING FOR NO REASON"]
tokenizer = Tokenizer(BaseTokenizer)
toks = tokenizer.process_all(texts)
assert (tok... |
def test_tokenize_handles_empty_lines():
texts = ['= Markdown Title =\n\nMakrdown Title does not have spaces around']
tokenizer = Tokenizer(BaseTokenizer)
toks = tokenizer.process_all(texts)
assert (toks[0] == ['=', 'xxmaj', 'markdown', 'xxmaj', 'title', '=', '\n', '\n', 'xxmaj', 'makrdown', 'xxmaj', ... |
def test_tokenize_ignores_extraneous_space():
texts = ['test ']
tokenizer = Tokenizer(BaseTokenizer)
toks = tokenizer.process_all(texts)
assert (toks[0] == ['test'])
|
def test_numericalize_and_textify():
toks = [['ok', '!', 'xxmaj', 'nice', '!', 'anti', '-', 'virus'], ['!', 'xxmaj', 'meg', 'xxmaj', 'nice', 'meg']]
vocab = Vocab(max_vocab=20, min_freq=2).create(toks)
assert (vocab.numericalize(toks[0]) == [0, 9, 5, 10, 9, 0, 0, 0])
assert (vocab.textify([0, 3, 10, 1... |
@pytest.mark.parametrize('as_frame', [True, False])
def test_load_bio_kdd04(as_frame):
df = load_bio_kdd04(as_frame=as_frame)
if as_frame:
assert ((df.shape, type(df)) == ((145751, 77), pd.DataFrame))
else:
assert ((df.shape, type(df)) == ((145751, 77), np.ndarray))
|
@pytest.mark.parametrize('as_frame', [True, False])
def test_load_adult(as_frame):
df = load_adult(as_frame=as_frame)
if as_frame:
assert ((df.shape, type(df)) == ((48842, 15), pd.DataFrame))
else:
assert ((df.shape, type(df)) == ((48842, 15), np.ndarray))
|
@pytest.mark.parametrize('as_frame', [True, False])
def test_load_ecoli(as_frame):
df = load_ecoli(as_frame=as_frame)
if as_frame:
assert ((df.shape, type(df)) == ((336, 9), pd.DataFrame))
else:
assert ((df.shape, type(df)) == ((336, 9), np.ndarray))
|
@pytest.mark.parametrize('as_frame', [True, False])
def test_load_womens_ecommerce(as_frame):
df = load_womens_ecommerce(as_frame=as_frame)
if as_frame:
assert ((df.shape, type(df)) == ((23486, 10), pd.DataFrame))
else:
assert ((df.shape, type(df)) == ((23486, 10), np.ndarray))
|
@pytest.mark.parametrize('as_frame', [True, False])
def test_load_rf1(as_frame):
df = load_rf1(as_frame=as_frame)
if as_frame:
assert ((df.shape, type(df)) == ((4108, 72), pd.DataFrame))
else:
assert ((df.shape, type(df)) == ((4108, 72), np.ndarray))
|
@pytest.mark.parametrize('as_frame', [True, False])
def test_load_birds(as_frame):
df = load_birds(as_frame=as_frame)
if as_frame:
assert ((df.shape, type(df)) == ((322, 279), pd.DataFrame))
else:
assert ((df.shape, type(df)) == ((322, 279), np.ndarray))
|
@pytest.mark.parametrize('as_frame', [True, False])
def test_load_california_housing(as_frame):
df = load_california_housing(as_frame=as_frame)
if as_frame:
assert ((df.shape, type(df)) == ((20640, 9), pd.DataFrame))
else:
assert ((df.shape, type(df)) == ((20640, 9), np.ndarray))
|
@pytest.mark.parametrize('as_frame', [True, False])
def test_load_movielens100k(as_frame):
(df_data, df_users, df_items) = load_movielens100k(as_frame=as_frame)
if as_frame:
assert ((df_data.shape, df_users.shape, df_items.shape, type(df_data), type(df_users), type(df_items)) == ((100000, 4), (943, 5)... |
def _build_model_for_feat_imp_test(model_name, params):
if (model_name == 'tabtransformer'):
return TabTransformer(input_dim=6, n_blocks=2, n_heads=2, embed_continuous=True, **params)
if (model_name == 'saint'):
return SAINT(input_dim=6, n_blocks=2, n_heads=2, **params)
if (model_name == '... |
@pytest.mark.parametrize('with_cls_token', [True, False])
@pytest.mark.parametrize('model_name', ['tabtransformer', 'saint', 'fttransformer', 'tabfastformer', 'self_attn_mlp', 'cxt_attn_mlp'])
def test_feature_importances(with_cls_token, model_name):
tab_preprocessor = TabPreprocessor(cat_embed_cols=cat_cols, con... |
def test_fttransformer_valueerror():
tab_preprocessor = TabPreprocessor(cat_embed_cols=cat_cols, continuous_cols=cont_cols, with_attention=True)
X_tr = tab_preprocessor.fit_transform(df_tr).astype(float)
params = {'column_idx': tab_preprocessor.column_idx, 'cat_embed_input': tab_preprocessor.cat_embed_inp... |
def test_feature_importances_tabnet():
tab_preprocessor = TabPreprocessor(cat_embed_cols=cat_cols, continuous_cols=cont_cols)
X_tr = tab_preprocessor.fit_transform(df_tr).astype(float)
X_te = tab_preprocessor.transform(df_te).astype(float)
tabnet = TabNet(column_idx=tab_preprocessor.column_idx, cat_em... |
class TextModeTestClass(nn.Module):
def __init__(self):
super(TextModeTestClass, self).__init__()
self.word_embed = nn.Embedding(5, 16, padding_idx=0)
self.rnn = nn.LSTM(16, 8, batch_first=True)
self.linear = nn.Linear(8, 1)
def forward(self, X):
embed = self.word_emb... |
class ImageModeTestClass(nn.Module):
def __init__(self):
super(ImageModeTestClass, self).__init__()
self.conv_block = nn.Sequential(conv_layer(3, 64, 3), conv_layer(64, 128, 1, maxpool=False, adaptiveavgpool=True))
self.linear = nn.Linear(128, 1)
def forward(self, X):
x = sel... |
def loss_fn(y_pred, y_true):
return F.binary_cross_entropy_with_logits(y_pred, y_true.view((- 1), 1))
|
@pytest.mark.parametrize('model, modelname, loader, n_epochs, max_lr', [(wide, 'wide', mmloader, 1, 0.01), (tab_mlp, 'deeptabular', mmloader, 1, 0.01), (deeptext, 'deeptext', mmloader, 1, 0.01), (deepimage, 'deepimage', mmloader, 1, 0.01)])
def test_finetune_all(model, modelname, loader, n_epochs, max_lr):
has_ru... |
@pytest.mark.parametrize('model, modelname, loader, max_lr, layers, routine', [(tab_mlp, 'deeptabular', mmloader, 0.01, tab_layers, 'felbo'), (tab_mlp, 'deeptabular', mmloader, 0.01, tab_layers, 'howard'), (deeptext, 'deeptext', mmloader, 0.01, text_layers, 'felbo'), (deeptext, 'deeptext', mmloader, 0.01, text_layers... |
def test_chunk_wide_processor_one_chunk():
df = pd.read_csv(os.path.join(data_folder, fname))
wide_processor = WidePreprocessor(wide_cols=cat_cols)
X_wide = wide_processor.fit_transform(df)
chunk_wide_processor = ChunkWidePreprocessor(wide_cols=cat_cols, n_chunks=1)
chunk_wide_processor.partial_fi... |
def test_chunk_wide_processor():
df = pd.read_csv(os.path.join(data_folder, fname))
wide_processor = WidePreprocessor(wide_cols=cat_cols)
X_wide = wide_processor.fit_transform(df)
chunk_wide_processor = ChunkWidePreprocessor(wide_cols=cat_cols, n_chunks=n_chunks)
for chunk in pd.read_csv(os.path.j... |
def test_chunk_tab_preprocessor_one_chunk():
df = pd.read_csv(os.path.join(data_folder, fname))
tab_processor = TabPreprocessor(cat_embed_cols=cat_cols, continuous_cols=num_cols)
X_tab = tab_processor.fit_transform(df)
chunk_tab_processor = ChunkTabPreprocessor(cat_embed_cols=cat_cols, continuous_cols... |
def test_chunk_tab_preprocessor():
df = pd.read_csv(os.path.join(data_folder, fname))
tab_processor = TabPreprocessor(cat_embed_cols=cat_cols, continuous_cols=num_cols)
X_tab = tab_processor.fit_transform(df)
chunk_tab_processor = ChunkTabPreprocessor(cat_embed_cols=cat_cols, continuous_cols=num_cols,... |
@pytest.mark.parametrize('with_attention', [True, False])
@pytest.mark.parametrize('quantization_setup', [{'numeric2': [0.0, 50.0, 100.0]}, None])
def test_chunk_tab_preprocessor_with_params(with_attention, quantization_setup):
df = pd.read_csv(os.path.join(data_folder, fname))
tab_processor = TabPreprocessor... |
def test_chunk_text_preprocessor_one_go():
df = pd.read_csv(os.path.join(data_folder, fname))
text_processor = TextPreprocessor(text_col=text_col, n_cpus=1, maxlen=10, max_vocab=50)
X_text = text_processor.fit_transform(df)
chunk_text_processor = ChunkTextPreprocessor(text_col=text_col, n_chunks=1, n_... |
def test_chunk_text_preprocessor():
df = pd.read_csv(os.path.join(data_folder, fname))
text_processor = TextPreprocessor(text_col=text_col, n_cpus=1, maxlen=10, max_vocab=50)
X_text = text_processor.fit_transform(df)
chunk_text_processor = ChunkTextPreprocessor(text_col=text_col, n_chunks=n_chunks, n_... |
def test_tab_from_folder_alone():
df = pd.read_csv('/'.join([data_folder, fname]))
tab_preprocessor = ChunkTabPreprocessor(embed_cols=cat_cols, continuous_cols=num_cols, n_chunks=n_chunks)
for (i, chunk) in enumerate(pd.read_csv('/'.join([data_folder, fname]), chunksize=chunksize)):
tab_preprocess... |
def test_tab_from_folder_with_reference():
df = pd.read_csv('/'.join([data_folder, fname]))
tab_preprocessor = ChunkTabPreprocessor(embed_cols=cat_cols, continuous_cols=num_cols, n_chunks=n_chunks)
for (i, chunk) in enumerate(pd.read_csv('/'.join([data_folder, fname]), chunksize=chunksize)):
tab_p... |
def test_text_from_folder_alone():
df = pd.read_csv('/'.join([data_folder, fname]))
chunk_text_processor = ChunkTextPreprocessor(text_col=text_col, n_chunks=1, n_cpus=1, maxlen=10, max_vocab=50)
for chunk in pd.read_csv('/'.join([data_folder, fname]), chunksize=chunksize):
chunk_text_processor.par... |
def test_image_from_folder_alone():
df = pd.read_csv('/'.join([data_folder, fname]))
img_preprocessor = ImagePreprocessor(img_col=img_col, img_path=img_folder)
img_from_folder = ImageFromFolder(preprocessor=img_preprocessor)
processed_sample = img_preprocessor.transform(df)[1]
processed_sample = p... |
def test_image_from_folder_with_transforms():
df = pd.read_csv('/'.join([data_folder, fname]))
img_transforms = transforms.Compose([transforms.CenterCrop(10), transforms.ToTensor()])
img_from_folder = ImageFromFolder(directory=img_folder, transforms=img_transforms)
processed_sample_from_folder = img_f... |
def test_full_wide_deep_dataset_from_folder():
df = pd.read_csv('/'.join([data_folder, fname]))
tab_preprocessor = ChunkTabPreprocessor(embed_cols=cat_cols, continuous_cols=num_cols, n_chunks=n_chunks, default_embed_dim=8, verbose=0)
text_preprocessor = ChunkTextPreprocessor(n_chunks=n_chunks, text_col=te... |
@pytest.mark.parametrize('tabular_component', ['wide', 'deeptabular'])
def test_wide_and_tab_optional(tabular_component):
df = pd.read_csv('/'.join([data_folder, fname]))
if (tabular_component == 'wide'):
tab_preprocessor = ChunkWidePreprocessor(wide_cols=cat_cols, n_chunks=n_chunks)
else:
... |
def _build_preprocessors(tab_params={}):
wide_preprocessor = ChunkWidePreprocessor(wide_cols=cat_cols, n_chunks=n_chunks)
tab_preprocessor = ChunkTabPreprocessor(embed_cols=cat_cols, continuous_cols=num_cols, n_chunks=n_chunks, default_embed_dim=8, verbose=0, **tab_params)
text_preprocessor = ChunkTextPre... |
def _build_data_mode_from_folder(wide_preprocessor, tab_preprocessor, text_preprocessor, img_preprocessor, target_col='target_regression'):
tab_from_folder = TabFromFolder(fname=fname, directory=data_folder, target_col=target_col, preprocessor=tab_preprocessor, img_col=img_col, text_col=text_col)
wide_from_fo... |
def _build_eval_and_test_data_mode_from_folder(wide_from_folder, tab_from_folder, eval_fname, test_fname):
eval_wide_from_folder = TabFromFolder(fname=eval_fname, reference=wide_from_folder)
eval_tab_from_folder = TabFromFolder(fname=eval_fname, reference=tab_from_folder)
test_wide_from_folder = TabFromFo... |
def _buid_model(wide_preprocessor, tab_preprocessor, text_preprocessor, pred_dim=1, with_attention=False):
wide = Wide(input_dim=wide_preprocessor.wide_dim, num_class=pred_dim)
if with_attention:
deeptabular = TabTransformer(column_idx=tab_preprocessor.column_idx, cat_embed_input=tab_preprocessor.cat_... |
@pytest.mark.parametrize('objective', ['regression', 'binary', 'multiclass'])
def test_trainer_from_loader_basic_inputs(objective):
(wide_preprocessor, tab_preprocessor, text_preprocessor, img_preprocessor) = _build_preprocessors()
if (objective == 'regression'):
target_col = 'target_regression'
e... |
@pytest.mark.parametrize('pred_with_loader', [True, False])
def test_trainer_from_loader_with_valid_and_test(pred_with_loader):
(wide_preprocessor, tab_preprocessor, text_preprocessor, img_preprocessor) = _build_preprocessors()
(wide_from_folder, tab_from_folder, text_from_folder, img_from_folder) = _build_da... |
@pytest.mark.parametrize('tab_params', [{'with_attention': True, 'with_cls_token': True}, {'with_attention': True, 'with_cls_token': False}])
def test_trainer_from_loader_with_tab_params(tab_params):
(wide_preprocessor, tab_preprocessor, text_preprocessor, img_preprocessor) = _build_preprocessors(tab_params=tab_p... |
def f2_score_bin(y_true, y_pred):
return fbeta_score(y_true, y_pred, beta=2)
|
@pytest.mark.parametrize('sklearn_metric, widedeep_metric', [(accuracy_score, Accuracy()), (precision_score, Precision()), (recall_score, Recall()), (f1_score, F1Score()), (f2_score_bin, FBetaScore(beta=2))])
def test_binary_metrics(sklearn_metric, widedeep_metric):
assert np.isclose(sklearn_metric(y_true_bin_np,... |
@pytest.mark.parametrize('top_k, expected_acc', [(1, 0.33), (2, 0.66)])
def test_categorical_accuracy_topk(top_k, expected_acc):
y_true = torch.from_numpy(np.random.choice(3, 100))
y_pred = torch.from_numpy(np.random.rand(100, 3))
metric = Accuracy(top_k=top_k)
acc = metric(y_pred, y_true)
assert ... |
def f2_score_multi(y_true, y_pred, average):
return fbeta_score(y_true, y_pred, average=average, beta=2)
|
@pytest.mark.parametrize('sklearn_metric, widedeep_metric', [(accuracy_score, Accuracy()), (precision_score, Precision()), (recall_score, Recall()), (f1_score, F1Score()), (f2_score_multi, FBetaScore(beta=2))])
def test_muticlass_metrics(sklearn_metric, widedeep_metric):
if (sklearn_metric.__name__ == 'accuracy_s... |
@pytest.mark.parametrize('sklearn_metric, widedeep_metric', [(precision_score, Precision(average=False)), (recall_score, Recall(average=False)), (f1_score, F1Score(average=False)), (f2_score_multi, FBetaScore(beta=2, average=False))])
def test_muticlass_metrics_without_average(sklearn_metric, widedeep_metric):
sk... |
@pytest.mark.parametrize('metric, metric_name', [(Accuracy(), 'accuracy'), (Precision(), 'precision'), (Recall(), 'recall'), (FBetaScore(beta=2), 'fbeta'), (F1Score(), 'f1'), (R2Score(), 'r2')])
def test_reset_methods(metric, metric_name):
if (metric_name == 'r2'):
res = metric(y_pred_reg_np, y_true_reg_n... |
def test_r2_score():
assert (r2_score(y_true_reg_np, y_pred_reg_np) == R2Score()(y_pred_reg_pt, y_true_reg_pt))
|
def f2_score_bin(y_true, y_pred):
return fbeta_score(y_true, y_pred, beta=2)
|
@pytest.mark.parametrize('metric_name, sklearn_metric, torch_metric', [('BinaryAccuracy', accuracy_score, Accuracy(task='binary')), ('BinaryPrecision', precision_score, Precision(task='binary')), ('BinaryRecall', recall_score, Recall(task='binary')), ('BinaryF1Score', f1_score, F1Score(task='binary')), ('BinaryFBetaS... |
def f2_score_multi(y_true, y_pred, average):
return fbeta_score(y_true, y_pred, average=average, beta=2)
|
@pytest.mark.parametrize('metric_name, sklearn_metric, torch_metric', [('MulticlassAccuracy', accuracy_score, Accuracy(task='multiclass', num_classes=3, average='micro')), ('MulticlassPrecision', precision_score, Precision(task='multiclass', num_classes=3, average='macro')), ('MulticlassRecall', recall_score, Recall(... |
@pytest.mark.skipif((not torch.cuda.is_available()), reason='requires CUDA to run')
def test_flash_standard_shapes():
assert (standard_attn(X).shape == flash_attn(X).shape)
|
@pytest.mark.skipif((not torch.cuda.is_available()), reason='requires CUDA to run')
def test_flash_standard_values():
assert torch.allclose(standard_attn(X), flash_attn(X), atol=1e-07)
|
@pytest.mark.skipif((not torch.cuda.is_available()), reason='requires CUDA to run')
def test_speedup_flash():
standard_its = timeit.timeit((lambda : standard_attn(X)), number=500)
flash_its = timeit.timeit((lambda : flash_attn(X)), number=500)
assert (standard_its > flash_its)
assert (((standard_its -... |
def test_flash_standard_vs_linear_shapes():
assert (standard_attn(X).shape == linear_attn(X).shape)
|
def test_output_sizes():
model = Vision()
out = model(X_images)
assert ((out.size(0) == 10) and (out.size(1) == 512))
|
def test_n_trainable():
model = Vision(pretrained_model_setup='resnet18', n_trainable=6)
out = model(X_images)
assert ((out.size(0) == 10) and (out.size(1) == 512))
|
@pytest.mark.parametrize('arch, expected_out_shape', [('shufflenet_v2_x0_5', 1024), ('resnext50_32x4d', 2048), ('wide_resnet50_2', 2048), ('mobilenet_v2', 1280), ('mnasnet1_0', 1280), ('squeezenet1_0', 512), ({'shufflenet_v2_x0_5': ShuffleNet_V2_X0_5_Weights.IMAGENET1K_V1}, 1024), ({'resnext50_32x4d': ResNeXt50_32X4D... |
def test_head():
model = Vision(head_hidden_dims=[256, 128], head_dropout=0.1)
out = model(X_images)
assert ((out.size(0) == 10) and (out.size(1) == 128))
|
def test_all_frozen():
model = Vision(pretrained_model_setup='resnet18', n_trainable=0)
is_trainable = []
for p in model.parameters():
is_trainable.append((not p.requires_grad))
assert all(is_trainable)
|
@pytest.mark.parametrize('arch, expected_out_shape', [('resnet', 512), ('shufflenet', 1024), ('resnext', 2048), ('wide_resnet', 2048), ('regnet', 912), ('mobilenet', 1280), ('mnasnet', 1280), ('squeezenet', 512), ({'shufflenet': ShuffleNet_V2_X0_5_Weights.IMAGENET1K_V1}, 1024), ({'resnext': ResNeXt50_32X4D_Weights.IM... |
@pytest.mark.skipif(IN_GITHUB_ACTIONS, reason='For reasons beyond me, when running in GH actions, throws a RuntimeError when trying to download the weights')
def test_pretrained_model_efficientnet():
model = Vision(pretrained_model_setup='efficientnet', n_trainable=0)
out = model(X_images)
assert ((out.si... |
def test_wide():
out = model(inp)
assert ((out.size(0) == 10) and (out.size(1) == 1))
|
def test_deephead_and_head_layers_dim():
deephead = nn.Sequential(nn.Linear(32, 16), nn.Linear(16, 8))
with pytest.raises(ValueError):
model = WideDeep(wide=wide, deeptabular=tabmlp, head_hidden_dims=[16, 8], deephead=deephead)
|
def test_no_deephead_and_head_layers_dim():
out = []
model = WideDeep(wide=wide, deeptabular=tabmlp, head_hidden_dims=[8, 4])
for (n, p) in model.named_parameters():
if (n == 'deephead.head_layer_0.0.weight'):
out.append(((p.size(0) == 8) and (p.size(1) == 8)))
if (n == 'deephe... |
def test_tabnet_warning():
with pytest.warns(UserWarning):
model = WideDeep(wide=wide, deeptabular=tabnet)
|
@pytest.mark.parametrize('optimizers, schedulers, len_loss_output, len_lr_output, init_lr, schedulers_type', [(optimizers_1, lr_schedulers_1, 5, 5, 0.001, 'step'), (optimizers_2, lr_schedulers_2, 5, 11, 0.001, 'cyclic'), (optimizers_3, lr_schedulers_3, 5, 5, None, None), (optimizers_4, lr_schedulers_4, 5, 11, None, N... |
def test_early_stop():
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(column_idx=column_idx, cat_embed_input=embed_input, continuous_cols=colnames[(- 5):], mlp_hidden_dims=[32, 16], mlp_dropout=[0.5, 0.5])
model = WideDeep(wide=wide, deeptabular=deeptabular)
trainer = Trainer(model=mo... |
@pytest.mark.parametrize('fpath, save_best_only, max_save, n_files', [('tests/test_model_functioning/weights/test_weights', True, 2, 2), ('tests/test_model_functioning/weights/test_weights', False, 2, 2), ('tests/test_model_functioning/weights/test_weights', False, 0, 5), (None, False, 0, 0)])
def test_model_checkpoi... |
def test_filepath_error():
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(mlp_hidden_dims=[16, 4], column_idx=column_idx, cat_embed_input=embed_input, continuous_cols=colnames[(- 5):])
model = WideDeep(wide=wide, deeptabular=deeptabular)
with pytest.raises(ValueError):
trainer... |
@pytest.mark.parametrize('optimizers, schedulers, len_loss_output, len_lr_output, init_lr, schedulers_type', [(optimizers_1, lr_schedulers_1, 5, 5, 0.001, 'step'), (optimizers_2, lr_schedulers_2, 5, 11, 0.001, 'cyclic'), (optimizers_3, lr_schedulers_3, 5, 5, None, None), (optimizers_4, lr_schedulers_4, 5, 11, None, N... |
def test_modelcheckpoint_mode_warning():
fpath = 'tests/test_model_functioning/modelcheckpoint/weights_out'
with pytest.warns(RuntimeWarning):
model_checkpoint = ModelCheckpoint(filepath=fpath, monitor='val_loss', mode='unknown')
shutil.rmtree('tests/test_model_functioning/modelcheckpoint/')
|
def test_modelcheckpoint_mode_options():
fpath = 'tests/test_model_functioning/modelcheckpoint/weights_out'
model_checkpoint_1 = ModelCheckpoint(filepath=fpath, monitor='val_loss', mode='min')
model_checkpoint_2 = ModelCheckpoint(filepath=fpath, monitor='val_loss')
model_checkpoint_3 = ModelCheckpoint... |
def test_modelcheckpoint_get_state():
fpath = 'tests/test_model_functioning/modelcheckpoint/'
model_checkpoint = ModelCheckpoint(filepath='/'.join([fpath, 'weights_out']), monitor='val_loss')
trainer = Trainer(model, objective='binary', callbacks=[model_checkpoint], verbose=0)
trainer.fit(X_wide=X_wid... |
def test_early_stop_mode_warning():
with pytest.warns(RuntimeWarning):
model_checkpoint = EarlyStopping(monitor='val_loss', mode='unknown')
|
def test_early_stop_mode_options():
early_stopping_1 = EarlyStopping(monitor='val_loss', mode='min')
early_stopping_2 = EarlyStopping(monitor='val_loss')
early_stopping_3 = EarlyStopping(monitor='acc', mode='max')
early_stopping_4 = EarlyStopping(monitor='acc')
is_min = (early_stopping_1.monitor_o... |
def test_early_stopping_get_state():
early_stopping_path = Path('tests/test_model_functioning/early_stopping')
early_stopping_path.mkdir()
early_stopping = EarlyStopping()
trainer_tt = Trainer(model, objective='binary', callbacks=[early_stopping], verbose=0)
trainer_tt.fit(X_train={'X_wide': X_wid... |
def test_early_stopping_restore_weights_with_metric():
early_stopping = EarlyStopping(restore_best_weights=True, min_delta=1000, patience=1000)
trainer = Trainer(model, objective='regression', callbacks=[early_stopping], verbose=0)
trainer.fit(X_train={'X_wide': X_wide, 'X_tab': X_tab, 'target': target}, ... |
def test_early_stopping_restore_weights_with_state():
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(column_idx=column_idx, cat_embed_input=embed_input, continuous_cols=colnames[(- 5):], mlp_hidden_dims=[16, 8])
model = WideDeep(wide=wide, deeptabular=deeptabular)
fpath = 'tests/test_... |
def test_model_checkpoint_restore_weights():
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(column_idx=column_idx, cat_embed_input=embed_input, continuous_cols=colnames[(- 5):], mlp_hidden_dims=[16, 8])
model = WideDeep(wide=wide, deeptabular=deeptabular)
fpath = 'tests/test_model_fun... |
@pytest.mark.parametrize('X_wide, X_tab, X_text, X_img, X_train, X_val, target, val_split, transforms', [(X_wide, X_tab, X_text, X_img, None, None, target, None, transforms1), (X_wide, X_tab, X_text, X_img, None, None, target, None, transforms2), (X_wide, X_tab, X_text, X_img, None, None, target, None, None), (X_wide... |
@pytest.mark.parametrize('X_wide, X_tab, X_text, X_img, X_train, X_val, target', [(X_wide, X_tab, X_text, X_img, None, {'X_wide': X_wide_val, 'X_tab': X_tab_val, 'X_text': X_text_val, 'X_img': X_img_val, 'target': y_val}, target)])
def test_xtrain_xval_assertion(X_wide, X_tab, X_text, X_img, X_train, X_val, target):
... |
@pytest.mark.parametrize('wide, deeptabular, deeptext, deepimage, X_wide, X_tab, X_text, X_img, target', [(wide, None, None, None, X_wide, None, None, None, target), (None, deeptabular, None, None, None, X_tab, None, None, target), (None, None, deeptext, None, None, None, X_text, None, target), (None, None, None, dee... |
@pytest.mark.parametrize('deeptabular, deeptext, deepimage, X_tab, X_text, X_img, deephead, target', [(deeptabular, None, None, X_tab, None, None, deephead_ds, target), (None, deeptext, None, None, X_text, None, deephead_dt, target), (None, None, deepimage, None, None, X_img, deephead_di, target)])
def test_deephead_... |
@pytest.mark.parametrize('deeptabular, deeptext, deepimage, X_tab, X_text, X_img, target', [(deeptabular, None, None, X_tab, None, None, target), (None, deeptext, None, None, X_text, None, target), (None, None, deepimage, None, None, X_img, target)])
def test_head_layers_individual_components(deeptabular, deeptext, d... |
@pytest.mark.parametrize('X_wide, X_tab, target, objective, X_test, pred_dim, probs_dim, uncertainties_pred_dim', [(X_wide, X_tab, target_regres, 'regression', None, 1, None, 4), (X_wide, X_tab, target_binary, 'binary', None, 1, 2, 3), (X_wide, X_tab, target_multic, 'multiclass', None, 3, 3, 4), (X_wide, X_tab, targe... |
def test_fit_with_deephead():
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(column_idx=column_idx, cat_embed_input=embed_input, continuous_cols=colnames[(- 5):], mlp_hidden_dims=[32, 16])
deephead = nn.Sequential(nn.Linear(16, 8), nn.Linear(8, 4))
deephead.output_dim = 4
model = ... |
@pytest.mark.parametrize('X_wide, X_tab, target, objective, X_wide_test, X_tab_test, X_test, pred_dim, probs_dim, uncertainties_pred_dim', [(X_wide, X_tab, target_regres, 'regression', X_wide, X_tab, None, 1, None, 4), (X_wide, X_tab, target_binary, 'binary', X_wide, X_tab, None, 1, 2, 3), (X_wide, X_tab, target_mult... |
@pytest.mark.parametrize('X_wide, X_tab, target, objective, X_wide_test, X_tab_test, X_test, pred_dim, probs_dim, uncertainties_pred_dim', [(X_wide, X_tab, target_regres, 'regression', X_wide, X_tab, None, 1, None, 4), (X_wide, X_tab, target_binary, 'binary', X_wide, X_tab, None, 1, 2, 3), (X_wide, X_tab, target_mult... |
def test_fit_with_regression_and_metric():
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(column_idx=column_idx, cat_embed_input=embed_input, continuous_cols=colnames[(- 5):], mlp_hidden_dims=[32, 16], mlp_dropout=[0.5, 0.5])
model = WideDeep(wide=wide, deeptabular=deeptabular, pred_dim=1... |
def test_aliases():
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(column_idx=column_idx, cat_embed_input=embed_input, continuous_cols=colnames[(- 5):], mlp_hidden_dims=[32, 16], mlp_dropout=[0.5, 0.5])
model = WideDeep(wide=wide, deeptabular=deeptabular, pred_dim=1)
trainer = Trainer... |
def test_custom_dataloader():
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(column_idx=column_idx, cat_embed_input=embed_input, continuous_cols=colnames[(- 5):], mlp_hidden_dims=[32, 16], mlp_dropout=[0.5, 0.5])
model = WideDeep(wide=wide, deeptabular=deeptabular)
trainer = Trainer(m... |
def test_multiclass_warning():
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(column_idx=column_idx, cat_embed_input=embed_input, continuous_cols=colnames[(- 5):], mlp_hidden_dims=[32, 16], mlp_dropout=[0.5, 0.5])
model = WideDeep(wide=wide, deeptabular=deeptabular)
with pytest.raises... |
@pytest.mark.parametrize('initializers, test_layers', [(initializers_1, test_layers), (initializers_2, test_layers)])
def test_initializers_1(initializers, test_layers):
wide = Wide(np.unique(X_wide).shape[0], 1)
deeptabular = TabMlp(column_idx=column_idx, cat_embed_input=embed_input, continuous_cols=colnames... |
def test_initializers_with_pattern():
wide = Wide(100, 1)
deeptabular = TabMlp(column_idx=column_idx, cat_embed_input=embed_input, continuous_cols=colnames[(- 5):], mlp_hidden_dims=[32, 16], mlp_dropout=[0.5, 0.5])
deeptext = BasicRNN(vocab_size=vocab_size, embed_dim=32, padding_idx=0)
model = WideDee... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.