def test_qaoa_initial_state(self, w, init_state):
""" QAOA initial state test """
optimizer = COBYLA()
qubit_op, _ = max_cut.get_operator(w)
init_pt = [0.0, 0.0] # Avoid generating random initial point
if init_state is None:
initial_state = None
else:
initial_state = Custom(num_qubits=4, state_vector=init_state)
quantum_instance = QuantumInstance(
BasicAer.get_backend('statevector_simulator'))
qaoa_zero_init_state = QAOA(qubit_op,
optimizer,
initial_point=init_pt,
initial_state=Zero(qubit_op.num_qubits),
quantum_instance=quantum_instance)
qaoa = QAOA(qubit_op,
optimizer,
initial_point=init_pt,
initial_state=initial_state,
quantum_instance=quantum_instance)
zero_circuits = qaoa_zero_init_state.construct_circuit(init_pt)
custom_circuits = qaoa.construct_circuit(init_pt)
self.assertEqual(len(zero_circuits), len(custom_circuits))
backend = BasicAer.get_backend('statevector_simulator')
for zero_circ, custom_circ in zip(zero_circuits, custom_circuits):
z_length = len(zero_circ.data)
c_length = len(custom_circ.data)
self.assertGreaterEqual(c_length, z_length)
self.assertTrue(zero_circ.data == custom_circ.data[-z_length:])
custom_init_qc = custom_circ.copy()
custom_init_qc.data = custom_init_qc.data[0:c_length - z_length]
if initial_state is None:
original_init_qc = QuantumCircuit(qubit_op.num_qubits)
original_init_qc.h(range(qubit_op.num_qubits))
else:
original_init_qc = initial_state.construct_circuit()
job_init_state = execute(original_init_qc, backend)
job_qaoa_init_state = execute(custom_init_qc, backend)
statevector_original = job_init_state.result().get_statevector(
original_init_qc)
statevector_custom = job_qaoa_init_state.result().get_statevector(
custom_init_qc)
self.assertEqual(statevector_original.tolist(),
statevector_custom.tolist())
def objective(params):
aqua_globals.random_seed = 10598
quantum_instance = QuantumInstance(Aer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
qaoa_mes = QAOA(quantum_instance=quantum_instance,operator = qubitOp,p=n_layers,initial_point= params)
circuit2 = QuantumCircuit(n**2)
circuit = qaoa_mes.construct_circuit(params)
#create measurements on classical register
reg = ClassicalRegister(n**2)
circuit[0].add_register(reg)
circuit[0].measure(range(n**2),range(n**2))
# Execution of circuit(either simulation or on real quantum machines)
backend = Aer.get_backend("qasm_simulator")
shots = 1024
simulate = execute(circuit[0], backend=backend, shots=shots)
QAOA_results = simulate.result()
val = 0
# Evaluate the data from the simulator
counts = QAOA_results.get_counts()
expectedCost = 0
maxCost = [0,0]
hist = {}
for sample in list(counts.keys()):
# use sampled bit string x to compute C(x)
x2 = [int(num) for num in list(sample)]
tmp_eng = cost_function_C(x2)
# compute the expectation value and energy distribution
expectedCost = expectedCost + counts[sample]*tmp_eng
return expectedCost/shots; #/(shots);
pauli_list.append([value, Pauli(zp, xp)])
return WeightedPauliOperator(paulis=pauli_list), constant
isingdict ={(0,1):0.5,(1,2):0.5,(2,3):0.5,(3,4):0.5,():-2.0}
qubitOp, shift = get_ising_qubitops(isingdict,5)
provider = OpenSuperQ_Provider()
backend = provider.get_backend('OSQ_ETH7_rev1')
optimizer = POWELL()
qaoa = QAOA(qubitOp, optimizer, p=1, operator_mode='paulis',initial_point=[0.0, 0.0])
quantum_instance = QuantumInstance(backend)
circ = qaoa.construct_circuit(parameter=[2.0, 1.0],circuit_name_prefix='Hello',statevector_mode=True)
latex = circ[0].draw(output='latex_source')
result = qaoa.run(quantum_instance)
print('shift: ', shift)
print('name: ', result.keys())
print([str(key) + " " + str(value) for key, value in result.items()])
plot_histogram(result['eigvecs'], figsize = (18,5))
x = max_cut.sample_most_likely(result['eigvecs'][0])
graph_solution = max_cut.get_graph_solution(x)
#qaoa._circuit.draw(output='mpl')
print('Hello')
for i in range(len(sample)):
if f[i] < f[best_index]:
best_index = i
print(sample[best_index])
# creates circuit using qaoa instance and optimal parameters
aqua_globals.random_seed = 10598
quantum_instance = QuantumInstance(Aer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
qaoa_mes = QAOA(quantum_instance=quantum_instance,operator = qubitOp,p=n_layers) #initial_state = initial #initial_point=[0.,0.]
circuit2 = QuantumCircuit(n**2)
circuit = qaoa_mes.construct_circuit(sample[best_index])
reg = ClassicalRegister(n**2)
circuit[0].add_register(reg)
circuit[0].measure(range(n**2),range(n**2))
# Execution of circuit(either simulation or on real quantum machines)
backend = Aer.get_backend("qasm_simulator")
shots = 1024
simulate = execute(circuit[0], backend=backend, shots=shots)
QAOA_results = simulate.result()
counts = QAOA_results.get_counts()
counts = {k: v for k, v in sorted(counts.items(), key=lambda item: item[1])} #sort the counts dictionary