def eval_test_set_fidelity(self): """Method for evaluating points in the training set, using fidelity. Returns: list of guesses. """ labels = [[0]] * len(self.test_set[0]) for j, x in enumerate(self.test_set[0]): params = [] for i in range(0, 4 * self.layers, 4): params.append(self.params[i] * x[0] + self.params[i + 1]) params.append(self.params[i + 2] * x[1] + self.params[i + 3]) q = QuantumRegister(1) C = QuantumCircuit(q) for i in range(self.layers): C.ry(params[i], q) C.rz(params[i + 1], q) state = Statevector.from_int(0, 2**1) state = state.evolve(C) state_real = np.array([ mt.sqrt(np.conj(state.data[0]) * state.data[0]), mt.sqrt(np.conj(state.data[1]) * state.data[1]) ]) fids = np.empty(len(self.target)) for i, t in enumerate(self.target): fids[i] = fidelity(state_real, t) labels[j] = np.argmax(fids) return labels
def test_rxry(self, gradient_function): p = [0.8, 0.2] ansatz = QuantumCircuit(1) ansatz.rx(p[0], 0) ansatz.ry(p[1], 0) op = np.array([[1, 1], [1, -1]]) / np.sqrt(2) init = Statevector.from_int(1, dims=(2,)) # set up gradient object and compute gradient grad = StateGradient(op, ansatz, init) grads = getattr(grad, gradient_function)() # reference value ref = [-0.5979106735501365, 0.3849522583908403] np.testing.assert_array_almost_equal(grads, ref)
def test_global_phase_1q(self): """Test global phase preservation with some simple 1q statevectors""" target_list = [ Statevector([1j, 0]), Statevector([0, 1j]), Statevector([1j / np.sqrt(2), 1j / np.sqrt(2)]), ] n_qubits = 1 dim = 2**n_qubits qr = QuantumRegister(n_qubits) for target in target_list: with self.subTest(i=target): initializer = QuantumCircuit(qr) initializer.initialize(target, qr) # need to get rid of the resets in order to use the Operator class disentangler = Operator(initializer.data[0][0].definition.data[1][0]) zero = Statevector.from_int(0, dim) actual = zero & disentangler self.assertEqual(target, actual)
def cost_function_one_point_fidelity(self, x, y): """Method for computing the cost function for a given sample (in the datasets), using fidelity. Args: x (array): Point to create the circuit. y (int): label of x. Returns: float with the cost function. """ C = self.my_circuit(x) state = Statevector.from_int(0, 2**1) state = state.evolve(C) state_real = np.array([ mt.sqrt(np.conj(state.data[0]) * state.data[0]), mt.sqrt(np.conj(state.data[1]) * state.data[1]) ]) cf = .5 * (1 - fidelity(state_real, self.target[y]))**2 return cf
def test_partial_gradient(self): p = ParameterVector('p', 2) values = [0.8, 0.2] ansatz = QuantumCircuit(1) ansatz.rx(p[0], 0) ansatz.ry(p[1], 0) op = np.array([[1, 1], [1, -1]]) / np.sqrt(2) init = Statevector.from_int(1, dims=(2,)) # set up gradient object and compute gradient grad = StateGradient(op, ansatz, init, [p[1]]) grads = grad.iterative_gradients(dict(zip(p, values)))[0] # reference value ref = 0.3849522583908403 self.assertAlmostEqual(grads, ref)
def eval_test_set_fidelity(self): """Method for evaluating points in the training set, using fidelity. Returns: list of guesses. """ labels = [[0]] * len(self.test_set[0]) for j, x in enumerate(self.test_set[0]): C = self.my_circuit(x) state = Statevector.from_int(0, 2**1) state = state.evolve(C) state_real = np.array([ mt.sqrt(np.conj(state.data[0]) * state.data[0]), mt.sqrt(np.conj(state.data[1]) * state.data[1]) ]) fids = np.empty(len(self.target)) for i, t in enumerate(self.target): fids[i] = fidelity(state_real, t) labels[j] = np.argmax(fids) return labels
def test_partial_large_circuit(self, method): np.random.seed(21) featuremap = ZFeatureMap(2, reps=1) featuremap.assign_parameters(np.random.random( featuremap.num_parameters), inplace=True) ansatz = RealAmplitudes(2, reps=1) params = ansatz.ordered_parameters[:] values = np.random.random(ansatz.num_parameters) init = Statevector.from_int(1, dims=(2, 2)) circuit = featuremap.compose(ansatz) grad = StateGradient(X ^ X, circuit, init, params) grads = getattr(grad, method)(dict(zip(params, values))) ref = [-0.7700884147948044, 0.011116605029003569, -0.6889501710944109, -0.07972088641561373] np.testing.assert_array_almost_equal(grads, ref)
def test_product_rule(self, method): x, y = Parameter('x'), Parameter('y') circuit = QuantumCircuit(1) circuit.rx(x, 0) circuit.ry(x, 0) circuit.rz(y, 0) circuit.rx(x, 0) circuit.h(0) circuit.rx(y, 0) state_in = Statevector.from_int(1, dims=(2,)) parameter_binds = {x: 1, y: 2} grad = StateGradient(Z, circuit, state_in, [x, y]) grads = getattr(grad, method)(parameter_binds) ref_grad = Gradient().convert(~StateFn(Z) @ StateFn(circuit), params=[x, y]) ref = ref_grad.bind_parameters(parameter_binds).eval() np.testing.assert_array_almost_equal(grads, ref)
def test_bogoliubov_transform(self, n_orbitals, num_conserving): """Test Bogoliubov transform.""" converter = QubitConverter(JordanWignerMapper()) hamiltonian = random_quadratic_hamiltonian( n_orbitals, num_conserving=num_conserving, seed=5740) ( transformation_matrix, orbital_energies, transformed_constant, ) = hamiltonian.diagonalizing_bogoliubov_transform() matrix = converter.map(hamiltonian.to_fermionic_op()).to_matrix() bog_circuit = BogoliubovTransform(transformation_matrix, qubit_converter=converter) for initial_state in range(2**n_orbitals): state = Statevector.from_int(initial_state, dims=2**n_orbitals) final_state = np.array(state.evolve(bog_circuit)) occupied_orbitals = [ i for i in range(n_orbitals) if initial_state >> i & 1 ] eig = np.sum( orbital_energies[occupied_orbitals]) + transformed_constant np.testing.assert_allclose(matrix @ final_state, eig * final_state, atol=1e-8)
def paint_world_map(self): """Method for plotting the proper labels on the Bloch sphere. Returns: plot with 2D representation of Bloch sphere. """ angles = np.zeros((len(self.test_set[0]), 2)) from datasets import laea_x, laea_y fig, ax = world_map_template() colors_classes = get_cmap('tab10') norm_class = Normalize(vmin=0, vmax=10) for i, x in enumerate(self.test_set[0]): state = Statevector.from_int(0, 2**1) C = self.my_circuit(x) state = state.evolve(C) angles[i, 0] = np.pi / 2 - \ np.arccos(np.abs(state.data[0]) ** 2 - np.abs(state.data[1]) ** 2) angles[i, 1] = np.angle(state.data[1] / state.data[0]) ax.scatter(laea_x(angles[:, 1], angles[:, 0]), laea_y(angles[:, 1], angles[:, 0]), c=self.test_set[1], cmap=colors_classes, s=15, norm=norm_class) if len(self.target) == 2: angles_0 = np.zeros(len(self.target)) angles_1 = np.zeros(len(self.target)) angles_0[0] = np.pi / 2 angles_0[1] = -np.pi / 2 col = list(range(2)) elif len(self.target) == 3: angles_0 = np.zeros(len(self.target) + 1) angles_1 = np.zeros(len(self.target) + 1) angles_0[0] = np.pi / 2 angles_0[1] = -np.pi / 6 angles_0[2] = -np.pi / 6 angles_0[3] = -np.pi / 6 angles_1[2] = np.pi angles_1[3] = -np.pi col = list(range(3)) + [2] else: angles_0 = np.zeros(len(self.target)) angles_1 = np.zeros(len(self.target)) for i, state in enumerate(self.target): angles_0[i] = np.pi / 2 - \ np.arccos(np.abs(state.data[0]) ** 2 - np.abs(state.data[1]) ** 2) angles_1[i] = np.angle(state.data[1] / state.data[0]) col = list(range(len(self.target))) ax.scatter(laea_x(angles_1, angles_0), laea_y(angles_1, angles_0), c=col, cmap=colors_classes, s=500, norm=norm_class, marker='P', zorder=11) ax.axis('off') fig.savefig('results/' + self.name + '/%s_layers/world_map.pdf' % self.layers)