Skip to main content
IBM Quantum Platform

Notas de versão do Qiskit 0.37

0.37.2

Terra 0.21.2

Prelúdio

O Qiskit Terra 0.21.2 é principalmente uma versão de correção de bugs e também vem com várias páginas de documentação aprimoradas.

Correções de bugs

  • aer_simulator_statevector_gpu agora será reconhecido corretamente como método statevector em alguma função ao usar os simuladores de GPU do Qiskit Aer em QuantumInstance e outros executores de algoritmos.

  • Corrigido o método UCGate.inverse() que anteriormente não invertia a fase global.

  • QuantumCircuit.compose() agora funcionará corretamente quando usado com o argumento inplace=True em contextos de construtor de fluxo de controle. Anteriormente, as instruções eram adicionadas fora do escopo do fluxo de controle. Corrigido #8433.

  • Foi corrigido um bug em que uma expressão vinculada ParameterExpression não era identificado como real se o site symengine estivesse instalado e a expressão de limite não fosse um simples 1j. Por exemplo:

    from qiskit.circuit import Parameter

x = Parameter("x")
expr = 1j * x
bound = expr.bind({x: 2})
print(bound.is_real())  # used to be True, but is now False

  • Correção da serialização e desserialização do QPY de ControlledGate com controles abertos (ou seja, aqueles cujo ctrl_state não é "all ones"). Corrigido #8549.

  • Todos os back-ends falsos em qiskit.providers.fake_provider.backends foram atualizados para retornar os objetos de canal de pulso correspondentes com a chamada de método de drive_channel(), measure_channel(), acquire_channel(), control_channel().

  • Corrigido o suporte à execução do site Z2Symmetries.taper() em problemas maiores. Anteriormente, o método exigia uma grande quantidade de memória, o que normalmente causava falhas em problemas maiores. Como efeito colateral dessa correção, o desempenho melhorou significativamente.

Aer 0.10.4

Nenhuma mudança

IBM 0.19.2

Nenhuma mudança

0.37.1

Terra 0.21.1

Correções de bugs

  • Foi corrigido um problema no método QuantumCircuit.decompose() ao passar uma lista de classes Gate para o argumento gates_to_decompose . Se alguma porta do circuito tivesse um rótulo definido, esse argumento não seria tratado corretamente e faria com que a decomposição de saída ignorasse incorretamente as portas explicitamente na lista gates_to_decompose .

  • Correção to_instruction() que anteriormente tentava criar um UnitaryGate sem exponenciar o operador para evoluir. Como esse operador geralmente não é unitário, isso gerou um erro (e se o operador tivesse sido unitário por acaso, não teria sido o resultado esperado).

    Agora, chamar to_instruction() produz corretamente uma porta que implementa a evolução temporal do operador que ela mantém:

    >>> from qiskit.opflow import EvolvedOp, X
>>> op = EvolvedOp(0.5 * X)
>>> op.to_instruction()
Instruction(
    name='unitary', num_qubits=1, num_clbits=0,
    params=[array([[0.87758256+0.j, 0.-0.47942554j], [0.-0.47942554j, 0.87758256+0.j]])]
)

  • Corrigido um problema com a função marginal_distribution() quando uma matriz numpy era passada para o argumento indices , a função gerava um erro. Corrigido #8283

  • Anteriormente, não era possível associar um CircuitStateFn que tenha sido construído a partir de um VectorStateFn. Isso se deve ao fato de o vetor de estado ter sido convertido em um circuito com a instrução Initialize , que não é unitária. Esse problema agora é corrigido com o uso da instrução StatePreparation que pode ser usada, pois se presume que o estado comece no estado totalmente 0.

    Por exemplo, agora podemos fazer:

    from qiskit import QuantumCircuit
from qiskit.opflow import StateFn

left = StateFn([0, 1])
left_circuit = left.to_circuit_op().primitive

right_circuit = QuantumCircuit(1)
right_circuit.x(0)

overlap = left_circuit.inverse().compose(right_circuit)  # this line raised an error before!

  • Corrigir um bug nas classes Optimizer em que a reconstrução de uma nova instância do otimizador a partir de uma instância existente anteriormente settings redefinia as configurações do otimizador novo e anterior para os padrões. Isso levou a um bug, principalmente se os objetos Optimizer fossem enviados como entrada para os programas Qiskit Runtime.

    Agora os objetos do otimizador são reconstruídos corretamente:

    >>> from qiskit.algorithms.optimizers import COBYLA
>>> original = COBYLA(maxiter=1)
>>> reconstructed = COBYLA(**original.settings)
>>> reconstructed._options["maxiter"]
1  # used to be 1000!

  • Foi corrigido um problema em que o argumento limit_amplitude em um arquivo SymbolicPulse ou Waveform não era refletido corretamente pela validação de parâmetros. Além disso, o QPY schedule dump() foi corrigido para armazenar corretamente o valor limit_amplitude vinculado à instância, em vez de salvar a variável de classe global.

  • Fixe a estrutura de emaranhamento em pares para NLocal circuitos. Isso levou a um erro no ZZFeatureMaponde o uso do entanglement="pairwise" gerava um erro. Agora ele produz corretamente o mapa de recursos desejado:

    from qiskit.circuit.library import ZZFeatureMap
encoding = ZZFeatureMap(4, entanglement="pairwise", reps=1)
print(encoding.decompose().draw())

    As impressões acima:

         ┌───┐┌─────────────┐
