def run_sweep(
self,
program: 'cirq.Circuit',
params: 'cirq.Sweepable',
repetitions: int = 1,
) -> List['cirq.TrialResult']:
assert isinstance(program, circuits.Circuit)
meas = list(program.findall_operations_with_gate_type(
ops.MeasurementGate))
if len(meas) == 0:
raise ValueError()
elif len(meas) > 1:
for _, m, _ in meas:
assert len(m.qubits) == 1
results = [
study.TrialResult(
params=p,
measurements={gate.key: np.zeros(
(repetitions, 1), dtype=int)
for _, _, gate in meas})
for p in study.to_resolvers(params)
]
else:
assert len(meas) == 1
i, op, gate = meas[0]
n_qubits = len(op.qubits)
k = gate.key
results = [
study.TrialResult(
params=p,
measurements={k: np.zeros(
(repetitions, n_qubits), dtype=int)})
for p in study.to_resolvers(params)
]
return results
def run_sweep(
self,
program: Union[circuits.Circuit, schedules.Schedule],
params: study.Sweepable,
repetitions: int = 1,
) -> List[study.TrialResult]:
"""Runs the entire supplied Circuit, mimicking the quantum hardware.
In contrast to run, this allows for sweeping over different parameter
values.
Args:
program: The circuit or schedule to simulate.
params: Parameters to run with the program.
repetitions: The number of repetitions to simulate.
Returns:
TrialResult list for this run; one for each possible parameter
resolver.
"""
circuit = (program if isinstance(program, circuits.Circuit) else
program.to_circuit())
param_resolvers = study.to_resolvers(params)
trial_results = [] # type: List[study.TrialResult]
for param_resolver in param_resolvers:
measurements = self._run(circuit=circuit,
param_resolver=param_resolver,
repetitions=repetitions)
trial_results.append(
study.TrialResult(params=param_resolver,
repetitions=repetitions,
measurements=measurements))
return trial_results
def _trial_sweep_from_proto(
msg: result_pb2.SweepResult,
measurements: Dict[str, MeasureInfo],
) -> List[study.TrialResult]:
trial_sweep: List[study.TrialResult] = []
for pr in msg.parameterized_results:
m_data: Dict[str, np.ndarray] = {}
for mr in pr.measurement_results:
m = measurements[mr.key]
qubit_results: Dict[devices.GridQubit, np.ndarray] = {}
for qmr in mr.qubit_measurement_results:
qubit = devices.GridQubit.from_proto_id(qmr.qubit.id)
if qubit in qubit_results:
raise ValueError('qubit already exists: {}'.format(qubit))
qubit_results[qubit] = unpack_bits(qmr.results,
msg.repetitions)
ordered_results = [qubit_results[qubit] for qubit in m.qubits]
m_data[mr.key] = np.array(ordered_results).transpose()
trial_sweep.append(
study.TrialResult(
params=study.ParamResolver(dict(pr.params.assignments)),
measurements=m_data,
repetitions=msg.repetitions,
))
return trial_sweep
def run_sweep(
self,
program: 'cirq.Circuit',
params: study.Sweepable,
repetitions: int = 1,
) -> List[study.TrialResult]:
"""Samples circuit as if every measurement resulted in zero.
Args:
program: The circuit to sample from.
params: Parameters to run with the program.
repetitions: The number of times to sample.
Returns:
TrialResult list for this run; one for each possible parameter
resolver.
Raises:
ValueError if this sampler has a device and the circuit is not
valid for the device.
"""
if self.device:
self.device.validate_circuit(program)
measurements = {} # type: Dict[str, np.ndarray]
for op in program.all_operations():
key = protocols.measurement_key(op, default=None)
if key is not None:
measurements[key] = np.zeros((repetitions, len(op.qubits)),
dtype=int)
return [
study.TrialResult(params=param_resolver, measurements=measurements)
for param_resolver in study.to_resolvers(params)
]
def run_sweep(self,
program: Union[circuits.Circuit, schedules.Schedule],
params: study.Sweepable,
repetitions: int = 1) -> List[study.TrialResult]:
"""Samples from the given Circuit or Schedule.
In contrast to run, this allows for sweeping over different parameter
values.
Args:
program: The circuit or schedule to simulate.
Should be generated using AQTSampler.generate_circuit_from_list
params: Parameters to run with the program.
repetitions: The number of repetitions to simulate.
The parameters remote_host and access_token are not used.
Returns:
TrialResult list for this run; one for each possible parameter
resolver.
"""
meas_name = 'm' # TODO: Get measurement name from circuit
circuit = (program if isinstance(program, circuits.Circuit) else
program.to_circuit())
assert isinstance(circuit.device, IonDevice)
param_resolvers = study.to_resolvers(params)
trial_results = [] # type: List[study.TrialResult]
for param_resolver in param_resolvers:
id_str = uuid.uuid1()
num_qubits = len(circuit.device.qubits)
json_str = self._generate_json(circuit=circuit,
param_resolver=param_resolver)
results = self._send_json(json_str=json_str,
id_str=id_str,
repetitions=repetitions,
num_qubits=num_qubits)
results = results.astype(bool)
res_dict = {meas_name: results}
trial_results.append(
study.TrialResult(params=param_resolver,
measurements=res_dict))
return trial_results
def run_sweep(self,
program: 'cirq.Circuit',
params: study.Sweepable,
repetitions: int = 1) -> List[study.TrialResult]:
"""Samples from the given Circuit.
In contrast to run, this allows for sweeping over different parameter
values.
Args:
program: The circuit to simulate.
Should be generated using AQTSampler.generate_circuit_from_list
params: Parameters to run with the program.
repetitions: The number of repetitions to simulate.
Returns:
TrialResult list for this run; one for each possible parameter
resolver.
"""
# TODO: Use measurement name from circuit.
# Github issue: https://github.com/quantumlib/Cirq/issues/2199
meas_name = 'm'
assert isinstance(program.device, IonDevice)
trial_results = [] # type: List[study.TrialResult]
for param_resolver in study.to_resolvers(params):
id_str = uuid.uuid1()
num_qubits = len(program.device.qubits)
json_str = self._generate_json(circuit=program,
param_resolver=param_resolver)
results = self._send_json(json_str=json_str,
id_str=id_str,
repetitions=repetitions,
num_qubits=num_qubits)
results = results.astype(bool)
res_dict = {meas_name: results}
trial_results.append(
study.TrialResult(params=param_resolver, measurements=res_dict))
return trial_results
