Lewati ke konten utama

Perubahan fitur Qiskit 1.0

Panduan ini menjelaskan jalur migrasi untuk perubahan fitur terpenting di Qiskit 1.0, yang diorganisasi berdasarkan modul. Gunakan daftar isi di sisi kanan untuk navigasi ke modul yang kamu butuhkan.

Alat migrasi Qiskit 1.0​

Untuk mempermudah proses migrasi, kamu bisa menggunakan alat flake8-qiskit-migration untuk mendeteksi jalur impor yang sudah dihapus di kode kamu dan menyarankan alternatifnya.

Kalau kamu sudah menginstal pipx, cukup jalankan perintah berikut.

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

Ini akan menginstal paket ke virtual environment sementara dan menjalankannya pada kode kamu.

Keterbatasan

Alat ini hanya mendeteksi jalur impor yang sudah dihapus. Alat ini tidak mendeteksi penggunaan metode yang sudah dihapus (seperti QuantumCircuit.qasm) maupun argumennya. Alat ini juga tidak bisa melacak assignment seperti qk = qiskit, meskipun bisa menangani alias seperti import qiskit as qk.

Untuk informasi lebih lanjut, lihat repositori proyek ini.

Instance dan fungsi global​

Aer​

Objek qiskit.Aer tidak tersedia di Qiskit 1.0. Sebagai gantinya, gunakan objek yang sama dari namespace qiskit_aer, yang merupakan pengganti langsung. Untuk menginstal qiskit_aer, jalankan:

pip install qiskit-aer

BasicAer​

Objek qiskit.BasicAer tidak tersedia di Qiskit 1.0. Lihat bagian migrasi basicaer untuk pilihan migrasi.

execute​

Fungsi qiskit.execute tidak tersedia di Qiskit 1.0. Fungsi ini berperan sebagai wrapper tingkat tinggi di sekitar fungsi transpile dan run di Qiskit. Alih-alih qiskit.execute, gunakan fungsi transpile diikuti oleh 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)

Alternatifnya, primitif Sampler secara semantis setara dengan fungsi qiskit.execute yang sudah dihapus. Kelas BackendSampler adalah wrapper generik untuk Backend yang tidak mendukung primitif:

from qiskit.primitives import BackendSampler

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

qiskit.circuit​

QuantumCircuit.qasm​

Metode QuantumCircuit.qasm telah dihapus. Sebagai gantinya, gunakan qasm2.dump atau qasm2.dumps.

Untuk output yang diformat dengan Pygments, lihat paket standalone openqasm-pygments, karena qasm2.dump dan qasm2.dumps tidak menyediakan output berwarna Pygments.

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)

Gate QuantumCircuit​

Metode-metode Gate berikut telah dihapus demi metode yang lebih mapan yang menambahkan Gate yang sama:

DihapusAlternatif
QuantumCircuit.cnotQuantumCircuit.cx
QuantumCircuit.toffoliQuantumCircuit.ccx
QuantumCircuit.fredkinQuantumCircuit.cswap
QuantumCircuit.mctQuantumCircuit.mcx
QuantumCircuit.iQuantumCircuit.id
QuantumCircuit.squQuantumCircuit.unitary

Metode-metode Circuit berikut telah dihapus. Sebagai gantinya, Gate-gate ini bisa ditambahkan ke Circuit dengan QuantumCircuit.append.

DihapusAlternatif (append)
QuantumCircuit.diagonalDiagonalGate
QuantumCircuit.hamiltonianHamiltonianGate
QuantumCircuit.isometryIsometry
QuantumCircuit.isoIsometry
QuantumCircuit.ucUCGate
QuantumCircuit.ucrxUCRXGate
QuantumCircuit.ucryUCRYGate
QuantumCircuit.ucrzUCRZGate

Contohnya, untuk 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

Metode-metode QuantumCircuit berikut juga telah dihapus:

DihapusAlternatif
QuantumCircuit.bind_parametersQuantumCircuit.assign_parameters
QuantumCircuit.snapshotinstruksi save dari qiskit-aer

qiskit.converters​