q_0: ┤ H ├┤ P(2.0*x[0]) ├──■────────────────────────────────────■────────────────────────────────────────────
     ├───┤├─────────────┤┌─┴─┐┌──────────────────────────────┐┌─┴─┐
q_1: ┤ H ├┤ P(2.0*x[1]) ├┤ X ├┤ P(2.0*(π - x[0])*(π - x[1])) ├┤ X ├──■────────────────────────────────────■──
     ├───┤├─────────────┤└───┘└──────────────────────────────┘└───┘┌─┴─┐┌──────────────────────────────┐┌─┴─┐
q_2: ┤ H ├┤ P(2.0*x[2]) ├──■────────────────────────────────────■──┤ X ├┤ P(2.0*(π - x[1])*(π - x[2])) ├┤ X ├
     ├───┤├─────────────┤┌─┴─┐┌──────────────────────────────┐┌─┴─┐└───┘└──────────────────────────────┘└───┘
q_3: ┤ H ├┤ P(2.0*x[3]) ├┤ X ├┤ P(2.0*(π - x[2])*(π - x[3])) ├┤ X ├──────────────────────────────────────────
     └───┘└─────────────┘└───┘└──────────────────────────────┘└───┘

  • Foi corrigido um problema no tratamento da fase global da classe UCGate classe.

Aer 0.10.4

Nenhuma mudança

IBM 0.19.2

Nenhuma mudança

0.37.0

Esta versão marca oficialmente o fim do suporte ao projeto Qiskit Ignis da Qiskit. Ele foi originalmente descontinuado na versão 0.33.0 e, como foi documentado nessa versão, o pacote qiskit-ignis foi removido do metapacote do Qiskit, o que significa que, na versão futura, o pip install qiskit não incluirá mais o qiskit-ignis. No entanto, observe que, devido a limitações no empacotamento do python, não podemos remover automaticamente uma instalação pré-existente do qiskit-ignis. Se estiver atualizando a partir de uma versão anterior, é recomendável desinstalar manualmente o Qiskit Ignis com pip uninstall qiskit-ignis ou instalar o metapacote em um ambiente python novo.

O Qiskit Ignis foi superado pelo projeto Qiskit Experiments. Você pode consultar o guia de migração para obter detalhes sobre como mudar do Qiskit Ignis para o Qiskit Experiments.

Terra 0.21.0

Prelúdio

Os destaques da versão do Qiskit 0.21.0 são:

  • Suporte à serialização de um pulso ScheduleBlock via qiskit.qpy. O formato QPY foi atualizado para a versão 5, que inclui uma definição para incluir as programações de pulso. Para dar suporte a isso, uma nova classe SymbolicPulse foi introduzida para permitir a definição de formas de onda de pulso paramétrico por meio de expressões simbólicas.
  • Aprimoramentos no trabalho com gerenciadores de passes predefinidos. Uma nova função generate_preset_pass_manager() permite gerar facilmente um gerenciador de passes equivalente ao que o transpile() usará internamente. Além disso, os gerenciadores de passagem predefinidos agora são instâncias de StagedPassManager o que facilita a modificação das seções.
  • Uma refatoração da estrutura de dados interna do atributo QuantumCircuit.data atributo. Antes era uma lista de tuplas no formato (instruction, qubits, clbits) e agora é uma lista de CircuitInstruction objetos. Os objetos CircuitInstruction é compatível com as versões anteriores do acesso baseado em tuplas, porém com custo adicional de tempo de execução.

Além disso, o transpilador foi aprimorado para permitir saídas de melhor qualidade. Isso inclui a introdução de novos passes, como VF2PostLayout e ToqmSwap.

Novos Recurso

  • Adicionada uma nova classe, qiskit.transpiler.StagedPassManagerque é uma subclasse PassManager que tem um pipeline com fases definidas para realizar a compilação de circuitos. Cada fase é um objeto PassManager objeto que será executado em uma ordem fixa. Por exemplo:

    from qiskit.transpiler.passes import *
from qiskit.transpiler import PassManager, StagedPassManager

basis_gates = ['rx', 'ry', 'rxx']
init = PassManager([UnitarySynthesis(basis_gates, min_qubits=3), Unroll3qOrMore()])
translate = PassManager([Collect2qBlocks(),
                         ConsolidateBlocks(basis_gates=basis_gates),
                         UnitarySynthesis(basis_gates)])

staged_pm = StagedPassManager(stages=['init', 'translation'], init=init, translation=translate)

  • Adicionados os métodos PauliList.group_commuting() e SparsePauliOp.group_commuting()que dividem esses operadores em sublistas em que cada elemento comuta com todos os outros. Por exemplo:

    from qiskit.quantum_info import PauliList, SparsePauliOp

groups = PauliList(["XX", "YY", "IZ", "ZZ"]).group_commuting()
# 'groups' is [PauliList(['IZ', 'ZZ']), PauliList(['XX', 'YY'])]

