def run(self, schedules, validate=True, **run_options): """Run a qobj on the backend. Args: schedules (Schedule or list): The pulse :class:`~qiskit.pulse.Schedule` (or list of ``Schedule`` objects) to be executed. validate (bool): validate the Qobj before running (default: True). run_options (kwargs): additional run time backend options. Returns: AerJob: The simulation job. Additional Information: * kwarg options specified in ``run_options`` will override options of the same kwarg specified in the simulator options, the ``backend_options`` and the ``Qobj.config``. """ if isinstance(schedules, list): new_schedules = [] for i in schedules: if isinstance(i, QuantumCircuit): new_schedules.append(schedule(i, self)) else: new_schedules.append(i) schedules = new_schedules elif isinstance(schedules, QuantumCircuit): schedules = schedule(schedules, self) return super().run(schedules, validate=validate, **run_options)
def test_call_gate_and_circuit(self): """Test calling circuit with gates.""" h_control = circuit.QuantumCircuit(2) h_control.h(0) with pulse.build(self.backend) as schedule: with pulse.align_sequential(): # this is circuit, a subroutine stored as Call instruction pulse.call(h_control) # this is instruction, not subroutine pulse.cx(0, 1) # this is macro, not subroutine pulse.measure([0, 1]) # subroutine h_reference = compiler.schedule(compiler.transpile(h_control, self.backend), self.backend) # gate cx_circ = circuit.QuantumCircuit(2) cx_circ.cx(0, 1) cx_reference = compiler.schedule(compiler.transpile(cx_circ, self.backend), self.backend) # measurement measure_reference = macros.measure( qubits=[0, 1], inst_map=self.inst_map, meas_map=self.configuration.meas_map ) reference = pulse.Schedule() reference += pulse.instructions.Call(h_reference) reference += cx_reference reference += measure_reference << reference.duration self.assertScheduleEqual(schedule, reference)
def test_transpile_and_sequence_agree_with_schedule_for_circuits_without_measures(self): qc = QuantumCircuit(2, name="bell_without_measurement") qc.h(0) qc.cx(0, 1) sc = transpile(qc, self.backend, scheduling_method="alap") actual = sequence(sc, self.backend) expected = schedule(transpile(qc, self.backend), self.backend) self.assertEqual(actual, pad(expected))
def test_transpile_and_sequence_agree_with_schedule(self): qc = QuantumCircuit(2, name="bell") qc.h(0) qc.cx(0, 1) qc.measure_all() sc = transpile(qc, self.backend, scheduling_method='alap') actual = sequence(sc, self.backend) expected = schedule(transpile(qc, self.backend), self.backend) self.assertEqual(actual, pad(expected))
def test_u2(self): """Test u2 gate.""" with pulse.build(self.backend) as schedule: pulse.u2(np.pi, 0, 0) reference_qc = circuit.QuantumCircuit(1) reference_qc.append(circuit.library.U2Gate(np.pi, 0), [0]) reference = compiler.schedule(reference_qc, self.backend) self.assertEqual(schedule, reference)
def test_u3(self): """Test u3 gate.""" with pulse.build(self.backend) as schedule: pulse.u3(np.pi, 0, np.pi/2, 0) reference_qc = circuit.QuantumCircuit(1) reference_qc.u3(np.pi, 0, np.pi/2, 0) reference = compiler.schedule(reference_qc, self.backend) self.assertEqual(schedule, reference)
def test_lazy_evaluation_with_transpiler(self): """Test that the two cx gates are optimizied away by the transpiler.""" with pulse.build(self.backend) as schedule: pulse.cx(0, 1) pulse.cx(0, 1) reference_qc = circuit.QuantumCircuit(2) reference = compiler.schedule(reference_qc, self.backend) self.assertEqual(schedule, reference)
def test_u3(self): """Test u3 gate.""" with pulse.build(self.backend) as schedule: pulse.u3(np.pi / 8, np.pi / 16, np.pi / 4, 0) reference_qc = circuit.QuantumCircuit(1) reference_qc.append(circuit.library.U3Gate(np.pi / 8, np.pi / 16, np.pi / 4), [0]) reference = compiler.schedule(reference_qc, self.backend) self.assertScheduleEqual(schedule, reference)
def test_cx(self): """Test cx gate.""" with pulse.build(self.backend) as schedule: pulse.cx(0, 1) reference_qc = circuit.QuantumCircuit(2) reference_qc.cx(0, 1) reference = compiler.schedule(reference_qc, self.backend) self.assertEqual(schedule, reference)
def test_x(self): """Test x gate.""" with pulse.build(self.backend) as schedule: pulse.x(0) reference_qc = circuit.QuantumCircuit(1) reference_qc.x(0) reference_qc = compiler.transpile(reference_qc, self.backend) reference = compiler.schedule(reference_qc, self.backend) self.assertEqual(schedule, reference)
def test_u1(self): """Test u1 gate.""" with pulse.build(self.backend) as schedule: with pulse.transpiler_settings(layout_method="trivial"): pulse.u1(np.pi / 2, 0) reference_qc = circuit.QuantumCircuit(1) reference_qc.append(circuit.library.U1Gate(np.pi / 2), [0]) reference = compiler.schedule(reference_qc, self.backend) self.assertScheduleEqual(schedule, reference)
def test_transpile_and_sequence_agree_with_schedule_for_circuit_with_delay( self): qc = QuantumCircuit(1, 1, name="t2") qc.h(0) qc.delay(500, 0, unit='ns') qc.h(0) qc.measure(0, 0) sc = transpile(qc, self.backend, scheduling_method='alap') actual = sequence(sc, self.backend) expected = schedule(qc.decompose(), self.backend) self.assertEqual(actual, pad(expected))
def test_transpile_and_sequence_agree_with_schedule_for_circuit_with_delay( self): qc = QuantumCircuit(1, 1, name="t2") qc.h(0) qc.delay(500, 0, unit='ns') qc.h(0) qc.measure(0, 0) sc = transpile(qc, self.backend, scheduling_method='alap') actual = sequence(sc, self.backend) expected = schedule(transpile(qc, self.backend), self.backend) self.assertEqual(actual.exclude(instruction_types=[pulse.Delay]), expected.exclude(instruction_types=[pulse.Delay]))
def test_measure(self): """Test pulse measurement macro against circuit measurement and ensure agreement.""" with pulse.build(self.backend) as schedule: with pulse.align_sequential(): pulse.x(0) pulse.measure(0) reference_qc = circuit.QuantumCircuit(1, 1) reference_qc.x(0) reference_qc.measure(0, 0) reference_qc = compiler.transpile(reference_qc, self.backend) reference = compiler.schedule(reference_qc, self.backend) self.assertEqual(schedule, reference)
def test_call_circuit_with_cregs(self): """Test calling of circuit wiht classical registers.""" qc = circuit.QuantumCircuit(2, 2) qc.h(0) qc.cx(0, 1) qc.measure([0, 1], [0, 1]) with pulse.build(self.backend) as schedule: pulse.call(qc) reference_qc = compiler.transpile(qc, self.backend) reference = compiler.schedule(reference_qc, self.backend) self.assertEqual(schedule, reference)
def main( backend, user_messenger, circuits, initial_layout=None, seed_transpiler=None, optimization_level=None, transpiler_options=None, scheduling_method=None, schedule_circuit=False, inst_map=None, meas_map=None, measurement_error_mitigation=False, **kwargs, ): """Run the circuits on the backend.""" # transpiling the circuits using given transpile options transpiler_options = transpiler_options or {} circuits = transpile( circuits, initial_layout=initial_layout, seed_transpiler=seed_transpiler, optimization_level=optimization_level, backend=backend, **transpiler_options, ) if schedule_circuit: circuits = schedule( circuits=circuits, backend=backend, inst_map=inst_map, meas_map=meas_map, method=scheduling_method, ) if not isinstance(circuits, list): circuits = [circuits] # Compute raw results result = backend.run(circuits, **kwargs).result() if measurement_error_mitigation: # Performs measurement error mitigation. pass user_messenger.publish(result.to_dict(), final=True)
def prep_experiments(qc_list: List[QuantumCircuit], backend: IBMQBackend, physical_dist_list: List[int], save_path, output=False): """prepare experiments multiple qcs varing hardware usage""" # prepare pandas dataframe columns = [ "Backend", "Physical distance", "Hardware Usage (%)", "Total Circuit Duration Time", "Quantum Circuits", "Scheduled Pulse" ] df = pd.DataFrame(columns=columns) # backend info num_hw_qubit = backend.configuration().num_qubits for physical_dist in physical_dist_list: transpiled, num_usage = dynamic_multiqc_compose( queued_qc=qc_list, backend=backend, routing_method="sabre", scheduling_method="alap", num_hw_dist=physical_dist, return_num_usage=True, ) scheduled = [schedule(_tqc, backend=backend) for _tqc in transpiled] usage = "{:.2%}".format( average([_usage / num_hw_qubit for _usage in num_usage[0:-1]])) tdt = sum([_sched._duration for _sched in scheduled]) df = df.append( { "Backend": backend.name, "Physical distance": physical_dist, "Hardware Usage (%)": usage, "Total Circuit Duration Time": tdt, "Quantum Circuits": transpiled, "Scheduled Pulse": scheduled, }, ignore_index=True) # save the DataFrame as pickle file pickle_dump(obj=df, path=save_path) if output: return df
def get_audio_waveform(string): words = string.split(" ") audio_waveform = np.array([]) for word in words: word_waveforms = [ pulse_schedule_to_complex_waveform( schedule(transpile(char_to_qc(char), backend), backend)) for char in word ] waveform_size = max([waveform.size for waveform in word_waveforms]) word_waveform = np.zeros(waveform_size) for waveform in word_waveforms: word_waveform = word_waveform + np.pad( waveform, (0, waveform_size - waveform.size), mode='constant') audio_waveform = np.concatenate( (audio_waveform, complex_waveform_to_amplitude_waveform(waveform))) return audio_waveform
def execute(experiments, backend, basis_gates=None, coupling_map=None, # circuit transpile options backend_properties=None, initial_layout=None, seed_transpiler=None, optimization_level=None, pass_manager=None, qobj_id=None, qobj_header=None, shots=1024, # common run options memory=False, max_credits=10, seed_simulator=None, default_qubit_los=None, default_meas_los=None, # schedule run options schedule_los=None, meas_level=MeasLevel.CLASSIFIED, meas_return=MeasReturnType.AVERAGE, memory_slots=None, memory_slot_size=100, rep_time=None, parameter_binds=None, schedule_circuit=False, inst_map=None, meas_map=None, scheduling_method=None, **run_config): """Execute a list of :class:`qiskit.circuit.QuantumCircuit` or :class:`qiskit.pulse.Schedule` on a backend. The execution is asynchronous, and a handle to a job instance is returned. Args: experiments (QuantumCircuit or list[QuantumCircuit] or Schedule or list[Schedule]): Circuit(s) or pulse schedule(s) to execute backend (BaseBackend): Backend to execute circuits on. Transpiler options are automatically grabbed from backend.configuration() and backend.properties(). If any other option is explicitly set (e.g. coupling_map), it will override the backend's. basis_gates (list[str]): List of basis gate names to unroll to. e.g: ``['u1', 'u2', 'u3', 'cx']`` If ``None``, do not unroll. coupling_map (CouplingMap or list): Coupling map (perhaps custom) to target in mapping. Multiple formats are supported: #. CouplingMap instance #. list Must be given as an adjacency matrix, where each entry specifies all two-qubit interactions supported by backend e.g: ``[[0, 1], [0, 3], [1, 2], [1, 5], [2, 5], [4, 1], [5, 3]]`` backend_properties (BackendProperties): Properties returned by a backend, including information on gate errors, readout errors, qubit coherence times, etc. Find a backend that provides this information with: ``backend.properties()`` initial_layout (Layout or dict or list): Initial position of virtual qubits on physical qubits. If this layout makes the circuit compatible with the coupling_map constraints, it will be used. The final layout is not guaranteed to be the same, as the transpiler may permute qubits through swaps or other means. Multiple formats are supported: #. :class:`qiskit.transpiler.Layout` instance #. ``dict``: virtual to physical:: {qr[0]: 0, qr[1]: 3, qr[2]: 5} physical to virtual:: {0: qr[0], 3: qr[1], 5: qr[2]} #. ``list`` virtual to physical:: [0, 3, 5] # virtual qubits are ordered (in addition to named) physical to virtual:: [qr[0], None, None, qr[1], None, qr[2]] seed_transpiler (int): Sets random seed for the stochastic parts of the transpiler optimization_level (int): How much optimization to perform on the circuits. Higher levels generate more optimized circuits, at the expense of longer transpilation time. #. No optimization #. Light optimization #. Heavy optimization #. Highest optimization If None, level 1 will be chosen as default. pass_manager (PassManager): The pass manager to use during transpilation. If this arg is present, auto-selection of pass manager based on the transpile options will be turned off and this pass manager will be used directly. qobj_id (str): String identifier to annotate the Qobj qobj_header (QobjHeader or dict): User input that will be inserted in Qobj header, and will also be copied to the corresponding :class:`qiskit.result.Result` header. Headers do not affect the run. shots (int): Number of repetitions of each circuit, for sampling. Default: 1024 memory (bool): If True, per-shot measurement bitstrings are returned as well (provided the backend supports it). For OpenPulse jobs, only measurement level 2 supports this option. Default: False max_credits (int): Maximum credits to spend on job. Default: 10 seed_simulator (int): Random seed to control sampling, for when backend is a simulator default_qubit_los (list): List of default qubit LO frequencies in Hz default_meas_los (list): List of default meas LO frequencies in Hz schedule_los (None or list or dict or LoConfig): Experiment LO configurations, if specified the list is in the format:: list[Union[Dict[PulseChannel, float], LoConfig]] or Union[Dict[PulseChannel, float], LoConfig] meas_level (int or MeasLevel): Set the appropriate level of the measurement output for pulse experiments. meas_return (str or MeasReturn): Level of measurement data for the backend to return For ``meas_level`` 0 and 1: ``"single"`` returns information from every shot. ``"avg"`` returns average measurement output (averaged over number of shots). memory_slots (int): Number of classical memory slots used in this job. memory_slot_size (int): Size of each memory slot if the output is Level 0. rep_time (int): repetition time of the experiment in μs. The delay between experiments will be rep_time. Must be from the list provided by the device. parameter_binds (list[dict]): List of Parameter bindings over which the set of experiments will be executed. Each list element (bind) should be of the form ``{Parameter1: value1, Parameter2: value2, ...}``. All binds will be executed across all experiments, e.g. if parameter_binds is a length-n list, and there are m experiments, a total of :math:`m x n` experiments will be run (one for each experiment/bind pair). schedule_circuit (bool): If ``True``, ``experiments`` will be converted to :class:`qiskit.pulse.Schedule` objects prior to execution. inst_map (InstructionScheduleMap): Mapping of circuit operations to pulse schedules. If None, defaults to the ``instruction_schedule_map`` of ``backend``. meas_map (list(list(int))): List of sets of qubits that must be measured together. If None, defaults to the ``meas_map`` of ``backend``. scheduling_method (str or list(str)): Optionally specify a particular scheduling method. run_config (dict): Extra arguments used to configure the run (e.g. for Aer configurable backends). Refer to the backend documentation for details on these arguments. Note: for now, these keyword arguments will both be copied to the Qobj config, and passed to backend.run() Returns: BaseJob: returns job instance derived from BaseJob Raises: QiskitError: if the execution cannot be interpreted as either circuits or schedules Example: Construct a 5-qubit GHZ circuit and execute 4321 shots on a backend. .. jupyter-execute:: from qiskit import QuantumCircuit, execute, BasicAer backend = BasicAer.get_backend('qasm_simulator') qc = QuantumCircuit(5, 5) qc.h(0) qc.cx(0, range(1, 5)) qc.measure_all() job = execute(qc, backend, shots=4321) """ # transpiling the circuits using given transpile options if pass_manager is not None: _check_conflicting_argument(optimization_level=optimization_level, basis_gates=basis_gates, coupling_map=coupling_map, seed_transpiler=seed_transpiler, backend_properties=backend_properties, initial_layout=initial_layout, backend=backend) experiments = pass_manager.run(experiments) else: experiments = transpile(experiments, basis_gates=basis_gates, coupling_map=coupling_map, backend_properties=backend_properties, initial_layout=initial_layout, seed_transpiler=seed_transpiler, optimization_level=optimization_level, backend=backend) if schedule_circuit: if isinstance(experiments, Schedule) or isinstance(experiments[0], Schedule): raise QiskitError("Must supply QuantumCircuit to schedule circuit.") experiments = schedule(circuits=experiments, backend=backend, inst_map=inst_map, meas_map=meas_map, method=scheduling_method ) # assembling the circuits into a qobj to be run on the backend qobj = assemble(experiments, qobj_id=qobj_id, qobj_header=qobj_header, shots=shots, memory=memory, max_credits=max_credits, seed_simulator=seed_simulator, default_qubit_los=default_qubit_los, default_meas_los=default_meas_los, schedule_los=schedule_los, meas_level=meas_level, meas_return=meas_return, memory_slots=memory_slots, memory_slot_size=memory_slot_size, rep_time=rep_time, parameter_binds=parameter_binds, backend=backend, **run_config ) # executing the circuits on the backend and returning the job start_time = time() job = backend.run(qobj, **run_config) end_time = time() _log_submission_time(start_time, end_time) return job
def test_complex_build(self): """Test a general program build with nested contexts, circuits and macros.""" d0 = pulse.DriveChannel(0) d1 = pulse.DriveChannel(1) d2 = pulse.DriveChannel(2) delay_dur = 19 short_dur = 31 long_dur = 101 with pulse.build(self.backend) as schedule: with pulse.align_sequential(): pulse.delay(delay_dur, d0) pulse.u2(0, pi/2, 1) with pulse.align_right(): pulse.play(library.Constant(short_dur, 0.1), d1) pulse.play(library.Constant(long_dur, 0.1), d2) pulse.u2(0, pi/2, 1) with pulse.align_left(): pulse.u2(0, pi/2, 0) pulse.u2(0, pi/2, 1) pulse.u2(0, pi/2, 0) pulse.measure(0) # prepare and schedule circuits that will be used. single_u2_qc = circuit.QuantumCircuit(2) single_u2_qc.u2(0, pi/2, 1) single_u2_qc = compiler.transpile(single_u2_qc, self.backend) single_u2_sched = compiler.schedule(single_u2_qc, self.backend) # sequential context sequential_reference = pulse.Schedule() sequential_reference += instructions.Delay(delay_dur, d0) sequential_reference.insert(delay_dur, single_u2_sched, inplace=True) # align right align_right_reference = pulse.Schedule() align_right_reference += pulse.Play( library.Constant(long_dur, 0.1), d2) align_right_reference.insert(long_dur-single_u2_sched.duration, single_u2_sched, inplace=True) align_right_reference.insert( long_dur-single_u2_sched.duration-short_dur, pulse.Play(library.Constant(short_dur, 0.1), d1), inplace=True) # align left triple_u2_qc = circuit.QuantumCircuit(2) triple_u2_qc.u2(0, pi/2, 0) triple_u2_qc.u2(0, pi/2, 1) triple_u2_qc.u2(0, pi/2, 0) triple_u2_qc = compiler.transpile(triple_u2_qc, self.backend) align_left_reference = compiler.schedule( triple_u2_qc, self.backend, method='alap') # measurement measure_reference = macros.measure(qubits=[0], inst_map=self.inst_map, meas_map=self.configuration.meas_map) reference = pulse.Schedule() reference += sequential_reference # Insert so that the long pulse on d2 occurs as early as possible # without an overval on d1. insert_time = (reference.ch_stop_time(d1) - align_right_reference.ch_start_time(d1)) reference.insert(insert_time, align_right_reference, inplace=True) reference.insert(reference.ch_stop_time(d0, d1), align_left_reference, inplace=True) reference += measure_reference self.assertEqual(schedule, reference)
def execute( experiments, backend, basis_gates=None, coupling_map=None, # circuit transpile options backend_properties=None, initial_layout=None, seed_transpiler=None, optimization_level=None, pass_manager=None, qobj_id=None, qobj_header=None, shots=None, # common run options memory=None, max_credits=None, seed_simulator=None, default_qubit_los=None, default_meas_los=None, # schedule run options qubit_lo_range=None, meas_lo_range=None, schedule_los=None, meas_level=None, meas_return=None, memory_slots=None, memory_slot_size=None, rep_time=None, rep_delay=None, parameter_binds=None, schedule_circuit=False, inst_map=None, meas_map=None, scheduling_method=None, init_qubits=None, **run_config, ): """Execute a list of :class:`qiskit.circuit.QuantumCircuit` or :class:`qiskit.pulse.Schedule` on a backend. The execution is asynchronous, and a handle to a job instance is returned. Args: experiments (QuantumCircuit or list[QuantumCircuit] or Schedule or list[Schedule]): Circuit(s) or pulse schedule(s) to execute backend (Backend): Backend to execute circuits on. Transpiler options are automatically grabbed from backend.configuration() and backend.properties(). If any other option is explicitly set (e.g. coupling_map), it will override the backend's. basis_gates (list[str]): List of basis gate names to unroll to. e.g: ``['u1', 'u2', 'u3', 'cx']`` If ``None``, do not unroll. coupling_map (CouplingMap or list): Coupling map (perhaps custom) to target in mapping. Multiple formats are supported: #. CouplingMap instance #. list Must be given as an adjacency matrix, where each entry specifies all two-qubit interactions supported by backend e.g: ``[[0, 1], [0, 3], [1, 2], [1, 5], [2, 5], [4, 1], [5, 3]]`` backend_properties (BackendProperties): Properties returned by a backend, including information on gate errors, readout errors, qubit coherence times, etc. Find a backend that provides this information with: ``backend.properties()`` initial_layout (Layout or dict or list): Initial position of virtual qubits on physical qubits. If this layout makes the circuit compatible with the coupling_map constraints, it will be used. The final layout is not guaranteed to be the same, as the transpiler may permute qubits through swaps or other means. Multiple formats are supported: #. :class:`qiskit.transpiler.Layout` instance #. ``dict``: virtual to physical:: {qr[0]: 0, qr[1]: 3, qr[2]: 5} physical to virtual:: {0: qr[0], 3: qr[1], 5: qr[2]} #. ``list`` virtual to physical:: [0, 3, 5] # virtual qubits are ordered (in addition to named) physical to virtual:: [qr[0], None, None, qr[1], None, qr[2]] seed_transpiler (int): Sets random seed for the stochastic parts of the transpiler optimization_level (int): How much optimization to perform on the circuits. Higher levels generate more optimized circuits, at the expense of longer transpilation time. #. No optimization #. Light optimization #. Heavy optimization #. Highest optimization If None, level 1 will be chosen as default. pass_manager (PassManager): The pass manager to use during transpilation. If this arg is present, auto-selection of pass manager based on the transpile options will be turned off and this pass manager will be used directly. qobj_id (str): DEPRECATED: String identifier to annotate the Qobj. This has no effect and the :attr:`~.QuantumCircuit.name` attribute of the input circuit(s) should be used instead. qobj_header (QobjHeader or dict): DEPRECATED: User input that will be inserted in Qobj header, and will also be copied to the corresponding :class:`qiskit.result.Result` header. Headers do not affect the run. Headers do not affect the run. This kwarg has no effect anymore and the :attr:`~.QuantumCircuit.metadata` attribute of the input circuit(s) should be used instead. shots (int): Number of repetitions of each circuit, for sampling. Default: 1024 memory (bool): If True, per-shot measurement bitstrings are returned as well (provided the backend supports it). For OpenPulse jobs, only measurement level 2 supports this option. Default: False max_credits (int): DEPRECATED This parameter is deprecated as of Qiskit Terra 0.20.0 and will be removed in a future release. This parameter has no effect on modern IBM Quantum systems, no alternative is necessary. seed_simulator (int): Random seed to control sampling, for when backend is a simulator default_qubit_los (Optional[List[float]]): List of job level qubit drive LO frequencies in Hz. Overridden by ``schedule_los`` if specified. Must have length ``n_qubits``. default_meas_los (Optional[List[float]]): List of job level measurement LO frequencies in Hz. Overridden by ``schedule_los`` if specified. Must have length ``n_qubits``. qubit_lo_range (Optional[List[List[float]]]): List of job level drive LO ranges each of form ``[range_min, range_max]`` in Hz. Used to validate ``qubit_lo_freq``. Must have length ``n_qubits``. meas_lo_range (Optional[List[List[float]]]): List of job level measurement LO ranges each of form ``[range_min, range_max]`` in Hz. Used to validate ``meas_lo_freq``. Must have length ``n_qubits``. schedule_los (list): Experiment level (ie circuit or schedule) LO frequency configurations for qubit drive and measurement channels. These values override the job level values from ``default_qubit_los`` and ``default_meas_los``. Frequencies are in Hz. Settable for qasm and pulse jobs. If a single LO config or dict is used, the values are set at job level. If a list is used, the list must be the size of the number of experiments in the job, except in the case of a single experiment. In this case, a frequency sweep will be assumed and one experiment will be created for every list entry. Not every channel is required to be specified. If not specified, the backend default value will be used. meas_level (int or MeasLevel): Set the appropriate level of the measurement output for pulse experiments. meas_return (str or MeasReturn): Level of measurement data for the backend to return For ``meas_level`` 0 and 1: ``"single"`` returns information from every shot. ``"avg"`` returns average measurement output (averaged over number of shots). memory_slots (int): Number of classical memory slots used in this job. memory_slot_size (int): Size of each memory slot if the output is Level 0. rep_time (int): Time per program execution in seconds. Must be from the list provided by the backend (``backend.configuration().rep_times``). Defaults to the first entry. rep_delay (float): Delay between programs in seconds. Only supported on certain backends (``backend.configuration().dynamic_reprate_enabled`` ). If supported, ``rep_delay`` will be used instead of ``rep_time`` and must be from the range supplied by the backend (``backend.configuration().rep_delay_range``). Default is given by ``backend.configuration().default_rep_delay``. parameter_binds (list[dict]): List of Parameter bindings over which the set of experiments will be executed. Each list element (bind) should be of the form ``{Parameter1: value1, Parameter2: value2, ...}``. All binds will be executed across all experiments, e.g. if parameter_binds is a length-:math:`n` list, and there are :math:`m` experiments, a total of :math:`m \\times n` experiments will be run (one for each experiment/bind pair). schedule_circuit (bool): If ``True``, ``experiments`` will be converted to :class:`qiskit.pulse.Schedule` objects prior to execution. inst_map (InstructionScheduleMap): Mapping of circuit operations to pulse schedules. If None, defaults to the ``instruction_schedule_map`` of ``backend``. meas_map (list(list(int))): List of sets of qubits that must be measured together. If None, defaults to the ``meas_map`` of ``backend``. scheduling_method (str or list(str)): Optionally specify a particular scheduling method. init_qubits (bool): Whether to reset the qubits to the ground state for each shot. Default: ``True``. run_config (dict): Extra arguments used to configure the run (e.g. for Aer configurable backends). Refer to the backend documentation for details on these arguments. Note: for now, these keyword arguments will both be copied to the Qobj config, and passed to backend.run() Returns: Job: returns job instance derived from Job Raises: QiskitError: if the execution cannot be interpreted as either circuits or schedules Example: Construct a 5-qubit GHZ circuit and execute 4321 shots on a backend. .. jupyter-execute:: from qiskit import QuantumCircuit, execute, BasicAer backend = BasicAer.get_backend('qasm_simulator') qc = QuantumCircuit(5, 5) qc.h(0) qc.cx(0, range(1, 5)) qc.measure_all() job = execute(qc, backend, shots=4321) """ if isinstance(experiments, (Schedule, ScheduleBlock)) or ( isinstance(experiments, list) and isinstance(experiments[0], (Schedule, ScheduleBlock)) ): # do not transpile a schedule circuit if schedule_circuit: raise QiskitError("Must supply QuantumCircuit to schedule circuit.") elif pass_manager is not None: # transpiling using pass_manager _check_conflicting_argument( optimization_level=optimization_level, basis_gates=basis_gates, coupling_map=coupling_map, seed_transpiler=seed_transpiler, backend_properties=backend_properties, initial_layout=initial_layout, ) experiments = pass_manager.run(experiments) else: # transpiling the circuits using given transpile options experiments = transpile( experiments, basis_gates=basis_gates, coupling_map=coupling_map, backend_properties=backend_properties, initial_layout=initial_layout, seed_transpiler=seed_transpiler, optimization_level=optimization_level, backend=backend, ) if schedule_circuit: experiments = schedule( circuits=experiments, backend=backend, inst_map=inst_map, meas_map=meas_map, method=scheduling_method, ) if max_credits is not None: warnings.warn( "The `max_credits` parameter is deprecated as of Qiskit Terra 0.20.0, " "and will be removed in a future release. This parameter has no effect on " "modern IBM Quantum systems, and no alternative is necessary.", DeprecationWarning, stacklevel=2, ) if qobj_id is not None: warnings.warn( "The qobj_id argument is deprecated as of the Qiskit Terra 0.21.0, " "and will be remvoed in a future release. This argument has no effect and " "is not used by any backends." ) if qobj_header is not None: warnings.warn( "The qobj_header argument is deprecated as of the Qiskit Terra 0.21.0, " "and will be remvoed in a future release. This argument has no effect and " "is not used by any backends." ) if isinstance(backend, Backend): start_time = time() run_kwargs = { "shots": shots, "memory": memory, "seed_simulator": seed_simulator, "qubit_lo_freq": default_qubit_los, "meas_lo_freq": default_meas_los, "qubit_lo_range": qubit_lo_range, "meas_lo_range": meas_lo_range, "schedule_los": schedule_los, "meas_level": meas_level, "meas_return": meas_return, "memory_slots": memory_slots, "memory_slot_size": memory_slot_size, "rep_time": rep_time, "rep_delay": rep_delay, "init_qubits": init_qubits, } for key in list(run_kwargs.keys()): if not hasattr(backend.options, key): if run_kwargs[key] is not None: logger.info( "%s backend doesn't support option %s so not passing that kwarg to run()", backend.name, key, ) del run_kwargs[key] elif run_kwargs[key] is None: del run_kwargs[key] if parameter_binds: run_kwargs["parameter_binds"] = parameter_binds run_kwargs.update(run_config) job = backend.run(experiments, **run_kwargs) end_time = time() _log_submission_time(start_time, end_time) else: raise QiskitError("Invalid backend type %s" % type(backend)) return job
#Overwrite the default CNOT schedule in the inst_map #inst_map.add('cx', [1,0], cnot_sched10) #inst_map.add('cx', [0,1], cnot_sched01) #import pyfits #schedule the randomized branchmarking experiment into pulse schedules. rb_schedules_seeds = [] #i = 0 #plt.figure() for rb_circuits_seed in rb_circuits_seeds: # ax = plt.subplot(len(rb_circuits_seeds),1, i+1) # rb_fit.plot_rb_data(0,ax = ax) rb_circuits_seed = transpile(rb_circuits_seed, backend, basis_gates) rb_schedules_seed = schedule(rb_circuits_seed, backend, inst_map) rb_schedules_seeds.append(rb_schedules_seed) # rb_schedules_seed[0].draw(label = True) # i += 1 #plt.show() # Create a new circuit without the measurement qr = rb_circuits_seeds[0][-1].qregs cr = rb_circuits_seeds[0][-1].cregs QC = qiskit.QuantumCircuit(*qr, *cr) for i in rb_circuits_seeds[0][-1][0:-n]: QC.data.append(i) # The Unitary is an identity (with a global phase) backend = qiskit.Aer.get_backend('unitary_simulator')
def run( self, schedules, *args, backend_options=None, # DEPRECATED validate=True, **run_options): """Run a qobj on the backend. Args: schedules (Schedule or list): The pulse :class:`~qiskit.pulse.Schedule` (or list of ``Schedule`` objects) to be executed. backend_options (dict or None): DEPRECATED dictionary of backend options for the execution (default: None). validate (bool): validate the Qobj before running (default: True). run_options (kwargs): additional run time backend options. Returns: AerJob: The simulation job. Additional Information: * kwarg options specified in ``run_options`` will override options of the same kwarg specified in the simulator options, the ``backend_options`` and the ``Qobj.config``. * The entries in the ``backend_options`` will be combined with the ``Qobj.config`` dictionary with the values of entries in ``backend_options`` taking precedence. This kwarg is deprecated and direct kwarg's should be used for options to pass them to ``run_options``. """ qobj = schedules if args: if isinstance(args[0], PulseSystemModel): warn( 'Passing `system_model` as a positional argument to' ' `PulseSimulator.run` has been deprecated as of' ' qiskit-aer 0.7.0 and will be removed no earlier than 3' ' months from that release date. Pass `system_model` as a kwarg' ' `system_model=model` instead.', DeprecationWarning, stacklevel=3) run_options['system_model'] = args[0] if len(args) > 1: backend_options = args[1] if len(args) > 2: validate = args[3] elif isinstance(args[0], bool): validate = args[0] if len(args) > 1: backend_options = args[1] if isinstance(qobj, list): new_qobj = [] for circuit in qobj: if isinstance(circuit, QuantumCircuit): new_qobj.append(schedule(circuit, self)) else: new_qobj.append(circuit) qobj = new_qobj elif isinstance(qobj, QuantumCircuit): qobj = schedule(qobj, self) return super().run(qobj, backend_options=backend_options, validate=validate, **run_options)