def test_vqe_callback(self, var_form_type): """ VQE Callback test """ history = {'eval_count': [], 'parameters': [], 'mean': [], 'std': []} def store_intermediate_result(eval_count, parameters, mean, std): history['eval_count'].append(eval_count) history['parameters'].append(parameters) history['mean'].append(mean) history['std'].append(std) backend = BasicAer.get_backend('qasm_simulator') num_qubits = self.qubit_op.num_qubits init_state = Zero(num_qubits) var_form = RY(num_qubits, depth=1, initial_state=init_state) if var_form_type is QuantumCircuit: params = ParameterVector('θ', var_form.num_parameters) var_form = var_form.construct_circuit(params) optimizer = COBYLA(maxiter=3) algo = VQE(self.qubit_op, var_form, optimizer, callback=store_intermediate_result, auto_conversion=False) aqua_globals.random_seed = 50 quantum_instance = QuantumInstance(backend, seed_transpiler=50, shots=1024, seed_simulator=50) algo.run(quantum_instance) self.assertTrue(all(isinstance(count, int) for count in history['eval_count'])) self.assertTrue(all(isinstance(mean, float) for mean in history['mean'])) self.assertTrue(all(isinstance(std, float) for std in history['std'])) for params in history['parameters']: self.assertTrue(all(isinstance(param, float) for param in params))
def test_vqc_callback(self, use_circuits): """ vqc callback test """ history = { 'eval_count': [], 'parameters': [], 'cost': [], 'batch_index': [] } def store_intermediate_result(eval_count, parameters, cost, batch_index): history['eval_count'].append(eval_count) history['parameters'].append(parameters) history['cost'].append(cost) history['batch_index'].append(batch_index) aqua_globals.random_seed = self.seed backend = BasicAer.get_backend('qasm_simulator') num_qubits = 2 optimizer = COBYLA(maxiter=3) feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) var_form = RY(num_qubits=num_qubits, depth=1) # convert to circuit if circuits should be used if use_circuits: x = ParameterVector('x', feature_map.feature_dimension) feature_map = feature_map.construct_circuit(x) theta = ParameterVector('theta', var_form.num_parameters) var_form = var_form.construct_circuit(theta) vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data, callback=store_intermediate_result) quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=self.seed, seed_transpiler=self.seed) vqc.run(quantum_instance) self.assertTrue( all(isinstance(count, int) for count in history['eval_count'])) self.assertTrue( all(isinstance(cost, float) for cost in history['cost'])) self.assertTrue( all(isinstance(index, int) for index in history['batch_index'])) for params in history['parameters']: self.assertTrue(all(isinstance(param, float) for param in params))
def test_vqe_qasm(self, var_form_type): """ VQE QASM test """ backend = BasicAer.get_backend('qasm_simulator') num_qubits = self.qubit_op.num_qubits var_form = RY(num_qubits, depth=3) if var_form_type is QuantumCircuit: params = ParameterVector('θ', var_form.num_parameters) var_form = var_form.construct_circuit(params) optimizer = SPSA(max_trials=300, last_avg=5) algo = VQE(self.qubit_op, var_form, optimizer, max_evals_grouped=1) quantum_instance = QuantumInstance(backend, shots=10000, seed_simulator=self.seed, seed_transpiler=self.seed) result = algo.run(quantum_instance) self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=2)
def test_vqe_qasm_snapshot_mode(self, var_form_type): """ VQE Aer qasm_simulator snapshot mode test """ try: # pylint: disable=import-outside-toplevel from qiskit import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex))) return backend = Aer.get_backend('qasm_simulator') num_qubits = self.qubit_op.num_qubits init_state = Zero(num_qubits) var_form = RY(num_qubits, depth=3, initial_state=init_state) if var_form_type is QuantumCircuit: params = ParameterVector('θ', var_form.num_parameters) var_form = var_form.construct_circuit(params) optimizer = L_BFGS_B() algo = VQE(self.qubit_op, var_form, optimizer, max_evals_grouped=1) quantum_instance = QuantumInstance(backend, shots=1, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed) result = algo.run(quantum_instance) self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=6)
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 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 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 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 self.g_var_form = UnivariateVariationalDistribution( sum(num_qubits), var_form, init_params, low=self._bounds[0], high=self._bounds[1]) theta = ParameterVector('θ', var_form.num_parameters) var_form = var_form.construct_circuit(theta) self.g_circuit = UnivariateVariationalDistribution( sum(num_qubits), var_form, init_params, low=self._bounds[0], high=self._bounds[1])
two_qubit_reduction=core._two_qubit_reduction, num_particles=core._molecule_info['num_particles'], sq_list=sqlist) circuit = init_state.construct_circuit() outfile.write("\nHartree-Fock energy %f \n" % (molecule.hf_energy)) outfile.write("\nHartree-Fock circuit\n") outfile.write(str(circuit.draw()) + "\n") var_form = RY(H_op.num_qubits, depth=3, entanglement='full', entanglement_gate='cz', initial_state=init_state) optimizer = CG(maxiter=1000) algo = VQE(H_op, var_form, optimizer, aux_operators=A_op) backend = Aer.get_backend('statevector_simulator') quantum_instance = QuantumInstance(backend=backend) algo_result = algo.run(quantum_instance) get_results(H_op, A_op, molecule, core, algo_result, outfile) outfile.write("\nRY circuit\n") outfile.write( str(var_form.construct_circuit(algo_result['optimal_point']).draw()) + "\n") print_circuit_requirements( var_form.construct_circuit(algo_result['optimal_point']), 'ibmq_16_melbourne', 3, range(H_op.num_qubits), outfile)
def test_ecev(self, use_circuits): """ European Call Expected Value test """ if not use_circuits: # ignore deprecation warnings from the deprecation of VariationalForm as input for # the univariate variational distribution warnings.filterwarnings("ignore", category=DeprecationWarning) bounds = np.array([0., 7.]) num_qubits = [3] entangler_map = [] for i in range(sum(num_qubits)): entangler_map.append([i, int(np.mod(i + 1, sum(num_qubits)))]) 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(int(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) var_form = RY(int(np.sum(num_qubits)), depth=1, initial_state=init_distribution, entangler_map=entangler_map, entanglement_gate='cz') if use_circuits: theta = ParameterVector('θ', var_form.num_parameters) var_form = var_form.construct_circuit(theta) uncertainty_model = UnivariateVariationalDistribution(int( sum(num_qubits)), var_form, g_params, low=bounds[0], high=bounds[1]) if use_circuits: uncertainty_model._var_form_params = theta strike_price = 2 c_approx = 0.25 european_call = EuropeanCallExpectedValue(uncertainty_model, strike_price=strike_price, c_approx=c_approx) uncertainty_model.set_probabilities( QuantumInstance(BasicAer.get_backend('statevector_simulator'))) algo = AmplitudeEstimation(5, european_call) result = algo.run( quantum_instance=BasicAer.get_backend('statevector_simulator')) self.assertAlmostEqual(result['estimation'], 1.2580, places=4) self.assertAlmostEqual(result['max_probability'], 0.8785, places=4) if not use_circuits: warnings.filterwarnings(action="always", category=DeprecationWarning)
return psi # 1 - |<Psi|RY(theta1,..,theta4)>|^2 :: minimize this to obtain (theta1,..,theta4) def diff(psi): return lambda x: 1 - np.abs(psi.dot(ry_state_vec(x[0], x[1], x[2], x[3])))**2 # In[35]: # RY-Ansatz parameters(theta1,..,theta4) obtained by VQD-iteration params = np.array([1.70075589, 1.72352203, -0.32227027, -1.34956145]) # circuit for 2-qubit RY Ansatz var_form = RY(2, depth=1, entanglement="linear") circ = var_form.construct_circuit(parameters = params) #circ.draw(output = 'mpl') # In[36]: # generate circuits for state tomography tomo_circuits = state_tomography_circuits(circ, circ.qregs) # In[44]: # exec state tomography experiments job = execute(tomo_circuits, backend = backend_qasm, shots = 8192)