op = SparsePauliOp.from_list([("XX", 2), ("YY", 1), ("IZ", 2j), ("ZZ", 1j)])
groups = op.group_commuting()
# 'groups' is [
#     SparsePauliOp(['IZ', 'ZZ'], coeffs=[0.+2.j, 0.+1.j]),
#     SparsePauliOp(['XX', 'YY'], coeffs=[2.+0.j, 1.+0.j]),
# ]

  • Adicionada uma nova função, marginal_distribution()que é usada para marginalizar um dicionário de entrada de bitstrings para um número inteiro (como Counts). A funcionalidade é semelhante à da função marginal_counts() existente, com três diferenças importantes. A primeira é que o marginal_counts() funciona com um dicionário de contagens ou com um objeto Results , enquanto marginal_distribution() só funciona com um dicionário. A segunda é que o marginal_counts() não respeita a ordem dos índices em seu argumento indices , enquanto marginal_distribution() respeita e permutará os bits de saída com base na ordem indices . A terceira diferença é que o marginal_distribution() deve ser mais rápido, pois sua implementação foi escrita em Rust e simplificada para apenas marginalizar uma entrada de dicionário.

  • Adição do operador binário @ (__matmul__) às subclasses BaseOperator no módulo qiskit.quantum_info módulo. Essa é uma forma abreviada de chamar o método dot das classes (A @ B == A.dot(B)).

  • Adicionado um novo argumento opcional, reps, ao QuantumCircuit.decompose()que permite a decomposição repetida do circuito. Por exemplo:

    from qiskit import QuantumCircuit

circuit = QuantumCircuit(1)
circuit.ry(0.5, 0)

# Equivalent to circuit.decompose().decompose()
circuit.decompose(reps=2)

# decompose 2 times, but only RY gate 2 times and R gate 1 times
circuit.decompose(gates_to_decompose=['ry','r'], reps=2)

  • Adição de uma nova classe base de pulso SymbolicPulse. Esse é um substituto do convencional ParametricPulseconvencional, que será descontinuado. Na nova classe base, as funções de envelope de pulso e de validação de parâmetro são representadas por objetos de expressão simbólica. A nova classe fornece dados de pulso autônomos e portáteis, pois essas equações simbólicas podem ser facilmente serializadas por meio de bibliotecas de computação simbólica.

  • Adicionado suporte para operadores não hermitianos em AerPauliExpectation. Isso permite o uso dos cálculos rápidos de expectativa de instantâneos do Aer em algoritmos como QEOM.

  • Foi adicionado um novo estilo de desenho de circuito, textbook, que usa o esquema de cores do Qiskit Textbook.

  • Um novo atributo QuantumCircuit.op_start_times é preenchido quando uma das passagens de análise de agendamento é executada no circuito. Ele pode ser usado para obter instruções de circuito com tempo de instrução, por exemplo:

    from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import FakeMontreal

backend = FakeMontreal()

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

qct = transpile(
    qc, backend, initial_layout=[0, 1], coupling_map=[[0, 1]], scheduling_method="alap"
)
scheduled_insts = list(zip(qct.op_start_times, qct.data))

  • Adicionado um novo método QuantumCircuit.clear() que é usado para remover todas as instruções de um arquivo QuantumCircuit.

  • Adicionado um novo método QuantumCircuit.copy_empty_like() que é usado para obter uma cópia limpa de uma instância QuantumCircuit instância. Isso é logicamente equivalente a qc.copy().clear(), mas é significativamente mais rápido e eficiente em termos de memória. Isso é útil quando se precisa de um novo circuito vazio com todos os mesmos recursos (qubits, bits clássicos, metadados e assim por diante) já adicionados.

  • O método Target.instruction_supported() agora suporta dois novos argumentos de palavra-chave, operation_class e parameters. Usando esses argumentos, o método instruction_supported() pode agora ser usado para verificar se uma operação específica com valores de parâmetros é compatível com um objeto Target objeto. Por exemplo, se você quiser verificar se um site Target chamado target suporta a execução de um RXGate com θ=π2\theta = \frac{\pi}{2}, você faria algo como:

    from math import pi
from qiskit.circuit.library import RXGate

target.instruction_supported(operation_class=RXGate, parameters=[pi/2])

    que retornará True se target suportar a execução RXGate com θ=π2\theta = \frac{\pi}{2} e False caso contrário.

  • Adição de um algoritmo de evolução quântica em tempo real baseado em Trotterização qiskit.algorithms.TrotterQRTE. Ele está em conformidade com a nova estrutura de evolução do tempo quântico e faz uso das funções ProductFormula e PauliEvolutionGate implementações.

    from qiskit.algorithms import EvolutionProblem
from qiskit.algorithms.evolvers.trotterization import TrotterQRTE
from qiskit.opflow import X, Z, StateFn, SummedOp

operator = SummedOp([X, Z])
initial_state = StateFn([1, 0])
time = 1
evolution_problem = EvolutionProblem(operator, time, initial_state)

trotter_qrte = TrotterQRTE()
evolution_result = trotter_qrte.evolve(evolution_problem)
evolved_state_circuit = evolution_result.evolved_state

  • Adicionada uma nova função generate_preset_pass_manager() que pode ser usada para gerar rapidamente um objeto predefinido PassManager que espelha o objeto PassManager usado internamente pela função transpile() função. Por exemplo:

    from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.providers.fake_provider import FakeWashingtonV2

