def test_inverse_transform(self):
reg = ShiftRegistration()
fd = reg.fit_transform(self.fd)
fd = reg.inverse_transform(fd)
np.testing.assert_array_almost_equal(fd.data_matrix,
self.fd.data_matrix,
decimal=3)
def test_fit_and_transform(self):
"""Test wrapper of shift_registration_deltas"""
fd = make_sinusoidal_process(n_samples=2, error_std=0, random_state=10)
reg = ShiftRegistration()
response = reg.fit(self.fd)
# Check attributes and returned value
self.assertTrue(hasattr(reg, 'template_'))
self.assertTrue(response is reg)
fd_registered = reg.transform(fd)
deltas = reg.deltas_.round(3)
np.testing.assert_allclose(deltas, [0.071, -0.072])
def test_fit_transform(self):
reg = ShiftRegistration()
# Test fit transform with FDataGrid
fd_reg = reg.fit_transform(self.fd)
# Check attributes fitted
self.assertTrue(hasattr(reg, 'deltas_'))
self.assertTrue(hasattr(reg, 'template_'))
self.assertTrue(hasattr(reg, 'n_iter_'))
self.assertTrue(isinstance(fd_reg, FDataGrid))
deltas = reg.deltas_.round(3)
np.testing.assert_array_almost_equal(deltas, [-0.022, 0.03])
# Test with Basis
fd = self.fd.to_basis(Fourier())
reg.fit_transform(fd)
deltas = reg.deltas_.round(3)
np.testing.assert_array_almost_equal(deltas, [-0.022, 0.03])
def test_restrict_domain(self):
reg = ShiftRegistration(restrict_domain=True)
fd_registered_1 = reg.fit_transform(self.fd)
np.testing.assert_array_almost_equal(
np.array(fd_registered_1.domain_range).round(3), [[0.022, 0.969]])
reg2 = ShiftRegistration(restrict_domain=True, template=reg.template_)
fd_registered_2 = reg2.fit_transform(self.fd)
np.testing.assert_array_almost_equal(fd_registered_2.data_matrix,
fd_registered_1.data_matrix,
decimal=3)
reg3 = ShiftRegistration(restrict_domain=True, template=mean)
fd_registered_3 = reg3.fit_transform(self.fd)
np.testing.assert_array_almost_equal(fd_registered_3.data_matrix,
fd_registered_1.data_matrix)
# is essential due to the use of derivatives in the optimization process. # Because of their sinusoidal nature we will use a Fourier basis. fd_basis = fd.to_basis(Fourier(n_basis=11)) fd_basis.plot() ############################################################################## # We will use the # :func:`~skfda.preprocessing.registration.ShiftRegistration` transformer, # which is suitable due to the periodicity of the dataset and the small # amount of amplitude variation. # # We can observe how the sinusoidal pattern is easily distinguishable # once the alignment has been made. shift_registration = ShiftRegistration() fd_registered = shift_registration.fit_transform(fd_basis) fd_registered.plot() ############################################################################## # We will plot the mean of the original smoothed curves and the registered # ones, and we will compare with the original sinusoidal process without # noise. # # We can see how the phase variation affects to the mean of the original # curves varying their amplitude with respect to the original process, # however, this effect is mitigated after the registration. # sinusoidal process without variation and noise sine = make_sinusoidal_process(n_samples=1,
def setUp(self):
"""Initialization of samples"""
self.X = make_sinusoidal_process(error_std=0, random_state=0)
self.shift_registration = ShiftRegistration().fit(self.X)
class TestRegistrationValidation(unittest.TestCase):
"""Test shift registration"""
def setUp(self):
"""Initialization of samples"""
self.X = make_sinusoidal_process(error_std=0, random_state=0)
self.shift_registration = ShiftRegistration().fit(self.X)
def test_amplitude_phase_score(self):
scorer = AmplitudePhaseDecomposition()
score = scorer(self.shift_registration, self.X)
np.testing.assert_allclose(score, 0.972095, rtol=1e-6)
def test_amplitude_phase_score_with_output_points(self):
eval_points = self.X.grid_points[0]
scorer = AmplitudePhaseDecomposition(eval_points=eval_points)
score = scorer(self.shift_registration, self.X)
np.testing.assert_allclose(score, 0.972095, rtol=1e-6)
def test_amplitude_phase_score_with_basis(self):
scorer = AmplitudePhaseDecomposition()
X = self.X.to_basis(Fourier())
score = scorer(self.shift_registration, X)
np.testing.assert_allclose(score, 0.995087, rtol=1e-6)
def test_default_score(self):
score = self.shift_registration.score(self.X)
np.testing.assert_allclose(score, 0.972095, rtol=1e-6)
def test_least_squares_score(self):
scorer = LeastSquares()
score = scorer(self.shift_registration, self.X)
np.testing.assert_allclose(score, 0.795933, rtol=1e-6)
def test_sobolev_least_squares_score(self):
scorer = SobolevLeastSquares()
score = scorer(self.shift_registration, self.X)
np.testing.assert_allclose(score, 0.76124, rtol=1e-6)
def test_pairwise_correlation(self):
scorer = PairwiseCorrelation()
score = scorer(self.shift_registration, self.X)
np.testing.assert_allclose(score, 1.816228, rtol=1e-6)
def test_mse_decomposition(self):
fd = make_multimodal_samples(n_samples=3, random_state=1)
landmarks = make_multimodal_landmarks(n_samples=3, random_state=1)
landmarks = landmarks.squeeze()
warping = landmark_registration_warping(fd, landmarks)
fd_registered = fd.compose(warping)
scorer = AmplitudePhaseDecomposition(return_stats=True)
ret = scorer.score_function(fd, fd_registered, warping=warping)
np.testing.assert_allclose(ret.mse_amp, 0.0009866997121476962)
np.testing.assert_allclose(ret.mse_pha, 0.11576935495450151)
np.testing.assert_allclose(ret.r_squared, 0.9915489952877273)
np.testing.assert_allclose(ret.c_r, 0.999999, rtol=1e-6)
def test_raises_amplitude_phase(self):
scorer = AmplitudePhaseDecomposition()
# Inconsistent number of functions registered
with np.testing.assert_raises(ValueError):
scorer.score_function(self.X, self.X[:2])
# Inconsistent number of functions registered
with np.testing.assert_raises(ValueError):
scorer.score_function(self.X, self.X, warping=self.X[:2])
def test_custom_output_points(self):
reg = ShiftRegistration(output_points=np.linspace(0, 1, 50))
reg.fit_transform(self.fd)
def test_initial_estimation(self):
reg = ShiftRegistration(initial=[-0.02161235, 0.03032652])
reg.fit_transform(self.fd)
# Only needed 1 iteration until convergence
self.assertEqual(reg.n_iter_, 1)
def test_template(self):
reg = ShiftRegistration()
fd_registered_1 = reg.fit_transform(self.fd)
reg_2 = ShiftRegistration(template=reg.template_)
fd_registered_2 = reg_2.fit_transform(self.fd)
reg_3 = ShiftRegistration(template=mean)
fd_registered_3 = reg_3.fit_transform(self.fd)
reg_4 = ShiftRegistration(template=reg.template_)
fd_registered_4 = reg_4.fit(self.fd).transform(self.fd)
np.testing.assert_array_almost_equal(fd_registered_1.data_matrix,
fd_registered_3.data_matrix)
# With the template fixed could vary the convergence
np.testing.assert_array_almost_equal(fd_registered_1.data_matrix,
fd_registered_2.data_matrix,
decimal=3)
np.testing.assert_array_almost_equal(fd_registered_2.data_matrix,
fd_registered_4.data_matrix)
def test_raises(self):
reg = ShiftRegistration()
# Test not fitted
with np.testing.assert_raises(NotFittedError):
reg.transform(self.fd)
reg.fit(self.fd)
reg.set_params(restrict_domain=True)
# Test use fit or transform with restrict_domain=True
with np.testing.assert_raises(AttributeError):
reg.transform(self.fd)
with np.testing.assert_raises(AttributeError):
reg.fit(self.fd)
# Test inverse_transform without previous transformation
with np.testing.assert_raises(AttributeError):
reg.inverse_transform(self.fd)
reg.fit_transform(self.fd)
# Test inverse transform with different number of sample
with np.testing.assert_raises(ValueError):
reg.inverse_transform(self.fd[:1])
fd = make_multimodal_samples(dim_domain=2, random_state=0)
with np.testing.assert_raises(ValueError):
reg.fit_transform(fd)
reg.set_params(initial=[0.])
# Wrong initial estimation
with np.testing.assert_raises(ValueError):
reg.fit_transform(self.fd)