Fungsi qiskit.converters.ast_to_dag telah dihapus dari Qiskit. Fungsi ini mengonversi abstract syntax tree yang dihasilkan oleh parser OpenQASM 2 lawas ke sebuah DAGCircuit. Karena parser OpenQASM 2 lawas sudah dihapus (lihat qiskit.qasm), fungsi ini tidak lagi berguna. Sebagai gantinya, parse file OpenQASM 2 kamu ke QuantumCircuit menggunakan metode konstruktor QuantumCircuit.from_qasm_file atau QuantumCircuit.from_qasm_str (atau modul qiskit.qasm2), lalu konversi QuantumCircuit tersebut ke DAGCircuit dengan 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​

Modul qiskit.extensions tidak lagi tersedia. Sebagian besar objeknya telah diintegrasikan ke dalam circuit library (qiskit.circuit.library). Untuk migrasi ke lokasi baru, cukup ganti qiskit.extensions dengan qiskit.circuit.library di jalur impor objek. Ini adalah pengganti langsung.

# Previous
from qiskit.extensions import DiagonalGate

# Current alternative
from qiskit.circuit.library import DiagonalGate

Kelas-kelas yang dipindahkan ke qiskit.circuit.library adalah:

Kelas-kelas berikut telah dihapus dari codebase, karena fungsinya sudah redundan atau terkait dengan modul extensions:

DihapusAlternatif
SingleQubitUnitaryqiskit.circuit.library.UnitaryGate
SnapshotGunakan instruksi save dari qiskit-aer
ExtensionErrorKelas error yang relevan

qiskit.primitives​

Perubahan paling menonjol dalam modul qiskit.primitives adalah diperkenalkannya antarmuka primitives V2 yang baru. Bagian ini menjelaskan cara migrasi alur kerjamu dari primitives V1 ke primitives V2, serta beberapa perubahan pada input yang diterima oleh antarmuka V1.

catatan

Mulai dari rilis 1.0, antarmuka primitives sebelum 1.0 akan disebut sebagai "primitives V1".

Migrasi dari V1 ke V2​

Perbedaan formal antara API primitives V1 dan V2 adalah kelas dasar tempat implementasi primitives mewarisi sifatnya. Untuk beralih ke kelas dasar yang baru, kamu bisa tetap menggunakan jalur impor asli dari qiskit.primitives:

Migrasi dariGanti dengan
BaseEstimatorBaseEstimatorV2
BaseSamplerBaseSamplerV2

Nama implementasi inti qiskit dari primitives V2 (yang bisa diimpor dari qiskit.primitives) telah diubah untuk memperjelas fungsinya sebagai implementasi yang bisa dijalankan secara lokal dengan Backend simulator statevector. Nama baru tidak menyertakan sufiks -V2.

Migrasi dariGanti dengan
qiskit.primitives.Estimatorqiskit.primitives.StatevectorEstimator
qiskit.primitives.Samplerqiskit.primitives.StatevectorSampler

Ada beberapa perbedaan konseptual yang perlu diperhatikan saat migrasi dari V1 ke V2. Perbedaan ini ditentukan oleh kelas dasar, namun ditunjukkan dalam contoh berikut menggunakan implementasi statevector yang ada di qiskit.primitives:

catatan

Untuk contoh-contoh berikut, asumsikan impor dan inisialisasi primitives berikut ini:

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
  1. Sampler dan Estimator: Primitives V2 yang baru dirancang untuk menerima input yang divektorisasi, di mana Circuit tunggal bisa dikelompokkan dengan spesifikasi bernilai array. Artinya, satu Circuit bisa dieksekusi untuk array n set parameter, n observables, atau keduanya (dalam kasus estimator). Setiap kelompok disebut primitive unified bloc (PUB), dan bisa direpresentasikan sebagai tuple: (1 x circuit, [n x observables], [n x parameters]). Antarmuka V1 tidak memungkinkan fleksibilitas yang sama. Sebaliknya, jumlah Circuit input harus cocok dengan jumlah observables dan set parameter, seperti yang ditunjukkan dalam contoh berikut (pilih tab untuk melihat setiap contoh):
# 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

Primitives V2 menerima beberapa PUB sebagai input, dan setiap PUB mendapatkan hasilnya sendiri. Ini memungkinkan kamu menjalankan Circuit yang berbeda dengan berbagai kombinasi parameter/observable, yang tidak selalu mungkin dilakukan di antarmuka V1:

# 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)

  1. Sampler: Sampler V2 kini mengembalikan sampel hasil pengukuran dalam bentuk bitstring atau counts, bukan distribusi quasi-probabilitas dari antarmuka V1. Bitstring menampilkan hasil pengukuran sambil mempertahankan urutan shot saat diukur. Objek hasil Sampler V2 mengorganisasi data berdasarkan nama register klasik Circuit input, untuk kompatibilitas dengan dynamic circuits.

    # 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
    Nama register klasik default

    Pada Circuit di atas, perhatikan bahwa nama register klasik defaultnya adalah "meas". Nama ini akan digunakan nanti untuk mengakses bitstring pengukuran.

    # 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}

  2. Sampler dan Estimator: Overhead sampling, yang umumnya diekspos oleh implementasi V1 melalui opsi run shots, kini merupakan argumen dari metode run() primitives yang bisa ditentukan di level PUB. Kelas dasar V2 mengekspos argumen dalam format yang berbeda dari API V1:

    • BaseSamplerV2.run mengekspos argumen shots (mirip dengan alur kerja sebelumnya):

      # 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)])

    • EstimatorV2.run memperkenalkan argumen precision yang menentukan error bar yang harus ditargetkan oleh implementasi primitives untuk estimasi nilai ekspektasi:

      # Estimate expectation values for two PUBs, both with 0.05 precision.
      estimator_v2.run([(circuit1, obs_array1), (circuit2, obs_array_2)], precision=0.05)

Pembaruan pada antarmuka V1​

qiskit.providers​

basicaer​

Sebagian besar fungsionalitas dalam modul qiskit.providers.basicaer telah digantikan oleh modul qiskit.providers.basic_provider yang baru, kecuali untuk kelas UnitarySimulatorPy dan StatevectorSimulatorPy yang telah dihapus; fungsionalitasnya sudah tersedia dalam modul quantum_info.

Migrasi ke jalur baru sangat mudah. Kamu bisa mengganti sebagian besar kelas di qiskit.providers.basicaer dengan padanannya di qiskit.providers.basic_provider (pengganti langsung/drop-in replacement). Perlu diperhatikan bahwa kelas-kelas berikut memiliki jalur dan nama baru:

DihapusAlternatif
qiskit.providers.basicaerqiskit.providers.basic_provider
BasicAerProviderBasicProvider
BasicAerJobBasicProviderJob
QasmSimulatorPyBasicSimulator
Instance global

Perhatikan instance global apapun saat migrasi ke modul baru. Tidak ada pengganti untuk instance global BasicAer yang bisa diimpor langsung sebagai qiskit.BasicAer. Artinya, from qiskit import BasicProvider bukan lagi impor yang valid. Sebagai gantinya, kelas provider harus diimpor dari submodulnya dan diinstansiasi oleh pengguna:

# 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")

Simulator unitary dan statevector bisa digantikan dengan kelas quantum_info yang berbeda. Ini bukan pengganti langsung, namun perubahannya minimal. Lihat contoh migrasi berikut:

DihapusAlternatif
UnitarySimulatorPyquantum_info.Operator
StatevectorSimulatorPyquantum_info.Statevector

Contoh berikut menunjukkan jalur migrasi simulator basicaer.

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)

fake_provider​

Sebagian besar komponen qiskit.providers.fake_provider yang menghadap pengguna telah dimigrasikan ke paket Python qiskit-ibm-runtime. Ini termasuk kelas fake provider, semua fake Backend spesifik perangkat (seperti FakeVigo, FakeNairobiV2, dan FakeSherbrooke), serta kelas dasar fake Backend. Klik tab berikut untuk melihat kelas yang terpengaruh.

  • Kelas apapun di qiskit.providers.fake_provider.backends
  • fake_provider.fake_backend.FakeBackend
  • fake_provider.fake_backend.FakeBackendV2

Untuk migrasi ke jalur baru:

  1. Install qiskit-ibm-runtime versi 0.17.1 atau lebih baru:

    pip install 'qiskit-ibm-runtime>=0.17.1'

  2. Ganti instance qiskit.providers.fake_provider dalam kode kamu dengan qiskit_ibm_runtime.fake_provider. Contohnya:

    # 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()

Kelas dasar fake Backend juga telah dimigrasikan, namun ada beberapa perbedaan pada jalur impor:

DihapusAlternatif
qiskit.providers.fake_provider.FakeQasmBackendqiskit_ibm_runtime.fake_provider.fake_qasm_backend.FakeQasmBackend
qiskit.providers.fake_provider.FakePulseBackendqiskit_ibm_runtime.fake_provider.fake_pulse_backend.FakePulseBackend
catatan

Jika kamu mengandalkan fake Backend untuk pengujian unit library downstream dan memiliki konflik dengan dependensi qiskit-ibm-runtime, kamu juga bisa menemukan alternatif fake Backend generik bawaan Qiskit. Ini mencakup kelas BackendV1 berikut (pengganti langsung/drop-in replacement):

Ini adalah kelas yang bisa dikonfigurasi dan mengembalikan instance BackendV2:

fake_provider (Backend pengujian khusus)​

Kelas fake Backend untuk keperluan pengujian khusus dalam qiskit.providers.fake_provider tidak dimigrasikan ke qiskit_ibm_runtime.fake_provider. Jalur migrasi yang direkomendasikan adalah menggunakan kelas GenericBackendV2 yang baru untuk mengkonfigurasi Backend dengan properti serupa atau membangun target kustom.

DihapusAlternatif
fake_provider.FakeBackendV2fake_provider.GenericBackendV2
fake_provider.FakeBackend5QV2fake_provider.GenericBackendV2
fake_provider.FakeBackendV2LegacyQubitPropsfake_provider.GenericBackendV2
fake_provider.FakeBackendSimplefake_provider.GenericBackendV2
fake_provider.ConfigurableFakeBackendfake_provider.GenericBackendV2

Contoh: Migrasi ke kelas GenericBackendV2 yang baru:

# 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.

Tips migrasi lainnya​

  • Mengimpor dari qiskit.providers.aer tidak lagi memungkinkan. Sebagai gantinya, impor dari qiskit_aer, yang merupakan pengganti langsung. Untuk menginstall qiskit_aer, jalankan:

    pip install qiskit-aer

  • Dukungan untuk menjalankan pulse job pada Backend dari qiskit.providers.fake_provider telah dihapus di Qiskit 1.0. Ini karena Qiskit Aer menghapus fungsionalitas simulasi untuk job semacam itu. Untuk beban kerja simulasi Hamiltonian tingkat rendah, pertimbangkan menggunakan library khusus seperti Qiskit Dynamics.

qiskit.pulse​

ParametricPulse​

Kelas dasar qiskit.pulse.library.parametric_pulses.ParametricPulse dan pustaka pulse-nya sudah digantikan oleh qiskit.pulse.SymbolicPulse beserta pustaka pulse yang sesuai. SymbolicPulse mendukung serialisasi QPY:

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)
DihapusAlternatif
pulse.library.parametric_pulses.ParametricPulseqiskit.pulse.SymbolicPulse
pulse.library.parametric_pulses.Constantpulse.library.symbolic_pulses.Constant
pulse.library.parametric_pulses.Dragpulse.library.symbolic_pulses.Drag
pulse.library.parametric_pulses.Gaussianpulse.library.symbolic_pulses.Gaussian
qiskit.pulse.library.parametric_pulses.GaussianSquarepulse.library.symbolic_pulses.GaussianSquare

Amplitudo bernilai kompleks​

Amplitudo pulse bernilai kompleks (amp) digantikan oleh pasangan (amp, angle). Representasi ini lebih intuitif, terutama untuk beberapa tugas kalibrasi seperti kalibrasi sudut:

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})

Menyisipkan operasi gate Circuit​

Menyisipkan operasi gate Circuit ke dalam konteks pulse builder melalui qiskit.pulse.builder.call sudah tidak bisa dilakukan lagi. Penghapusan ini berdampak pada argumen input bertipe QuantumCircuit, maupun fungsi-fungsi berikut:

  • 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

Kalau kamu masih ingin menyisipkan jadwal yang sudah dikalibrasi oleh backend, gunakan pola berikut sebagai pengganti pemanggilan perintah gate.

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)

Begitu pula, sebuah QuantumCircuit bisa disisipkan ke dalam konteks builder dengan cara melakukan transpilasi dan penjadwalan objek tersebut secara manual.

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)