# Generate an optimization level 3 pass manager targeting FakeWashingtonV2
pass_manager = generate_preset_pass_manager(3, FakeWashingtonV2())

  • Adicionada uma nova função marginal_memory() que é usada para marginalizar matrizes de memória de captura. Fornecida com a matriz de memória de disparo e os índices de interesse, a função retornará uma matriz de memória de disparo maginizada. Essa função é diferente do suporte à memória no método marginal_counts() que só funciona no campo memory em um objeto Results .

  • A interface de primitivos foi ampliada para aceitar objetos, além de índices, como argumentos para o método __call__ . O argumento parameter_values agora pode ser opcional.

  • O exportador do OpenQASM 3 (qiskit.qasm3) agora oferece suporte à exportação de circuitos com atrasos explícitos, como os do QuantumCircuit.delay().

  • Adicionado um novo método de layout e roteamento ao transpile() com base no documento "Time-optimal qubit mapping". Para usá-lo, o pacote opcional Qiskit TOQM deve ser instalado. O kwarg routing_method de transpile() suporta um valor adicional, 'toqm' , que é usado para ativar o layout e o roteamento via TOQM.

    Para instalar o qiskit-toqm junto com o Terra, execute:

    pip install qiskit-terra[toqm]

  • Inclusão de um novo módulo qiskit.quantum_info.synthesis.qsd para aplicar a Decomposição Quântica de Shannon em unidades arbitrárias. Essa funcionalidade substitui a abordagem anterior baseada em isometria na passagem padrão do transpilador de síntese unitária, bem como ao adicionar unitários a um circuito usando um UnitaryGate.

    A Decomposição Quântica de Shannon usa cerca de metade das portas cnot como a implementação de isometria ao decompor matrizes unitárias de mais de dois qubits.

  • As classes no módulo quantum_info que suportam a multiplicação escalar agora podem ser multiplicadas por um escalar da esquerda ou da direita. Anteriormente, eles só aceitavam multiplicadores escalares da esquerda.

  • A passagem do transpilador LookaheadSwap (usado por transpile() quando routing_method="lookahead") teve algumas melhorias de desempenho e agora será aproximadamente três vezes mais rápida. Isso é apenas ser mais eficiente em seus cálculos e não altera a complexidade do algoritmo. Na maioria dos casos, um algoritmo de roteamento mais moderno, como o SabreSwap (routing_method="sabre") terá um desempenho muito melhor.

  • Novos passes de transpiladores foram adicionados. A passagem do transpilador Commuting2qGateRouter usa estratégias de troca para rotear um bloco de portas de comutação para o mapa de acoplamento. De fato, o roteamento é um problema difícil, mas é significativamente mais fácil quando os portões se alternam, como nas redes CZ. Blocos de portões de deslocamento também são normalmente encontrados na QAOA. Esses casos podem ser tratados com estratégias de troca que aplicam um conjunto predefinido de camadas de portas SWAP. Além disso, a nova passagem do transpilador FindCommutingPauliEvolutions identifica blocos de evoluções de Pauli feitos de termos de dois qubits comutáveis. Aqui, uma estratégia de troca é especificada pela classe SwapStrategy. As estratégias de troca precisam ser adaptadas ao mapa de acoplamento e, idealmente, ao circuito para obter os melhores resultados.

  • Introduziu um novo otimizador na biblioteca Qiskit, que adiciona suporte à otimização de parâmetros de algoritmos quânticos variacionais. Esse é o Algoritmo de Distribuição Marginal Univariada (UMDA), que é um tipo específico de Algoritmos de Estimativa de Distribuição. Por exemplo:

    from qiskit.opflow import X, Z, I
from qiskit import Aer
from qiskit.algorithms.optimizers import UMDA
from qiskit.algorithms import QAOA
from qiskit.utils import QuantumInstance

H2_op = (-1.052373245772859 * I ^ I) + \
        (0.39793742484318045 * I ^ Z) + \
        (-0.39793742484318045 * Z ^ I) + \
        (-0.01128010425623538 * Z ^ Z) + \
        (0.18093119978423156 * X ^ X)

p = 2  # Toy example: 2 layers with 2 parameters in each layer: 4 variables

opt = UMDA(maxiter=100, size_gen=20)
backend = Aer.get_backend('statevector_simulator')
vqe = QAOA(opt,
           quantum_instance=QuantumInstance(backend=backend),
           reps=p)

result = vqe.compute_minimum_eigenvalue(operator=H2_op)

  • O construtor da passagem Unroll3qOrMore transpiler pass tem dois novos argumentos opcionais de palavra-chave, target e basis_gates. Essas opções permitem que você especifique o Target ou as portas de base suportadas, respectivamente, para descrever o backend de destino. Se alguma das operações no circuito estiver em target ou basis_gates , elas não serão desenroladas pela passagem, pois o dispositivo de destino tem suporte nativo para a operação.

  • A serialização QPY foi atualizada para suportar ScheduleBlock. Agora você pode salvar o programa de pulso em binário e carregá-lo posteriormente:

    from qiskit import pulse, qpy

with pulse.build() as schedule:
    pulse.play(pulse.Gaussian(160, 0.1, 40), pulse.DriveChannel(0))

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

