Alterações nas funcionalidades do Qiskit v1.0

Este guia descreve os caminhos de migração para as principais alterações de funcionalidades no Qiskit v1.0, organizadas por módulo. Use o índice à direita para acessar o módulo de seu interesse.

Ferramenta de migração do Qiskit para o v1.0

Para facilitar o processo de migração, você pode usar o flake8-qiskit-migration para detectar caminhos de importação removidos em seu código e sugerir alternativas.

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

# 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

Para obter mais informações, consulte o repositório do projeto.

Instâncias e funções globais

AER

O qiskit.Aer objeto não está disponível no Qiskit v1.0. Em vez disso, use o mesmo objeto do namespace qiskit_aer , que é um substituto direto. qiskit_aerPara instalar, execute:

pip install qiskit-aer

BasicAer

O qiskit.BasicAer objeto não está disponível no Qiskit v1.0. Consulte a basicaer seção sobre migração para conhecer as opções de migração.

executar

A qiskit.execute função não está disponível no Qiskit v1.0. Essa função servia como uma camada de abstração de alto nível para as transpile funções run no Qiskit. Em vez de qiskit.execute, use a transpile função seguida de 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)

Como alternativa, a primitiva Sampler é semanticamente equivalente à função qiskit.execute removida. A classe BackendSampler é um wrapper genérico para backends que não oferecem suporte a primitivos:

from qiskit.primitives import BackendSampler

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

qiskit.circuit

QuantumCircuit.qasm

O método QuantumCircuit.qasm foi removido. Em vez disso, use qasm2.dump ou qasm2.dumps.

Para obter uma saída formatada pelo Pygments, consulte o aplicativo autônomo openqasm-pygments autônomo, pois qasm2.dump e qasm2.dumps não fornecem saída colorida do 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)

QuantumCircuit portões

Os seguintes métodos de portões foram removidos em favor de métodos mais estabelecidos mais estabelecidos que anexam os mesmos portões:

Os seguintes métodos de circuito foram removidos. Em vez disso, essas portas podem ser aplicadas a um circuito com QuantumCircuit.append.

Por exemplo, para um DiagonalGate:

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

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

Os seguintes métodos do site QuantumCircuit também foram removidos:

qiskit.converters

A função qiskit.converters.ast_to_dag foi removida do Qiskit. Ele converteu a árvore de sintaxe abstrata gerada pelo analisador legado OpenQASM 2 em um DAGCircuit. Como o analisador legado OpenQASM 2 legado foi removido (consulte qiskit.qasm ), essa função não tem mais utilidade. Em vez disso, analise seus arquivos OpenQASM 2 em um QuantumCircuit usando o QuantumCircuit.from_qasm_file ou QuantumCircuit.from_qasm_str métodos do construtor (ou o módulo qiskit.qasm2 módulo), então converta esse QuantumCircuit em um DAGCircuit com 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

O módulo qiskit.extensions não está mais disponível. A maioria de seus objetos foi integrados à biblioteca de circuitos (qiskit.circuit.library). Para migrar para o basta substituir qiskit.extensions por qiskit.circuit.library no caminho de importação do objeto. Trata-se de uma substituição imediata.

# Previous
from qiskit.extensions import DiagonalGate

# Current alternative
from qiskit.circuit.library import DiagonalGate

As classes movidas para qiskit.circuit.library são:

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

As seguintes classes foram removidas da base de código, pois suas funções funções eram redundantes ou estavam vinculadas ao módulo extensions :

qiskit.primitives

A mudança mais notável no módulo qiskit.primitives módulo é a introdução da nova interface de primitivos V2. Esta seção mostra como migrar seu fluxo de trabalho das primitivas V1 para as primitivas V2, bem como as poucas alterações que ocorreram nas entradas aceitas pela interface V1.

Migrar de V1 para V2

A distinção formal entre as primitivas V1 e as APIs V2 são as classes de base das quais as implementações de implementações de primitivas herdam. Para fazer a transição para as novas classes de base, você pode manter o caminho de importação original de qiskit.primitives:

Os nomes das implementações do núcleo do qiskit das primitivas do V2 (aquelas importáveis do qiskit.primitives), foram modificados para esclarecer sua finalidade como implementações que podem ser executadas localmente com um backend de simulador de vetor de estado. Os novos nomes não incluem o sufixo -V2.

