def test_sc_transform_shape(X, metric, metric_params):
sc = Scaler(metric=metric, metric_params=metric_params, n_jobs=1)
X_res = sc.fit_transform(X)
assert X_res.shape == X.shape
X_inv_res = sc.inverse_transform(X_res)
assert_almost_equal(X_inv_res, X)
def cubical_persistence(images,
title,
plot_diagrams=False,
betti_curves=False,
scaled=False):
homology_dimensions = (0, 1, 2)
cp = CubicalPersistence(
homology_dimensions=homology_dimensions,
coeff=2,
periodic_dimensions=None,
infinity_values=None,
reduced_homology=True,
n_jobs=N_JOBS,
)
diagrams_cubical_persistence = cp.fit_transform(images)
if scaled:
sc = Scaler(metric="bottleneck")
diagrams_cubical_persistence = sc.fit_transform(
diagrams_cubical_persistence)
else:
scaled_diagrams_cubical_persistence = diagrams_cubical_persistence
if plot_diagrams:
fig = cp.plot(diagrams_cubical_persistence)
fig.update_layout(title=title)
fig.show()
if betti_curves:
BC = BettiCurve()
X_betti_curves = BC.fit_transform(diagrams_cubical_persistence)
fig = BC.plot(X_betti_curves)
fig.update_layout(title=title)
fig.show()
if title is not None:
print(f"Computed CP for {title}")
return diagrams_cubical_persistence
def test_not_fitted():
with pytest.raises(NotFittedError):
ForgetDimension().transform(X_1)
with pytest.raises(NotFittedError):
Scaler().transform(X_1)
with pytest.raises(NotFittedError):
Scaler().inverse_transform(X_1)
with pytest.raises(NotFittedError):
Filtering().transform(X_1)
def parallel_embed_(self, embedding):
vr = VietorisRipsPersistence(
metric='euclidean',
homology_dimensions=self.homology_dimensions_,
n_jobs=self.n_job)
diagram_scaler = Scaler(n_jobs=self.n_job)
persistence_diagrams = diagram_scaler.fit_transform(
vr.fit_transform([embedding]))
if self.filtering_:
diagram_filter = Filtering(
epsilon=0.1, homology_dimensions=self.filtering_dimensions_)
persistence_diagrams = diagram_filter.fit_transform(
persistence_diagrams)
return persistence_diagrams[0]
def cubical_persistence(patch):
cp = CubicalPersistence(
homology_dimensions=HOMOLOGY_DIMENSIONS,
coeff=2,
periodic_dimensions=None,
infinity_values=None,
reduced_homology=True,
n_jobs=N_JOBS,
)
diagrams_cubical_persistence = cp.fit_transform(patch)
sc = Scaler(metric="bottleneck")
scaled_diagrams_cubical_persistence = sc.fit_transform(
diagrams_cubical_persistence)
print("Computed cubical persistence")
return scaled_diagrams_cubical_persistence
def test_fit_transform_plot(hom_dims):
Scaler().fit_transform_plot(
X_1, sample=0, homology_dimensions=hom_dims,
plotly_params=plotly_params
)
Filtering().fit_transform_plot(
X_1, sample=0, homology_dimensions=hom_dims,
plotly_params=plotly_params
)
def extract_top_features(X, filtrations, vectorizations):
"""
Extracts topological features from a MNIST-like dataset.
For each specified filtration and vectorization, features are extracted
according to the pipeline:
Filtration -> Persistence diagram -> Rescaling -> Vectorization.
Parameters
----------
X : ndarray of shape (n_samples, 28, 28)
A collection of greyscale images.
filtrations : list of tuples (string, filtration)
A list of filtrations.
Assumptions: 1) The first filtration is 'Voxel', the second is
'Binary', and for both of them the pipeline is
to be run on the original greyscale images. For all
subsequent filtrations, the pipeline is to be run on
binarized images.
2) For all filtrations except 'Vietoris-Rips', the
corresponding diagram is the cubical persistence
diagram. For 'Vietoris-Rips', i's the Vietoris-Rips
persistence diagram.
vectorizations : list of tuples (string, vectorization)
A list of vectorizations.
Returns
-------
X_f : ndarray of shape (n_samples, n_features)
Topological features for all images in X
"""
# Put all vectorizations together for convenience
vect_union = FeatureUnion(vectorizations, n_jobs=num_jobs)
X_bin = img.Binarizer(threshold=0.4, n_jobs=num_jobs).fit_transform(X)
X_f = np.array([]).reshape(X.shape[0], 0)
current_time = [time.perf_counter()]
for filt in filtrations:
filt_features = make_pipeline(\
filt[1],\
VietorisRipsPersistence(n_jobs=num_jobs) if filt[0] == 'Vietoris-Rips' else CubicalPersistence(n_jobs=num_jobs),\
Scaler(n_jobs=num_jobs),\
vect_union).fit_transform(X)
X_f = np.hstack((X_f, filt_features))
print("{} complete: {} seconds".format(filt[0],
elapsed_time(current_time)))
if filt[0] == 'Binary':
X = X_bin # From now on, we only work with binarized images
return X_f
def test_dd_transform(X, metric, metric_params):
dsc = Scaler(metric=metric, metric_params=metric_params, n_jobs=1)
X_res = dsc.fit_transform(X)
assert X_res.shape == X.shape
dsc = Scaler(metric=metric, metric_params=metric_params, n_jobs=1)
X_inv_res = dsc.fit(X_res).inverse_transform(X_res)
assert X_inv_res.shape == X.shape
def test_not_fitted():
dst = ForgetDimension()
dsc = Scaler()
with pytest.raises(NotFittedError):
dst.transform(X_1)
with pytest.raises(NotFittedError):
dsc.transform(X_1)
with pytest.raises(NotFittedError):
dsc.inverse_transform(X_1)