Kami menyarankan untuk menulis program pulse minimal dengan builder dan melampirkannya ke QuantumCircuit melalui metode QuantumCircuit.add_calibration sebagai mikrokode dari instruksi gate, daripada menulis seluruh program dengan model pulse.

builder.build​

Argumen-argumen berikut dalam qiskit.pulse.builder.build telah dihapus tanpa ada penggantinya.

  • default_transpiler_settings
  • default_circuit_scheduler_settings

Fungsi-fungsi ini juga telah dihapus:

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

Ini karena injeksi objek Circuit ke dalam konteks builder sudah tidak mungkin dilakukan (lihat Menyisipkan operasi gate Circuit); pengaturan ini memang digunakan untuk mengonversi objek yang disisipkan menjadi representasi pulse.

library​

Pustaka pulse diskret telah dihapus dari kode. Ini mencakup:

  • 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

Sebagai gantinya, gunakan qiskit.pulse.SymbolicPulse yang sesuai, dengan SymbolicPulse.get_waveform(). Misalnya, alih-alih pulse.gaussian(100,0.5,10), gunakan pulse.Gaussian(100,0.5,10).get_waveform(). Perlu diingat bahwa fase dari Sawtooth dan Square didefinisikan sedemikian rupa sehingga fase 2\\pi bergeser satu siklus penuh, berbeda dari versi diskretnya. Perlu dicatat juga bahwa amplitudo kompleks tidak lagi didukung di pustaka pulse simbolik; gunakan float, amp, dan angle sebagai gantinya.

ScalableSymbolicPulse​

Tidak lagi memungkinkan untuk memuat objek qiskit.pulse.ScalableSymbolicPulse dari pustaka dengan parameter amp kompleks dari file qpy versi 5 atau lebih lama (Qiskit Terra < 0.23.0). Tidak perlu tindakan migrasi, karena amp kompleks akan secara otomatis dikonversi menjadi float (amp, angle).

Perubahan ini berlaku untuk pulse-pulse berikut:

qiskit.qasm​

Modul parser OpenQASM 2 lawas yang sebelumnya ada di qiskit.qasm kini sudah digantikan oleh modul qiskit.qasm2, yang menyediakan parser yang lebih cepat dan akurat untuk OpenQASM 2. Metode tingkat tinggi QuantumCircuit yaitu from_qasm_file() dan from_qasm_str() tetap sama, tapi akan menggunakan parser baru secara internal. Namun, antarmuka publik untuk modul qasm2 tidak sama. Sementara modul qiskit.qasm menyediakan antarmuka ke pohon sintaks abstrak yang dikembalikan oleh pustaka parser ply, qiskit.qasm2 tidak mengekspos AST atau detail implementasi tingkat rendah tentang parser. Sebagai gantinya, ia menerima input OpenQASM 2 dan menghasilkan objek QuantumCircuit.

Misalnya, jika sebelumnya kamu menjalankan sesuatu seperti ini:

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)

Ganti dengan yang berikut:

import qiskit.qasm2

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

qiskit.quantum_info​

Modul qiskit.quantum_info.synthesis telah dipindahkan ke berbagai lokasi dalam codebase, sebagian besar ke qiskit.synthesis.

DihapusAlternatif
OneQubitEulerDecomposerqiskit.synthesis.one_qubit.OneQubitEulerDecomposer
TwoQubitBasisDecomposerqiskit.synthesis.two_qubits.TwoQubitBasisDecomposer
XXDecomposerqiskit.synthesis.two_qubits.XXDecomposer
two_qubit_cnot_decomposeqiskit.synthesis.two_qubits.two_qubit_cnot_decompose
Quaternionqiskit.quantum_info.Quaternion

Perpindahan ini tidak mempengaruhi jalur impor biasa dari Quaternion, tapi kamu tidak bisa lagi mengaksesnya melalui qiskit.quantum_info.synthesis.

Terakhir, cnot_rxx_decompose telah dihapus.

qiskit.test​

Modul qiskit.test tidak lagi merupakan modul publik. Ini memang tidak pernah dimaksudkan untuk menjadi publik, dan tidak dimaksudkan untuk digunakan di luar suite pengujian Qiskit. Semua fungsionalitasnya spesifik untuk Qiskit dan tidak ada alternatif yang disediakan; jika kamu membutuhkan fungsionalitas serupa, kamu harus memasukkannya ke dalam test harness milikmu sendiri.

