def test_calibration():
space = odl.uniform_discr(min_pt=[-1],
max_pt=[1],
shape=[128],
dtype='float32',
interp='linear')
cell_side = space.cell_sides
#kernel = get_kernel(space)
kernel = get_kernel_gauss(space, 0.2)
def product(f, g):
return struct.scalar_product_structured(f, g, kernel)
#points = space.points()[::2].T
points = np.array([[
-0.75,
0.0,
0.2,
0.5,
]])
vectors = np.array([[
0.3,
0.0,
0,
1,
]])
original = struct.create_structured(points, vectors)
g = group.Translation(space)
translation = np.array([1.0])
translated = action.apply_element_to_field(g, translation, original)
covariance_matrix = struct.make_covariance_matrix(space.points().T, kernel)
noise_l2 = odl.phantom.noise.white_noise(space) * 0.05
decomp = np.linalg.cholesky(covariance_matrix +
1e-5 * np.identity(len(covariance_matrix)))
noise_rkhs = np.dot(decomp, noise_l2)
get_unstructured = struct.get_from_structured_to_unstructured(
space, kernel)
noisy = space.tangent_bundle.element(
get_unstructured(translated) + noise_rkhs)
def act(element, struct):
return action.apply_element_to_field(g, element, struct)
result_calibration = calib.calibrate(original, noisy, g, act, product,
struct.scalar_product_unstructured)
estimated_translated = get_unstructured(act(result_calibration.x,
original))
print('real = {}, computed ={} , log diff = {}'.format(
translation, result_calibration.x,
np.log10(np.abs(translation[0] - result_calibration.x[0]))))
def test_make_covariance_matrix():
def kernel(x, y):
return np.sum(x + y, axis=0)
dim = 2
nb_points = 3
points = np.random.randn(dim, nb_points)
Mat_expected = np.empty([nb_points, nb_points])
for i in range(nb_points):
for j in range(nb_points):
Mat_expected[i, j] = kernel(points[:, i], points[:, j])
Mat_computed = structured_vector_fields.make_covariance_matrix(
points, kernel)
npt.assert_allclose(Mat_computed, Mat_expected)
def iterative_scheme(solve_regression, calibration, action, g, kernel,
field_list, sigma0, sigma1, points, nb_iteration):
nb_data = len(field_list)
eval_kernel = struct.make_covariance_matrix(points, kernel)
dim, nb_points = points.shape
def product(vect0, vect1):
return struct.scalar_product_structured(vect0, vect1, kernel)
# initialization with a structured version of first vector field (NOT GOOD)
group_element_init = g.identity
vectors_original = solve_regression(g, [group_element_init],
[field_list[0]], sigma0, sigma1,
points, eval_kernel)
vectors_original_struct = struct.get_structured_vectors_from_concatenated(
vectors_original, nb_points, dim)
original = struct.create_structured(points, vectors_original_struct)
get_unstructured_op = struct.get_from_structured_to_unstructured(
field_list[0].space[0], kernel)
get_unstructured_op(original).show('initialisation')
for k in range(nb_iteration):
velocity_list = calibrate_list(original, field_list, calibration)
group_element_list = [
g.exponential(velocity_list[i]) for i in range(nb_data)
]
vectors_original = solve_regression(g, group_element_list, field_list,
sigma0, sigma1, points,
eval_kernel)
vectors_original_struct = struct.get_structured_vectors_from_concatenated(
vectors_original, nb_points, dim)
original = struct.create_structured(points, vectors_original_struct)
print('iteration {}'.format(k))
get_unstructured_op(original).show('iteration {}'.format(k))
return [original, group_element_list]
vectors = vectors_list[i].copy()
#points, vectors = cmp.compute_pointsvectors_2articulations_nb(a_list[i], b_list[i], c_list[i], width, sigma, nb_ab, nb_ab_orth, nb_bc, nb_bc_orth)
eval_field = np.array([
space.element(vector_fields_list[i][:, :, u]).interpolation(points)
for u in range(dim)
]).copy()
vector_syst = np.zeros(dim * nb_points)
basis = np.identity(dim)
for k0 in range(nb_points):
for l0 in range(dim):
vector_syst[dim * k0 + l0] += np.dot(eval_field.T[k0], basis[:,
l0])
eval_kernel = struct.make_covariance_matrix(points, kernel)
matrix_syst = np.kron(eval_kernel, basis)
alpha_concatenated = np.linalg.solve(matrix_syst, vector_syst)
alpha = struct.get_structured_vectors_from_concatenated(
alpha_concatenated, nb_points, dim)
structured = struct.create_structured(points, alpha)
structured_list.append(structured.copy())
unstructured_list.append(get_unstructured_op(structured).copy())
#
#%% See projection
#plt.plot(points[0] , points[1], 'xb')
get_unstructured_op_generate = struct.get_from_structured_to_unstructured(
space, kernel_generate)
#%% define data
dim = 1
nb_pt_generate = 3
points_truth = np.random.uniform(low=-1.0, high=1.0, size=nb_pt_generate)
vectors_truth = np.random.uniform(low=-1.0, high=1.0, size=nb_pt_generate)
original = struct.create_structured(points_truth, vectors_truth)
original_unstructured = get_unstructured_op_generate(original)
data_list = []
nb_data = 10
translation_list = np.random.uniform(low=-1.0, high=1.0, size=nb_data)
covariance_matrix = struct.make_covariance_matrix(space.points().T,
kernel_generate)
noise_l2 = odl.phantom.noise.white_noise(odl.ProductSpace(space,
nb_data)) * 0.1
decomp = np.linalg.cholesky(covariance_matrix +
1e-4 * np.identity(len(covariance_matrix)))
noise_rkhs = [np.dot(decomp, noise_l2[i]) for i in range(nb_data)]
pts_space = space.points().T
#data_list=[]
#for i in range(nb_data):
# pts_displaced = g.apply(np.array([-translation_list[i]]), pts_space)
# data_list.append(space.tangent_bundle.element([original_unstructured[u].interpolation(pts_displaced) for u in range(dim)]))
data_list_noisy = [
space.tangent_bundle.element(
get_unstructured_op_generate(
action(np.array([translation_list[i]]), original)) + noise_rkhs[i])
points_list = []
vectors_list = []
cov_mat_list = []
param_list = []
A_inner_prod_list = []
nbdatamax = 10
for i in range(nbdatamax):
structured_list.append(np.loadtxt(name + 'structured' + str(i)))
unstructured_list.append(np.loadtxt(name + 'unstructured' + str(i)))
vectors_i = structured_list[i][dim:2 * dim]
points_list.append(np.loadtxt(name + 'points' + str(i)))
vectors_list.append(np.loadtxt(name + 'vectors' + str(i)))
param_list.append(np.loadtxt(name + 'param' + str(i)))
cov_mat_list.append(
struct.make_covariance_matrix(points_list[i], kernel_np))
A_inner_prod_list.append(
np.dot(cov_mat_list[i], np.dot(vectors_i.T, vectors_list[i])).T)
#
param_list = np.array(param_list).T
nb_points = len(points_list[0][0])
nb_vectors = len(vectors_list[0][0])
##%% Graph 1 : projection of data on zeta(o, 1) and diff with data
#
##inp = tf.placeholder(shape=(nb_vectors, nb_points), dtype=tf.float64)
#inp = tf.Variable(np.ones([nb_vectors, nb_points]), name="alpha")
#
## List of zeta_(o_i) (1)
#structured_list_computed = [create_structured(points_list[i], tf.matmul(vectors_list[i], inp)) for i in range(nbdatamax)]