with open('schedule.qpy', 'rb') as fd:
    new_schedule = qpy.load(fd)[0]

    Isso usa a interface QPY comum ao QuantumCircuit. Consulte SCHEDULE_BLOCK para obter detalhes sobre a estrutura de dados.

  • Adicionada uma nova passagem de transpilador, VF2PostLayout. Essa passagem é de um novo tipo para executar uma nova fase/função no pipeline de compilação, pós-layout ou seleção de qubit pós-otimização. A ideia por trás dessa passagem é que, depois de terminarmos o loop de otimização no transpiler, saberemos quais serão as contagens finais de portas em cada qubit do circuito, de modo que possamos encontrar um subconjunto de qubits com melhor desempenho em um backend para executar o circuito. A passagem procurará um subgrafo isomórfico no gráfico de conectividade do backend de destino e examinará a taxa de erro total do circuito completo em qualquer subgrafo encontrado e retornará o layout encontrado com a menor taxa de erro para o circuito.

    Essa passagem é semelhante à passagem VF2Layout e ambas usam internamente a mesma implementação VF2 do retworkx. No entanto, VF2PostLayout foi projetado para ser executado após a execução do layout inicial, do roteamento, da conversão de base e de quaisquer passes de otimização, e só funcionará se um layout já tiver sido aplicado, se o circuito tiver sido roteado e se todas as portas estiverem na base de destino. Isso é necessário para que, quando um novo layout for aplicado, o circuito ainda possa ser executado no dispositivo de destino. VF2Layout por outro lado, foi projetado para encontrar um layout inicial perfeito e pode funcionar com qualquer circuito.

  • A passagem do ApplyLayout agora tem suporte para atualizar um layout em um circuito depois que um layout já foi aplicado uma vez. Se o campo post_layout estiver presente (além do campo obrigatório layout ), o property_set , quando a ApplyLayout for executada, a passagem atualizará o layout para aplicar o novo layout. Isso retornará um DAGCircuit com os qubits na nova ordem física e o conjunto de propriedades layout será atualizado de modo a mapear os qubits virtuais do layout original para os qubits físicos no novo campo post_layout .

  • Os gerentes de passagem predefinidos gerados por level_1_pass_manager(), level_2_pass_manager(), e level_3_pass_manager() que correspondem a optimization_level 1, 2 e 3, respectivamente, na função transpile() agora executam a passagem VF2PostLayout depois de executar a passagem de roteamento. Isso permite que o transpilador encontre um conjunto diferente de qubits físicos no backend de destino para executar o circuito com taxas de erro mais baixas. A passagem VF2PostLayout não será executada se você especificar manualmente os argumentos layout_method, routing_method, ou initial_layout para transpile(). Se o passe puder encontrar um subconjunto de qubits de melhor desempenho no backend para executar o circuito físico, ele ajustará o layout do circuito para usar os qubits alternativos.

  • O algoritmo calcula iterativamente cada estado próprio, começando pelo estado fundamental (que é calculado como no VQE) e, em seguida, otimizando uma função de custo modificada que tenta calcular estados próprios que sejam ortogonais aos estados calculados nas iterações anteriores e que tenham a menor energia quando calculados sobre o ansatz. A interface implementada é muito semelhante à do VQE e tem o seguinte formato:

    from qiskit.algorithms import VQD
from qiskit.utils import QuantumInstance
from qiskit.circuit.library import TwoLocal
from qiskit.algorithms.optimizers import COBYLA
from qiskit import BasicAer
from qiskit.opflow import I,Z,X

h2_op = (
    -1.052373245772859 * (I ^ I)
    + 0.39793742484318045 * (I ^ Z)
    - 0.39793742484318045 * (Z ^ I)
    - 0.01128010425623538 * (Z ^ Z)
    + 0.18093119978423156 * (X ^ X)
)

vqd = VQD(k =2, ansatz = TwoLocal(rotation_blocks="ry", entanglement_blocks="cz"),optimizer = COBYLA(maxiter = 0), quantum_instance = QuantumInstance(
            BasicAer.get_backend("qasm_simulator"), shots = 2048)
        )
vqd_res = vqd.compute_eigenvalues(op)

    Esse trecho de código específico gera 2 autovalores (estado fundamental e primeiro estado excitado) Os testes também foram implementados.

Notas da Atualização

  • As classes de pulso em qiskit.pulse.library agora são subclasses de SymbolicPulse em vez de ParametricPulse. As classes disponíveis permanecem inalteradas como Gaussian, GaussianSquare, Drag, e Constant. SymbolicPulse tem total compatibilidade com versões anteriores, e não deve haver perda de funcionalidade.

  • O tipo de dados de cada elemento em QuantumCircuit.data foi alterado. Costumava ser uma simples tripla de an Instruction, uma lista de Qubits, e uma lista de Clbits, enquanto agora é uma instância de CircuitInstruction.

    Os atributos dessa nova classe são operation, qubits e clbitscorrespondentes aos elementos da tupla anterior. No entanto, qubits e clbits são agora instâncias de tuple , e não lists.

    Essa nova classe se comportará exatamente como a antiga 3-tupla se alguém tentar acessar seu índice, seus elementos ou iterar por ela. Isso inclui o uso de qubits e clbits para listas. Isso é para ajudar na compatibilidade com versões anteriores. A partir do Qiskit Terra 0.21, essa não é mais a maneira preferida de acessar esses elementos. Em vez disso, você deve usar o formulário de acesso a atributos descrito acima.

    Isso foi feito para permitir novos desenvolvimentos da estrutura de dados QuantumCircuit estrutura de dados no Terra, sem quebrar constantemente a compatibilidade com versões anteriores. Os desenvolvimentos planejados incluem circuitos parametrizados dinâmicos e uma redução geral no uso de memória de circuitos profundos.

  • A dependência python-constraint , que é usada somente pela passagem CSPLayout não está mais na lista de requisitos do pacote Qiskit Terra. Isso ocorre porque o passe CSPLayout não é mais usado por padrão em nenhum dos gerenciadores de passes predefinidos para o transpile(). Embora o passe ainda esteja disponível, se você o estiver usando, precisará instalar manualmente o python-contraint ou, quando instalar o qiskit-terra , poderá usar o extra csp-layout , por exemplo:

    pip install "qiskit-terra[csp-layout]"

  • A versão do formato de versão QPY emitida por qpy.dump() foi aumentada para a versão 5. Essa nova versão do formato é incompatível com as versões anteriores e resultará em um erro ao tentar carregá-la com um desserializador que não seja capaz de lidar com o QPY versão 5. Essa alteração foi necessária para corrigir o suporte para representar corretamente as portas controladas e os estados de controle não padrão.

  • As extensões Rust compiladas do Qiskit Terra agora têm uma versão Rust mínima suportada (MSRV) de 1.56.1. Isso significa que, ao compilar o Qiskit Terra a partir do código-fonte, a versão mais antiga do compilador Rust suportada é 1.56.1. Se estiver usando uma versão mais antiga do compilador Rust, será necessário atualizar para uma versão mais recente para continuar a compilar o Qiskit a partir do código-fonte. Essa alteração foi necessária porque várias dependências upstream também atualizaram suas versões mínimas suportadas.

  • A programação de circuitos agora é executada em paralelo quando mais de um circuito é fornecido para schedule(). Consulte o número 2695 para obter mais detalhes.

  • As classes BaseBackend, BaseJob e BaseProvider , anteriormente obsoletas, foram removidas. Eles foram originalmente descontinuados na versão 0.18.0. Em vez dessas classes, você deve usar as classes de interface de provedores com versão, sendo as mais recentes BackendV2, JobV1, e ProviderV1.

  • O argumento backend , anteriormente obsoleto, para o construtor da passagem RZXCalibrationBuilder transpiler pass foi removido. Ele foi originalmente preterido na versão 0.19.0. Em vez disso, você deve consultar o objeto Backend para os endereços instruction_schedule_map e qubit_channel_mapping e passá-los diretamente para o construtor. Por exemplo, com um BackendV1 backend:

    from qiskit.transpiler.passes import RZXCalibrationBuilder
