def test_qubits_qubits_given_mismatch(self):
""" qubits 5 given mismatch test """
with self.assertRaises(AquaError):
_ = Custom(5, state_vector=[1.0] * 23)
def test_evolution(self):
SIZE = 2
#SPARSITY = 0
#X = [[0, 1], [1, 0]]
#Y = [[0, -1j], [1j, 0]]
Z = [[1, 0], [0, -1]]
I = [[1, 0], [0, 1]]
# + 0.5 * np.kron(Y, X)# + 0.3 * np.kron(Z, X) + 0.4 * np.kron(Z, Y)
h1 = np.kron(I, Z)
# np.random.seed(2)
temp = np.random.random((2 ** SIZE, 2 ** SIZE))
h1 = temp + temp.T
qubit_op = Operator(matrix=h1)
# qubit_op_jw.chop_by_threshold(10 ** -10)
if qubit_op.grouped_paulis is None:
qubit_op._matrix_to_paulis()
qubit_op._paulis_to_grouped_paulis()
for ps in qubit_op.grouped_paulis:
for p1 in ps:
for p2 in ps:
if p1 != p2:
np.testing.assert_almost_equal(
p1[1].to_matrix() @ p2[1].to_matrix(),
p2[1].to_matrix() @ p1[1].to_matrix()
)
state_in = Custom(SIZE, state='random')
evo_time = 1
num_time_slices = 3
# announces params
self.log.debug('evo time: {}'.format(evo_time))
self.log.debug('num time slices: {}'.format(num_time_slices))
self.log.debug('state_in: {}'.format(state_in._state_vector))
# get the exact state_out from raw matrix multiplication
state_out_exact = qubit_op.evolve(
state_in=state_in.construct_circuit('vector'),
evo_time=evo_time,
evo_mode='matrix',
num_time_slices=0
)
# self.log.debug('exact:\n{}'.format(state_out_exact))
qubit_op_temp = copy.deepcopy(qubit_op)
for expansion_mode in ['trotter', 'suzuki']:
self.log.debug(
'Under {} expansion mode:'.format(expansion_mode))
for expansion_order in [1, 2, 3, 4] if expansion_mode == 'suzuki' else [1]:
# assure every time the operator from the original one
qubit_op = copy.deepcopy(qubit_op_temp)
if expansion_mode == 'suzuki':
self.log.debug(
'With expansion order {}:'.format(expansion_order))
state_out_matrix = qubit_op.evolve(
state_in=state_in.construct_circuit('vector'),
evo_time=evo_time,
evo_mode='matrix',
num_time_slices=num_time_slices,
expansion_mode=expansion_mode,
expansion_order=expansion_order
)
quantum_registers = QuantumRegister(qubit_op.num_qubits, name='q')
qc = QuantumCircuit(quantum_registers)
qc += state_in.construct_circuit(
'circuit', quantum_registers)
qc += qubit_op.evolve(
evo_time=evo_time,
evo_mode='circuit',
num_time_slices=num_time_slices,
quantum_registers=quantum_registers,
expansion_mode=expansion_mode,
expansion_order=expansion_order,
)
job = q_execute(qc, BasicAer.get_backend('statevector_simulator'))
state_out_circuit = np.asarray(
job.result().get_statevector(qc, decimals=16))
self.log.debug('The fidelity between exact and matrix: {}'.format(
state_fidelity(state_out_exact, state_out_matrix)
))
self.log.debug('The fidelity between exact and circuit: {}'.format(
state_fidelity(state_out_exact, state_out_circuit)
))
f_mc = state_fidelity(state_out_matrix, state_out_circuit)
self.log.debug(
'The fidelity between matrix and circuit: {}'.format(f_mc))
self.assertAlmostEqual(f_mc, 1)
def __init__(self,
oracle: Oracle, init_state: Optional[InitialState] = None,
incremental: bool = False,
num_iterations: int = 1,
lam: float = 1.34,
rotation_counts: Optional[list] = None,
mct_mode: str = 'basic',
quantum_instance: Optional[Union[QuantumInstance, BaseBackend]] = None) -> None:
# pylint: disable=line-too-long
r"""
Args:
oracle: The oracle component
init_state: An optional initial quantum state. If None (default) then Grover's Search
by default uses uniform superposition to initialize its quantum state. However,
an initial state may be supplied, if useful, for example, if the user has some
prior knowledge regarding where the search target(s) might be located.
incremental: Whether to use incremental search mode (True) or not (False).
Supplied *num_iterations* is ignored when True and instead the search task will
be carried out in successive rounds, using circuits built with incrementally
higher number of iterations for the repetition of the amplitude amplification
until a target is found or the maximal number :math:`\log N` (:math:`N` being the
total number of elements in the set from the oracle used) of iterations is
reached. The implementation follows Section 4 of [2].
lam: For incremental search mode, the maximum number of repetition of amplitude
amplification increases by factor lam in every round,
:math:`R_{i+1} = lam \times R_{i}`. If this parameter is not set, the default
value lam = 1.34 is used, which is proved to be optimal [1].
rotation_counts: For incremental mode, if rotation_counts is defined, parameter *lam*
is ignored. rotation_counts is the list of integers that defines the number of
repetition of amplitude amplification for each round.
num_iterations: How many times the marking and reflection phase sub-circuit is
repeated to amplify the amplitude(s) of the target(s). Has a minimum value of 1.
mct_mode: Multi-Control Toffoli mode ('basic' | 'basic-dirty-ancilla' |
'advanced' | 'noancilla')
quantum_instance: Quantum Instance or Backend
Raises:
AquaError: evaluate_classically() missing from the input oracle
References:
[1]: Baritompa et al., Grover's Quantum Algorithm Applied to Global Optimization
`<https://www.researchgate.net/publication/220133694_Grover%27s_Quantum_Algorithm_Applied_to_Global_Optimization>`_
[2]: Boyer et al., Tight bounds on quantum searching
`<https://arxiv.org/abs/quant-ph/9605034>`_
"""
validate_min('num_iterations', num_iterations, 1)
validate_in_set('mct_mode', mct_mode,
{'basic', 'basic-dirty-ancilla',
'advanced', 'noancilla'})
super().__init__(quantum_instance)
if not callable(getattr(oracle, "evaluate_classically", None)):
raise AquaError(
'Missing the evaluate_classically() method from the provided oracle instance.'
)
self._oracle = oracle
self._mct_mode = mct_mode
self._init_state = \
init_state if init_state else Custom(len(oracle.variable_register), state='uniform')
self._init_state_circuit = \
self._init_state.construct_circuit(mode='circuit', register=oracle.variable_register)
self._init_state_circuit_inverse = self._init_state_circuit.inverse()
self._diffusion_circuit = self._construct_diffusion_circuit()
self._max_num_iterations = np.ceil(2 ** (len(oracle.variable_register) / 2))
self._incremental = incremental
self._lam = lam
self._rotation_counts = rotation_counts
self._num_iterations = num_iterations if not incremental else 1
if incremental:
logger.debug('Incremental mode specified, ignoring "num_iterations".')
else:
if num_iterations > self._max_num_iterations:
logger.warning('The specified value %s for "num_iterations" '
'might be too high.', num_iterations)
self._ret = {} # type: Dict[str, Any]
self._qc_aa_iteration = None
self._qc_amplitude_amplification = None
self._qc_measurement = None
def test_qubits_2_given_vector(self):
self.custom = Custom(2, state_vector=[0.5] * 4)
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_equal(cct, [0.5] * 4)
def test_qubits_5_randgiven_vector(self):
self.custom = Custom(5, state_vector=np.random.rand(32))
cct = self.custom.construct_circuit('vector')
prob = np.sqrt(np.sum([x**2 for x in cct]))
self.assertAlmostEqual(prob, 1.0)
def test_qubits_5_zero_circuit(self):
self.custom = Custom(5, state='zero')
cct = self.custom.construct_circuit('circuit')
self.assertEqual(cct.qasm(),
'OPENQASM 2.0;\ninclude "qelib1.inc";\nqreg q[5];\n')
def test_qubits_2_uniform_circuit(self):
self.custom = Custom(2, state='uniform')
cct = self.custom.construct_circuit('circuit')
self.assertEqual(
cct.qasm(), 'OPENQASM 2.0;\ninclude "qelib1.inc";\nqreg q[2];\n'
'u2(0.0,3.14159265358979) q[0];\nu2(0.0,3.14159265358979) q[1];\n')
# Initialize qGAN
qgan = QGAN(real_data, bounds, num_qubits, batch_size, num_epochs, snapshot_dir=None)
qgan.seed = 1
# Set quantum instance to run the quantum generator
quantum_instance = QuantumInstance(backend=Aer.get_backend('statevector_simulator'))
# Set entangler map
entangler_map = [[0, 1]]
# Set an initial state for the generator circuit
init_dist = UniformDistribution(sum(num_qubits), low=bounds[0], high=bounds[1])
print(init_dist.probabilities)
q = QuantumRegister(sum(num_qubits), name='q')
qc = QuantumCircuit(q)
init_dist.build(qc, q)
init_distribution = Custom(num_qubits=sum(num_qubits), circuit=qc)
var_form = RY(int(np.sum(num_qubits)), depth=1, initial_state = init_distribution,
entangler_map=entangler_map, entanglement_gate='cz')
# Set generator's initial parameters
init_params = aqua_globals.random.rand(var_form._num_parameters) * 2 * np.pi
# Set generator circuit
g_circuit = UnivariateVariationalDistribution(int(sum(num_qubits)), var_form, init_params,
low=bounds[0], high=bounds[1])
# Set quantum generator
qgan.set_generator(generator_circuit=g_circuit)
# Set classical discriminator neural network
discriminator = NumpyDiscriminator(len(num_qubits))
qgan.set_discriminator(discriminator)
# -
# Run qGAN
def build(self, qc, q, q_ancillas=None, params=None):
""" build """
custom_state = Custom(self.num_target_qubits,
state_vector=np.sqrt(self.probabilities))
qc.extend(custom_state.construct_circuit('circuit', q))
def test_qubits_5_random_vector(self):
""" qubits 5 random vector test """
custom = Custom(5, state='random')
cct = custom.construct_circuit('vector')
prob = np.sqrt(np.sum([x**2 for x in cct]))
self.assertAlmostEqual(prob, 1.0)
def fidelity(hhl, ref):
solution_hhl_normed = hhl / np.linalg.norm(hhl)
solution_ref_normed = ref / np.linalg.norm(ref)
fidelity = state_fidelity(solution_hhl_normed, solution_ref_normed)
print("fidelity %f" % fidelity)
orig_size = len(vector)
matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize(
matrix, vector)
# Initialize eigenvalue finding module
eigs = create_eigs(matrix, 3, False)
num_q, num_a = eigs.get_register_sizes()
# Initialize initial state module
init_state = Custom(num_q, state_vector=vector)
# Initialize reciprocal rotation module
reci = LookupRotation(negative_evals=eigs._negative_evals,
evo_time=eigs._evo_time)
algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs,
init_state, reci, num_q, num_a, orig_size)
result = algo.run(
QuantumInstance(BasicAer.get_backend('statevector_simulator')))
print(np.round(result['solution'], 5))
# IBMQ.save_account('2014e54721e8677688e0c1dffdc92dfe0f39dbae5d75dd5b14fd087c4f93349b6ea92cbbc872d9a838e946527e10144d554b04587662f5567309b75aca0085f0')
# IBMQ.load_account()
def test_qubits_2_uniform_vector(self):
""" qubits 2 uniform vector test """
custom = Custom(2, state='uniform')
cct = custom.construct_circuit('vector')
np.testing.assert_array_equal(cct, [0.5] * 4)
def test_qubits_2_zero_circuit(self):
""" qubits 2 zero circuit test """
custom = Custom(2, state='zero')
cct = custom.construct_circuit('circuit')
self.assertEqual(cct.qasm(),
'OPENQASM 2.0;\ninclude "qelib1.inc";\nqreg q[2];\n')
def test_qubits_2_zero_vector_wrong_cct_mode(self):
""" qubits 2 zero vector wrong cct mode test """
custom = Custom(5, state='zero')
with self.assertRaises(AquaError):
_ = custom.construct_circuit('matrix')
class TestInitialStateCustom(QiskitAquaTestCase):
def test_qubits_2_zero_vector(self):
self.custom = Custom(2, state='zero')
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_equal(cct, [1.0, 0.0, 0.0, 0.0])
def test_qubits_5_zero_vector(self):
self.custom = Custom(5, state='zero')
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_equal(cct, [
1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0
])
def test_qubits_2_zero_circuit(self):
self.custom = Custom(2, state='zero')
cct = self.custom.construct_circuit('circuit')
self.assertEqual(cct.qasm(),
'OPENQASM 2.0;\ninclude "qelib1.inc";\nqreg q[2];\n')
def test_qubits_5_zero_circuit(self):
self.custom = Custom(5, state='zero')
cct = self.custom.construct_circuit('circuit')
self.assertEqual(cct.qasm(),
'OPENQASM 2.0;\ninclude "qelib1.inc";\nqreg q[5];\n')
def test_qubits_2_uniform_vector(self):
self.custom = Custom(2, state='uniform')
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_equal(cct, [0.5] * 4)
def test_qubits_5_uniform_vector(self):
self.custom = Custom(5, state='uniform')
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_almost_equal(cct, [0.1767767] * 32)
def test_qubits_2_uniform_circuit(self):
self.custom = Custom(2, state='uniform')
cct = self.custom.construct_circuit('circuit')
self.assertEqual(
cct.qasm(), 'OPENQASM 2.0;\ninclude "qelib1.inc";\nqreg q[2];\n'
'u2(0.0,3.14159265358979) q[0];\nu2(0.0,3.14159265358979) q[1];\n')
def test_qubits_2_random_vector(self):
self.custom = Custom(2, state='random')
cct = self.custom.construct_circuit('vector')
prob = np.sqrt(np.sum([x**2 for x in cct]))
self.assertAlmostEqual(prob, 1.0)
def test_qubits_5_random_vector(self):
self.custom = Custom(5, state='random')
cct = self.custom.construct_circuit('vector')
prob = np.sqrt(np.sum([x**2 for x in cct]))
self.assertAlmostEqual(prob, 1.0)
def test_qubits_2_given_vector(self):
self.custom = Custom(2, state_vector=[0.5] * 4)
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_equal(cct, [0.5] * 4)
def test_qubits_5_given_vector(self):
self.custom = Custom(5, state_vector=[1.0] * 32)
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_almost_equal(cct, [0.1767767] * 32)
def test_qubits_5_randgiven_vector(self):
self.custom = Custom(5, state_vector=np.random.rand(32))
cct = self.custom.construct_circuit('vector')
prob = np.sqrt(np.sum([x**2 for x in cct]))
self.assertAlmostEqual(prob, 1.0)
def test_qubits_qubits_given_mistmatch(self):
with self.assertRaises(ValueError):
self.custom = Custom(5, state_vector=[1.0] * 23)
def test_qubits_2_zero_vector_wrong_cct_mode(self):
self.custom = Custom(5, state='zero')
with self.assertRaises(ValueError):
cct = self.custom.construct_circuit('matrix')
bounds = np.array([0.,7.])
# Set number of qubits used in the uncertainty model
num_qubits = [3]
# Set entangler map
entangler_map = []
for i in range(sum(num_qubits)):
entangler_map.append([i, int(np.mod(i+1, sum(num_qubits)))])
# Load the trained circuit parameters
g_params = [0.29399714, 0.38853322, 0.9557694, 0.07245791, 6.02626428, 0.13537225]
# Set an initial state for the generator circuit
init_dist = NormalDistribution(sum(num_qubits), mu=1., sigma=1., low=bounds[0], high=bounds[1])
init_distribution = np.sqrt(init_dist.probabilities)
init_distribution = Custom(num_qubits=sum(num_qubits), state_vector=init_distribution)
# construct the variational form
var_form = RealAmplitudes(sum(num_qubits), entanglement=entangler_map, reps=1, initial_state=init_distribution)
var_form.entanglement_blocks = 'cz'
theta = ParameterVector('θ', var_form.num_parameters)
var_form = var_form.assign_parameters(theta)
# Set generator circuit
g_circuit = UnivariateVariationalDistribution(sum(num_qubits), var_form, g_params,
low=bounds[0], high=bounds[1])
g_circuit._var_form_params = theta
# construct circuit factory for uncertainty model
uncertainty_model = g_circuit
def test_qubits_2_zero_vector(self):
self.custom = Custom(2, state='zero')
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_equal(cct, [1.0, 0.0, 0.0, 0.0])
def setUp(self):
super().setUp()
self.seed = 7
aqua_globals.random_seed = self.seed
# Number training data samples
n_v = 5000
# Load data samples from log-normal distribution with mean=1 and standard deviation=1
m_u = 1
sigma = 1
self._real_data = aqua_globals.random.lognormal(mean=m_u,
sigma=sigma,
size=n_v)
# Set upper and lower data values as list of k
# min/max data values [[min_0,max_0],...,[min_k-1,max_k-1]]
self._bounds = [0., 3.]
# Set number of qubits per data dimension as list of k qubit values[#q_0,...,#q_k-1]
num_qubits = [2]
# Batch size
batch_size = 100
# Set number of training epochs
# num_epochs = 10
num_epochs = 5
# Initialize qGAN
self.qgan = QGAN(self._real_data,
self._bounds,
num_qubits,
batch_size,
num_epochs,
snapshot_dir=None)
self.qgan.seed = 7
# Set quantum instance to run the quantum generator
self.qi_statevector = QuantumInstance(
backend=BasicAer.get_backend('statevector_simulator'),
seed_simulator=2,
seed_transpiler=2)
self.qi_qasm = QuantumInstance(
backend=BasicAer.get_backend('qasm_simulator'),
shots=1000,
seed_simulator=2,
seed_transpiler=2)
# Set entangler map
entangler_map = [[0, 1]]
# Set an initial state for the generator circuit
init_dist = UniformDistribution(sum(num_qubits),
low=self._bounds[0],
high=self._bounds[1])
q = QuantumRegister(sum(num_qubits), name='q')
qc = QuantumCircuit(q)
init_dist.build(qc, q)
init_distribution = Custom(num_qubits=sum(num_qubits), circuit=qc)
# Set generator's initial parameters
init_params = aqua_globals.random.random(
2 * sum(num_qubits)) * 2 * 1e-2
# Set variational form
var_form = RealAmplitudes(sum(num_qubits),
reps=1,
initial_state=init_distribution,
entanglement=entangler_map)
self.generator_circuit = var_form
warnings.filterwarnings('ignore', category=DeprecationWarning)
self.generator_factory = UnivariateVariationalDistribution(
sum(num_qubits),
var_form,
init_params,
low=self._bounds[0],
high=self._bounds[1])
warnings.filterwarnings('always', category=DeprecationWarning)
def test_qubits_5_uniform_vector(self):
self.custom = Custom(5, state='uniform')
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_almost_equal(cct, [0.1767767] * 32)
def test_iqpe(self, qubitOp, simulator):
self.algorithm = 'IQPE'
self.log.debug('Testing IQPE')
self.qubitOp = qubitOp
exact_eigensolver = ExactEigensolver(self.qubitOp, k=1)
results = exact_eigensolver.run()
w = results['eigvals']
v = results['eigvecs']
self.qubitOp.to_matrix()
np.testing.assert_almost_equal(self.qubitOp._matrix @ v[0],
w[0] * v[0])
np.testing.assert_almost_equal(
expm(-1.j * sparse.csc_matrix(self.qubitOp._matrix)) @ v[0],
np.exp(-1.j * w[0]) * v[0])
self.ref_eigenval = w[0]
self.ref_eigenvec = v[0]
self.log.debug('The exact eigenvalue is: {}'.format(
self.ref_eigenval))
self.log.debug('The corresponding eigenvector: {}'.format(
self.ref_eigenvec))
num_time_slices = 50
num_iterations = 6
state_in = Custom(self.qubitOp.num_qubits,
state_vector=self.ref_eigenvec)
iqpe = IQPE(self.qubitOp,
state_in,
num_time_slices,
num_iterations,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend(simulator)
quantum_instance = QuantumInstance(backend,
shots=100,
pass_manager=PassManager())
result = iqpe.run(quantum_instance)
self.log.debug('top result str label: {}'.format(
result['top_measurement_label']))
self.log.debug('top result in decimal: {}'.format(
result['top_measurement_decimal']))
self.log.debug('stretch: {}'.format(
result['stretch']))
self.log.debug('translation: {}'.format(
result['translation']))
self.log.debug('final eigenvalue from IQPE: {}'.format(
result['energy']))
self.log.debug('reference eigenvalue: {}'.format(
self.ref_eigenval))
self.log.debug('ref eigenvalue (transformed): {}'.format(
(self.ref_eigenval + result['translation']) * result['stretch']))
self.log.debug('reference binary str label: {}'.format(
decimal_to_binary(
(self.ref_eigenval.real + result['translation']) *
result['stretch'],
max_num_digits=num_iterations + 3,
fractional_part_only=True)))
np.testing.assert_approx_equal(result['energy'],
self.ref_eigenval.real,
significant=2)
def test_qubits_2_random_vector(self):
self.custom = Custom(2, state='random')
cct = self.custom.construct_circuit('vector')
prob = np.sqrt(np.sum([x**2 for x in cct]))
self.assertAlmostEqual(prob, 1.0)
if __name__ == '__main__':
import numpy as np
from qiskit import Aer
from qiskit.aqua.algorithms.minimum_eigen_solvers import VQSD
from qiskit.quantum_info.states import Statevector
from qiskit.aqua.components.initial_states import Custom
from qiskit.aqua.components.optimizers import COBYLA
from qiskit.aqua.operators import MatrixOperator
from qiskit.aqua.algorithms.eigen_solvers import NumPyEigensolver
from qiskit.aqua.components.variational_forms import RY
from qiskit.quantum_info import partial_trace
num_ancillae = 1
state_vector = np.sqrt(6/10) * Statevector.from_label('+1+') \
+ np.sqrt(4/10) * Statevector.from_label('-0-')
initial_state = Custom(state_vector.num_qubits,
state_vector=state_vector.data)
vqsd_obj = VQSD(initial_state,
q=.25,
num_ancillae=num_ancillae,
quantum_instance=Aer.get_backend("qasm_simulator"),
optimizer=COBYLA(),
var_form=RY(initial_state._num_qubits - num_ancillae,
depth=2))
result = vqsd_obj.run(shots=1000)
print("=== VQSD ===")
print(result.eigenvalue)
print(result.eigenstate)
print("== Exact ===")
density_mat = state_vector.to_operator()
def test_qubits_5_given_vector(self):
self.custom = Custom(5, state_vector=[1.0] * 32)
cct = self.custom.construct_circuit('vector')
np.testing.assert_array_almost_equal(cct, [0.1767767] * 32)
def setUp(self):
super().setUp()
os.environ.pop('QISKIT_AQUA_CIRCUIT_CACHE', None)
# Number training data samples
N = 5000
# Load data samples from log-normal distribution with mean=1 and standard deviation=1
mu = 1
sigma = 1
self._real_data = np.random.lognormal(mean=mu, sigma=sigma, size=N)
# Set the data resolution
# Set upper and lower data values as list of k min/max data values [[min_0,max_0],...,[min_k-1,max_k-1]]
self._bounds = [0., 3.]
# Set number of qubits per data dimension as list of k qubit values[#q_0,...,#q_k-1]
num_qubits = [2]
# Batch size
batch_size = 100
# Set number of training epochs
num_epochs = 10
self._params_torch = {'algorithm': {'name': 'QGAN',
'num_qubits': num_qubits,
'batch_size': batch_size,
'num_epochs': num_epochs},
'problem': {'name': 'distribution_learning_loading', 'random_seed': 7},
'generative_network': {'name': 'QuantumGenerator',
'bounds': self._bounds,
'num_qubits': num_qubits,
'init_params': None,
'snapshot_dir': None
},
'discriminative_network': {'name': 'PytorchDiscriminator',
'n_features': len(num_qubits)}
}
self._params_numpy = {'algorithm': {'name': 'QGAN',
'num_qubits': num_qubits,
'batch_size': batch_size,
'num_epochs': num_epochs},
'problem': {'name': 'distribution_learning_loading', 'random_seed': 7},
'generative_network': {'name': 'QuantumGenerator',
'bounds': self._bounds,
'num_qubits': num_qubits,
'init_params': None,
'snapshot_dir': None
},
'discriminative_network': {'name': 'NumpyDiscriminator',
'n_features': len(num_qubits)}
}
# Initialize qGAN
self.qgan = QGAN(self._real_data, self._bounds, num_qubits, batch_size, num_epochs, snapshot_dir=None)
self.qgan.seed = 7
# Set quantum instance to run the quantum generator
self.quantum_instance_statevector = QuantumInstance(backend=BasicAer.get_backend('statevector_simulator'),
circuit_caching=False, seed_simulator=2, seed_transpiler=2)
self.quantum_instance_qasm = QuantumInstance(backend=BasicAer.get_backend('qasm_simulator'), shots=1000,
circuit_caching=False, seed_simulator=2, seed_transpiler=2)
# Set entangler map
entangler_map = [[0, 1]]
# Set an initial state for the generator circuit
init_dist = UniformDistribution(sum(num_qubits), low=self._bounds[0], high=self._bounds[1])
q = QuantumRegister(sum(num_qubits), name='q')
qc = QuantumCircuit(q)
init_dist.build(qc, q)
init_distribution = Custom(num_qubits=sum(num_qubits), circuit=qc)
# Set variational form
var_form = RY(sum(num_qubits), depth=1, initial_state=init_distribution, entangler_map=entangler_map,
entanglement_gate='cz')
# Set generator's initial parameters
init_params = aqua_globals.random.rand(var_form._num_parameters) * 2 * 1e-2
# Set generator circuit
g_circuit = UnivariateVariationalDistribution(sum(num_qubits), var_form, init_params,
low=self._bounds[0],
high=self._bounds[1])
# Set quantum generator
self.qgan.set_generator(generator_circuit=g_circuit)
def test_qubits_qubits_given_mistmatch(self):
with self.assertRaises(ValueError):
self.custom = Custom(5, state_vector=[1.0] * 23)
def test_qpe(self, qubit_op, simulator, num_time_slices, n_ancillae,
use_circuit_library):
""" QPE test """
self.log.debug('Testing QPE')
tmp_qubit_op = qubit_op.copy()
exact_eigensolver = NumPyMinimumEigensolver(qubit_op)
results = exact_eigensolver.run()
ref_eigenval = results.eigenvalue
ref_eigenvec = results.eigenstate
self.log.debug('The exact eigenvalue is: %s', ref_eigenval)
self.log.debug('The corresponding eigenvector: %s', ref_eigenvec)
state_in = Custom(qubit_op.num_qubits, state_vector=ref_eigenvec)
if use_circuit_library:
iqft = QFT(n_ancillae).inverse()
else:
# ignore deprecation warnings from QFTs
warnings.filterwarnings(action="ignore",
category=DeprecationWarning)
iqft = Standard(n_ancillae)
qpe = QPEMinimumEigensolver(qubit_op,
state_in,
iqft,
num_time_slices,
n_ancillae,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend(simulator)
quantum_instance = QuantumInstance(backend, shots=100)
# run qpe
result = qpe.run(quantum_instance)
# report result
self.log.debug('top result str label: %s',
result.top_measurement_label)
self.log.debug('top result in decimal: %s',
result.top_measurement_decimal)
self.log.debug('stretch: %s', result.stretch)
self.log.debug('translation: %s', result.translation)
self.log.debug('final eigenvalue from QPE: %s', result.eigenvalue)
self.log.debug('reference eigenvalue: %s', ref_eigenval)
self.log.debug('ref eigenvalue (transformed): %s',
(ref_eigenval + result.translation) * result.stretch)
self.log.debug(
'reference binary str label: %s',
decimal_to_binary(
(ref_eigenval.real + result.translation) * result.stretch,
max_num_digits=n_ancillae + 3,
fractional_part_only=True))
np.testing.assert_approx_equal(result.eigenvalue.real,
ref_eigenval.real,
significant=2)
self.assertEqual(tmp_qubit_op, qubit_op,
"Operator is modified after QPE.")
if not use_circuit_library:
warnings.filterwarnings(action="always",
category=DeprecationWarning)
def __init__(self, bounds, num_qubits, generator_circuit=None,
init_params=None, snapshot_dir=None):
"""
Initialize the generator network.
Args:
bounds (numpy.ndarray): k min/max data values [[min_1,max_1],...,[min_k,max_k]],
given input data dim k
num_qubits (list): k numbers of qubits to determine representation resolution,
i.e. n qubits enable the representation of 2**n values [n_1,..., n_k]
generator_circuit (Union): generator circuit
UnivariateVariationalDistribution for univariate data/
MultivariateVariationalDistribution for multivariate data, Quantum circuit
to implement the generator.
init_params (numpy.ndarray): 1D numpy array or list, Initialization for
the generator's parameters.
snapshot_dir (str): str or None, if not None save the optimizer's parameter after every
update step to the given directory
Raises:
AquaError: Set multivariate variational distribution to represent multivariate data
"""
super().__init__()
self._bounds = bounds
self._num_qubits = num_qubits
self.generator_circuit = generator_circuit
if self.generator_circuit is None:
entangler_map = []
if np.sum(num_qubits) > 2:
for i in range(int(np.sum(num_qubits))):
entangler_map.append([i, int(np.mod(i + 1, np.sum(num_qubits)))])
else:
if np.sum(num_qubits) > 1:
entangler_map.append([0, 1])
if len(num_qubits) > 1:
num_qubits = list(map(int, num_qubits))
low = bounds[:, 0].tolist()
high = bounds[:, 1].tolist()
init_dist = MultivariateUniformDistribution(num_qubits, low=low, high=high)
q = QuantumRegister(sum(num_qubits))
qc = QuantumCircuit(q)
init_dist.build(qc, q)
init_distribution = Custom(num_qubits=sum(num_qubits), circuit=qc)
# Set variational form
var_form = RY(sum(num_qubits), depth=1,
initial_state=init_distribution, entangler_map=entangler_map,
entanglement_gate='cz')
if init_params is None:
init_params = aqua_globals.random.rand(var_form.num_parameters) * 2 * 1e-2
# Set generator circuit
self.generator_circuit = MultivariateVariationalDistribution(num_qubits, var_form,
init_params,
low=low, high=high)
else:
init_dist = UniformDistribution(sum(num_qubits), low=bounds[0], high=bounds[1])
q = QuantumRegister(sum(num_qubits), name='q')
qc = QuantumCircuit(q)
init_dist.build(qc, q)
init_distribution = Custom(num_qubits=sum(num_qubits), circuit=qc)
var_form = RY(sum(num_qubits), depth=1, initial_state=init_distribution,
entangler_map=entangler_map,
entanglement_gate='cz')
if init_params is None:
init_params = aqua_globals.random.rand(var_form.num_parameters) * 2 * 1e-2
# Set generator circuit
self.generator_circuit = UnivariateVariationalDistribution(
int(np.sum(num_qubits)), var_form, init_params, low=bounds[0], high=bounds[1])
if len(num_qubits) > 1:
if isinstance(self.generator_circuit, MultivariateVariationalDistribution):
pass
else:
raise AquaError('Set multivariate variational distribution '
'to represent multivariate data')
else:
if isinstance(self.generator_circuit, UnivariateVariationalDistribution):
pass
else:
raise AquaError('Set univariate variational distribution '
'to represent univariate data')
# Set optimizer for updating the generator network
self._optimizer = ADAM(maxiter=1, tol=1e-6, lr=1e-3, beta_1=0.7,
beta_2=0.99, noise_factor=1e-6,
eps=1e-6, amsgrad=True, snapshot_dir=snapshot_dir)
if np.ndim(self._bounds) == 1:
bounds = np.reshape(self._bounds, (1, len(self._bounds)))
else:
bounds = self._bounds
for j, prec in enumerate(self._num_qubits):
# prepare data grid for dim j
grid = np.linspace(bounds[j, 0], bounds[j, 1], (2 ** prec))
if j == 0:
if len(self._num_qubits) > 1:
self._data_grid = [grid]
else:
self._data_grid = grid
self._grid_elements = grid
elif j == 1:
self._data_grid.append(grid)
temp = []
for g_e in self._grid_elements:
for g in grid:
temp0 = [g_e]
temp0.append(g)
temp.append(temp0)
self._grid_elements = temp
else:
self._data_grid.append(grid)
temp = []
for g_e in self._grid_elements:
for g in grid:
temp0 = deepcopy(g_e)
temp0.append(g)
temp.append(temp0)
self._grid_elements = deepcopy(temp)
self._data_grid = np.array(self._data_grid)
self._shots = None
self._discriminator = None
self._ret = {}
def test_qubits_2_zero_vector_wrong_cct_mode(self):
self.custom = Custom(5, state='zero')
with self.assertRaises(ValueError):
cct = self.custom.construct_circuit('matrix')
For n=4 qubits the first term encodes the amplitude of the state |0000> the second term encodes |0001> and so one.
For n=4 i'll create the state = |s> = 1/sqrt(2) ( |0100> + |0010> ) and QMF should return
|0100> = 4 as the maximum value within the state.
'''
state = []
for i in range(2**n):
if i == 4 or i == 2:
state.append(complex(1 / math.sqrt(2), 0.0))
else:
state.append(complex(0.0, 0.0))
state = np.asarray(state)
quantum_state = Custom(n, state_vector=state)
index = int(sys.argv[1])
alg = QMF(initial_state=quantum_state,
search_register=qstate,
size=superpositions,
max_index=index)
Backend = Aer.get_backend('qasm_simulator')
maximum, top_measurement = alg.run(backend=Backend, shots=1024)
#measured_val = result['result']
#maximum = result['top_measurement']
print("MAXIMUM SHOULD BE |0100> = 4\n")
print("MAXIMUM ACHIEVED - %d\n" % maximum)
def main(run_mode):
# graph of city coordinates
cities = np.array([[0, 0], [0, 1]]) # coordinates of the cities
num_cities = len(cities)
num_qubits = num_cities ** 2
# algorithm properties
p = 2 # number of time steps
beta = np.random.uniform(0, np.pi * 2, p)
gamma = np.random.uniform(0, np.pi * 2, p)
# create matrix of distances between cities
distance_mat = tsp.calc_distance(cities).w # note that this method does integer distances
# create mixing Hamiltonian. A city may or may not be visited in a timestep
mixing_hamiltonian = reduce(lambda x, y: x + y,
[pauli_x(i, 1, num_qubits) for i in range(num_qubits)])
# penalty_operators = create_weights_cost_operators(num_cities=num_cities, num_qubits=num_qubits,
# dist_mat=distance_mat)
penalty_operators = create_penalty_operators_for_bilocation(num_qubits=num_qubits, num_cities=num_cities,
distance_mat=distance_mat)
penalty_operators += create_penalty_operators_for_repetition(num_qubits=num_qubits, num_cities=num_cities,
distance_mat=distance_mat)
print(penalty_operators)
cost_hamiltonian = penalty_operators
# circuit initial state vector. All states in equal superposition
init_state_vect = [1 for i in range(2 ** num_qubits)]
init_state = Custom(num_qubits, state_vector=init_state_vect)
# initialize quantum circuit
qr = QuantumRegister(num_qubits, name='q')
init_circ = init_state.construct_circuit('circuit', qr)
# find optimal beta and gamma
evaluate = partial(neg_evaluate_circuit, qr=qr, p=p, m_H=mixing_hamiltonian, c_H=cost_hamiltonian,
init_circ=init_circ)
print("Looking for optimal beta and gamma")
# TODO: maybe we should use a different or faster method of finding the min? Super long even with two cities
result = minimize(evaluate, np.concatenate([gamma, beta]), method='L-BFGS-B')
# result = minimize(evaluate, np.concatenate([gamma, beta]))
print(result)
# now use the result of the gathered angles to find the answer
circuit = create_circuit(qr, result['x'][:p], result['x'][p:], p, m_H=mixing_hamiltonian, c_H=cost_hamiltonian,
init_circ=init_circ)
if run_mode == "IBM quantum":
import secrets
from qiskit import IBMQ
from qiskit.providers.ibmq import least_busy
provider = IBMQ.enable_account(secrets.IBM_TOKEN)
large_enough_devices = provider.backends(filters=lambda x: x.configuration().n_qubits > 4 and
not x.configuration().simulator)
backend = least_busy(large_enough_devices)
print("This will be running on the IBM device " + backend.name())
else:
print("Preparing to run on local simulator")
backend = BasicAer.get_backend('statevector_simulator')
job = execute(circuit, backend)
state = np.asarray(job.result().get_statevector(circuit))
print(list_to_easier_vis(np.absolute(state)))
