Mga pagbabago sa feature ng Qiskit 1.0

Inilalarawan ng gabay na ito ang mga migration path para sa pinakamahalagang pagbabago sa feature sa Qiskit 1.0, na nakaayos ayon sa module. Gamitin ang talaan ng nilalaman sa kanang bahagi para mag-navigate sa module na gusto mo.

Migration tool ng Qiskit 1.0

Para mapabilis ang proseso ng migration, maaari kang gumamit ng flake8-qiskit-migration tool para matukoy ang mga tinanggal na import path sa iyong code at magmungkahi ng mga alternatibo.

Patakbuhin gamit ang pipx
Patakbuhin gamit ang venv

Kung naka-install ang pipx, patakbuhin lang ang sumusunod na command.

pipx run flake8-qiskit-migration <path-to-source-directory>

I-i-install nito ang package sa isang pansamantalang virtual environment at ipapatakbo ito sa iyong code.

Kung ayaw mong gumamit ng pipx, maaari kang manu-manong gumawa ng bagong environment para sa tool. Pinapahintulutan ka rin ng paraang ito na gumamit ng nbqa para suriin ang mga code example sa Jupyter notebooks. I-delete ang environment kapag tapos ka na.

# Make new environment and install
python -m venv .flake8-qiskit-migration-venv
source .flake8-qiskit-migration-venv/bin/activate
pip install flake8-qiskit-migration

# Run plugin on Python code
flake8 --select QKT100 <path-to-source-directory>  # e.g. `src/`

# (Optional) run plugin on notebooks
pip install nbqa
nbqa flake8 ./**/*.ipynb --select QKT100

# Deactivate and delete environment
deactivate
rm -r .flake8-qiskit-migration-venv

Mga limitasyon

Natutukoy lang ng tool na ito ang mga tinanggal na import path. Hindi nito natutukoy ang paggamit ng mga tinanggal na method (tulad ng QuantumCircuit.qasm) o ng mga argument. Hindi rin nito sinusubaybayan ang mga assignment tulad ng qk = qiskit, kahit kaya nitong hawakan ang mga alias tulad ng import qiskit as qk.

Para sa karagdagang impormasyon, tingnan ang repository ng proyekto.

Mga global na instance at function

Aer

Hindi available ang qiskit.Aer object sa Qiskit 1.0. Sa halip, gamitin ang parehong object mula sa qiskit_aer namespace, na isang drop-in replacement. Para i-install ang qiskit_aer, patakbuhin ang:

pip install qiskit-aer

BasicAer

Hindi available ang qiskit.BasicAer object sa Qiskit 1.0. Tingnan ang seksyon ng migration ng basicaer para sa mga opsyon sa migration.

execute

Hindi available ang qiskit.execute function sa Qiskit 1.0. Ang function na ito ay nagsilbing isang mataas na antas na wrapper sa paligid ng transpile at run na mga function sa Qiskit. Sa halip na qiskit.execute, gamitin ang transpile function na sinusundan ng backend.run().

# Legacy path
from qiskit import execute

job = execute(circuit, backend)

# New path
from qiskit import transpile

new_circuit = transpile(circuit, backend)
job = backend.run(new_circuit)

Bilang alternatibo, ang Sampler primitive ay semantically katumbas ng tinanggal na qiskit.execute function. Ang klase na BackendSampler ay isang generic na wrapper para sa mga backend na hindi sumusuporta sa mga primitive:

from qiskit.primitives import BackendSampler

sampler = BackendSampler(backend)
job = sampler.run(circuit)

qiskit.circuit

QuantumCircuit.qasm

Tinanggal na ang QuantumCircuit.qasm method. Sa halip, gamitin ang qasm2.dump o qasm2.dumps.

Para sa Pygments-formatted na output, tingnan ang standalone na openqasm-pygments package, dahil hindi nagbibigay ng Pygments-colored na output ang qasm2.dump at qasm2.dumps.

from qiskit import QuantumCircuit

qc = QuantumCircuit(1)

# Old
qasm_str = qc.qasm()

# Alternative
from qiskit.qasm2 import dumps

qasm_str = dumps(qc)

# Alternative: Write to file
from qiskit.qasm2 import dump

with open("my_file.qasm", "w") as f:
    dump(qc, f)

Mga Gate ng QuantumCircuit

Tinanggal na ang mga sumusunod na gate method pabor sa mas kilalang mga method na nagdadagdag ng parehong mga gate:

Tinanggal	Alternatibo
`QuantumCircuit.cnot`	`QuantumCircuit.cx`
`QuantumCircuit.toffoli`	`QuantumCircuit.ccx`
`QuantumCircuit.fredkin`	`QuantumCircuit.cswap`
`QuantumCircuit.mct`	`QuantumCircuit.mcx`
`QuantumCircuit.i`	`QuantumCircuit.id`
`QuantumCircuit.squ`	`QuantumCircuit.unitary`

Tinanggal na rin ang mga sumusunod na circuit method. Sa halip, maaaring ilapat ang mga gate na ito sa isang circuit gamit ang QuantumCircuit.append.