Há algumas diferenças conceituais que devem ser consideradas ao migrar de V1 para V2. Essas diferenças são ditadas pela classe base, mas são mostradas nos exemplos a seguir usando as implementações do statevector encontradas em qiskit.primitives:

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 and Estimator: As novas primitivas do V2 foram projetadas para aceitar entradas vetorizadas, nas quais circuitos individuais podem ser agrupados com especificações que retornam valores em forma de matriz. Ou seja, um circuito pode ser executado para matrizes de conjuntos n de parâmetros, n observáveis ou ambos (no caso do Estimador). Cada grupo é chamado de bloco unificado primitivo (pub) e pode ser representado como uma tupla: (1 x circuit, [n x observables], [n x parameters]). A interface do V1 não oferecia a mesma flexibilidade. Em vez disso, o número de circuitos de entrada precisava corresponder ao número de observáveis e conjuntos de parâmetros, conforme mostrado nos exemplos a seguir (selecione uma guia para ver cada exemplo):

# 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

V2 aceitam vários PUBs como entradas, e cada pub obtém seu próprio resultado. Isso permite que você execute circuitos diferentes com várias combinações de parâmetros/observáveis, o que nem sempre foi possível na interface 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)

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

2. Sampler : O sampler V2 agora retorna amostras de resultados de medição na forma de cadeias de bits ou contagens , em vez das distribuições de quase-probabilidade da interface V1 . As sequências de bits mostram os resultados das medições, mantendo a ordem em que foram realizadas. Os objetos de resultado do Sampler do V2 organizam os dados de acordo com os nomes clássicos dos registros de seus circuitos de entrada, para garantir a compatibilidade com circuitos dinâmicos.

   # 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

   Nome do registro clássico padrão

   No circuito acima, observe que o nome do registro clássico tem como padrão "meas". Esse nome será usado posteriormente para acessar os bitstrings de medição.

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

3. Sampler and Estimator: A sobrecarga de amostragem, comumente exposta pelas implementações do V1 por meio da opção de execução shots , agora é um argumento do método primitivo run() que pode ser especificado no nível PUB nível. As classes de base V2 expõem os argumentos em formatos diferentes da API V1 :

   • BaseSamplerV2.run expõe um argumento shots (semelhante ao fluxo de trabalho anterior):

     # 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 introduz um argumento precision que especifica as barras de erro que a implementação primitiva deve ter como alvo para estimativas de valores de expectativa:

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

Atualizações na interface V1

• Conversão implícita de um BaseOperator denso para um SparsePauliOp em Estimator argumentos observáveis não é mais permitida. Você deve converter explicitamente para um SparsePauliOp usando SparsePauliOp.from_operator(operator) em vez disso.

• Usando um PauliList em Os argumentos observáveis do Estimator não são mais permitidos. Em vez disso, você deve converter explicitamente o argumento usando SparsePauliOp(pauli_list) primeiro.

qiskit.providers

basicaer

A maior parte da funcionalidade do módulo qiskit.providers.basicaer foi substituída pelo novo módulo qiskit.providers.basic_provider com exceção das classes UnitarySimulatorPy e StatevectorSimulatorPy que foram removidas; sua funcionalidade já estava contida no o módulo quantum_info módulo.

A migração para os novos caminhos é simples. Você pode substituir a maioria das classes em qiskit.providers.basicaer por suas respectivas classes qiskit.providers.basic_provider (substituição por drop-in). Observe que as seguintes classes têm novos caminhos e nomes:

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

Os simuladores unitários e de vetor de estado podem ser substituídos por diferentes quantum_info classes. Essa não é uma substituição imediata, mas as alterações são mínimas. Veja os seguintes exemplos de migração exemplos:

Os exemplos a seguir mostram os caminhos de migração dos simuladores do 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)

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

provedor_falso

A maioria dos componentes voltados para o usuário qiskit.providers.fake_provider voltados para o usuário foram foram migrados para o pacote qiskit-ibm-runtime Python. Isso inclui as todas as classes de provedor falsas, todos os back-ends falsos específicos do dispositivo (como FakeVigo, FakeNairobiV2, e FakeSherbrooke) e as classes de base de backend falso e as classes de base de backend falso. Clique nas guias a seguir para ver as turmas afetadas.

Para migrar para o novo caminho:

1. Instale o site qiskit-ibm-runtime 0.17.1 ou posterior:

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

2. Substitua as instâncias de qiskit.providers.fake_provider em seu código por qiskit_ibm_runtime.fake_provider. Por exemplo:

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

As classes de base do backend falso também foram migradas, mas apresentam algumas diferenças no caminho de importação:

fake_provider (backends de teste especiais)