from qiskit.providers.fake_provider import FakeMumbai

backend = FakeMumbai()
inst_map = backend.defaults().instruction_schedule_map
channel_map = backend.configuration().qubit_channel_mapping
cal_pass = RZXCalibrationBuilder(
    instruction_schedule_map=inst_map,
    qubit_channel_mapping=channel_map,
)

    ou com um BackendV2 backend:

    from qiskit.transpiler.passes import RZXCalibrationBuilder
from qiskit.providers.fake_provider import FakeMumbaiV2

backend = FakeMumbaiV2()
inst_map = backend.instruction_schedule_map
channel_map = {bit: backend.drive_channel(bit) for bit in range(backend.num_qubits)}
cal_pass = RZXCalibrationBuilder(
    instruction_schedule_map=inst_map,
    qubit_channel_mapping=channel_map,
)

  • O limite de medições para o backend BasicAer foi removido.

  • Para o DAGNode, os kwargs e atributos anteriormente obsoletos type, op, qargs, cargs e wire foram removidos. Eles foram originalmente descontinuados na versão 0.19.0. Os kwargs e atributos op, qargs e cargs só podem ser acessados em instâncias de DAGOpNode, e o kwarg e o atributo wire só podem ser acessados em instâncias de DAGInNode ou DAGOutNode.

  • A função obsoleta pauli_group() foi removida. Ele foi originalmente descontinuado no Qiskit Terra 0.17.

  • Vários métodos obsoletos em Pauli foram removidos, os quais foram originalmente descontinuados no Qiskit Terra 0.17. Foram eles:

    sgn_prod

    Usar Pauli.compose() ou Pauli.dot() em vez disso.

    to_spmatrix

    Use Pauli.to_matrix() com o argumento sparse=True em vez disso.

    kron

    Use Pauli.expand()mas lembre-se de que ele retorna um novo objeto, em vez de alterar o existente.

    update_z e update_x

    Defina os atributos z e x do objeto diretamente.

    insert_paulis

    Use Pauli.insert().

    append_paulis

    Use Pauli.expand().

    delete_qubits

    Use Pauli.delete().

    pauli_single

    Construa o rótulo manualmente e passe diretamente para o inicializador, por exemplo:

    Pauli("I" * index + pauli_label + "I" * (num_qubits - index - len(pauli_label)))

    random

    Use quantum_info.random_pauli() em vez disso.

  • Removido o método optimize das classes Optimizer que foi substituído pelo método minimize() como substituição direta. A única exceção é SPSAonde o aviso de depreciação não foi acionado, portanto, o método ainda é mantido.

  • Result foi modificado para que sempre contenha os atributos date, status e header (definido como None se não for especificado).

  • Para Python 3.7 shared-memory38 agora é uma dependência. Isso foi adicionado como uma dependência para Python 3.7 para permitir o aproveitamento das construções de memória compartilhada na biblioteca padrão das versões mais recentes do Python. Se você estiver executando em Python >= 3.8, não será necessária nenhuma dependência extra.

  • Instruction os rótulos agora são verificados quanto ao tipo na criação da instrução.

  • A serialização do QPY foi atualizada para serializar QuantumCircuit com QuantumCircuit.calibrations. A partir da versão 5 do QPY, somente as entradas de calibração do tipo ScheduleBlock podem ser serializadas.

  • A definição de XXPlusYYGate foi alterada. Consulte o número 7969 para obter detalhes.

  • Os gerentes de passagem predefinidos gerados por level_1_pass_manager(), level_2_pass_manager(), e level_3_pass_manager() e usados pelo argumento transpile() da função optimization_level em 1, 2 e 3, respectivamente, não definem mais um limite de tempo rígido para a VF2Layout passagem do transpilador. Isso significa que a passagem não vai mais parar de tentar encontrar uma alternativa melhor para o layout perfeito até um limite de tempo fixo ( 100ms para o nível 1, 10 segundos para o nível 2 e 60 segundos para o nível 3), pois isso limitava a reprodutibilidade da compilação quando um layout perfeito estava disponível. Isso significa que a saída ao usar a passagem pode ser diferente da anterior, embora em todos os casos ela só mude se for possível encontrar um conjunto de qubits com menos ruído em relação à saída anterior. Se quiser manter o comportamento anterior, você pode criar um PassManager personalizado que define o argumento time_limit no construtor para a passagem VF2Layout .