Tinanggal	Alternatibo (append)
`QuantumCircuit.diagonal`	`DiagonalGate`
`QuantumCircuit.hamiltonian`	`HamiltonianGate`
`QuantumCircuit.isometry`	`Isometry`
`QuantumCircuit.iso`	`Isometry`
`QuantumCircuit.uc`	`UCGate`
`QuantumCircuit.ucrx`	`UCRXGate`
`QuantumCircuit.ucry`	`UCRYGate`
`QuantumCircuit.ucrz`	`UCRZGate`

Halimbawa, para sa isang DiagonalGate:

from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import DiagonalGate  # new location in the circuit library

circuit = QuantumCircuit(2)
circuit.h([0, 1])  # some initial state

gate = DiagonalGate([1, -1, -1, 1])
qubits = [0, 1]  # qubit indices on which to apply the gate
circuit.append(gate, qubits)  # apply the gate

Tinanggal na rin ang mga sumusunod na QuantumCircuit method:

Tinanggal	Alternatibo
`QuantumCircuit.bind_parameters`	`QuantumCircuit.assign_parameters`
`QuantumCircuit.snapshot`	Mga save instruction ng `qiskit-aer`

qiskit.converters

Tinanggal na ang qiskit.converters.ast_to_dag function mula sa Qiskit. Kino-convert nito ang abstract syntax tree na nabuo ng legacy na OpenQASM 2 parser papunta sa isang DAGCircuit. Dahil tinanggal na ang legacy na OpenQASM 2 parser (tingnan ang qiskit.qasm), wala nang silbi ang function na ito. Sa halip, i-parse ang iyong mga OpenQASM 2 file papunta sa isang QuantumCircuit gamit ang QuantumCircuit.from_qasm_file o QuantumCircuit.from_qasm_str na mga constructor method (o ang qiskit.qasm2 module), tapos i-convert ang QuantumCircuit na iyon papunta sa isang DAGCircuit gamit ang circuit_to_dag.

# Previous
from qiskit.converters import ast_to_dag
from qiskit.qasm import Qasm

dag = ast_to_dag(Qasm(filename="myfile.qasm").parse())

# Current alternative
import qiskit.qasm2
from qiskit.converters import circuit_to_dag

dag = circuit_to_dag(qiskit.qasm2.load("myfile.qasm"))

qiskit.extensions

Hindi na available ang qiskit.extensions module. Karamihan sa mga object nito ay naisama na sa circuit library (qiskit.circuit.library). Para mag-migrate sa bagong lokasyon, palitan lang ang qiskit.extensions ng qiskit.circuit.library sa import path ng object. Ito ay isang drop-in replacement.

# Previous
from qiskit.extensions import DiagonalGate

# Current alternative
from qiskit.circuit.library import DiagonalGate

Ang mga klase na inilipat sa qiskit.circuit.library ay:

DiagonalGate
HamiltonianGate
Initialize
Isometry
qiskit.circuit.library.generalized_gates.mcg_up_diag.MCGupDiag
UCGate
UCPauliRotGate
UCRXGate
UCRYGate
UCRZGate
UnitaryGate

Tinanggal na ang mga sumusunod na klase mula sa codebase, dahil ang kanilang mga function ay alinman ay redundant o naka-link sa extensions module:

Tinanggal	Alternatibo
`SingleQubitUnitary`	`qiskit.circuit.library.UnitaryGate`
`Snapshot`	Gamitin ang mga save instruction ng `qiskit-aer`
`ExtensionError`	Isang relevant na error class

qiskit.primitives

Ang pinakakapansin-pansing pagbabago sa qiskit.primitives module ay ang pagpapakilala ng bagong primitives V2 interface. Ipinapakita ng seksyong ito kung paano i-migrate ang iyong workflow mula sa primitives V1 patungong primitives V2, pati na rin ang ilang pagbabago sa mga input na tinatanggap ng V1 interface.

tala

Simula sa 1.0 release, ang pre-1.0 na primitives interface ay tatawagin nating "primitives V1".

Mag-migrate mula V1 patungong V2

Ang pormal na pagkakaiba sa pagitan ng primitives V1 at V2 API ay ang mga base class kung saan nagmamana ang mga implementasyon ng primitive. Para lumipat sa mga bagong base class, maaari mong panatilihin ang orihinal na import path mula sa qiskit.primitives:

Mag-migrate mula sa	Palitan ng
`BaseEstimator`	`BaseEstimatorV2`
`BaseSampler`	`BaseSamplerV2`

Ang mga pangalan ng qiskit core implementations ng V2 primitives (ang mga maaaring i-import mula sa qiskit.primitives), ay binago para linawin ang kanilang layunin bilang mga implementasyon na maaaring patakbuhin nang lokal gamit ang isang statevector simulator backend. Ang mga bagong pangalan ay hindi kasama ang -V2 suffix.

Mag-migrate mula sa	Palitan ng
`qiskit.primitives.Estimator`	`qiskit.primitives.StatevectorEstimator`
`qiskit.primitives.Sampler`	`qiskit.primitives.StatevectorSampler`