As classes de back-end falsas para fins de testes especiais em qiskit.providers.fake_provider foram não foram migradas para qiskit_ibm_runtime.fake_provider. O caminho de migração é usar o novo GenericBackendV2 para configurar um backend com propriedades semelhantes ou para criar um personalizado.

Exemplo: Migrar para o novo GenericBackendV2 classe:

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

Outras dicas de migração

• A importação de qiskit.providers.aer não é mais possível. Em vez disso, importe de qiskit_aer, que é um substituto imediato. Para instalar o qiskit_aer, execute:

  pip install qiskit-aer

• O suporte à execução de tarefas Pulse em backends do qiskit.providers.fake_provider has foi removido no Qiskit v1.0. Isso ocorre porque o Qiskit Aer removeu sua funcionalidade de simulação para esses trabalhos. Para cargas de trabalho de simulação de hamiltonianos de baixo nível, considere usar uma biblioteca especializada, como o Qiskit Dynamics.

qiskit.pulse

ParametricPulse

A classe base qiskit.pulse.library.parametric_pulses.ParametricPulse e a biblioteca pulse library foram substituídas por qiskit.pulse.SymbolicPulse e a biblioteca de pulsos correspondente. SymbolicPulse suportes Serialização 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)

Amplitude de valor complexo

A amplitude de pulso com valor complexo (amp) é substituída por um (amp, angle). Essa representação é mais intuitiva, especialmente para algumas tarefas de calibração, como a calibração de ângulos:

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

Operações de porta do circuito de injeção

Injetar operações de porta de circuito no contexto do construtor de pulsos por meio de qiskit.pulse.builder.call não é mais possível. Essa remoção afeta os argumentos de entrada do tipo QuantumCircuit, bem como as seguintes funções:

• 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

Se você ainda quiser injetar programações calibradas pelo backend, use o seguinte padrão em vez de chamar os comandos do 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)

Da mesma forma, a QuantumCircuit pode ser injetado no contexto do construtor, transpilando e agendando manualmente o objeto objeto.

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)

Recomendamos escrever um programa de pulso mínimo com o construtor e anexá-lo ao QuantumCircuit por meio da função QuantumCircuit.add_calibration método como um microcódigo de uma instrução de porta, em vez de escrever o programa inteiro programa inteiro com o modelo de pulso.

builder.build

Os seguintes argumentos em qiskit.pulse.builder.build foram removidos com nenhuma alternativa.

• default_transpiler_settings
• default_circuit_scheduler_settings

Essas funções também foram removidas:

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

Isso ocorre porque não é mais possível injetar objetos de circuito no contexto do construtor (consulte Injetando operações de portas de circuito ); essas configurações serviam para converter objetos injetados em representações de pulso.

biblioteca

A biblioteca de pulsos discretos foi removida da base de código. Isso inclui:

• 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

Em vez disso, use o qiskit.pulse.SymbolicPulse, correspondente com SymbolicPulse.get_waveform(). Por exemplo, em vez de pulse.gaussian(100,0.5,10), use pulse.Gaussian(100,0.5,10).get_waveform(). Observe que a fase de ambos os Sawtooth e Square é definida de tal forma que uma fase de 2\pi se desloca em um ciclo completo, ao contrário da discreta. Observe também que as amplitudes complexas não são mais compatíveis com a biblioteca de pulsos simbólicos a biblioteca de pulsos simbólicos; em vez disso, use float, amp e angle .

ScalableSymbolicPulse

Não é mais possível carregar objetos da biblioteca qiskit.pulse.ScalableSymbolicPulse com um parâmetro amp complexo a partir de arquivos qpy da versão 5 ou anteriores (Qiskit Terra < 0.23.0 ). Nenhuma ação de migração é necessária, pois o complexo amp será será automaticamente convertido para float (amp, angle).

Essa alteração se aplica a esses pulsos:

• qiskit.pulse.Constant
• qiskit.pulse.Drag
• qiskit.pulse.Gaussian
• qiskit.pulse.GaussianSquare

qiskit.qasm

O módulo do analisador legado OpenQASM 2, anteriormente em qiskit.qasm , foi foi substituído pelo módulo qiskit.qasm2 módulo, que fornece um analisador mais rápido e mais preciso para OpenQASM 2. Os métodos de alto nível QuantumCircuit métodos from_qasm_file() e from_qasm_str() permanecem os mesmos, mas usarão o novo analisador internamente. Entretanto, a interface pública para o módulo qasm2 não é a mesma. Enquanto o módulo qiskit.qasm forneceu uma interface para uma árvore de sintaxe abstrata retornada pela biblioteca ply biblioteca do analisador, o site qiskit.qasm2 não expõe a AST ou qualquer detalhe de detalhes de implementação de nível inferior sobre o analisador. Em vez disso, ele recebe a entrada OpenQASM 2 e produz um QuantumCircuit objeto.

