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)
