def test_search_neighbors_precomputed(self):
d = pairwise_distance(lp_distance)
distances = d(self.X[:4], self.X[:4])
nn = NearestNeighbors(metric='precomputed', n_neighbors=2)
nn.fit(distances, self.y[:4])
_, neighbors = nn.kneighbors(distances)
result = np.array([[0, 3], [1, 2], [2, 1], [3, 0]])
np.testing.assert_array_almost_equal(neighbors, result)
def test_knn_functional_response_precomputed(self):
knnr = KNeighborsRegressor(n_neighbors=4, weights='distance',
metric='precomputed')
d = pairwise_distance(lp_distance)
distances = d(self.X[:4], self.X[:4])
knnr.fit(distances, self.X[:4])
res = knnr.predict(distances)
np.testing.assert_array_almost_equal(res.data_matrix,
self.X[:4].data_matrix)
def test_lof_fit_predict(self):
""" Test same results with different forms to call fit_predict"""
# Outliers
expected = np.ones(len(self.fd_lof))
expected[0:2] = -1
# With default l2 distance
lof = LocalOutlierFactor()
res = lof.fit_predict(self.fd_lof)
np.testing.assert_array_equal(expected, res)
# With explicit l2 distance
lof2 = LocalOutlierFactor(metric=lp_distance)
res2 = lof2.fit_predict(self.fd_lof)
np.testing.assert_array_equal(expected, res2)
d = pairwise_distance(lp_distance)
distances = d(self.fd_lof, self.fd_lof)
# With precompute distances
lof3 = LocalOutlierFactor(metric="precomputed")
res3 = lof3.fit_predict(distances)
np.testing.assert_array_equal(expected, res3)
# With multivariate sklearn
lof4 = LocalOutlierFactor(metric="euclidean", multivariate_metric=True)
res4 = lof4.fit_predict(self.fd_lof)
np.testing.assert_array_equal(expected, res4)
# Other way of call fit_predict, undocumented in sklearn
lof5 = LocalOutlierFactor(novelty=True)
res5 = lof5.fit(self.fd_lof).predict()
np.testing.assert_array_equal(expected, res5)
# Check values of negative outlier factor
negative_lof = [-7.1068, -1.5412, -0.9961, -0.9854, -0.9896, -1.0993,
-1.065, -0.9871, -0.9821, -0.9955, -1.0385, -1.0072,
-0.9832, -1.0134, -0.9939, -1.0074, -0.992, -0.992,
-0.9883, -1.0012, -1.1149, -1.002, -0.9994, -0.9869,
-0.9726, -0.9989, -0.9904]
np.testing.assert_array_almost_equal(
lof.negative_outlier_factor_.round(4), negative_lof)
# Check same negative outlier factor
np.testing.assert_array_almost_equal(lof.negative_outlier_factor_,
lof2.negative_outlier_factor_)
np.testing.assert_array_almost_equal(lof.negative_outlier_factor_,
lof3.negative_outlier_factor_)
def test_functional_regression_distance_weights(self):
knnr = KNeighborsRegressor(
weights='distance', n_neighbors=10)
knnr.fit(self.X[:10], self.X[:10])
res = knnr.predict(self.X[11])
d = pairwise_distance(lp_distance)
distances = d(self.X[:10], self.X[11]).flatten()
weights = 1 / distances
weights /= weights.sum()
response = self.X[:10].mean(weights=weights)
np.testing.assert_array_almost_equal(res.data_matrix,
response.data_matrix)
import unittest
import numpy as np
from skfda import FDataGrid
from skfda.datasets import make_multimodal_samples
from skfda.misc.metrics import (fisher_rao_distance, amplitude_distance,
phase_distance, pairwise_distance, lp_distance,
warping_distance)
from skfda.preprocessing.registration import (elastic_registration, to_srsf,
from_srsf,
elastic_registration_warping,
invert_warping,
normalize_warping)
metric = pairwise_distance(lp_distance)
pairwise_fisher_rao = pairwise_distance(fisher_rao_distance)
class TestElasticRegistration(unittest.TestCase):
"""Test elastic registration"""
def setUp(self):
"""Initialization of samples"""
template = make_multimodal_samples(n_samples=1, std=0, random_state=1)
self.template = template
self.template_rep = template.concatenate(template).concatenate(
template)
self.unimodal_samples = make_multimodal_samples(n_samples=3,
random_state=1)
t = np.linspace(-3, 3, 9)
lower = sample - radius
upper = sample + radius
fig.axes[0].fill_between(sample.grid_points[0],
lower.data_matrix.flatten(),
upper.data_matrix[0].flatten(),
alpha=.25,
color='C1')
##############################################################################
#
# In this case, all the neighbors in the ball belong to the first class, so
# this will be the class predicted.
#
# Creation of pairwise distance
l_inf = pairwise_distance(lp_distance, p=np.inf)
distances = l_inf(sample, X_train)[0] # L_inf distances to 'sample'
# Plot samples in the ball
fig = X_train[distances <= radius].plot(color='C0')
sample.plot(fig=fig, color='red', linewidth=3)
fig.axes[0].fill_between(sample.grid_points[0],
lower.data_matrix.flatten(),
upper.data_matrix[0].flatten(),
alpha=.25,
color='C1')
##############################################################################
#
# We will fit the classifier
# :class:`~skfda.ml.classification.RadiusNeighborsClassifier`, which has a
plt.figure("means")
fd.mean().plot(label=r"cross-sectional mean")
mean_el = elastic_mean(fd)
mean_el.plot(label=f"elastic mean")
#plt.ylim(ylims)
plt.legend()
plt.tight_layout()
plt.figure("dataset-by-amplitude")
# Get colors
cmap = plt.cm.Reds_r
amp = pairwise_distance(amplitude_distance)
distances = amp(mean_el, fd)[0]
#print(distances)
index = np.argsort(distances)[::-1]
maximun = np.max(distances)
minimun = np.min(distances)
color = cmap((distances - minimun) / (maximun - minimun))
#print(color)
for i in range(len(fd)):
indice = int(index[i])
fd[indice].plot(color=color[indice])