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 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]
#nb_bc_orth = int(2*width / sigma) +1 # #points_temp, vectors_temp = cmp.compute_pointsvectors_2articulations_nb(a_list[0], b_list[0], c_list[0], width, sigma, nb_ab, nb_ab_orth, nb_bc, nb_bc_orth) nb_vectors = len(vectors_list[0][0]) nb_points = len(points_list[0][0]) dim = 2 # Create list of structured and unstructured def kernel(x, y): return np.exp(-sum([(xi - yi)**2 for xi, yi in zip(x, y)]) / (sigma**2)) get_unstructured_op = struct.get_from_structured_to_unstructured(space, kernel) structured_list = [] unstructured_list = [] for i in range(nbdata): points = points_list[i].copy() 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)
solve_regression = reg.solve_regression calibration = cali.calibrate def action(group_element, structured_field): return act.apply_element_to_field(g, group_element, structured_field) def product(vect0, vect1): return struct.scalar_product_structured(vect0, vect1, kernel) pairing = struct.scalar_product_unstructured #%% define calibration get_unstructured_op = struct.get_from_structured_to_unstructured(space, kernel) #mg = space.meshgrid #def get_unstructured_op(structured_field): # dim_double, nb_points = structured_field.shape # points = struct.get_points(structured_field) # vectors = struct.get_vectors(structured_field) # unstructured = space.tangent_bundle.zero() # # for k in range(nb_points): # def kern_app_point(x): # return kernel(proj([xu - pu for xu, pu in zip(x, points[:, k])]) , [0]) # # kern_discr = kern_app_point(mg) # # unstructured += space.tangent_bundle.element([kern_discr * vect for vect in vectors[:, k]]).copy()
def __init__(self, space, kernel): self.space = space self.unstructured_op = struct.get_from_structured_to_unstructured(space, kernel)
def __init__(self, space, kernel): self.space = space self.extent = space.max_pt[0] - space.min_pt[0] self.k = 1 self.unstructured_op = struct.get_from_structured_to_unstructured( space, kernel)