Por exemplo, se você estava executando algo como isto:

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)

Substitua-o pelo seguinte:

import qiskit.qasm2

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

qiskit.quantum_info

O módulo qiskit.quantum_info.synthesis foi migrado para vários locais na base de código, principalmente qiskit.synthesis.

Essa mudança não afetou o caminho normal de importação do Quaternion, mas você não pode mais acessá-lo por meio do por meio do site qiskit.quantum_info.synthesis.

Por fim, o site cnot_rxx_decompose foi removido.

qiskit.test

O módulo qiskit.test não é mais um módulo público. Nunca foi planejado para ser público, nem para ser usado fora do conjunto de testes do Qiskit. Todas as funcionalidades são específicas do Qiskit e nenhuma alternativa é fornecida alternativa é fornecida; se você precisar de uma funcionalidade semelhante, deverá incluí-la em seus próprios arneses de teste.

qiskit.tools

O qiskit.tools módulo foi removido no Qiskit v1.0. A maior parte dessas funcionalidades foi substituída por funcionalidades semelhantes em outros pacotes ou removida sem nenhuma alternativa. A principal exceção é a qiskit.tools.parallel_map() função, que foi transferida para o qiskit.utils módulo. Pode ser usado a partir deste novo local. Por exemplo:

Se você estava executando anteriormente:

# Previous
from qiskit.tools import parallel_map

parallel_map(func, input)

# Current
from qiskit.utils import parallel_map

parallel_map(func, input)

Jupyter

O submódulo qiskit.tools.jupyter foi removido porque a funcionalidade nesse módulo está vinculada ao pacote legado qiskit-ibmq-provider , que não é mais suportado não é mais suportado. Ele também era compatível apenas com o site BackendV1 e não com o mais recente BackendV2 interface.

monitorar

O submódulo qiskit.tools.monitor foi removido porque estava vinculado ao pacote pacote legado qiskit-ibmq-provider , que não é mais suportado (ele também também suportava apenas a interface BackendV1 e não a mais recente BackendV2 mais recente). Não há nenhuma alternativa para essa funcionalidade.

dados

O submódulo qiskit.tools.visualization foi removido. Esse módulo era um redirecionamento legado do local original do módulo de visualização do Qiskit e foi movido para qiskit.visualization no Qiskit 0.8.0. Se você ainda estiver usando esse caminho, atualize suas importações de qiskit.tools.visualization para qiskit.visualization.

# Previous
from qiskit.tools.visualization import plot_histogram

plot_histogram(counts)

# Current
from qiskit.visualization import plot_histogram

plot_histogram(counts)

eventos

O módulo qiskit.tools.events e o utilitário progressbar() que ele expôs foram removidos. A funcionalidade desse módulo não foi amplamente utilizada e é melhor coberta por pacotes dedicados, como o tqdm.

qiskit.transpiler

síntese

Os itens do módulo qiskit.transpiler.synthesis foram migrados para novos locais:

Aprovações

A passagem do transpilador NoiseAdaptiveLayout foi substituída por VF2Layout e VF2PostLayout, que definem um layout com base nas características de ruído relatadas de um backend. Tanto o passe quanto o plug-in "noise_adaptive" layout stage correspondentes foram removidos do Qiskit.

A passagem do transpilador CrosstalkAdaptiveSchedule foi removida da base de código. Essa passagem não era mais utilizável porque sua operação interna dependia da definição de propriedades personalizadas na carga útil do BackendProperties de uma instância de BackendV1 . Como nenhum backend está definindo esses campos, o passe foi foi removido.

gerenciador de senhas

Os métodos append do ConditionalController, FlowControllerLinear, e DoWhileController classes foram removidos. Em vez disso, todas as tarefas devem ser fornecidas quando os objetos são construídos.

qiskit.utils

As seguintes ferramentas em qiskit.utils foram removidas sem substituição:

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

Essas funções foram usadas exclusivamente nos módulos qiskit.algorithms e qiskit.opflow que também foram removidos.

qiskit.visualization

O módulo qiskit.visualization.qcstyle foi removido. Use qiskit.visualization.circuit.qcstyle como substituto direto.