May ilang konseptwal na pagkakaiba na dapat isaalang-alang kapag nag-mi-migrate mula V1 patungong V2. Ang mga pagkakaibang ito ay nakasalalay sa base class, ngunit ipinapakita sa mga sumusunod na halimbawa gamit ang mga statevector implementation na makikita sa qiskit.primitives:

tala

Para sa mga sumusunod na halimbawa, ipagpalagay ang mga sumusunod na import at primitive initialization:

from qiskit.primitives import (
    Sampler,
    StatevectorSampler,
    Estimator,
    StatevectorEstimator,
)

estimator_v1 = Estimator()
sampler_v1 = Sampler()
estimator_v2 = StatevectorEstimator()
sampler_v2 = StatevectorSampler()

# define circuits, observables and parameter values

Sampler at Estimator: Ang mga bagong V2 primitive ay dinisenyo para tanggapin ang vectorized na input, kung saan ang mga solong circuit ay maaaring pagsamahin kasama ang mga array-valued na specification. Ibig sabihin, isang circuit ang maaaring i-execute para sa mga array ng n na parameter set, n na observable, o pareho (sa kaso ng estimator). Ang bawat grupo ay tinatawag na primitive unified bloc (pub), at maaaring katawanin bilang isang tuple: (1 x circuit, [n x observables], [n x parameters]). Hindi pinahintulutan ng V1 interface ang parehong flexibility. Sa halip, ang bilang ng mga input na circuit ay kailangang tumugma sa bilang ng mga observable at parameter set, tulad ng ipinapakita sa mga sumusunod na halimbawa (pumili ng tab para makita ang bawat halimbawa):

Estimator, 1 circuit, 4 observable
Sampler, 1 circuit, 3 parameter set
Estimator, 1 circuit, 4 observable, 2 parameter set

# executing 1 circuit with 4 observables using Estimator V1
job = estimator_v1.run([circuit] * 4, [obs1, obs2, obs3, obs4])
evs = job.result().values

# executing 1 circuit with 4 observables using Estimator V2
job = estimator_v2.run([(circuit, [obs1, obs2, obs3, obs4])])
evs = job.result()[0].data.evs

# executing 1 circuit with 3 parameter sets using Sampler V1
job = sampler_v1.run([circuit] * 3, [vals1, vals2, vals3])
dists = job.result().quasi_dists

# executing 1 circuit with 3 parameter sets using Sampler V2
job = sampler_v2.run([(circuit, [vals1, vals2, vals3])])
counts = job.result()[0].data.meas.get_counts()

# executing 1 circuit with 4 observables and 2 parameter sets using Estimator V1
job = estimator_v1.run([circuit] * 8, [obs1, obs2, obs3, obs4] * 2, [vals1, vals2] * 4)
evs = job.result().values

# executing 1 circuit with 4 observables and 2 parameter sets using Estimator V2
job = estimator_v2.run([(circuit, [[obs1, obs2, obs3, obs4]], [[vals1], [vals2]])])
evs = job.result()[0].data.evs

Tinatanggap ng mga V2 primitive ang maramihang PUB bilang input, at ang bawat pub ay may sariling resulta. Nagbibigay-daan ito sa iyo na magpatakbo ng iba't ibang circuit na may iba't ibang kombinasyon ng parameter/observable, na hindi laging posible sa V1 interface:

Sampler, 2 circuit, 1 parameter set
Estimator, 2 circuit, 2 magkaibang observable

# executing 2 circuits with 1 parameter set using Sampler V1
job = sampler_v1.run([circuit1, circuit2], [vals1] * 2)
dists = job.result().quasi_dists

# executing 2 circuits with 1 parameter set using Sampler V2
job = sampler_v2.run([(circuit1, vals1), (circuit2, vals1)])
counts1 = job.result()[0].data.meas.get_counts()  # result for pub 1 (circuit 1)
counts2 = job.result()[1].data.meas.get_counts()  # result for pub 2 (circuit 2)

# executing 2 circuits with 2 different observables using Estimator V1
job = estimator_v1.run([circuit1, circuit2] , [obs1, obs2])
evs = job.result().values

# executing 2 circuits with 2 different observables using Estimator V2
job = estimator_v2.run([(circuit1, obs1), (circuit2, obs2)])
evs1 = job.result()[0].data.evs  # result for pub 1 (circuit 1)
evs2 = job.result()[1].data.evs  # result for pub 2 (circuit 2)

Sampler: Ang V2 sampler ay nagbabalik na ngayon ng mga measurement outcome sample sa anyo ng mga bitstring o count, sa halip na ang mga quasi-probability distribution mula sa V1 interface. Ipinapakita ng mga bitstring ang mga measurement outcome, pinapanatili ang pagkakasunud-sunod ng shot kung saan sila sinukat. Nag-oorganisa ng data ang mga V2 sampler result object batay sa mga classical register name ng kanilang input na circuit, para sa compatibility sa mga dynamic circuit.

# Define quantum circuit with 2 qubits
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure_all()
circuit.draw()

        ┌───┐      ░ ┌─┐
   q_0: ┤ H ├──■───░─┤M├───
        └───┘┌─┴─┐ ░ └╥┘┌─┐
   q_1: ─────┤ X ├─░──╫─┤M├
             └───┘ ░  ║ └╥┘
