def set_vqe_circuit(self, backend = None):
#Check https://qiskit.org/documentation/tutorials/algorithms/03_vqe_simulation_with_noise.html
#seed = 170
iterations = self.vqe_options['maxiter']
#aqua_globals.random_seed = seed
if backend is None:
backend = 'statevector_simulator'
backend = Aer.get_backend(backend)
counts = []
values = []
stds = []
def store_intermediate_result(eval_count, parameters, mean, std):
counts.append(eval_count)
values.append(mean)
stds.append(std)
var_form = TwoLocal(reps = self.vqe_options['n_steps'],
rotation_blocks = 'ry',
entanglement_blocks = 'cx',
entanglement = 'linear',
insert_barriers = True)
spsa = SPSA(maxiter=iterations)
if self.vqe_options['noise']:
os.environ['QISKIT_IN_PARALLEL'] = 'TRUE'
device = QasmSimulator.from_backend(device_backend)
coupling_map = device.configuration().coupling_map
noise_model = NoiseModel.from_backend(device)
basis_gates = noise_model.basis_gates
qi = QuantumInstance(backend=backend,
coupling_map=coupling_map,
noise_model=noise_model)
else:
qi = QuantumInstance(backend=backend)
vqe = VQE(var_form=var_form, optimizer=spsa, callback=store_intermediate_result, quantum_instance=qi)
result = vqe.compute_minimum_eigenvalue(operator=self.H)
return vqe.get_optimal_circuit(), vqe.optimal_params, vqe.get_optimal_vector(), vqe.get_optimal_cost()
class SeparableInitialStateReal(InitialState):
"""An initial state constructed from a completely separable VQE ansatz."""
CONFIGURATION = {
'name': 'VQE-Separable-State',
'description': 'VQE Separable initial state',
'input_schema': {
'$schema': 'http://json-schema.org/schema#',
'id': 'separable_state_schema',
'type': 'object',
'properties': {},
'additionalProperties': False
}
}
def __init__(self, operator, optimizer, **vqe_kwargs):
"""Initialize separable state object.
Parameters
----------
operator : Operator
Operator to minimize the separable state with respect to.
optimizer : Optimzer
Optimizer to use for determining optimal separable state.
**vqe_kwargs : type
Options for VQE that determines optimal initial state.
"""
super().__init__()
self.vqe = VQE(operator=operator,
var_form=SingleQubitRotationsReal(operator.num_qubits),
optimizer=optimizer,
**vqe_kwargs)
self._circuit = None
self._result = None
def initialize(self, quantum_instance):
"""Initialize the separable initial state.
Parameters
----------
quantum_instance : QuantumInstance
What device/simulator to use for determining the optimal separable state.
"""
if self._circuit is None:
self._result = self.vqe.run(quantum_instance)
logger.info('Found initial separable state cost {}'.format(
self.vqe.get_optimal_cost()))
self._circuit = self.vqe.get_optimal_circuit()
return self._circuit
else:
return self._circuit
def construct_circuit(self, mode='circuit', register=None):
"""Return the optimal separable state.
Parameters
----------
mode : str
Mode to use for construction.
register : type
Register to use for constructing circuit. Currently unused.
Returns
-------
QuantumCircuit
Circuit that prepares optimal separable state.
"""
if mode != 'circuit':
raise ValueError('Selected mode {} is not supported'.format(mode))
if self._circuit is None:
raise ValueError('Initial state has not yet been initialized.')
circuit = self._circuit
return circuit
