def test_vader_save_load_transfer_learning(self):
save_folder = "test_vader_save_load_transfer_learning"
save_path = f"{save_folder}//weights"
if os.path.exists(save_folder):
shutil.rmtree(save_folder)
X_train, W_train, y_train = generate_x_w_y(7, 400)
# noinspection PyTypeChecker
vader = VADER(X_train=X_train,
W_train=W_train,
y_train=y_train,
save_path=save_path,
n_hidden=[12, 2],
k=4,
learning_rate=1e-3,
output_activation=None,
recurrent=True,
batch_size=16)
vader.pre_fit(n_epoch=10, verbose=True)
vader.fit(n_epoch=10, verbose=True)
clustering_before_loading = vader.cluster(X_train)
X_train_ft, W_train_ft, y_train_ft = generate_x_w_y(7, 400)
vader = VADER(X_train=X_train_ft,
W_train=W_train_ft,
y_train=y_train_ft,
save_path=None,
n_hidden=[12, 2],
k=4,
learning_rate=1e-3,
output_activation=None,
recurrent=True,
batch_size=16)
vader.load_weights(save_path)
vader.pre_fit(n_epoch=10, verbose=True)
vader.fit(n_epoch=10, verbose=True)
# get the clusters
clustering = vader.cluster(X_train_ft)
if os.path.exists(save_folder):
shutil.rmtree(save_folder)
assert any(clustering)
assert len(clustering) == len(X_train_ft)
# get the re-constructions
prediction = vader.predict(X_train_ft)
assert prediction.shape == X_train_ft.shape
# compute the loss given the network
loss = vader.get_loss(X_train_ft)
assert loss
assert "reconstruction_loss" in loss
assert "latent_loss" in loss
assert loss["reconstruction_loss"] >= 0
assert loss["latent_loss"] >= 0
def test_vader_save_load(self):
save_path = "test_vader_save_load"
if os.path.exists(save_path):
shutil.rmtree(save_path)
X_train, W_train, y_train = generate_x_w_y(7, 400)
# noinspection PyTypeChecker
vader = VADER(X_train=X_train,
W_train=W_train,
y_train=y_train,
save_path=save_path,
n_hidden=[12, 2],
k=4,
learning_rate=1e-3,
output_activation=None,
recurrent=True,
batch_size=16)
vader.pre_fit(n_epoch=10, verbose=True)
vader.fit(n_epoch=10, verbose=True)
clustering_before_loading = vader.cluster(X_train)
loaded_vader = VADER.load_model(save_path, X_train, W_train, y_train)
clustering_after_loading = loaded_vader.cluster(X_train)
if os.path.exists(save_path):
shutil.rmtree(save_path)
assert list(clustering_before_loading) == list(
clustering_after_loading)
def test_vader_recur(self):
X_train, W_train, y_train = generate_x_w_y(7, 400)
# Note: y_train is used purely for monitoring performance when a ground truth clustering is available.
# It can be omitted if no ground truth is available.
# noinspection PyTypeChecker
vader = VADER(X_train=X_train,
W_train=W_train,
y_train=y_train,
save_path=None,
n_hidden=[12, 2],
k=4,
learning_rate=1e-3,
output_activation=None,
recurrent=True,
batch_size=16)
# pre-train without latent loss
vader.pre_fit(n_epoch=10, verbose=True)
# train with latent loss
vader.fit(n_epoch=10, verbose=True)
# get the clusters
clustering = vader.cluster(X_train)
assert any(clustering)
assert len(clustering) == len(X_train)
# get the re-constructions
prediction = vader.predict(X_train)
assert prediction.shape == X_train.shape
# compute the loss given the network
loss = vader.get_loss(X_train)
assert loss
assert "reconstruction_loss" in loss
assert "latent_loss" in loss
assert loss["reconstruction_loss"] >= 0
assert loss["latent_loss"] >= 0
def test_vader_transfer_learning(self):
X_train, W_train, y_train = generate_x_w_y(7, 400)
# noinspection PyTypeChecker
vader = VADER(X_train=X_train,
W_train=W_train,
y_train=y_train,
save_path=None,
n_hidden=[12, 2],
k=4,
learning_rate=1e-3,
output_activation=None,
recurrent=True,
batch_size=16)
# pre-train without latent loss
vader.pre_fit(n_epoch=10, verbose=True)
# train with latent loss
vader.fit(n_epoch=10, verbose=True)
X_train_ft, W_train_ft, y_train_ft = generate_x_w_y(7, 400)
vader.set_inputs(X_train_ft, W_train_ft, y_train_ft)
# pre-train without latent loss
vader.pre_fit(n_epoch=10, verbose=True)
# train with latent loss
vader.fit(n_epoch=10, verbose=True)
# get the clusters
clustering = vader.cluster(X_train_ft)
assert any(clustering)
assert len(clustering) == len(X_train_ft)
# get the re-constructions
prediction = vader.predict(X_train_ft)
assert prediction.shape == X_train_ft.shape
# compute the loss given the network
loss = vader.get_loss(X_train_ft)
assert loss
assert "reconstruction_loss" in loss
assert "latent_loss" in loss
assert loss["reconstruction_loss"] >= 0
assert loss["latent_loss"] >= 0
def test_run(self):
X_train, W_train, _ = generate_x_w_y(7, 400)
optimizer = VADERHyperparametersOptimizer(
params_factory=self.MyParamGridFactory(),
seed=None,
n_repeats=3,
n_proc=mp.cpu_count(),
n_sample=3,
n_consensus=1,
n_epoch=5,
n_splits=2,
n_perm=10,
output_folder=self.OUTPUT_FOLDER
)
optimizer.run(X_train, W_train)
assert os.path.exists(optimizer.output_pdf_report_file)
assert os.path.getsize(optimizer.output_pdf_report_file) > 0
def test_run(self):
input_data, input_weights, _ = generate_x_w_y(7, 400)
params_dict = {
"k": 4,
"n_hidden": [32, 8],
"learning_rate": 0.01,
"batch_size": 16,
"alpha": 1.0
}
seed = 42
n_consensus = 1
n_epoch = 10
n_splits = 2
n_perm = 10
job = FullOptimizationJob(input_data, input_weights, params_dict, seed, n_consensus, n_epoch, n_splits, n_perm)
result = job.run()
assert result is not None
def test_grid_search(self):
X_train, _, _ = generate_x_w_y(7, 400)
parameters = {'k': (3, 4, 5)}
clf = GridSearchCV(VaDERSklearnClustering(), parameters)
clf.fit(X_train)
assert clf.cv_results_
def test_generate_x_w_y(self):
X_train, W_train, y_train = generate_x_w_y(7, 400)
assert X_train.shape == (400, 7, 2)
assert W_train.shape == (400, 7, 2)
assert y_train.shape == (400, )