meas: 2/══════════════╩══╩═
                      0  1

Default na pangalan ng classical register

Sa circuit sa itaas, pansinin na ang pangalan ng classical register ay default sa "meas". Gagamitin ang pangalang ito mamaya para ma-access ang mga measurement bitstring.

# Run using V1 sampler
result = sampler_v1.run(circuit).result()
quasi_dist = result.quasi_dists[0]
print(f"The quasi-probability distribution is: {quasi_dist}")

The quasi-probability distribution is: {0: 0.5, 3: 0.5}

# Run using V2 sampler
result = sampler_v2.run([circuit]).result()
# Access result data for pub 0
data_pub = result[0].data
# Access bitstrings for the classical register "meas"
bitstrings = data_pub.meas.get_bitstrings()
print(f"The number of bitstrings is: {len(bitstrings)}")
# Get counts for the classical register "meas"
counts = data_pub.meas.get_counts()
print(f"The counts are: {counts}")

The number of bitstrings is: 1024
The counts are: {'00': 523, '11': 501}

Sampler at Estimator: Ang sampling overhead, na karaniwang inilalantad ng mga V1 implementation sa pamamagitan ng shots run option, ay isang argument na ngayon ng run() method ng mga primitive na maaaring tukuyin sa antas ng PUB. Inilalantad ng mga V2 base class ang mga argument sa mga format na naiiba sa V1 API:
- Ang BaseSamplerV2.run ay naglalantad ng shots argument (katulad ng nakaraang workflow):
  # Sample two circuits at 128 shots each. sampler_v2.run([circuit1, circuit2], shots=128) # Sample two circuits at different amounts of shots. The "None"s are necessary # as placeholders # for the lack of parameter values in this example. sampler_v2.run([(circuit1, None, 123), (circuit2, None, 456)])
- Ang EstimatorV2.run ay nagpapakilala ng precision argument na tumutukoy sa mga error bar na dapat i-target ng implementasyon ng primitive para sa mga estimate ng expectation value:
  # Estimate expectation values for two PUBs, both with 0.05 precision. estimator_v2.run([(circuit1, obs_array1), (circuit2, obs_array_2)], precision=0.05)

Mga update sa V1 interface

Hindi na pinahihintulutan ang implicit na conversion mula sa isang dense na BaseOperator patungong SparsePauliOp sa mga observable argument ng Estimator. Dapat mong explicit na i-convert patungong SparsePauliOp gamit ang SparsePauliOp.from_operator(operator) sa halip.
Hindi na pinahihintulutan ang paggamit ng PauliList sa mga observable argument ng Estimator. Sa halip, dapat mong explicit na i-convert ang argument gamit ang SparsePauliOp(pauli_list) muna.

qiskit.providers

basicaer

Karamihan sa functionality ng qiskit.providers.basicaer module ay napalitan na ng bagong qiskit.providers.basic_provider module, maliban sa UnitarySimulatorPy at StatevectorSimulatorPy na mga klase, na inalis na; ang kanilang functionality ay mayroon na sa quantum_info module.

Ang paglipat sa mga bagong path ay direkta. Karamihan sa mga klase sa qiskit.providers.basicaer ay maaaring palitan ng kanilang qiskit.providers.basic_provider katumbas (drop-in replacement). Tandaan na ang mga sumusunod na klase ay may bagong mga path at pangalan:

Inalis	Alternatibo
`qiskit.providers.basicaer`	`qiskit.providers.basic_provider`
`BasicAerProvider`	`BasicProvider`
`BasicAerJob`	`BasicProviderJob`
`QasmSimulatorPy`	`BasicSimulator`

Mga global na instance

Mag-ingat sa mga global na instance kapag lumilipat sa bagong module. Wala nang kapalit para sa BasicAer global instance na maaaring direktang i-import bilang qiskit.BasicAer. Ibig sabihin, ang from qiskit import BasicProvider ay hindi na valid na import. Sa halip, ang provider class ay dapat i-import mula sa submodule nito at i-instantiate ng user:

# Previous
from qiskit import BasicAer
backend = BasicAer.get_backend("backend_name")

# Current
from qiskit.providers.basic_provider import BasicProvider
backend = BasicProvider().get_backend("backend_name")

Ang unitary at statevector simulator ay maaaring palitan ng iba't ibang quantum_info na klase. Hindi ito drop-in replacement, pero minimal lang ang mga pagbabago. Tingnan ang mga sumusunod na halimbawa ng migration:

Inalis	Alternatibo
`UnitarySimulatorPy`	`quantum_info.Operator`
`StatevectorSimulatorPy`	`quantum_info.Statevector`

Ipinapakita ng mga sumusunod na halimbawa ang mga migration path ng basicaer simulators.

Statevector simulator
Unitary simulator
QASM simulator

from qiskit import QuantumCircuit

qc = QuantumCircuit(3)
qc.h(0)
qc.h(1)
qc.cx(1, 2)
qc.measure_all()

# Previous
from qiskit import BasicAer
backend = BasicAer.get_backend("statevector_simulator")
statevector = backend.run(qc).result().get_statevector()

