def test_vector_valued(self):
def f(x):
return x**2
def g(y):
return 3 * y
t = np.linspace(0, 1, 100)
data_matrix = np.array([np.array([f(t), g(t)]).T])
sample_points = [t]
fd = skfda.FDataGrid(data_matrix, sample_points=sample_points)
basis = VectorValued([Monomial(n_basis=5), Monomial(n_basis=5)])
fd_basis = fd.to_basis(basis)
res = 1 / 5 + 3
np.testing.assert_allclose(skfda.misc.inner_product(fd, fd),
res,
rtol=1e-5)
np.testing.assert_allclose(skfda.misc.inner_product(
fd_basis, fd_basis),
res,
rtol=1e-5)
def test_several_variables(self):
def f(x, y, z):
return x * y * z
t = np.linspace(0, 1, 100)
x2, y2, z2 = ndm(t, 2 * t, 3 * t)
data_matrix = f(x2, y2, z2)
sample_points = [t, 2 * t, 3 * t]
fd = skfda.FDataGrid(data_matrix[np.newaxis, ...],
sample_points=sample_points)
basis = Tensor([
Monomial(n_basis=5, domain_range=(0, 1)),
Monomial(n_basis=5, domain_range=(0, 2)),
Monomial(n_basis=5, domain_range=(0, 3))
])
fd_basis = fd.to_basis(basis)
res = 8
np.testing.assert_allclose(skfda.misc.inner_product(fd, fd),
res,
rtol=1e-5)
np.testing.assert_allclose(skfda.misc.inner_product(
fd_basis, fd_basis),
res,
rtol=1e-5)
def test_regression_mixed(self):
multivariate = np.array([[0, 0], [2, 7], [1, 7], [3, 9], [4, 16],
[2, 14], [3, 5]])
X = [
multivariate,
FDataBasis(Monomial(n_basis=3),
[[1, 0, 0], [0, 1, 0], [0, 0, 1], [1, 0, 1], [1, 0, 0],
[0, 1, 0], [0, 0, 1]])
]
# y = 2 + sum([3, 1] * array) + int(3 * function)
intercept = 2
coefs_multivariate = np.array([3, 1])
coefs_functions = FDataBasis(Monomial(n_basis=3), [[3, 0, 0]])
y_integral = np.array([3, 3 / 2, 1, 4, 3, 3 / 2, 1])
y_sum = multivariate @ coefs_multivariate
y = 2 + y_sum + y_integral
scalar = LinearRegression()
scalar.fit(X, y)
np.testing.assert_allclose(scalar.intercept_, intercept, atol=0.01)
np.testing.assert_allclose(scalar.coef_[0],
coefs_multivariate,
atol=0.01)
np.testing.assert_allclose(scalar.coef_[1].coefficients,
coefs_functions.coefficients,
atol=0.01)
y_pred = scalar.predict(X)
np.testing.assert_allclose(y_pred, y, atol=0.01)
def test_comutativity_inprod(self):
monomial = Monomial(n_basis=4)
bspline = BSpline(n_basis=5, order=3)
bsplinefd = FDataBasis(bspline, np.arange(0, 15).reshape(3, 5))
np.testing.assert_array_almost_equal(
bsplinefd.inner_product(monomial).round(3),
np.transpose(monomial.inner_product(bsplinefd).round(3)))
def test_error_y_is_FData(self):
"""Tests that none of the explained variables is an FData object
"""
x_fd = FDataBasis(Monomial(n_basis=7), np.identity(7))
y = list(FDataBasis(Monomial(n_basis=7), np.identity(7)))
scalar = LinearScalarRegression([Fourier(n_basis=5)])
np.testing.assert_raises(ValueError, scalar.fit, [x_fd], y)
def test_error_beta_not_basis(self):
""" Test that all beta are Basis objects. """
x_fd = FDataBasis(Monomial(n_basis=7), np.identity(7))
y = [1 for _ in range(7)]
beta = FDataBasis(Monomial(n_basis=7), np.identity(7))
scalar = LinearScalarRegression([beta])
np.testing.assert_raises(ValueError, scalar.fit, [x_fd], y)
def test_fdatabasis_times_fdatabasis_list(self):
monomial = FDataBasis(Monomial(nbasis=3),
[[1, 2, 3], [4, 5, 6], [7, 8, 9]])
result = monomial.times([3, 2, 1])
expec_basis = Monomial(nbasis=3)
expec_coefs = np.array([[3, 6, 9], [8, 10, 12], [7, 8, 9]])
self.assertEqual(expec_basis, result.basis)
np.testing.assert_array_almost_equal(expec_coefs, result.coefficients)
def test_basis_fdatabasis_inprod(self):
monomial = Monomial(n_basis=4)
bspline = BSpline(n_basis=5, order=3)
bsplinefd = FDataBasis(bspline, np.arange(0, 15).reshape(3, 5))
np.testing.assert_array_almost_equal(
monomial.inner_product(bsplinefd).round(3),
np.array([[2., 7., 12.], [1.29626206, 3.79626206, 6.29626206],
[0.96292873, 2.62959539, 4.29626206],
[0.7682873, 2.0182873, 3.2682873]]).round(3))
def test_fdatabasis_times_fdatabasis_int(self):
monomial = FDataBasis(Monomial(n_basis=3),
[[1, 2, 3], [4, 5, 6], [7, 8, 9]])
result = monomial.times(3)
expec_basis = Monomial(n_basis=3)
expec_coefs = np.array([[3, 6, 9], [12, 15, 18], [21, 24, 27]])
self.assertEqual(expec_basis, result.basis)
np.testing.assert_array_almost_equal(expec_coefs, result.coefficients)
def test_error_weights_negative(self):
""" Test that none of the weights are negative. """
x_fd = FDataBasis(Monomial(n_basis=7), np.identity(7))
y = [1 for _ in range(7)]
weights = [-1 for _ in range(7)]
beta = Monomial(n_basis=7)
scalar = LinearScalarRegression([beta])
np.testing.assert_raises(ValueError, scalar.fit, [x_fd], y, weights)
def test_basis_gram_matrix_monomial(self):
basis = Monomial(n_basis=3)
gram_matrix = basis.gram_matrix()
gram_matrix_numerical = basis._gram_matrix_numerical()
gram_matrix_res = np.array([[1, 1 / 2, 1 / 3], [1 / 2, 1 / 3, 1 / 4],
[1 / 3, 1 / 4, 1 / 5]])
np.testing.assert_allclose(gram_matrix, gram_matrix_res)
np.testing.assert_allclose(gram_matrix_numerical, gram_matrix_res)
def test_error_weights_lenght(self):
""" Test that the number of weights is equal to the
number of samples """
x_fd = FDataBasis(Monomial(n_basis=7), np.identity(7))
y = [1 for _ in range(7)]
weights = [1 for _ in range(8)]
beta = Monomial(n_basis=7)
scalar = LinearScalarRegression([beta])
np.testing.assert_raises(ValueError, scalar.fit, [x_fd], y, weights)
def test_basis_constant_product(self):
constant = Constant()
monomial = Monomial()
fourier = Fourier()
bspline = BSpline(n_basis=5, order=3)
self.assertEqual(constant.basis_of_product(monomial), monomial)
self.assertEqual(constant.basis_of_product(fourier), fourier)
self.assertEqual(constant.basis_of_product(bspline), bspline)
self.assertEqual(monomial.basis_of_product(constant), monomial)
self.assertEqual(fourier.basis_of_product(constant), fourier)
self.assertEqual(bspline.basis_of_product(constant), bspline)
def test_basis_basis_inprod(self):
monomial = Monomial(nbasis=4)
bspline = BSpline(nbasis=5, order=4)
np.testing.assert_array_almost_equal(
monomial.inner_product(bspline).round(3),
np.array(
[[0.12499983, 0.25000035, 0.24999965, 0.25000035, 0.12499983],
[0.01249991, 0.07500017, 0.12499983, 0.17500017, 0.11249991],
[0.00208338, 0.02916658, 0.07083342, 0.12916658, 0.10208338],
[0.00044654, 0.01339264, 0.04375022, 0.09910693, 0.09330368]])
.round(3)
)
def test_fdatabasis__div__(self):
monomial1 = FDataBasis(Monomial(n_basis=3), [1, 2, 3])
monomial2 = FDataBasis(Monomial(n_basis=3), [[1, 2, 3], [3, 4, 5]])
self.assertTrue((monomial1 / 2).equals(
FDataBasis(Monomial(n_basis=3), [[1 / 2, 1, 3 / 2]])))
self.assertTrue((monomial2 / 2).equals(
FDataBasis(Monomial(n_basis=3),
[[1 / 2, 1, 3 / 2], [3 / 2, 2, 5 / 2]])))
self.assertTrue((monomial2 / [1, 2]).equals(
FDataBasis(Monomial(n_basis=3), [[1, 2, 3], [3 / 2, 2, 5 / 2]])))
def test_basis_inner_matrix(self):
np.testing.assert_array_almost_equal(
Monomial(n_basis=3)._inner_matrix(),
[[1, 1 / 2, 1 / 3], [1 / 2, 1 / 3, 1 / 4], [1 / 3, 1 / 4, 1 / 5]])
np.testing.assert_array_almost_equal(
Monomial(n_basis=3)._inner_matrix(Monomial(n_basis=3)),
[[1, 1 / 2, 1 / 3], [1 / 2, 1 / 3, 1 / 4], [1 / 3, 1 / 4, 1 / 5]])
np.testing.assert_array_almost_equal(
Monomial(n_basis=3)._inner_matrix(Monomial(n_basis=4)),
[[1, 1 / 2, 1 / 3, 1 / 4], [1 / 2, 1 / 3, 1 / 4, 1 / 5],
[1 / 3, 1 / 4, 1 / 5, 1 / 6]])
def test_fdatabasis__mul__2(self):
monomial1 = FDataBasis(Monomial(n_basis=3), [1, 2, 3])
monomial2 = FDataBasis(Monomial(n_basis=3), [[1, 2, 3], [3, 4, 5]])
np.testing.assert_equal(monomial1 / 2,
FDataBasis(Monomial(n_basis=3),
[[1 / 2, 1, 3 / 2]]))
np.testing.assert_equal(monomial2 / 2,
FDataBasis(Monomial(n_basis=3),
[[1 / 2, 1, 3 / 2], [3 / 2, 2, 5 / 2]]))
np.testing.assert_equal(monomial2 / [1, 2],
FDataBasis(Monomial(n_basis=3),
[[1, 2, 3], [3 / 2, 2, 5 / 2]]))
def test_evaluation_composed_keepdims_monomial(self):
"""Test behaviour of keepdims with composed evaluation"""
monomial = Monomial(domain_range=(0, 1), nbasis=3)
coefficients = [[1, 2, 3], [0.5, 1.4, 1.3]]
f = FDataBasis(monomial, coefficients)
f_keepdims = FDataBasis(monomial, coefficients, keepdims=True)
t = [[0, 0.5, 0.6], [0.2, 0.7, 0.1]]
res = np.array([[1., 2.75, 3.28],
[0.832, 2.117, 0.653]])
res_keepdims = res.reshape((2, 3, 1))
# Case default behaviour keepdims=False
np.testing.assert_array_almost_equal(
f(t, aligned_evaluation=False).round(3), res)
np.testing.assert_array_almost_equal(f(t, aligned_evaluation=False,
keepdims=False).round(3), res)
np.testing.assert_array_almost_equal(f(t, aligned_evaluation=False,
keepdims=True).round(3),
res_keepdims)
# Case default behaviour keepdims=True
np.testing.assert_array_almost_equal(
f_keepdims(t, aligned_evaluation=False).round(3),
res_keepdims)
np.testing.assert_array_almost_equal(
f_keepdims(t, aligned_evaluation=False, keepdims=False).round(3),
res)
np.testing.assert_array_almost_equal(
f_keepdims(t, aligned_evaluation=False, keepdims=True).round(3),
res_keepdims)
def test_evaluation_keepdims_monomial(self):
"""Test behaviour of keepdims """
monomial = Monomial(domain_range=(0, 1), nbasis=3)
coefficients = [[1, 2, 3], [0.5, 1.4, 1.3]]
f = FDataBasis(monomial, coefficients)
f_keepdims = FDataBasis(monomial, coefficients, keepdims=True)
np.testing.assert_equal(f.keepdims, False)
np.testing.assert_equal(f_keepdims.keepdims, True)
t = np.linspace(0, 1, 4)
res = np.array([[1., 2., 3.667, 6.],
[0.5, 1.111, 2.011, 3.2]])
res_keepdims = res.reshape((2, 4, 1))
# Case default behaviour keepdims=False
np.testing.assert_array_almost_equal(f(t).round(3), res)
np.testing.assert_array_almost_equal(
f(t, keepdims=False).round(3), res)
np.testing.assert_array_almost_equal(f(t, keepdims=True).round(3),
res_keepdims)
# Case default behaviour keepdims=True
np.testing.assert_array_almost_equal(
f_keepdims(t).round(3), res_keepdims)
np.testing.assert_array_almost_equal(
f_keepdims(t, keepdims=False).round(3), res)
np.testing.assert_array_almost_equal(
f_keepdims(t, keepdims=True).round(3), res_keepdims)
def test_monomial_linear_diff_op(self):
n_basis = 5
basis = Monomial(n_basis=n_basis)
linear_diff_op = [3]
res = np.array([[0., 0., 0., 0., 3.], [0., 0., 0., 3., 0.],
[0., 0., 3., 0., 0.], [0., 3., 0., 0., 0.],
[3., 0., 0., 0., 0.]])
np.testing.assert_allclose(
_monomial_evaluate_constant_linear_diff_op(basis, linear_diff_op),
res)
linear_diff_op = [3, 2]
res = np.array([[0., 0., 0., 0., 3.], [0., 0., 0., 3., 2.],
[0., 0., 3., 4., 0.], [0., 3., 6., 0., 0.],
[3., 8., 0., 0., 0.]])
np.testing.assert_allclose(
_monomial_evaluate_constant_linear_diff_op(basis, linear_diff_op),
res)
linear_diff_op = [3, 0, 5]
res = np.array([[0., 0., 0., 0., 3.], [0., 0., 0., 3., 0.],
[0., 0., 3., 0., 10.], [0., 3., 0., 30., 0.],
[3., 0., 60., 0., 0.]])
np.testing.assert_allclose(
_monomial_evaluate_constant_linear_diff_op(basis, linear_diff_op),
res)
def test_basis_gram_matrix(self):
np.testing.assert_array_almost_equal(
Monomial(n_basis=3).gram_matrix(),
[[1, 1 / 2, 1 / 3], [1 / 2, 1 / 3, 1 / 4], [1 / 3, 1 / 4, 1 / 5]])
np.testing.assert_almost_equal(
Fourier(n_basis=3).gram_matrix(), np.identity(3))
np.testing.assert_almost_equal(
BSpline(n_basis=6).gram_matrix().round(4),
np.array([[
4.760e-02, 2.920e-02, 6.200e-03, 4.000e-04, 0.000e+00,
0.000e+00
],
[
2.920e-02, 7.380e-02, 5.210e-02, 1.150e-02,
1.000e-04, 0.000e+00
],
[
6.200e-03, 5.210e-02, 1.090e-01, 7.100e-02,
1.150e-02, 4.000e-04
],
[
4.000e-04, 1.150e-02, 7.100e-02, 1.090e-01,
5.210e-02, 6.200e-03
],
[
0.000e+00, 1.000e-04, 1.150e-02, 5.210e-02,
7.380e-02, 2.920e-02
],
[
0.000e+00, 0.000e+00, 4.000e-04, 6.200e-03,
2.920e-02, 4.760e-02
]]))
def test_regression_single_explanatory(self):
x_basis = Monomial(n_basis=7)
x_fd = FDataBasis(x_basis, np.identity(7))
beta_basis = Fourier(n_basis=5)
beta_fd = FDataBasis(beta_basis, [1, 1, 1, 1, 1])
y = [
0.9999999999999993, 0.162381381441085, 0.08527083481359901,
0.08519946930844623, 0.09532291032042489, 0.10550022969639987,
0.11382675064746171
]
scalar = LinearRegression(coef_basis=[beta_basis])
scalar.fit(x_fd, y)
np.testing.assert_allclose(scalar.coef_[0].coefficients,
beta_fd.coefficients)
np.testing.assert_allclose(scalar.intercept_, 0.0, atol=1e-6)
y_pred = scalar.predict(x_fd)
np.testing.assert_allclose(y_pred, y)
scalar = LinearRegression(coef_basis=[beta_basis], fit_intercept=False)
scalar.fit(x_fd, y)
np.testing.assert_allclose(scalar.coef_[0].coefficients,
beta_fd.coefficients)
np.testing.assert_equal(scalar.intercept_, 0.0)
y_pred = scalar.predict(x_fd)
np.testing.assert_allclose(y_pred, y)
def test_evaluation_composed_monomial(self):
"""Test the evaluation of FDataBasis the a matrix of times instead of
a list of times """
monomial = Monomial(domain_range=(0, 1), nbasis=3)
coefficients = [[1, 2, 3], [0.5, 1.4, 1.3]]
f = FDataBasis(monomial, coefficients)
t = np.linspace(0, 1, 4)
res_test = f(t)
# Test same result than evaluation standart
np.testing.assert_array_almost_equal(f([1]), f([[1], [1]],
aligned_evaluation=False))
np.testing.assert_array_almost_equal(f(t), f(np.vstack((t, t)),
aligned_evaluation=False))
# Different evaluation times
t_multiple = [[0, 0.5], [0.2, 0.7]]
np.testing.assert_array_almost_equal(f(t_multiple[0])[0],
f(t_multiple,
aligned_evaluation=False)[0])
np.testing.assert_array_almost_equal(f(t_multiple[1])[1],
f(t_multiple,
aligned_evaluation=False)[1])
def test_monomial_penalty(self):
basis = Monomial(n_basis=5, domain_range=(0, 3))
# Theorethical result
res = np.array([[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.],
[0., 0., 12., 54., 216.], [0., 0., 54., 324., 1458.],
[0., 0., 216., 1458., 6998.4]])
self._test_penalty(basis, linear_diff_op=2, result=res)
basis = Monomial(n_basis=8, domain_range=(1, 5))
self._test_penalty(basis, linear_diff_op=[1, 2, 3])
self._test_penalty(basis, linear_diff_op=7)
self._test_penalty(basis, linear_diff_op=0)
self._test_penalty(basis, linear_diff_op=1)
self._test_penalty(basis, linear_diff_op=27)
def test_error_y_X_samples_different(self):
""" Test that the number of response samples and explanatory samples
are not different """
x_fd = FDataBasis(Monomial(n_basis=7), np.identity(7))
y = [1 for _ in range(8)]
beta = Fourier(n_basis=5)
scalar = LinearScalarRegression([beta])
np.testing.assert_raises(ValueError, scalar.fit, [x_fd], y)
x_fd = FDataBasis(Monomial(n_basis=8), np.identity(8))
y = [1 for _ in range(7)]
beta = Fourier(n_basis=5)
scalar = LinearScalarRegression([beta])
np.testing.assert_raises(ValueError, scalar.fit, [x_fd], y)
def test_comutativity_inprod(self):
monomial = Monomial(n_basis=4)
bspline = BSpline(n_basis=5, order=3)
bsplinefd = FDataBasis(bspline, np.arange(0, 15).reshape(3, 5))
np.testing.assert_allclose(
inner_product_matrix(bsplinefd, monomial),
np.transpose(inner_product_matrix(monomial, bsplinefd)))
def test_domain_in_list_monomial(self):
"""Test the evaluation of FDataBasis"""
for monomial in (Monomial(domain_range=[(0, 1)], n_basis=3),
Monomial(domain_range=((0, 1), ), n_basis=3),
Monomial(domain_range=np.array((0, 1)), n_basis=3),
Monomial(domain_range=np.array([(0, 1)]), n_basis=3)):
coefficients = [[1, 2, 3], [0.5, 1.4, 1.3]]
f = FDataBasis(monomial, coefficients)
t = np.linspace(0, 1, 4)
res = np.array([[1., 2., 3.667, 6.], [0.5, 1.111, 2.011, 3.2]])
np.testing.assert_array_almost_equal(f(t).round(3), res)
np.testing.assert_array_almost_equal(f.evaluate(t).round(3), res)
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_basis_fdatabasis_inprod(self):
monomial = Monomial(n_basis=4)
bspline = BSpline(n_basis=5, order=3)
bsplinefd = FDataBasis(bspline, np.arange(0, 15).reshape(3, 5))
np.testing.assert_allclose(
inner_product_matrix(monomial, bsplinefd),
np.array([[2., 7., 12.],
[1.29626206, 3.79626206, 6.29626206],
[0.96292873, 2.62959539, 4.29626206],
[0.7682873, 2.0182873, 3.2682873]]), rtol=1e-4)
def test_monomial_smoothing(self):
# It does not have much sense to apply smoothing in this basic case
# where the fit is very good but its just for testing purposes
t = np.linspace(0, 1, 5)
x = np.sin(2 * np.pi * t) + np.cos(2 * np.pi * t)
basis = Monomial(nbasis=4)
fd = FDataBasis.from_data(x, t, basis,
penalty_degree=2,
smoothness_parameter=1)
# These results where extracted from the R package fda
np.testing.assert_array_almost_equal(
fd.coefficients.round(2), np.array([[0.61, -0.88, 0.06, 0.02]]))