def test_2d(self):
vfc_op = meld.VertexFrequencyCluster(window_sizes=self.window_sizes)
clusters = vfc_op.fit_predict(self.G,
sample_indicator=self.sample_indicators,
likelihood=self.likelihoods)
assert len(clusters) == len(self.sample_labels)
def test_predict_before_fit(self):
# predict before fit
assert_raises_message(
ValueError,
"Estimator is not fit. Call VertexFrequencyCluster.fit().",
meld.VertexFrequencyCluster().predict,
)
def test_cluster_no_likelihood(self):
vfc_op = meld.VertexFrequencyCluster(window_sizes=self.window_sizes)
vfc_op.fit_predict(
self.G,
sample_indicator=self.sample_indicators["expt"],
likelihood=self.likelihoods["expt"],
)
def test_predit_setting_n_cluster(self):
vfc_op = meld.VertexFrequencyCluster(window_sizes=self.window_sizes)
vfc_op.fit_transform(
self.G,
sample_indicator=self.sample_indicators["expt"],
likelihood=self.likelihoods["expt"],
)
vfc_op.predict(n_clusters=2)
def test_sample_indicator_invalid(self):
# sample_indicator not array-like
assert_raises_message(
TypeError,
"`sample_indicator` must be array-like",
meld.VertexFrequencyCluster().fit_transform,
G=self.G,
sample_indicator="invalid",
)
def test_transform_before_fit(self):
# Transform before fit
assert_raises_message(
ValueError,
"Estimator must be `fit` before running `transform`.",
meld.VertexFrequencyCluster().transform,
sample_indicator=self.sample_indicators["expt"],
likelihood=self.likelihoods["expt"],
)
def test_predict_before_transform(self):
vfc_op = meld.VertexFrequencyCluster(
window_sizes=self.window_sizes)
vfc_op.fit(self.G)
# predict before transform
assert_raise_message(ValueError,
"Estimator is not transformed. "
"Call VertexFrequencyCluster.transform().",
vfc_op.predict, RES=self.labels)
def test_utils():
data, labels = make_batches(n_pts_per_cluster=250)
G = gt.Graph(data, sample_idx=labels, use_pygsp=True)
EES = meld.MELD().fit_transform(G, labels)
clusters = meld.VertexFrequencyCluster().fit_predict(G=G,
RES=labels,
EES=EES)
meld.utils.sort_clusters_by_meld_score(clusters, EES)
def test_mnn():
data, labels = make_batches(n_pts_per_cluster=250)
meld_op = meld.MELD(verbose=0)
sample_densities = meld_op.fit_transform(data, labels, sample_idx=labels)
sample_likelihoods = meld.utils.normalize_densities(sample_densities)
meld.VertexFrequencyCluster().fit_transform(
G=meld_op.graph,
sample_indicator=meld_op.sample_indicators["expt"],
likelihood=sample_likelihoods["expt"],
)
def test_likelihood_invalid(self):
# likelihood not array-like
assert_raises_message(
TypeError,
"`likelihood` must be array-like",
meld.VertexFrequencyCluster().fit_transform,
G=self.G,
sample_indicator=self.sample_indicators["expt"],
likelihood="invalid",
)
def test_likelihood_wrong_length(self):
# likelihood and n mismatch
assert_raises_message(
ValueError,
"At least one axis of `likelihood` must be of length `N`.",
meld.VertexFrequencyCluster().fit_transform,
G=self.G,
sample_indicator=self.sample_indicators["expt"],
likelihood=np.ones(7),
)
def test_2d(self):
RES = np.array([self.labels, self.labels]).T
vfc_op = meld.VertexFrequencyCluster(
window_sizes=self.window_sizes)
meld_op = meld.MELD()
EES = meld_op.fit_transform(G=self.G, RES=RES)
clusters = vfc_op.fit_predict(
self.G, RES=RES,
EES=EES)
assert len(clusters) == len(self.labels)
def test_RES_EES_shape(self):
RES = np.array([self.labels, self.labels]).T
vfc_op = meld.VertexFrequencyCluster(
window_sizes=self.window_sizes)
meld_op = meld.MELD()
EES = meld_op.fit_transform(G=self.G, RES=RES)
assert_raise_message(ValueError,
'`RES` and `EES` must have the same shape.'
'Got RES: {} and EES: {}'.format(str(RES[:,1].shape), str(EES.shape)),
vfc_op.fit_predict, G=self.G, RES=RES[:,1], EES=EES)
def test_sample_indicator_likelihood_shape(self):
vfc_op = meld.VertexFrequencyCluster(window_sizes=self.window_sizes)
assert_raises_message(
ValueError,
"`sample_indicator` and `likelihood` must have the same shape. "
"Got sample_indicator: {} and likelihood: {}".format(
str(self.sample_indicators["expt"].shape),
str(self.likelihoods.shape)),
vfc_op.fit_predict,
G=self.G,
sample_indicator=self.sample_indicators["expt"],
likelihood=self.likelihoods,
)
def test_cluster(self):
vfc_op = meld.VertexFrequencyCluster(
window_sizes=self.window_sizes)
spectrogram = vfc_op.fit_transform(
self.G, RES=self.labels, EES=self.EES)
# test sparse window
for t in self.window_sizes:
np.testing.assert_allclose(
vfc_op._compute_window(self.G.diff_op, t).toarray(),
vfc_op._compute_window(self.G.diff_op.toarray(), t))
# test sparse spectrogram
for window in vfc_op.windows:
np.testing.assert_allclose(
vfc_op._compute_spectrogram(self.labels, window),
vfc_op._compute_spectrogram(self.labels, sparse.csr_matrix(window)))
# test full sparse computation
vfc_op.sparse = True
sparse_spectrogram = vfc_op.fit_transform(
self.G, RES=self.labels, EES=self.EES)
assert sparse_spectrogram.shape == spectrogram.shape
assert sparse.issparse(vfc_op._basewindow)
def test_cluster(self):
vfc_op = meld.VertexFrequencyCluster(window_sizes=self.window_sizes)
spectrogram = vfc_op.fit_transform(
self.G,
sample_indicator=self.sample_indicators["expt"],
likelihood=self.likelihoods["expt"],
)
# test sparse window
for t in self.window_sizes:
np.testing.assert_allclose(
vfc_op._compute_window(self.G.diff_op, t).toarray(),
vfc_op._compute_window(self.G.diff_op.toarray(), t),
)
# test sparse spectrogram
for window in vfc_op.windows:
np.testing.assert_allclose(
vfc_op._compute_spectrogram(self.sample_indicators["expt"],
window),
vfc_op._compute_spectrogram(self.sample_indicators["expt"],
sparse.csr_matrix(window)),
)
# test full sparse computation
vfc_op.sparse = True
sparse_spectrogram = vfc_op.fit_transform(
self.G,
sample_indicator=self.sample_indicators["expt"],
likelihood=self.likelihoods["expt"],
)
assert sparse_spectrogram.shape == spectrogram.shape
assert sparse.issparse(vfc_op._basewindow)
# test _compute_spectrogram wrong size signal
with assert_raises_message(
ValueError,
"sample_indicator must be 1-dimensional. Got shape: {}".format(
self.data.shape),
):
vfc_op._compute_spectrogram(self.data, window)
def test_utils():
data, labels = make_batches(n_pts_per_cluster=250)
G = gt.Graph(data, sample_idx=labels, use_pygsp=True)
meld_op = meld.MELD()
sample_densities = meld_op.fit_transform(G, labels)
sample_likelihoods = meld.utils.normalize_densities(sample_densities)
meld.VertexFrequencyCluster().fit_predict(
G=G,
sample_indicator=meld_op.sample_indicators["expt"],
likelihood=sample_likelihoods["expt"],
)
meld.utils.get_meld_cmap()
# Test normalize_densities
# Three samples
densities = np.ones([100, 3])
meld.utils.normalize_densities(sample_densities=densities)
# Two samples
densities = np.ones([100, 2])
meld.utils.normalize_densities(sample_densities=densities)
def test_ees_invalid(self):
# EES not array-like
assert_raise_message(TypeError,
'`EES` must be array-like',
meld.VertexFrequencyCluster().fit_transform,
G=self.G, RES=self.labels, EES='invalid')
def test_mnn():
data, labels = make_batches(n_pts_per_cluster=250)
G = gt.Graph(data, sample_idx=labels, use_pygsp=True)
meld_op = meld.MELD()
EES = meld_op.fit_transform(G, labels)
meld.VertexFrequencyCluster().fit_transform(G=G, RES=labels, EES=EES)
def test_transform_before_fit(self):
# Transform before fit
assert_raise_message(ValueError,
'Estimator must be `fit` before running `transform`.',
meld.VertexFrequencyCluster().transform,
RES=self.labels, EES=self.EES)
def test_cluster_no_EES(self):
vfc_op = meld.VertexFrequencyCluster(
window_sizes=self.window_sizes)
spectrogram = vfc_op.fit_predict(
self.G, RES=self.labels, EES=None)
def test_ees_wrong_length(self):
# EES and n mismatch
assert_raise_message(ValueError,
'At least one axis of `EES` must be of length `N`.',
meld.VertexFrequencyCluster().fit_transform,
G=self.G, RES=self.labels, EES=np.ones(7))
def test_set_params(self):
# KMeans params
vfc_op = meld.VertexFrequencyCluster()
vfc_op.set_kmeans_params(k=2)
assert vfc_op._clusterobj.n_clusters == 2
def test_power_sparse(self):
vfc_op = meld.VertexFrequencyCluster()
vfc_op._power_matrix(self.G.diff_op, 2)