# Current
qc.remove_final_measurements()  # no measurements allowed
from qiskit.quantum_info import Statevector
statevector = Statevector(qc)

from qiskit import QuantumCircuit
qc = QuantumCircuit(3)
qc.h(0)
qc.h(1)
qc.cx(1, 2)
qc.measure_all()

# Previous
from qiskit import BasicAer
backend = BasicAer.get_backend("unitary_simulator")
result = backend.run(qc).result()

# Current
qc.remove_final_measurements()  # no measurements allowed
from qiskit.quantum_info import Operator
result = Operator(qc).data

from qiskit import QuantumCircuit
qc = QuantumCircuit(3)
qc.h(0)
qc.h(1)
qc.cx(1, 2)
qc.measure_all()

# Previous
from qiskit import BasicAer
backend = BasicAer.get_backend("qasm_simulator")
result = backend.run(qc).result()

# One current option
from qiskit.providers.basic_provider import BasicProvider
backend = BasicProvider().get_backend("basic_simulator")
result = backend.run(qc).result()

# Another current option is to specify it directly
from qiskit.providers.basic_provider import BasicSimulator
backend = BasicSimulator()
result = backend.run(qc).result()

fake_provider

Karamihan sa mga user-facing na bahagi ng qiskit.providers.fake_provider ay na-migrate na sa qiskit-ibm-runtime Python package. Kasama dito ang mga fake provider class, lahat ng device-specific na fake backend (tulad ng FakeVigo, FakeNairobiV2, at FakeSherbrooke), at ang mga fake backend base class. I-click ang mga sumusunod na tab para makita ang mga apektadong klase.

Mga Fake Backend
Mga Fake Provider

Anumang klase sa qiskit.providers.fake_provider.backends
fake_provider.fake_backend.FakeBackend
fake_provider.fake_backend.FakeBackendV2

fake_provider.FakeProvider
fake_provider.FakeProviderForBackendV2
fake_provider.FakeProviderFactory

Para lumipat sa bagong path:

I-install ang qiskit-ibm-runtime 0.17.1 o mas bago:
```
pip install 'qiskit-ibm-runtime>=0.17.1'
```

Palitan ang mga instance ng qiskit.providers.fake_provider sa iyong code ng qiskit_ibm_runtime.fake_provider. Halimbawa:

# Old
from qiskit.providers.fake_provider import FakeProvider
backend1 = FakeProvider().get_backend("fake_ourense")

from qiskit.providers.fake_provider import FakeSherbrooke
backend2 = FakeSherbrooke()

# Alternative
from qiskit_ibm_runtime.fake_provider import FakeProvider
backend1 = FakeProvider().get_backend("fake_ourense")

from qiskit_ibm_runtime.fake_provider import FakeSherbrooke
backend2 = FakeSherbrooke()

Ang mga fake backend base class ay na-migrate din, pero may ilang pagkakaiba sa import path:

Inalis	Alternatibo
`qiskit.providers.fake_provider.FakeQasmBackend`	`qiskit_ibm_runtime.fake_provider.fake_qasm_backend.FakeQasmBackend`
`qiskit.providers.fake_provider.FakePulseBackend`	`qiskit_ibm_runtime.fake_provider.fake_pulse_backend.FakePulseBackend`

tala

Kung umaasa ka sa mga fake backend para sa unit testing ng isang downstream library at may mga conflict sa qiskit-ibm-runtime dependency, makikita mo rin ang mga bagong Qiskit-native na generic fake backend na alternatibo. Kasama dito ang mga sumusunod na BackendV1 na klase (drop-in replacement):

Ito ay isang configurable class na nagbabalik ng mga BackendV2 instance:

qiskit.providers.fake_provider.GenericBackendV2

fake_provider (mga espesyal na testing backend)

Ang mga fake backend class para sa espesyal na layunin ng testing sa qiskit.providers.fake_provider ay hindi na-migrate sa qiskit_ibm_runtime.fake_provider. Ang inirerekomendang migration path ay ang paggamit ng bagong GenericBackendV2 class para i-configure ang isang backend na may katulad na properties o para gumawa ng custom na target.

Inalis	Alternatibo
`fake_provider.FakeBackendV2`	`fake_provider.GenericBackendV2`
`fake_provider.FakeBackend5QV2`	`fake_provider.GenericBackendV2`
`fake_provider.FakeBackendV2LegacyQubitProps`	`fake_provider.GenericBackendV2`
`fake_provider.FakeBackendSimple`	`fake_provider.GenericBackendV2`
`fake_provider.ConfigurableFakeBackend`	`fake_provider.GenericBackendV2`

Halimbawa: Lumipat sa bagong GenericBackendV2 class:

# Legacy path
from qiskit.providers.fake_provider import FakeBackend5QV2
backend = FakeBackend5QV2()

# New path
from qiskit.providers.fake_provider import GenericBackendV2
backend = GenericBackendV2(num_qubits=5)

# Note that this class generates a 5q backend with generic
# properties that serves the same purpose as FakeBackend5QV2
# but will not be identical.

Iba pang mga tip sa migration