Notas de descontinuação

  • Chamada timeline_drawer() com um circuito não programado foi descontinuada. Todos os circuitos, mesmo os que consistem apenas em instruções de atraso, devem ser transpilados com o argumento da palavra-chave scheduling_method de transpile() set, para gerar informações de programação que estão sendo armazenadas em QuantumCircuit.op_start_times.

  • As funções do conversor NetworkX para DAGCircuit.to_networkx() e from_networkx(), juntamente com o método DAGDependency.to_networkx() foram descontinuadas e serão removidas em uma versão futura. O Qiskit tem usado o retworkx como sua biblioteca de gráficos desde a versão do qiskit-terra 0.12.0 e, desde então, as funções do conversor networkx têm sofrido perdas. Elas foram originalmente adicionadas para que os usuários pudessem aproveitar a funcionalidade da biblioteca de algoritmos NetworkX’s não presente no retworkx. Desde aquela época, o retworkx amadureceu e oferece mais funcionalidades, e o DAGCircuit está fortemente acoplado ao retworkx para sua operação. Ter esses métodos de conversão oferece valor limitado no futuro e, portanto, serão removidos em uma versão futura.

  • O acesso a vários toggles antigos (HAS_MATPLOTLIB, HAS_PDFTOCAIRO, HAS_PYLATEX e HAS_PIL) do módulo qiskit.visualization agora está obsoleto, e esses caminhos de importação serão removidos em uma versão futura do Qiskit Terra. Em vez disso, os mesmos objetos devem ser acessados por meio do qiskit.utils.optionalsque contém testadores para quase todas as dependências opcionais do Terra.

  • O módulo qiskit.test.mock está obsoleto. As classes de backend falso e provedor falso que estavam disponíveis anteriormente em qiskit.test.mock estão acessíveis em qiskit.providers.fake_provider desde o Terra 0.20.0. Essa alteração representa um compromisso adequado de oferecer suporte às classes de back-end falsas como parte do Qiskit, enquanto anteriormente elas eram apenas parte do conjunto de testes internos e eram expostas aos usuários como um efeito colateral.

  • Os nomes dos argumentos ao chamar um Estimator ou Sampler como uma função são renomeados de circuit_indices e observable_indices para circuits e observables.

  • Os argumentos de palavra-chave qobj_id e qobj_header para a função execute() foram preteridos e serão removidos em uma versão futura. Desde a remoção da classe BaseBackend , esses argumentos não têm nenhum efeito, pois nenhum backend suporta a execução com um objeto Qobj diretamente e, em vez disso, só funciona com objetos QuantumCircuit diretamente.

  • Os argumentos x, z e label para o inicializador de Pauli foram documentados como obsoletos no Qiskit Terra 0.17, mas um erro impediu que o aviso esperado fosse exibido em tempo de execução. Agora, o aviso será exibido corretamente e os argumentos serão removidos no Qiskit Terra 0.23 ou posterior. Um par de x e z deve ser passado de forma posicional como uma única tupla (Pauli((z, x))). Uma cadeia de caracteres label deve ser passada em posição no primeiro argumento (Pauli("XYZ")).

  • O método SPSA.optimize() está obsoleto em favor do método SPSA.minimize()que pode ser usado como substituto direto. Observe que esse método retorna um objeto de resultado completo com mais informações do que as disponíveis anteriormente.

  • O argumento circuits de qpy.dump() foi descontinuado e substituído por programs , pois agora o QPY oferece suporte a vários tipos de dados além de circuitos.

  • AlignmentKind.to_dict() foi preterido e será removido.

Correções de bugs

  • Uma validação extra foi adicionada ao DiagonalGate para verificar se o argumento tem módulo um.

  • Os índices de qubit duplicados fornecidos a SparsePauliOp.from_sparse_list() agora gerarão corretamente um erro, em vez de sobrescrever silenciosamente os valores anteriores. O comportamento antigo pode ser acessado passando o argumento da palavra-chave new do_checks=False.

  • A visualização timeline_drawer() não mais desalinhará os slots de registro clássicos.

  • A validação de parâmetros para GaussianSquare agora é consistente antes e depois da construção. Consulte o número 7882 para obter mais detalhes.

  • Os BackendV2-baseados em backends falsos no módulo qiskit.providers.fake_provider como o FakeMontrealV2agora suportam a operação Delay em seus atributos target atributos. Anteriormente, QuantumCircuit que continham atrasos não podiam ser compilados para esses back-ends.

  • Corrigido um bug no site TridiagonalToeplitz.eigs_bounds(), que fazia com que limites incorretos de valores próprios fossem retornados em alguns casos com valores próprios negativos. Consulte o número 7939 para obter mais detalhes.

  • Foi corrigido um erro no qual a gaveta do vetor de estado LaTeX ignorava o parâmetro max_size .

  • Suporte fixo no método PassManagerConfig.from_backend() para criar um objeto PassManagerConfig a partir de uma instância BackendV2 instância. Anteriormente, isso não era tratado corretamente e falhava ao ser executado com um objeto BackendV2 objeto.

  • Corrigido o suporte para serialização (qpy.dump()) e desserialização (qpy.load()) de um QuantumCircuit contendo objetos ControlledGate personalizados. Anteriormente, uma exceção era gerada por qpy.load() ao tentar reconstruir o arquivo personalizado ControlledGate. Corrigido #7999.

  • Corrigido o suporte para serialização (qpy.dump()) e desserialização (qpy.load()) de um QuantumCircuit contendo objetos MCPhaseGate personalizados. Anteriormente, uma exceção era gerada por qpy.load() ao tentar reconstruir o arquivo MCPhaseGate.

  • Corrigido o suporte para serialização (qpy.dump()) e desserialização (qpy.load()) de um objeto QuantumCircuit contendo portas controladas com um estado de controle aberto. Anteriormente, o estado de controle aberto era perdido pelo processo de serialização e pelo circuito reconstruído.

  • Fixo QuantumCircuit.reverse_bits() com circuitos que contenham Qubit e Clbit. Por exemplo, o seguinte funcionará agora:

    from qiskit.circuit import QuantumCircuit, Qubit, Clbit

