def test_evaluation_grid_linear_keepdims(self):
"""Test grid evaluation with keepdims"""
# Default keepdims = False
f = FDataGrid(self.data_matrix_1_1,
sample_points=np.arange(10),
keepdims=False)
# Default keepdims = True
fk = FDataGrid(self.data_matrix_1_1,
sample_points=np.arange(10),
keepdims=True)
t = [0.5, 1.5, 2.5]
res = np.array([[0.5, 2.5, 6.5], [72.5, 56.5, 42.5]])
res_keepdims = res.reshape(2, 3, 1)
np.testing.assert_array_almost_equal(f(t, grid=True), res)
np.testing.assert_array_almost_equal(
f((t, ), grid=True, keepdims=True), res_keepdims)
np.testing.assert_array_almost_equal(f([t], grid=True, keepdims=False),
res)
np.testing.assert_array_almost_equal(fk(t, grid=True), res_keepdims)
np.testing.assert_array_almost_equal(
fk((t, ), grid=True, keepdims=True), res_keepdims)
np.testing.assert_array_almost_equal(
fk([t], grid=True, keepdims=False), res)
def test_basis_fpca_transform_result(self):
n_basis = 9
n_components = 3
fd_data = fetch_weather()['data'].coordinates[0]
fd_data = FDataGrid(np.squeeze(fd_data.data_matrix),
np.arange(0.5, 365, 1))
# initialize basis data
basis = Fourier(n_basis=n_basis, domain_range=(0, 365))
fd_basis = fd_data.to_basis(basis)
fpca = FPCA(n_components=n_components,
regularization=TikhonovRegularization(
LinearDifferentialOperator(2),
regularization_parameter=1e5))
fpca.fit(fd_basis)
scores = fpca.transform(fd_basis)
# results obtained using Ramsay's R package
results = [[-7.68307641e+01, 5.69034443e+01, -1.22440149e+01],
[-9.02873996e+01, 1.46262257e+01, -1.78574536e+01],
[-8.21155683e+01, 3.19159491e+01, -2.56212328e+01],
[-1.14163637e+02, 3.66425562e+01, -1.00810836e+01],
[-6.97263223e+01, 1.22817168e+01, -2.39417618e+01],
[-6.41886364e+01, -1.07261045e+01, -1.10587407e+01],
[1.35824412e+02, 2.03484658e+01, -9.04815324e+00],
[-1.46816399e+01, -2.66867491e+01, -1.20233465e+01],
[1.02507511e+00, -2.29840736e+01, -9.06081296e+00],
[-3.62936903e+01, -2.09520442e+01, -1.14799951e+01],
[-4.20649313e+01, -1.13618094e+01, -6.24909009e+00],
[-7.38115985e+01, -3.18423866e+01, -1.50298626e+01],
[-6.69822456e+01, -3.35518632e+01, -1.25167352e+01],
[-1.03534763e+02, -1.29513941e+01, -1.49103879e+01],
[-1.04542036e+02, -1.36794907e+01, -1.41555965e+01],
[-7.35863347e+00, -1.41171956e+01, -2.97562788e+00],
[7.28804530e+00, -5.34421830e+01, -3.39823418e+00],
[5.59974094e+01, -4.02154080e+01, 3.78800103e-01],
[1.80778702e+02, 1.87798201e+01, -1.99043247e+01],
[-3.69700617e+00, -4.19441020e+01, 6.45820740e+00],
[3.76527216e+01, -4.23056953e+01, 1.04221757e+01],
[1.23850646e+02, -4.24648130e+01, -2.22336786e-01],
[-7.23588457e+00, -1.20579536e+01, 2.07502089e+01],
[-4.96871011e+01, 8.88483448e+00, 2.02882768e+01],
[-1.36726355e+02, -1.86472599e+01, 1.89076217e+01],
[-1.83878661e+02, 4.12118550e+01, 1.78960356e+01],
[-1.81568820e+02, 5.20817910e+01, 2.01078870e+01],
[-5.08775852e+01, 1.34600555e+01, 3.18602712e+01],
[-1.37633866e+02, 7.50809631e+01, 2.42320782e+01],
[4.98276375e+01, 1.33401270e+00, 3.50611066e+01],
[1.51149934e+02, -5.47417776e+01, 3.97592325e+01],
[1.58366096e+02, -3.80762686e+01, -5.62415023e+00],
[2.17139548e+02, 6.34055987e+01, -1.98853635e+01],
[2.33615480e+02, -7.90787574e-02, 2.69069525e+00],
[3.45371437e+02, 9.58703622e+01, 8.47570770e+00]]
results = np.array(results)
# compare results
np.testing.assert_allclose(scores, results, atol=1e-7)
def test_evaluation_composed_linear_keepdims(self):
"""Test parameter keepdims with composed evaluation"""
# Default keepdims = False
f = FDataGrid(self.data_matrix_1_1,
sample_points=np.arange(10),
keepdims=False)
# Default keepdims = True
fk = FDataGrid(self.data_matrix_1_1,
sample_points=np.arange(10),
keepdims=True)
t = np.array([1, 2, 3])
t = [t, 9 - t]
res = np.array([[1., 4., 9.], [1., 4., 9.]])
res_keepdims = res.reshape((2, 3, 1))
# Test combinations of keepdims with list
np.testing.assert_array_almost_equal(f(t, aligned_evaluation=False),
res)
np.testing.assert_array_almost_equal(
f(t, aligned_evaluation=False, keepdims=False), res)
np.testing.assert_array_almost_equal(
f(t, aligned_evaluation=False, keepdims=True), res_keepdims)
np.testing.assert_array_almost_equal(fk(t, aligned_evaluation=False),
res_keepdims)
np.testing.assert_array_almost_equal(
fk(t, aligned_evaluation=False, keepdims=False), res)
np.testing.assert_array_almost_equal(
fk(t, aligned_evaluation=False, keepdims=True), res_keepdims)
def setUp(self):
"""Initialization of samples"""
self.time = np.linspace(-1, 1, 50)
interpolation = SplineInterpolation(3, monotone=True)
self.polynomial = FDataGrid([self.time**3, self.time**5],
self.time,
interpolation=interpolation)
def test_monary_ufunc(self):
data_matrix = np.arange(15).reshape(3, 5)
fd = FDataGrid(data_matrix)
fd_sqrt = np.sqrt(fd)
fd_sqrt_build = FDataGrid(np.sqrt(data_matrix))
self.assertEqual(fd_sqrt, fd_sqrt_build)
def setUp(self):
grid_points = [1, 2, 3, 4, 5]
self.fd = FDataGrid([[2, 3, 4, 5, 6], [1, 4, 9, 16, 25]],
grid_points=grid_points)
basis = Monomial(n_basis=3, domain_range=(1, 5))
self.fd_basis = FDataBasis(basis, [[1, 1, 0], [0, 0, 1]])
self.fd_curve = self.fd.concatenate(self.fd, as_coordinates=True)
self.fd_surface = make_multimodal_samples(n_samples=3,
dim_domain=2,
random_state=0)
def test_out_ufunc(self):
data_matrix = np.arange(15.).reshape(3, 5)
data_matrix_copy = np.copy(data_matrix)
fd = FDataGrid(data_matrix)
np.sqrt(fd, out=fd)
fd_sqrt_build = FDataGrid(np.sqrt(data_matrix_copy))
self.assertEqual(fd, fd_sqrt_build)
def test_warping_distance(self):
"""Test of warping distance"""
t = np.linspace(0, 1)
w1 = FDataGrid([t**5], t)
w2 = FDataGrid([t**3], t)
d = warping_distance(w1, w2)
np.testing.assert_allclose(d, np.arccos(np.sqrt(15) / 4), atol=1e-3)
d = warping_distance(w2, w2)
np.testing.assert_allclose(d, 0, atol=2e-2)
def _get_group_fd(X, group_mask, basis, grid_points=None):
_check_skfda()
group_X = np.copy(X[:, group_mask])
if grid_points is None:
group_grid_points = np.arange(0, group_X.shape[1])
else:
group_grid_points = np.copy(grid_points[group_mask])
fd = FDataGrid(group_X, group_grid_points)
if basis is not None:
fd = fd.to_basis(basis)
return fd
def test_binary_ufunc(self):
data_matrix = np.arange(15).reshape(3, 5)
data_matrix2 = 2 * np.arange(15).reshape(3, 5)
fd = FDataGrid(data_matrix)
fd2 = FDataGrid(data_matrix2)
fd_mul = np.multiply(fd, fd2)
fd_mul_build = FDataGrid(data_matrix * data_matrix2)
self.assertEqual(fd_mul, fd_mul_build)
def test_error_degree(self):
with np.testing.assert_raises(ValueError):
interpolation = SplineInterpolation(7)
f = FDataGrid(self.data_matrix_1_1, grid_points=np.arange(10),
interpolation=interpolation)
f(1)
with np.testing.assert_raises(ValueError):
interpolation = SplineInterpolation(0)
f = FDataGrid(self.data_matrix_1_1, grid_points=np.arange(10),
interpolation=interpolation)
f(1)
def test_discretized_fpca_fit_attributes(self):
fpca = FPCA()
with self.assertRaises(AttributeError):
fpca.fit(None)
# check that if n_components is bigger than the number of samples then
# an exception should be thrown
fd = FDataGrid([[0.5], [0.1]], grid_points=[0])
with self.assertRaises(AttributeError):
fpca.fit(fd)
# check that n_components must be smaller than the number of attributes
# in the FDataGrid object
fd = FDataGrid([[0.9], [0.7], [0.5]], grid_points=[0])
with self.assertRaises(AttributeError):
fpca.fit(fd)
def test_fisher_rao_invariance(self):
"""Test invariance of fisher rao metric: d(f,g)= d(foh, goh)"""
t = np.linspace(0, np.pi)
id = FDataGrid([t], t)
cos = np.cos(id)
sin = np.sin(id)
gamma = normalize_warping(np.sqrt(id), (0, np.pi))
gamma2 = normalize_warping(np.square(id), (0, np.pi))
distance_original = fisher_rao_distance(cos, sin)
# Construction of 2 warpings
distance_warping = fisher_rao_distance(cos.compose(gamma),
sin.compose(gamma))
distance_warping2 = fisher_rao_distance(cos.compose(gamma2),
sin.compose(gamma2))
# The error ~0.001 due to the derivation
np.testing.assert_almost_equal(distance_original,
distance_warping,
decimal=2)
np.testing.assert_almost_equal(distance_original,
distance_warping2,
decimal=2)
def test_add(self):
fd1 = FDataGrid([[1, 2, 3, 4], [2, 3, 4, 5]])
fd2 = fd1 + fd1
np.testing.assert_array_equal(fd2.data_matrix[..., 0],
[[2, 4, 6, 8], [4, 6, 8, 10]])
fd2 = fd1 + 2
np.testing.assert_array_equal(fd2.data_matrix[..., 0],
[[3, 4, 5, 6], [4, 5, 6, 7]])
fd2 = fd1 + np.array(2)
np.testing.assert_array_equal(fd2.data_matrix[..., 0],
[[3, 4, 5, 6], [4, 5, 6, 7]])
fd2 = fd1 + np.array([2])
np.testing.assert_array_equal(fd2.data_matrix[..., 0],
[[3, 4, 5, 6], [4, 5, 6, 7]])
fd2 = fd1 + np.array([1, 2, 3, 4])
np.testing.assert_array_equal(fd2.data_matrix[..., 0],
[[2, 4, 6, 8], [3, 5, 7, 9]])
fd2 = fd1 + fd1.data_matrix
np.testing.assert_array_equal(fd2.data_matrix[..., 0],
[[2, 4, 6, 8], [4, 6, 8, 10]])
fd2 = fd1 + fd1.data_matrix[..., 0]
np.testing.assert_array_equal(fd2.data_matrix[..., 0],
[[2, 4, 6, 8], [4, 6, 8, 10]])
def load_datagrid_sim(folder, arr, x):
'''
Load cif files from folder into ase crystal objects, simulate crystal
diffraction and represent data in timeseries
Args:
folder (string): Where we load the data from.
arr (list): List of cif filenames in folder.
x (nparray): representation of 1/angström for powder simulation.
Returns:
fd (datagrid): representation of intensity values and 1/angström
values in datagrid object.
'''
filename_arr = []
crys_arr = []
for file in arr:
filename = os.sep.join([folder, file])
filename_arr.append(file)
crys = read(filename)
crys = Crystal.from_ase(crys)
diff = powdersim(crys, x, fwhm_l=50)
diff_norm = diff / diff.max()
crys_arr.append(diff_norm)
crys_arr = np.array(crys_arr)
fd = FDataGrid(crys_arr,
x,
dataset_name='Diffraction Curves',
argument_names=[r'$q (1/\AA)$'],
coordinate_names=['Diffracted intensity (A.u.)'])
print(fd)
return fd
def test_fdboxplot_multivariate(self):
data_matrix = [[[1, 0.3], [2, 0.4], [3, 0.5], [4, 0.6]],
[[2, 0.5], [3, 0.6], [4, 0.7], [5, 0.7]],
[[3, 0.2], [4, 0.3], [5, 0.4], [6, 0.5]]]
sample_points = [2, 4, 6, 8]
fd = FDataGrid(data_matrix, sample_points)
fdataBoxplot = Boxplot(fd, prob=[0.75, 0.5, 0.25])
np.testing.assert_array_equal(fdataBoxplot.median,
np.array([[2., 3., 4., 5.],
[0.3, 0.4, 0.5, 0.6]]))
np.testing.assert_array_equal(fdataBoxplot.central_envelope, np.array(
[[[2., 3., 4., 5.], [1., 2., 3., 4.]],
[[0.5, 0.6, 0.7, 0.7],
[0.3, 0.4, 0.5, 0.6]]]))
np.testing.assert_array_equal(fdataBoxplot.outlying_envelope, np.array(
[[[3., 4., 5., 6.], [1., 2., 3., 4.]],
[[0.5, 0.6, 0.7, 0.7],
[0.2, 0.3, 0.4, 0.5]]]))
np.testing.assert_array_equal(fdataBoxplot.central_regions, np.array(
[[[3., 4., 5., 6.], [1., 2., 3., 4.]],
[[2., 3., 4., 5.], [1., 2., 3., 4.]],
[[2., 3., 4., 5.], [2., 3., 4., 5.]],
[[0.5, 0.6, 0.7, 0.7],
[0.2, 0.3, 0.4, 0.5]],
[[0.5, 0.6, 0.7, 0.7],
[0.3, 0.4, 0.5, 0.6]],
[[0.3, 0.4, 0.5, 0.6],
[0.3, 0.4, 0.5, 0.6]]]))
np.testing.assert_array_equal(fdataBoxplot.outliers,
np.array([[0., 0., 0.],
[0., 0., 0.]]))
def test_directional_outlyingness(self):
data_matrix = [[[1, 0.3], [2, 0.4], [3, 0.5], [4, 0.6]],
[[2, 0.5], [3, 0.6], [4, 0.7], [5, 0.7]],
[[3, 0.2], [4, 0.3], [5, 0.4], [6, 0.5]]]
sample_points = [2, 4, 6, 8]
fd = FDataGrid(data_matrix, sample_points)
dir_outlyingness, mean_dir_outl, variation_dir_outl = directional_outlyingness(
fd)
np.testing.assert_allclose(dir_outlyingness,
np.array([[[0., 0.], [0., 0.], [0., 0.],
[0., 0.]],
[[0.19611614, 0.03922323],
[0.19611614, 0.03922323],
[0.19611614, 0.03922323],
[0.19900744, 0.01990074]],
[[0.49937617, -0.02496881],
[0.49937617, -0.02496881],
[0.49937617, -0.02496881],
[0.49937617, -0.02496881]]]),
rtol=1e-06)
np.testing.assert_allclose(mean_dir_outl,
np.array([[0., 0.],
[0.29477656, 0.05480932],
[0.74906425, -0.03745321]]),
rtol=1e-06)
np.testing.assert_allclose(variation_dir_outl,
np.array([0., 0.01505136, 0.09375]))
def test_magnitude_shape_plot(self):
fd = fetch_weather()["data"]
fd_temperatures = FDataGrid(data_matrix=fd.data_matrix[:, :, 0],
sample_points=fd.sample_points,
dataset_label=fd.dataset_label,
axes_labels=fd.axes_labels[0:2])
msplot = MagnitudeShapePlot(fd_temperatures, random_state=0)
np.testing.assert_allclose(
msplot.points,
np.array([[0.28216472, 3.15069249], [1.43406267, 0.77729052],
[0.96089808, 2.7302293], [2.1469911, 7.06601804],
[0.89081951, 0.71098079], [1.22591999, 0.2363983],
[-2.65530111, 0.9666511], [0.47819535, 0.83989187],
[-0.11256072, 0.89035836], [0.99627103, 0.3255725],
[0.77889317, 0.32451932], [3.47490723, 12.5630275],
[3.14828582, 13.80605804], [3.51793514, 10.46943904],
[3.94435195, 15.24142224], [0., 0.],
[0.74574282, 6.68207165], [-0.82501844, 0.82694929],
[-3.4617439, 1.10389229], [0.44523944, 1.61262494],
[-0.52255157, 1.00486028], [-1.67260144, 0.74626351],
[-0.10133788, 0.96326946], [0.36576472, 0.93071675],
[7.57827303, 40.70985885], [7.51140842, 36.65641988],
[7.13000185, 45.56574331], [0.28166597, 1.70861091],
[1.55486533, 8.75149947], [-1.43363018, 0.36935927],
[-2.79138743, 4.80007762], [-2.39987853, 1.54992208],
[-5.87118328, 5.34300766], [-5.42854833, 5.1694065],
[-16.34459211, 0.9397118]]))
np.testing.assert_array_almost_equal(
msplot.outliers,
np.array([
0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0,
0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1
]))
def fit(self, Xtrain, ytrain):
grid_fd = FDataGrid(Xtrain, self.sample_points)
fpca_discretized = FPCA(n_components=self.Ncomps)
theta = fpca_discretized.fit_transform(grid_fd)
fpca = fpca_discretized.components_.data_matrix.squeeze()
fpca_gxl = fpca_discretized.explained_variance_ratio_
theta_m = theta - theta.mean(0)
T0 = np.eye(theta.shape[1])
fpca_lamda = self.COV_shrinkage_SCM(theta_m.T, T0)
self.fpca = fpca
self.fpca_lamda = fpca_lamda
n, p = Xtrain.shape
diff = self.sample_points[1] - self.sample_points[0]
y = (Xtrain.reshape(n, 1, p) -
np.tile(Xtrain,
(n, 1)).reshape(n, n, p)).reshape(n, n, 1, p) * (np.tile(
fpca, (n, 1)).reshape(n, self.Ncomps, p))
Xtrain_p = (((diff * y[:, :, :, 1:]).sum(3))**2 /
fpca_lamda.squeeze()).sum(2)
self.model.fit(Xtrain_p, ytrain)
return self
def test_lp_error_grid_points(self):
grid_points = [1, 2, 4, 4.3, 5]
fd2 = FDataGrid([[2, 3, 4, 5, 6], [1, 4, 9, 16, 25]],
grid_points=grid_points)
with np.testing.assert_raises(ValueError):
lp_distance(self.fd, fd2)
def test_fdboxplot_univariate(self):
data_matrix = [[1, 1, 2, 3, 2.5, 2], [0.5, 0.5, 1, 2, 1.5, 1],
[-1, -1, -0.5, 1, 1, 0.5],
[-0.5, -0.5, -0.5, -1, -1, -1]]
grid_points = [0, 2, 4, 6, 8, 10]
fd = FDataGrid(data_matrix, grid_points)
fdataBoxplot = Boxplot(fd, depth_method=IntegratedDepth())
np.testing.assert_array_equal(fdataBoxplot.median.ravel(),
np.array([-1., -1., -0.5, 1., 1., 0.5]))
np.testing.assert_array_equal(
fdataBoxplot.central_envelope[0].ravel(),
np.array([-1., -1., -0.5, -1., -1., -1.]))
np.testing.assert_array_equal(
fdataBoxplot.central_envelope[1].ravel(),
np.array([-0.5, -0.5, -0.5, 1., 1., 0.5]))
np.testing.assert_array_equal(
fdataBoxplot.non_outlying_envelope[0].ravel(),
np.array([-1., -1., -0.5, -1., -1., -1.]))
np.testing.assert_array_equal(
fdataBoxplot.non_outlying_envelope[1].ravel(),
np.array([-0.5, -0.5, -0.5, 1., 1., 0.5]))
self.assertEqual(len(fdataBoxplot.envelopes), 1)
np.testing.assert_array_equal(fdataBoxplot.envelopes[0],
fdataBoxplot.central_envelope)
np.testing.assert_array_equal(fdataBoxplot.outliers,
np.array([True, True, False, False]))
class TestLpMetrics(unittest.TestCase):
def setUp(self):
grid_points = [1, 2, 3, 4, 5]
self.fd = FDataGrid([[2, 3, 4, 5, 6], [1, 4, 9, 16, 25]],
grid_points=grid_points)
basis = Monomial(n_basis=3, domain_range=(1, 5))
self.fd_basis = FDataBasis(basis, [[1, 1, 0], [0, 0, 1]])
self.fd_curve = self.fd.concatenate(self.fd, as_coordinates=True)
self.fd_surface = make_multimodal_samples(n_samples=3,
dim_domain=2,
random_state=0)
def test_lp_norm(self):
np.testing.assert_allclose(lp_norm(self.fd, p=1), [16., 41.33333333])
np.testing.assert_allclose(lp_norm(self.fd, p='inf'), [6, 25])
def test_lp_norm_curve(self):
np.testing.assert_allclose(lp_norm(self.fd_curve, p=1, p2=1),
[32., 82.666667])
np.testing.assert_allclose(lp_norm(self.fd_curve, p='inf', p2='inf'),
[6, 25])
def test_lp_norm_surface_inf(self):
np.testing.assert_allclose(
lp_norm(self.fd_surface, p='inf').round(5),
[0.99994, 0.99793, 0.99868])
def test_lp_norm_surface(self):
# Integration of surfaces not implemented, add test case after
# implementation
self.assertEqual(lp_norm(self.fd_surface, p=1), NotImplemented)
def test_lp_error_dimensions(self):
# Case internal arrays
with np.testing.assert_raises(ValueError):
lp_distance(self.fd, self.fd_surface)
with np.testing.assert_raises(ValueError):
lp_distance(self.fd, self.fd_curve)
with np.testing.assert_raises(ValueError):
lp_distance(self.fd_surface, self.fd_curve)
def test_lp_error_domain_ranges(self):
grid_points = [2, 3, 4, 5, 6]
fd2 = FDataGrid([[2, 3, 4, 5, 6], [1, 4, 9, 16, 25]],
grid_points=grid_points)
with np.testing.assert_raises(ValueError):
lp_distance(self.fd, fd2)
def test_lp_error_grid_points(self):
grid_points = [1, 2, 4, 4.3, 5]
fd2 = FDataGrid([[2, 3, 4, 5, 6], [1, 4, 9, 16, 25]],
grid_points=grid_points)
with np.testing.assert_raises(ValueError):
lp_distance(self.fd, fd2)
def test_magnitude_shape_plot(self):
fd = fetch_weather()["data"]
fd_temperatures = FDataGrid(data_matrix=fd.data_matrix[:, :, 0],
sample_points=fd.sample_points,
dataset_label=fd.dataset_label,
axes_labels=fd.axes_labels[0:2])
msplot = MagnitudeShapePlot(fd_temperatures,
depth_method=modified_band_depth)
np.testing.assert_allclose(
msplot.points,
np.array([[0.2591055, 3.15861149], [1.3811996, 0.91806814],
[0.94648379, 2.75695426], [2.11346208, 7.24045853],
[0.82557436, 0.82727771], [1.23249759, 0.22004329],
[-2.66259589, 0.96925352], [0.15827963, 1.00235557],
[-0.43751765, 0.66236714], [0.70695162, 0.66482897],
[0.73095525, 0.33165117], [3.48445368, 12.59745018],
[3.15539264, 13.85234879], [3.52759979, 10.49810783],
[3.95518808, 15.28317686], [-0.48486514, 0.5035343],
[0.64492781, 6.83385521], [-0.83185751, 0.81125541],
[-3.47125418, 1.10683451], [0.22241054, 1.76783493],
[-0.54402406, 0.95229119], [-1.71310618, 0.61875513],
[-0.44161441, 0.77815135], [0.13851408, 1.02560672],
[7.59909246, 40.82126568], [7.57868277, 36.03923856],
[7.12930634, 45.96866318], [0.05746528, 1.75817588],
[1.53092075, 8.85227], [-1.48696387, 0.22472872],
[-2.853082, 4.50814844], [-2.42297615, 1.46926902],
[-5.8873129, 5.35742609], [-5.44346193, 5.18338576],
[-16.38949483, 0.94027717]]))
np.testing.assert_array_almost_equal(
msplot.outliers,
np.array([
0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0,
0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1
]))
def test_lp_error_domain_ranges(self):
sample_points = [2, 3, 4, 5, 6]
fd2 = FDataGrid([[2, 3, 4, 5, 6], [1, 4, 9, 16, 25]],
sample_points=sample_points)
with np.testing.assert_raises(ValueError):
lp_distance(self.fd, fd2)
def test_groupfpca_errors():
n_basis = 9
n_components = 1
grid_points = np.arange(0.5, 365, 1)
fd_data = fetch_weather()["data"].coordinates[0]
fd_data = FDataGrid(np.squeeze(fd_data.data_matrix), grid_points)
X = fd_data.data_matrix.squeeze()
X = np.hstack([X, X])
groups = [np.arange(0, 365), np.arange(365, 730)]
with pytest.raises(ValueError):
GroupFPCA(n_components=n_components,
n_basis=n_basis,
basis=object,
groups=groups).fit(X)
with pytest.raises(ValueError):
GroupFPCA(n_components=n_components,
n_basis=n_basis,
basis="error",
groups=groups).fit(X)
with pytest.raises(TypeError):
GroupFPCA(
n_components=n_components,
n_basis=n_basis,
groups=groups,
exclude_groups="error",
).fit(X)
def test_slice(self):
t = 10
fd = FDataGrid(data_matrix=numpy.ones(t))
fd = fd[:, 0]
numpy.testing.assert_array_equal(fd.data_matrix[..., 0],
numpy.array([[1]]))
numpy.testing.assert_array_equal(fd.sample_points, numpy.array([[0]]))
def test_group_fpca_bases(basis, use_grid_points, exclude_groups):
n_basis = 9
n_components = 1
grid_points = np.arange(0.5, 365, 1)
fd_data = fetch_weather()["data"].coordinates[0]
fd_data = FDataGrid(np.squeeze(fd_data.data_matrix), grid_points)
X = fd_data.data_matrix.squeeze()
X = np.hstack([X, X])
groups = [np.arange(0, 365), np.arange(365, 730)]
if use_grid_points:
grid_points = np.hstack([grid_points, grid_points])
else:
grid_points = None
gfpca = GroupFPCA(
n_components=n_components,
n_basis=n_basis,
basis_domain_range=(0, 365),
basis=basis,
groups=groups,
exclude_groups=exclude_groups,
).fit(X, grid_points=grid_points)
_ = gfpca.transform(X, grid_points=grid_points)
def test_evaluation_center_and_extreme_points_linear(self):
"""Test linear interpolation in the middle point of a grid square."""
dim_codomain = 4
n_samples = 2
@np.vectorize
def coordinate_function(*args):
_, *domain_indexes, _ = args
return np.sum(domain_indexes)
for dim_domain in range(1, 6):
grid_points = [np.array([0, 1]) for _ in range(dim_domain)]
data_matrix = np.fromfunction(
function=coordinate_function,
shape=(n_samples,) + (2,) * dim_domain + (dim_codomain,))
f = FDataGrid(data_matrix, grid_points=grid_points)
evaluation = f([[0.] * dim_domain, [0.5] *
dim_domain, [1.] * dim_domain])
self.assertEqual(evaluation.shape, (n_samples, 3, dim_codomain))
for i in range(n_samples):
for j in range(dim_codomain):
np.testing.assert_array_almost_equal(
evaluation[i, ..., j],
[0, dim_domain * 0.5, dim_domain])
def test_init(self):
fd = FDataGrid([[1, 2, 3, 4, 5], [2, 3, 4, 5, 6]])
np.testing.assert_array_equal(
fd.data_matrix[..., 0], np.array([[1, 2, 3, 4, 5], [2, 3, 4, 5,
6]]))
np.testing.assert_array_equal(fd.sample_range, [(0, 1)])
np.testing.assert_array_equal(fd.sample_points,
np.array([[0., 0.25, 0.5, 0.75, 1.]]))
def test_mean(self):
fd = FDataGrid([[1, 2, 3, 4, 5], [2, 3, 4, 5, 6]])
mean = stats.mean(fd)
np.testing.assert_array_equal(mean.data_matrix[0, ..., 0],
np.array([1.5, 2.5, 3.5, 4.5, 5.5]))
np.testing.assert_array_equal(fd.sample_range, [(0, 1)])
np.testing.assert_array_equal(fd.sample_points,
np.array([[0., 0.25, 0.5, 0.75, 1.]]))