Hindi na posible ang pag-import mula sa qiskit.providers.aer. Sa halip, mag-import mula sa qiskit_aer, na isang drop-in replacement. Para i-install ang qiskit_aer, patakbuhin ang:
```
pip install qiskit-aer
```
Ang suporta sa pagpapatakbo ng mga pulse job sa mga backend mula sa qiskit.providers.fake_provider ay inalis na sa Qiskit 1.0. Ito ay dahil inalis ng Qiskit Aer ang simulation functionality para sa ganitong mga job. Para sa mga low-level na Hamiltonian-simulation na workload, isaalang-alang ang paggamit ng espesyalisadong library tulad ng Qiskit Dynamics.

qiskit.pulse

ParametricPulse

Ang qiskit.pulse.library.parametric_pulses.ParametricPulse base class at pulse library ay napalitan na ng qiskit.pulse.SymbolicPulse at ang katumbas na pulse library. Sinusuportahan ng SymbolicPulse ang QPY serialization:

from qiskit import pulse, qpy

with pulse.build() as schedule:
    pulse.play(pulse.Gaussian(100, 0.1, 25), pulse.DriveChannel(0))

with open('schedule.qpy', 'wb') as fd:
    qpy.dump(schedule, fd)

Inalis	Alternatibo
`pulse.library.parametric_pulses.ParametricPulse`	`qiskit.pulse.SymbolicPulse`
`pulse.library.parametric_pulses.Constant`	`pulse.library.symbolic_pulses.Constant`
`pulse.library.parametric_pulses.Drag`	`pulse.library.symbolic_pulses.Drag`
`pulse.library.parametric_pulses.Gaussian`	`pulse.library.symbolic_pulses.Gaussian`
`qiskit.pulse.library.parametric_pulses.GaussianSquare`	`pulse.library.symbolic_pulses.GaussianSquare`

Complex-valued amplitude

Ang complex-valued pulse amplitude (amp) ay pinalitan ng (amp, angle) na pares. Mas madaling intindihin ang representasyong ito, lalo na para sa ilang calibration task tulad ng angle calibration:

from qiskit import pulse
from qiskit.circuit import Parameter
from math import pi

with pulse.build() as schedule:
    angle = Parameter("θ")
    pulse.play(pulse.Gaussian(100, 0.1, 25, angle=angle), pulse.DriveChannel(0))
schedule.assign_parameters({angle: pi})

Pag-inject ng mga circuit gate operation

Hindi na posible ang pag-inject ng mga circuit gate operation sa pulse builder context sa pamamagitan ng qiskit.pulse.builder.call. Apektado ng pag-aalis na ito ang mga input argument na may uri na QuantumCircuit, pati na rin ang mga sumusunod na function:

qiskit.pulse.builder.call_gate
qiskit.pulse.builder.cx
qiskit.pulse.builder.u1
qiskit.pulse.builder.u2
qiskit.pulse.builder.u3
qiskit.pulse.builder.x

Kung gusto mo pa ring mag-inject ng mga backend-calibrated schedule, gamitin ang sumusunod na pattern sa halip na tumawag ng mga gate command.

from qiskit.providers.fake_provider import GenericBackendV2
from qiskit import pulse

backend = GenericBackendV2(num_qubits=5)
sched = backend.target["x"][(qubit,)].calibration

with pulse.build() as only_pulse_scheds:
    pulse.call(sched)

Gayundin, ang QuantumCircuit ay maaaring i-inject sa builder context sa pamamagitan ng manu-manong pag-transpile at pag-schedule ng object.

from math import pi
from qiskit.compiler import schedule, transpile

qc = QuantumCircuit(2)
qc.rz(pi / 2, 0)
qc.sx(0)
qc.rz(pi / 2, 0)
qc.cx(0, 1)
qc_t = transpile(qc, backend)
sched = schedule(qc_t, backend)
with pulse.build() as only_pulse_scheds:
    pulse.call(sched)

Inirerekomenda naming sumulat ng minimal na pulse program gamit ang builder at ilakip ito sa QuantumCircuit sa pamamagitan ng QuantumCircuit.add_calibration method bilang microcode ng isang gate instruction, sa halip na isulat ang buong program gamit ang pulse model.

builder.build

Ang mga sumusunod na argumento sa qiskit.pulse.builder.build ay inalis nang walang alternatibo.

default_transpiler_settings
default_circuit_scheduler_settings

Ang mga function na ito ay inalis din:

qiskit.pulse.builder.active_transpiler_settings
qiskit.pulse.builder.active_circuit_scheduler_settings
qiskit.pulse.builder.transpiler_settings
qiskit.pulse.builder.circuit_scheduler_settings

Ito ay dahil hindi na posible ang pag-inject ng mga circuit object sa builder context (tingnan ang Pag-inject ng mga circuit gate operation); ang mga setting na ito ay para sa pag-convert ng mga na-inject na object sa mga pulse representation.

library

Ang discrete pulse library ay inalis na sa codebase. Kasama dito ang:

qiskit.pulse.library.constant
qiskit.pulse.library.zero
qiskit.pulse.library.square
qiskit.pulse.library.sawtooth
qiskit.pulse.library.triangle
qiskit.pulse.library.cos
qiskit.pulse.library.sin
qiskit.pulse.library.gaussian
qiskit.pulse.library.gaussian_deriv
qiskit.pulse.library.sech
qiskit.pulse.library.sech_deriv
qiskit.pulse.library.gaussian_square
qiskit.pulse.library.drag

Sa halip, gamitin ang katumbas na qiskit.pulse.SymbolicPulse, kasama ang SymbolicPulse.get_waveform(). Halimbawa, sa halip na pulse.gaussian(100,0.5,10), gamitin ang pulse.Gaussian(100,0.5,10).get_waveform(). Tandaan na ang phase ng parehong Sawtooth at Square ay tinukoy nang ang phase na 2\\pi ay nagge-geser ng isang buong cycle, salungat sa discrete na katumbas. Tandaan din na ang mga complex amplitude ay hindi na sinusuportahan sa symbolic pulse library; gamitin ang float, amp, at angle sa halip.

ScalableSymbolicPulse

Hindi na posible ang pag-load ng library qiskit.pulse.ScalableSymbolicPulse na mga object na may complex amp parameter mula sa version 5 o mas lumang qpy file (Qiskit Terra < 0.23.0). Hindi na kailangan ng anumang migration action, dahil ang complex amp ay awtomatikong ma-co-convert sa float (amp, angle).

Ang pagbabagong ito ay applicable sa mga pulse na ito:

qiskit.qasm

Ang legacy na OpenQASM 2 parser module na dating nasa qiskit.qasm ay pinalitan na ng qiskit.qasm2 module, na nagbibigay ng mas mabilis at mas tumpak na parser para sa OpenQASM 2. Ang mga mataas na antas na QuantumCircuit na method na from_qasm_file() at from_qasm_str() ay nananatiling pareho, ngunit gagamit na ng bagong parser sa loob. Gayunpaman, ang pampublikong interface ng qasm2 module ay hindi na katulad ng dati. Habang ang qiskit.qasm module ay nagbigay ng interface sa abstract syntax tree na ibinalik ng ply parser library, ang qiskit.qasm2 ay hindi na inilalantad ang AST o anumang mas mababang antas ng detalye ng parser. Sa halip, tumatanggap ito ng OpenQASM 2 na input at naglalabas ng QuantumCircuit na object.

Halimbawa, kung dati kang nagpapatakbo ng ganito:

import qiskit.qasm
from qiskit.converters import ast_to_dag, dag_to_circuit

ast = qiskit.qasm.Qasm(filename="myfile.qasm").parse()
dag = ast_to_dag(ast)
qasm_circ = dag_to_circuit(dag)

Palitan ito ng sumusunod:

import qiskit.qasm2

qasm_circ = qiskit.qasm2.load("myfile.qasm")

qiskit.quantum_info

Ang qiskit.quantum_info.synthesis module ay inilipat na sa iba't ibang lugar sa codebase, pangunahin sa qiskit.synthesis.

Tinanggal	Alternatibo
`OneQubitEulerDecomposer`	`qiskit.synthesis.one_qubit.OneQubitEulerDecomposer`
`TwoQubitBasisDecomposer`	`qiskit.synthesis.two_qubits.TwoQubitBasisDecomposer`
`XXDecomposer`	`qiskit.synthesis.two_qubits.XXDecomposer`
`two_qubit_cnot_decompose`	`qiskit.synthesis.two_qubits.two_qubit_cnot_decompose`
`Quaternion`	`qiskit.quantum_info.Quaternion`

Ang paglipat na ito ay hindi nakaapekto sa karaniwang import path ng Quaternion, ngunit hindi mo na ito maa-access sa pamamagitan ng qiskit.quantum_info.synthesis.

Sa wakas, ang cnot_rxx_decompose ay tinanggal na.

qiskit.test

Ang qiskit.test module ay hindi na isang pampublikong module. Hindi ito kailanman inilaan para maging pampubliko, ni gamitin sa labas ng Qiskit test suite. Lahat ng functionality ay espesipiko sa Qiskit at walang ibinigay na alternatibo; kung kailangan mo ng katulad na functionality, dapat mo itong isama sa iyong sariling test harness.

qiskit.tools

Ang qiskit.tools module ay tinanggal sa Qiskit 1.0. Karamihan sa functionality na ito ay pinalitan ng katulad na functionality sa ibang mga package o tinanggal nang walang alternatibo. Ang pangunahing pagbubukod ay ang qiskit.tools.parallel_map() function, na inilipat na sa qiskit.utils module. Maaari itong gamitin mula sa bagong lokasyon. Halimbawa:

Kung dati kang nagpapatakbo ng:

# Previous
from qiskit.tools import parallel_map

parallel_map(func, input)

# Current
from qiskit.utils import parallel_map

parallel_map(func, input)

jupyter

Ang qiskit.tools.jupyter submodule ay tinanggal dahil ang functionality sa module na ito ay nakatali sa legacy na qiskit-ibmq-provider package, na hindi na sinusuportahan. Sinusuportahan din nito ang BackendV1 lamang at hindi ang mas bagong BackendV2 interface.

monitor