qc = QuantumCircuit([Qubit(), Clbit()])
qc.h(0).c_if(qc.clbits[0], 0)
qc.reverse_bits()

  • Foi corrigido o atributo ConfigurableFakeBackend.t2 , que anteriormente era definido incorretamente com base no valor fornecido em t1 .

  • Foi corrigido um problema com as classes de back-end falsas baseadas em BackendV2-baseado em classes de backend falsas do módulo qiskit.providers.fake_provider tais como FakeMontrealV2 em que o valor do atributo dt (e o atributo Target.dt ) não estavam sendo convertidos corretamente em segundos. Isso causaria problemas ao usar esses back-ends falsos com agendamento.

  • Corrigido um erro no plot_histogram() quando o argumento number_to_keep era menor que o número de chaves. O código a seguir não gerará mais erros e será alinhado corretamente:

    from qiskit.visualization import plot_histogram
data = {'00': 3, '01': 5, '11': 8, '10': 11}
plot_histogram(data, number_to_keep=2)

  • Melhorou o desempenho da criação e do trabalho com instâncias parametrizadas QuantumCircuit com muitas portas que compartilham um número relativamente pequeno de parâmetros.

  • O exportador OpenQASM 3 (qiskit.qasm3) não tentará mais produzir definições para portas não padrão na opção basis_gates .

  • Corrigido o getter de OptimizerResult.nitque anteriormente retornava o número de avaliações Jacobianas em vez do número de iterações.

  • Foi corrigido um bug na representação de strings de objetos Result que fazia com que os atributos fossem especificados incorretamente.

  • Foi corrigido um problema com o transpile() em que, em alguns casos, o fornecimento de uma lista de cadeias de portas de base com o argumento da palavra-chave basis_gates ou implicitamente por meio de uma entrada Target por meio do argumento da palavra-chave target não era interpretado corretamente e resultava em um subconjunto das portas listadas sendo usadas para cada circuito.

  • Foi corrigido um problema na passagem do UnitarySynthesis que resultava em um erro quando um Target que não tinha nenhuma restrição de qubit nas operações (por exemplo, no caso de um alvo de simulador ideal) era especificado com o argumento da palavra-chave target para o construtor.

  • O método qiskit.result.marginal_counts(), quando passado um Result de um backend de pulso, falharia, pois contém uma matriz de objetos ExperimentResult , cada um dos quais tem um QobjExperimentHeader, e esses ExperimentHeaders não têm variáveis de instância creg_sizes. Se o Result viesse de um backend de simulador (por exemplo, Aer), essa variável de instância estaria lá. Corrigimos o site marginal_counts para que ele ignore a lógica que precisa de creg_sizes se o campo não estiver presente ou for diferente de None.

  • O exportador do OpenQASM 2 (QuantumCircuit.qasm()) agora definirá corretamente os parâmetros do qubit para operações UnitaryGate que não afetam todos os qubits sobre os quais são definidos. Corrigido #8224.

  • Corrigido um problema com a reprodutibilidade da função transpile() quando executada com optimization_level 1, 2 e 3. Anteriormente, em algumas condições, quando havia vários layouts perfeitos (um layout que não exige nenhuma porta SWAP) disponíveis, o layout selecionado e o circuito de saída podiam variar independentemente de o argumento seed_transpiler ter sido definido.

Aer 0.10.4

Nenhuma mudança

IBM 0.19.2

Correções de bugs

  • Na próxima versão do Terra, haverá um candidato à versão marcado antes da versão final. No entanto, a alteração da string da versão do pacote está bloqueada no qiskit-ibmq-provider no momento, porque ele está tentando analisar a versão e está assumindo que não haverá sufixo prelease na string da versão (consulte o número 8200 para obter detalhes). O PR #1135 corrige essa análise de versão para usar o regex do projeto pypa/packaging, que lida com todas as versões do pacote PEP440 e inclui sufixos de pré-lançamento. Isso permitirá que o terra libere uma tag 0.21.0rc1 sem quebrar o qiskit-ibmq-provider.
  • threading.currentThread e notifyAll foram descontinuados em Python 3.10 (outubro de 2021) e serão removidos em Python 3.12 (outubro de 2023). O PR nº 1133 os substitui por threading.current_thread, notify_all adicionado em Python 2.6 (outubro de 2008).
Esta página foi útil?
Relate um bug, erro de digitação ou solicite conteúdo no GitHub.