qiskit.tools​

Modul qiskit.tools dihapus di Qiskit 1.0. Sebagian besar fungsionalitasnya sudah digantikan oleh fungsionalitas serupa di paket lain atau dihapus tanpa ada alternatif. Pengecualian utamanya adalah fungsi qiskit.tools.parallel_map(), yang telah dipindahkan ke modul qiskit.utils. Fungsi ini bisa digunakan dari lokasi baru ini. Misalnya:

Jika sebelumnya kamu menjalankan:

# Previous
from qiskit.tools import parallel_map

parallel_map(func, input)

# Current
from qiskit.utils import parallel_map

parallel_map(func, input)

jupyter​

Submodul qiskit.tools.jupyter telah dihapus karena fungsionalitas dalam modul ini terkait dengan paket qiskit-ibmq-provider lawas, yang sudah tidak didukung lagi. Submodul ini juga hanya mendukung BackendV1 dan bukan antarmuka BackendV2 yang lebih baru.

monitor​

Submodul qiskit.tools.monitor telah dihapus karena terkait dengan paket qiskit-ibmq-provider lawas, yang sudah tidak didukung lagi (submodul ini juga hanya mendukung antarmuka BackendV1 dan bukan antarmuka BackendV2 yang lebih baru). Tidak ada alternatif yang disediakan untuk fungsionalitas ini.

visualization​

Submodul qiskit.tools.visualization telah dihapus. Modul ini adalah pengalihan lawas dari lokasi asli modul visualisasi Qiskit yang dipindahkan ke qiskit.visualization di Qiskit 0.8.0. Jika kamu masih menggunakan jalur ini, perbarui impormu dari qiskit.tools.visualization ke qiskit.visualization.

# Previous
from qiskit.tools.visualization import plot_histogram

plot_histogram(counts)

# Current
from qiskit.visualization import plot_histogram

plot_histogram(counts)

events​

Modul qiskit.tools.events dan utilitas progressbar() yang dieksposnya telah dihapus. Fungsionalitas modul ini tidak banyak digunakan dan lebih baik ditangani oleh paket khusus seperti tqdm.

qiskit.transpiler​

synthesis​

Item-item dalam modul qiskit.transpiler.synthesis telah dipindahkan ke lokasi baru:

DihapusAlternatif
qiskit.transpiler.synthesis.aqc (kecuali AQCSynthesisPlugin)qiskit.synthesis.unitary.aqc
qiskit.transpiler.synthesis.graysynthqiskit.synthesis.synth_cnot_phase_aam
qiskit.transpiler.synthesis.cnot_synthqiskit.synthesis.synth_cnot_count_full_pmh

passes​

Pass Transpiler NoiseAdaptiveLayout telah digantikan oleh VF2Layout dan VF2PostLayout, yang menetapkan layout berdasarkan karakteristik noise yang dilaporkan oleh backend. Baik pass maupun plugin stage layout "noise_adaptive" yang bersesuaian telah dihapus dari Qiskit.

Pass Transpiler CrosstalkAdaptiveSchedule telah dihapus dari codebase. Pass ini tidak bisa lagi digunakan karena operasi internalnya bergantung pada properti kustom yang diatur dalam payload BackendProperties dari sebuah instansi BackendV1. Karena tidak ada backend yang mengatur field-field ini, pass tersebut telah dihapus.

passmanager​

Metode append dari kelas ConditionalController, FlowControllerLinear, dan DoWhileController telah dihapus. Sebagai gantinya, semua tugas harus disediakan saat objek controller dibuat.

qiskit.utils​

Alat-alat berikut dalam qiskit.utils telah dihapus tanpa pengganti:

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

Fungsi-fungsi ini hanya digunakan di modul qiskit.algorithms dan qiskit.opflow, yang juga sudah dihapus.

qiskit.visualization​

Modul qiskit.visualization.qcstyle telah dihapus. Gunakan qiskit.visualization.circuit.qcstyle sebagai penggantinya secara langsung.

Source: IBM Quantum docs β€” updated 27 Apr 2026
English version on doQumentation β€” updated 7 Mei 2026
This translation based on the English version of 11 Mar 2026