Ang qiskit.tools.monitor submodule ay tinanggal dahil nakatali ito sa legacy na qiskit-ibmq-provider package, na hindi na sinusuportahan (sinusuportahan din nito ang BackendV1 interface lamang at hindi ang mas bagong BackendV2 interface). Walang ibinigay na alternatibo para sa functionality na ito.

visualization

Ang qiskit.tools.visualization submodule ay tinanggal. Ang module na ito ay isang legacy na redirect mula sa orihinal na lokasyon ng Qiskit visualization module at inilipat na sa qiskit.visualization sa Qiskit 0.8.0. Kung gumagamit ka pa rin ng path na ito, i-update ang iyong mga import mula sa qiskit.tools.visualization patungo sa qiskit.visualization.

# Previous
from qiskit.tools.visualization import plot_histogram

plot_histogram(counts)

# Current
from qiskit.visualization import plot_histogram

plot_histogram(counts)

events

Ang qiskit.tools.events module at ang progressbar() utility na inilantad nito ay tinanggal na. Ang functionality ng module na ito ay hindi gaanong ginagamit at mas maayos na naka-cover ng mga dedicated na package tulad ng tqdm.

qiskit.transpiler

synthesis

Ang mga item sa qiskit.transpiler.synthesis module ay inilipat na sa mga bagong lokasyon:

Tinanggal	Alternatibo
`qiskit.transpiler.synthesis.aqc` (maliban sa `AQCSynthesisPlugin`)	`qiskit.synthesis.unitary.aqc`
`qiskit.transpiler.synthesis.graysynth`	`qiskit.synthesis.synth_cnot_phase_aam`
`qiskit.transpiler.synthesis.cnot_synth`	`qiskit.synthesis.synth_cnot_count_full_pmh`

passes

Ang NoiseAdaptiveLayout Transpiler pass ay pinalitan na ng VF2Layout at VF2PostLayout, na nagtatakda ng layout batay sa iniulat na noise characteristics ng isang Backend. Ang parehong pass at ang kaukulang "noise_adaptive" layout stage plugin ay tinanggal na mula sa Qiskit.

Ang CrosstalkAdaptiveSchedule Transpiler pass ay tinanggal na mula sa codebase. Hindi na magagamit ang pass na ito dahil ang panloob na operasyon nito ay nakadepende sa mga custom na property na itinakda sa BackendProperties payload ng isang BackendV1 na instance. Dahil walang mga Backend na nagtatakda ng mga field na ito, ang pass ay tinanggal na.

passmanager

Ang mga append method ng mga klase na ConditionalController, FlowControllerLinear, at DoWhileController ay tinanggal na. Sa halip, lahat ng task ay dapat ibigay kapag ginagawa ang mga controller object.

qiskit.utils

Ang mga sumusunod na tool sa qiskit.utils ay tinanggal nang walang kapalit:

qiskit.utils.arithmetic
qiskit.utils.circuit_utils
qiskit.utils.entangler_map
qiskit.utils.name_unnamed_args

Ang mga function na ito ay eksklusibong ginagamit sa qiskit.algorithms at qiskit.opflow modules, na tinanggal na rin.

qiskit.visualization

Ang qiskit.visualization.qcstyle module ay tinanggal na. Gamitin ang qiskit.visualization.circuit.qcstyle bilang direktang kapalit.

Migration tool ng Qiskit 1.0​

Mga global na instance at function​

Aer​

BasicAer​

execute​

qiskit.circuit​

QuantumCircuit.qasm​

Mga Gate ng QuantumCircuit​

qiskit.converters​

qiskit.extensions​

qiskit.primitives​

Mag-migrate mula V1 patungong V2​

Mga update sa V1 interface​

qiskit.providers​

basicaer​

fake_provider​

fake_provider (mga espesyal na testing backend)​

Iba pang mga tip sa migration​

qiskit.pulse​

ParametricPulse​

Complex-valued amplitude​

Pag-inject ng mga circuit gate operation​

builder.build​

library​

ScalableSymbolicPulse​

qiskit.qasm​

qiskit.quantum_info​

qiskit.test​

qiskit.tools​

jupyter​

monitor​

visualization​

events​

qiskit.transpiler​

synthesis​

passes​

passmanager​

qiskit.utils​

qiskit.visualization​

Migration tool ng Qiskit 1.0

Mga global na instance at function

Aer

BasicAer

execute

qiskit.circuit

QuantumCircuit.qasm

Mga Gate ng QuantumCircuit

qiskit.converters

qiskit.extensions

qiskit.primitives

Mag-migrate mula V1 patungong V2

Mga update sa V1 interface

qiskit.providers

basicaer

fake_provider

fake_provider (mga espesyal na testing backend)

Iba pang mga tip sa migration

qiskit.pulse

ParametricPulse

Complex-valued amplitude

Pag-inject ng mga circuit gate operation

builder.build

library

ScalableSymbolicPulse

qiskit.qasm

qiskit.quantum_info

qiskit.test

qiskit.tools

jupyter

monitor

visualization

events

qiskit.transpiler

synthesis

passes

passmanager

qiskit.utils

qiskit.visualization