Skip to main content
IBM Quantum Platform

Notas de versão do Qiskit 0.12

0.12.0

Terra 0.9

Prelúdio

A versão 0.9 inclui muitos recursos novos e muitas correções de bugs. As maiores mudanças nesta versão são os novos recursos de depuração para PassManagers. Isso inclui uma função para visualizar um PassManager,, a capacidade de adicionar uma função de retorno de chamada a um PassManager, e o registro de passes executados no PassManager. Além disso, esta versão padroniza a maneira como você pode definir um layout inicial para o seu circuito. Portanto, agora você pode aproveitar initial_layout o parâmetro kwarg em qiskit.compiler.transpile() e qiskit.execute() e os qubits no circuito serão dispostos nos qubits desejados no dispositivo. A visualização de circuitos agora também mostrará isso claramente ao visualizar um circuito que foi transpilado com um layout.

Novos Recurso

  • Um objeto DAGCircuit (ou seja, a representação gráfica de um QuantumCircuit em que as dependências de operação são explícitas) agora pode ser visualizado com o método .draw() . Isso está de acordo com a filosofia de fácil visualização da Qiskit. Outros objetos que suportam um método .draw() são QuantumCircuit, PassManager e Schedule.

  • Adição de uma nova função de visualização qiskit.visualization.plot_error_map() para representar o mapa de erros de um determinado backend. Ele recebe um objeto de back-end do qiskit-ibmq-provider e traça o mapa de erros atual para esse dispositivo.

  • Os sites qiskit.QuantumCircuit.draw() e qiskit.visualization.circuit_drawer() agora suportam a anotação dos qubits na visualização com informações de layout. Se o objeto QuantumCircuit que estiver sendo desenhado incluir metadados de layout (que normalmente só são definidos na saída do circuito das chamadas transpile() ), então, por padrão, esse layout será mostrado no diagrama. Isso é feito para todos os back-ends de gaveta de circuito. Por exemplo:

    from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile

qr = QuantumRegister(2, 'userqr')
cr = ClassicalRegister(2, 'c0')
qc = QuantumCircuit(qr, cr)
qc.h(qr[0])
qc.cx(qr[0], qr[1])
qc.y(qr[0])
qc.x(qr[1])
qc.measure(qr, cr)

# Melbourne coupling map
coupling_map = [[1, 0], [1, 2], [2, 3], [4, 3], [4, 10], [5, 4],
                [5, 6], [5, 9], [6, 8], [7, 8], [9, 8], [9, 10],
                [11, 3], [11, 10], [11, 12], [12, 2], [13, 1],
                [13, 12]]
qc_result = transpile(qc, basis_gates=['u1', 'u2', 'u3', 'cx', 'id'],
                      coupling_map=coupling_map, optimization_level=0)
qc.draw(output='text')

    produzirá um diagrama como:

                      ┌──────────┐┌──────────┐┌───┐┌──────────┐┌──────────────────┐┌─┐
   (userqr0) q0|0>┤ U2(0,pi) ├┤ U2(0,pi) ├┤ X ├┤ U2(0,pi) ├┤ U3(pi,pi/2,pi/2) ├┤M├───
                  ├──────────┤└──────────┘└─┬─┘├──────────┤└─┬─────────────┬──┘└╥┘┌─┐
   (userqr1) q1|0>┤ U2(0,pi) ├──────────────■──┤ U2(0,pi) ├──┤ U3(pi,0,pi) ├────╫─┤M├
                  └──────────┘                 └──────────┘  └─────────────┘    ║ └╥┘
  (ancilla0) q2|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
  (ancilla1) q3|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
  (ancilla2) q4|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
  (ancilla3) q5|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
  (ancilla4) q6|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
  (ancilla5) q7|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
  (ancilla6) q8|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
  (ancilla7) q9|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
 (ancilla8) q10|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
 (ancilla9) q11|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
(ancilla10) q12|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
(ancilla11) q13|0>──────────────────────────────────────────────────────────────╫──╫─
                                                                                ║  ║
          c0_0: 0 ══════════════════════════════════════════════════════════════╩══╬═
                                                                                   ║
          c0_1: 0 ═════════════════════════════════════════════════════════════════╩═

    Se você não quiser que o layout seja mostrado em circuitos transpilados (ou em qualquer outro circuito com um layout definido), há um novo kwarg booleano para ambas as funções, with_layout (cujo padrão é True), que, quando definido como False , desabilitará a anotação do layout nos circuitos de saída.

  • Uma nova passagem de análise CountOpsLongest foi adicionada para recuperar o número de operações no caminho mais longo do DAGCircuit. Quando usado, ele adicionará uma chave count_ops_longest_path ao dicionário do conjunto de propriedades. Você pode adicioná-lo ao seu gerenciador de senhas com algo como:

    from qiskit.transpiler.passes import CountOpsLongestPath
from qiskit.transpiler.passes import CxCancellation
from qiskit.transpiler import PassManager

pm = PassManager()
pm.append(CountOpsLongestPath())

    e, em seguida, acessar o caminho mais longo por meio do valor definido pela propriedade com algo como:

    pm.append(
    CxCancellation(),
    condition=lambda property_set: property_set[
        'count_ops_longest_path'] < 5)

    que definirá uma condição para essa passagem com base no caminho mais longo.

  • Duas novas funções, sech() e sech_deriv() , foram adicionadas ao módulo da biblioteca de pulsos qiskit.pulse.pulse_lib para criar um objeto secante hiperbólico não normalizado SamplePulse e um objeto secante hiperbólico não normalizado derviativo SamplePulse , respectivamente.

  • Uma nova opção kwarg vertical_compression foi adicionada ao método QuantumCircuit.draw() e à função qiskit.visualization.circuit_drawer() . Essa opção só funciona com o backend text . Essa opção pode ser definida como high, medium (o padrão) ou low para ajustar a quantidade de espaço vertical usada pela visualização de saída.

  • Uma nova opção booleana kwarg idle_wires foi adicionada ao método QuantumCircuit.draw() e à função qiskit.visualization.circuit_drawer() . Funciona para todos os back-ends de gaveta. Quando idle_wires for definido como False em uma chamada de gaveta, a gaveta não extrairá nenhum bit que não tenha nenhum elemento de circuito na visualização do circuito quântico de saída.

  • Foi adicionada uma nova função de visualização PassManager qiskit.visualization.pass_mamanger_drawer() . Essa função recebe um objeto PassManager e gera um diagrama de controle de fluxo de todos os passes executados no PassManager.

  • Ao criar um PassManager, agora você pode especificar uma função de retorno de chamada que, se especificada, será executada após a execução de cada passagem. Essa função recebe um conjunto de kwargs em cada chamada com o estado do gerenciador de passes após a execução de cada passe. Atualmente, esses kwargs são:

    • pass_ (Pass): o passe que está sendo executado
    • dag (DAGCircuit): a saída de dados da passagem
    • time (float): o tempo para executar o passe
    • property_set (PropertySet): o conjunto de propriedades
    • count (int): o índice para a execução do passe

    No entanto, vale a pena observar que, embora esses argumentos estejam definidos para a versão 0.9, eles expõem os aspectos internos do gerenciador de passes e estão sujeitos a alterações em versões futuras.

    Por exemplo, você pode usar isso para criar uma função de retorno de chamada que visualizará a saída do circuito após a execução de cada passagem:

    from qiskit.transpiler import PassManager

def my_callback(**kwargs):
    print(kwargs['dag'])

pm = PassManager(callback=my_callback)

    Além disso, você pode especificar a função de retorno de chamada ao usar qiskit.compiler.transpile():

    from qiskit.compiler import transpile

def my_callback(**kwargs):
    print(kwargs['pass'])

transpile(circ, callback=my_callback)

  • Um novo método filter() foi adicionado à classe qiskit.pulse.Schedule . Isso permite filtrar as instruções em um cronograma. Por exemplo, filtrar por tipo de instrução:

    from qiskit.pulse import Schedule
from qiskit.pulse.commands import Acquire
from qiskit.pulse.commands import AcquireInstruction
from qiskit.pulse.commands import FrameChange

sched = Schedule(name='MyExperiment')
sched.insert(0, FrameChange(phase=-1.57)(device))
sched.insert(60, Acquire(5))
acquire_sched = sched.filter(instruction_types=[AcquireInstruction])

  • Métodos de decomposição adicionais para vários tipos de portas. Esses métodos usarão diferentes técnicas de decomposição para dividir uma porta em uma sequência de CNOTs e portas de qubit único. São adicionados os seguintes métodos:

    Método
    Descrição
    QuantumCircuit.iso()Adicione uma isometria arbitrária de m a n qubits a um circuito. Isso permite anexar unitários arbitrários em n qubits (m=n) ou preparar qualquer estado de n qubits ( m=0 )
    QuantumCircuit.diag_gate()Adicione uma porta diagonal ao circuito
    QuantumCircuit.squ()Decomponha uma 2x2 unitária arbitrária em três portas de rotação e adicione-a a um circuito
    QuantumCircuit.ucg()Anexar uma porta controlada uniformemente (também chamada de porta multiplexada) a um circuito
    QuantumCircuit.ucx()Anexe uma porta de rotação Rx uniformemente controlada (também chamada de multiplexada) a um circuito
    QuantumCircuit.ucy()Anexe uma porta de rotação Ry uniformemente controlada (também chamada de multiplexada) a um circuito
    QuantumCircuit.ucz()Anexe uma porta de rotação Rz uniformemente controlada (também chamada de multiplexada) a um circuito

  • Adição dos algoritmos Gray-Synth e Patel-Markov-Hayes para síntese de circuitos lineares CNOT-Phase e CNOT-only. Essas funções permitem a síntese de circuitos que consistem apenas em portas CNOT com uma função linear ou um circuito que consiste apenas em portas CNOT e de fase com uma descrição de matriz.

  • Uma nova função random_circuit foi adicionada ao módulo qiskit.circuit.random . Essa função gerará um circuito aleatório de um tamanho especificado, selecionando aleatoriamente diferentes portas e adicionando-as ao circuito. Por exemplo, você pode usar isso para gerar um circuito de 5 qubits com uma profundidade de 10 usando:

    from qiskit.circuit.random import random_circuit

circ = random_circuit(5, 10)

  • Um novo kwarg output_names foi adicionado à função qiskit.compiler.transpile() . Esse kwarg recebe uma string ou uma lista de strings e as utiliza como o valor do nome do circuito para os circuitos de saída que são retornados pela chamada transpile() . Por exemplo:

    from qiskit.compiler import transpile
my_circs = [circ_a, circ_b]
tcirc_a, tcirc_b = transpile(my_circs,
                             output_names=['Circuit A', 'Circuit B'])

    o atributo name em tcirc_a e tcirc_b será 'Circuit A' e 'Circuit B' , respectivamente.

  • Um novo método equiv() foi adicionado às classes qiskit.quantum_info.Operator e qiskit.quantum_info.Statevector . Esses métodos são usados para verificar se um segundo objeto Operator ou Statevector é equivalente até a fase global.

  • O arquivo de configuração do usuário tem várias opções novas:

    • O campo circuit_drawer agora aceita um valor automático. Quando definido como o valor do campo circuit_drawer , o backend de gaveta padrão será o mpl, se estiver disponível; caso contrário, será usado o backend de texto.
    • Um novo campo circuit_mpl_style pode ser usado para definir o estilo padrão usado pela gaveta de circuito do matplotlib. Os valores válidos para esse campo são bw e default para definir o padrão como preto e branco ou o estilo de cor padrão, respectivamente.
    • Um novo campo transpile_optimization_level pode ser usado para definir o nível de otimização padrão do transpilador a ser usado nas chamadas para qiskit.compiler.transpile(). O valor pode ser definido como 0, 1, 2 ou 3.

  • Introduziu um novo comando de pulso Delay que pode ser inserido em um pulso Schedule. Esse comando aceita um duration e pode ser adicionado a qualquer Channel. Outros comandos não podem ser programados em um canal durante um atraso.

    O atraso pode ser adicionado como qualquer outro comando de pulso. Por exemplo:

    from qiskit import pulse

drive_channel = pulse.DriveChannel(0)
delay = pulse.Delay(20)

sched = pulse.Schedule()
sched += delay(drive_channel)

Notas da Atualização

  • O módulo qiskit._util , anteriormente obsoleto, foi removido. qiskit.util deve ser usado em seu lugar.

  • O método QuantumCircuit.count_ops() agora retorna um objeto OrderedDict em vez de um dict. Isso deve ser compatível com a maioria dos casos de uso, pois OrderedDict é uma subclasse de dict . No entanto, as verificações de tipo e outras verificações de classe talvez precisem ser atualizadas.

  • O método DAGCircuit.width() agora retorna o número total de bits quânticos e clássicos. Antes, ele retornava apenas o número de bits quânticos. Se você precisar apenas do número de bits quânticos, poderá usar DAGCircuit.num_qubits() .

  • A função DAGCircuit.num_cbits() foi removida. Em vez disso, você pode usar DAGCircuit.num_clbits().

  • Os bits quânticos individuais e os bits clássicos não são mais representados como (register, index) tuples. Elas agora são instâncias das classes Qubit e Clbit. Se estiver lidando com bits individuais, certifique-se de atualizar qualquer uso ou verificação de tipo para procurar essas novas classes em vez de tuplas.

  • As classes de gerenciador de passes predefinidas qiskit.transpiler.preset_passmanagers.default_pass_manager e qiskit.transpiler.preset_passmanagers.default_pass_manager_simulator (que eram os gerenciadores de passes padrão anteriores para chamadas qiskit.compiler.transpile() ) foram removidas. Se você estava usando manualmente esse gerenciador de passes, mude para o novo padrão, qiskit.transpile.preset_passmanagers.level1_pass_manager.

  • O passe LegacySwap foi removido. Se você o estava usando em um gerenciador de passes personalizado, seu uso pode ser substituído pelo passe StochasticSwap , que é uma versão mais rápida e estável. Todos os gerenciadores de passes predefinidos foram atualizados para usar o StochasticSwap pass em vez do LegacySwap.

  • Os seguintes métodos obsoletos do site qiskit.dagcircuit.DAGCircuit foram removidos:

    • DAGCircuit.get_qubits() - Em vez disso, use DAGCircuit.qubits()

    • DAGCircuit.get_bits() - Em vez disso, use DAGCircuit.clbits()

    • DAGCircuit.qasm() - Use uma combinação de qiskit.converters.dag_to_circuit() e QuantumCircuit.qasm(). Por exemplo:

      from qiskit.dagcircuit import DAGCircuit
from qiskit.converters import dag_to_circuit
my_dag = DAGCircuit()
qasm = dag_to_circuit(my_dag).qasm()

    • DAGCircuit.get_op_nodes() - Em vez disso, use DAGCircuit.op_nodes() . Observe que o tipo de retorno é uma lista de objetos DAGNode para op_nodes() em vez da lista de tuplas retornada anteriormente por get_op_nodes().

    • DAGCircuit.get_gate_nodes() - Em vez disso, use DAGCircuit.gate_nodes() . Observe que o tipo de retorno é uma lista de objetos DAGNode para gate_nodes() em vez da lista de tuplas retornada anteriormente por get_gate_nodes().

    • DAGCircuit.get_named_nodes() - Em vez disso, use DAGCircuit.named_nodes() . Observe que o tipo de retorno é uma lista de objetos DAGNode para named_nodes() em vez da lista de node_ids retornada anteriormente por get_named_nodes().

    • DAGCircuit.get_2q_nodes() - Em vez disso, use DAGCircuit.twoQ_gates() . Observe que o tipo de retorno é uma lista de objetos DAGNode para twoQ_gates() em vez da lista de data_dicts retornada anteriormente por get_2q_nodes().

    • DAGCircuit.get_3q_or_more_nodes() - Em vez disso, use DAGCircuit.threeQ_or_more_gates() . Observe que o tipo de retorno é uma lista de objetos DAGNode para threeQ_or_more_gates() em vez da lista de tuplas retornada anteriormente por get_3q_or_more_nodes().

  • Os seguintes métodos do site qiskit.dagcircuit.DAGCircuit tinham suporte obsoleto para aceitar um node_id como parâmetro. Isso foi removido e agora somente os objetos DAGNode são aceitos como entrada:

    • successors()
    • predecessors()
    • ancestors()
    • descendants()
    • bfs_successors()
    • quantum_successors()
    • remove_op_node()
    • remove_ancestors_of()
    • remove_descendants_of()
    • remove_nonancestors_of()
    • remove_nondescendants_of()
    • substitute_node_with_dag()

  • O método qiskit.dagcircuit.DAGCircuit rename_register() foi removido. Isso não foi usado por todo o código do qiskit. Se você estava confiando nela externamente, terá que reimplementá-la como uma função externa.

  • A propriedade qiskit.dagcircuit.DAGCircuit multi_graph foi removida. O acesso direto ao objeto networkx multi_graph subjacente não é mais suportado. Em vez disso, deve ser usada a API fornecida pela classe DAGCircuit .

  • A classe de exceção obsoleta qiskit.qiskiterror.QiskitError foi removida. Em vez disso, você deve usar qiskit.exceptions.QiskitError.

  • Os kwargs booleanos, ignore_requires e ignore_preserves do construtor qiskit.transpiler.PassManager foram removidos. Essas opções não são mais válidas.

  • O módulo qiskit.tools.logging foi removido. Esse módulo não foi usado por nada e não acrescentou nada às interfaces que o módulo logging da biblioteca padrão do Python fornece. Se quiser definir um formatador personalizado para o registro, use o módulo logging da biblioteca padrão.

  • A classe CompositeGate foi removida. Em vez disso, você deve criar diretamente um objeto de instrução a partir de um circuito e anexá-lo ao seu circuito. Por exemplo, você pode executar algo como:

    custom_gate_circ = qiskit.QuantumCircuit(2)
custom_gate_circ.x(1)
custom_gate_circ.h(0)
custom_gate_circ.cx(0, 1)
custom_gate = custom_gate_circ.to_instruction()

  • Os kwargs anteriormente obsoletos, seed e config para qiskit.compiler.assemble() foram removidos; em vez disso, use seed_simulator e run_config , respectivamente.

  • Os conversores anteriormente obsoletos qiskit.converters.qobj_to_circuits() e qiskit.converters.circuits_to_qobj() foram removidos. Em vez disso, use qiskit.assembler.disassemble() e qiskit.compiler.assemble() , respectivamente.

  • O kwarg seed_mapper anteriormente obsoleto para qiskit.compiler.transpile() foi removido. Em vez disso, você deve usar seed_transpiler

  • Os kwargs anteriormente obsoletos seed, seed_mapper, config e circuits para a função qiskit.execute() foram removidos. Em vez disso, use os argumentos seed_simulator, seed_transpiler, run_config e experiments , respectivamente.

  • O módulo qiskit.tools.qcvv , anteriormente obsoleto, foi removido; em vez disso, use o qiskit-ignis.

  • As funções anteriormente obsoletas qiskit.transpiler.transpile() e qiskit.transpiler.transpile_dag() foram removidas. Em vez disso, você deve usar qiskit.compiler.transpile. Se você estava usando transpile_dag() , isso pode ser substituído por running:

    circ = qiskit.converters.dag_to_circuit(dag)
out_circ = qiskit.compiler.transpile(circ)
qiskit.converters.circuit_to_dag(out_circ)

  • A função anteriormente obsoleta qiskit.compile() foi removida; em vez disso, você deve usar qiskit.compiler.transpile() e qiskit.compiler.assemble().

  • A mágica de célula do jupyter %%qiskit_progress_bar de qiskit.tools.jupyter foi alterada para uma mágica de linha. Isso foi feito para refletir melhor como a mágica é usada e como ela funciona. Se estiver usando a mágica de célula %%qiskit_progress_bar em um bloco de notas existente, será necessário atualizá-la para ser uma mágica de linha, alterando-a para %qiskit_progress_bar . Todo o resto deve se comportar de forma idêntica.

  • A função obsoleta qiskit.tools.qi.qi.random_unitary_matrix() foi removida. Em vez disso, você deve usar a função qiskit.quantum_info.random.random_unitary() .

  • A função obsoleta qiskit.tools.qi.qi.random_density_matrix() foi removida. Em vez disso, você deve usar a função qiskit.quantum_info.random.random_density_matrix() .

  • A função obsoleta qiskit.tools.qi.qi.purity() foi removida. Em vez disso, você deve usar a função qiskit.quantum_info.purity() .

  • O método obsoleto QuantumCircuit._attach() foi removido. Em vez disso, você deve usar QuantumCircuit.append() .

  • O método qiskit.qasm.Qasm get_filename() foi removido. Em vez disso, você pode usar o método return_filename() .

  • O módulo obsoleto qiskit.mapper foi removido. A lista de funções e classes com suas alternativas é a seguinte:

    • qiskit.mapper.CouplingMap: qiskit.transpiler.CouplingMap deve ser usado em seu lugar.
    • qiskit.mapper.Layout: qiskit.transpiler.Layout deve ser usado em seu lugar
    • qiskit.mapper.compiling.euler_angles_1q(): qiskit.quantum_info.synthesis.euler_angles_1q() deve ser usado em seu lugar
    • qiskit.mapper.compiling.two_qubit_kak(): qiskit.quantum_info.synthesis.two_qubit_cnot_decompose() deve ser usado em seu lugar.

    As classes de exceção obsoletas qiskit.mapper.exceptions.CouplingError e qiskit.mapper.exceptions.LayoutError não têm uma alternativa, pois não servem para nada sem um módulo qiskit.mapper .

  • O módulo qiskit.pulse.samplers foi movido para qiskit.pulse.pulse_lib.samplers. Você precisará atualizar as importações de qiskit.pulse.samplers para qiskit.pulse.pulse_lib.samplers.

  • o seaborn agora é uma dependência da função qiskit.visualization.plot_state_qsphere(). Ele é necessário para gerar mapas de cores angulares adequados para a visualização. O alvo de instalação de extras qiskit-terra[visualization] foi atualizado para instalar seaborn>=0.9.0 . Se você estiver usando visualizações e especificamente a função plot_state_qsphere() , poderá usá-la para instalar seaborn ou simplesmente executar manualmente pip install seaborn>=0.9.0

  • As funções anteriormente obsoletas qiksit.visualization.plot_state e qiskit.visualization.iplot_state foram removidas. Em vez disso, você deve usar a função específica para cada tipo de gráfico. Você pode consultar as tabelas a seguir para mapear as funções obsoletas para as novas funções equivalentes:

    Qiskit Terra 0.6
    Qiskit Terra 0.7 +
    plot_state(rho)plot_state_city(rho)
    plot_state(rho, method='city')plot_state_city(rho)
    plot_state(rho, method='paulivec')plotagem_estado_paulivec(rho)
    plot_state(rho, method='qsphere')plotar_estado_qsphere(rho)
    plot_state(rho, method='bloch')plot_bloch_multivector(rho)
    plot_state(rho, method='hinton')plot_state_hinton(rho)

  • As dependências pylatexenc e pillow para os back-ends de gaveta de circuito latex e latex_source não estão mais listadas como requisitos. Se você for usar as gavetas de circuito latex, certifique-se de ter os dois pacotes instalados ou use os extras do setuptools para instalá-los junto com o qiskit-terra:

    pip install qiskit-terra[visualization]

  • A raiz do namespace qiskit agora emitirá um aviso na importação se não for possível configurar o qiskit.IBMQ ou o qiskit.Aer . Isso ocorrerá sempre que qualquer coisa no espaço de nomes qiskit for importada. Esses avisos foram adicionados para deixar claro para os usuários que eles estão executando o qiskit e os pacotes qiskit-aer e qiskit-ibmq-provider não puderam ser encontrados. Nem sempre fica claro se os pacotes estão faltando ou se o python packaging/pip instalou um elemento incorretamente até que você vá usá-los e receba um ImportError vazio. Esses avisos devem deixar claro desde o início se esses aliases comumente usados estiverem faltando.

    No entanto, para os usuários que optarem por não usar o qiskit-aer ou o qiskit-ibmq-provider, isso poderá causar ruído adicional. Para esses usuários, esses avisos podem ser facilmente suprimidos usando a biblioteca padrão do Python warnings. Os usuários podem suprimir os avisos colocando essas duas linhas antes de qualquer importação do qiskit:

    import warnings
warnings.filterwarnings('ignore', category=RuntimeWarning,
                        module='qiskit')

    Isso suprimirá os avisos emitidos por não ter o qiskit-aer ou o qiskit-ibmq-provider instalados, mas ainda preservará quaisquer outros avisos emitidos pelo qiskit ou por qualquer outro pacote.

Notas de descontinuação

  • As portas U e CX foram descontinuadas. Se estiver usando esses portões em seu código, atualize-os para usar u3 e cx . Por exemplo, se você estiver usando as funções de porta de circuito circuit.u_base() e circuit.cx_base() , deverá atualizá-las para circuit.u3() e circuit.cx() , respectivamente.

  • A porta u0 foi preterida em favor do uso de várias portas iden e será removida no futuro. Se você estiver usando a porta u0 em seu circuito, deverá atualizar suas chamadas para usar iden. Por exemplo, se você estava usando circuit.u0(2) em seu circuito antes, isso deve ser atualizado para ser:

    circuit.iden()
circuit.iden()

    Em vez disso.

  • A classe qiskit.pulse.DeviceSpecification está obsoleta agora. Em vez disso, você deve usar qiskit.pulse.PulseChannelSpec.

  • O acesso a uma classe qiskit.circuit.Qubit, qiskit.circuit.Clbit ou qiskit.circuit.Bit por índice está obsoleto (para compatibilidade com as tuplas (register, index) que essas classes substituíram). Em vez disso, você deve usar os atributos register e index .

  • A transmissão de um bit para o método qiskit.QuantumCircuit append como uma tupla (register, index) está obsoleta. Em vez disso, os objetos de bits devem ser usados diretamente.

  • O acesso aos elementos de um objeto qiskit.transpiler.Layout com uma tupla (register, index) está obsoleto. Em vez disso, um objeto de bit deve ser usado diretamente.

  • O método do construtor qiskit.transpiler.Layout qiskit.transpiler.Layout.from_tuplelist() está obsoleto. Em vez disso, o construtor qiskit.transpiler.Layout.from_qubit_list() deve ser usado.

  • O módulo qiskit.pulse.ops foi descontinuado. Todas as funções que ele oferecia:

    • union
    • flatten
    • shift
    • insert
    • append

    têm métodos equivalentes disponíveis diretamente nas classes qiskit.pulse.Schedule e qiskit.pulse.Instruction . Em vez disso, esses métodos devem ser usados.

  • O método qiskit.qasm.Qasm get_tokens() está obsoleto. Em vez disso, você deve usar o método generate_tokens() .

  • O método qiskit.qasm.qasmparser.QasmParser get_tokens() está obsoleto. Em vez disso, você deve usar o método read_tokens() .

  • O método as_dict() da classe Qobj foi preterido e será removido no futuro. Em vez disso, você deve substituir as chamadas para ele por to_dict() .

Correções de bugs

  • A definição do CU3Gate foi alterada para ser equivalente à definição canônica de um U3Gate controlado.

  • O tratamento do layout no gerenciador de passes foi padronizado. Isso corrige vários problemas relatados com o manuseio do layout. O parâmetro initial_layout kwarg em qiskit.compiler.transpile() e qiskit.execute() agora disporá seus qubits do circuito nos qubits desejados no dispositivo ao transpilar circuitos.

  • O suporte a unidades de n-qubit foi adicionado ao simulador BasicAer e unitary (portas unitárias arbitrárias) foi adicionado ao conjunto de portas de base para os simuladores

  • O site qiskit.visualization.plost_state_qsphere() foi atualizado para corrigir vários problemas. Agora, a visualização de saída do Q Sphere será gerada corretamente e os seguintes aspectos foram atualizados:

    • Todos os estados de base complementares são antipodais

    • A fase é indicada pela cor da linha e do marcador na superfície da esfera

    • A probabilidade é indicada pela translucidez da linha e pelo volume do marcador em

      superfície da esfera

Outras observações

  • O padrão PassManager para qiskit.compiler.transpile() e qiskit.execute() foi alterado para o gerenciador de passes de nível 1 de otimização definido em qiskit.transpile.preset_passmanagers.level1_pass_manager.

  • Todos os back-ends de desenho de circuito agora expressarão os parâmetros de porta em um circuito como frações comuns de pi na visualização de saída. Se o valor de um parâmetro puder ser expresso como uma fração de pi, isso será usado em vez do equivalente numérico.

  • Ao usar qiskit.assembler.assemble_schedules() , se você não fornecer o número de memory_slots a serem usados, o número será inferido com base no número de aquisições nas programações de entrada.

  • O aviso de depreciação da propriedade qiskit.dagcircuit.DAGCircuit node_counter foi removido. A mudança de comportamento sobre a qual o aviso está sendo alertado foi colocada em vigor quando o aviso foi adicionado, portanto, alertar que a mudança não serviu para nada.

  • As chamadas para PassManager.run() agora emitirão mensagens de registro do Python no nível INFO para cada execução de passagem. Essas mensagens incluirão o nome do passe e o tempo total de execução do passe. Python foi usado porque permite que o registro de log do Qiskit-Terra se integre de forma padrão a outros aplicativos e bibliotecas. Todo o registro para o transpilador ocorre no espaço de nomes qiskit.transpiler , conforme usado por logging.getLogger('qiskit.transpiler). Por exemplo, para ativar o registro de nível DEBUG para o transpilador, você pode executar:

    import logging

logging.basicConfig()
logging.getLogger('qiskit.transpiler').setLevel(logging.DEBUG)

    que definirá o nível de registro do transpilador como DEBUG e configurará essas mensagens para serem impressas no stderr.

Aer 0.3

  • Há um novo Simulador de Matriz de Densidade de alto desempenho que pode ser usado em conjunto com nossos modelos de ruído, para simular melhor os cenários do mundo real.
  • Adicionamos um simulador de MPS (Matrix Product State). O MPS permite a simulação eficiente de várias classes de circuitos quânticos, mesmo na presença de correlações fortes e estados altamente emaranhados. Para os casos passíveis de MPS, os circuitos com várias centenas de qubits ou mais podem ser simulados com exatidão, por exemplo, com o objetivo de obter valores de expectativa de observáveis.
  • Os instantâneos podem ser executados em todos os nossos simuladores.
  • Agora também podemos medir circuitos de amostragem com erros de leitura, e não apenas circuitos ideais.
  • Aumentamos algumas otimizações de circuito com a presença de ruído.
  • Foram incluídas aproximações de erro de 2 qubit melhores.
  • Incluímos algumas ferramentas para facilitar a criação e acelerar a simulação de determinadas simulações com ruídos.
  • Aumento do desempenho com simulações que exigem menos precisão numérica de ponto flutuante.

Ignis 0.2

Novos Recurso

Correções de bugs

  • Correção de um bug no erro de ajuste de RB
  • Correção de um erro no ajustador de caracterização ao selecionar um índice de qubit para ajustar

Outras observações

  • A atenuação da medição agora opera em paralelo quando aplicada a vários resultados
  • Os valores de estimativa para os instaladores de RB foram aprimorados

Aqua 0.6

Incluído

  • Portas de Toffoli de fase relativa rccx (com 2 controles) e rcccx (com 3 controles).

  • Forma de variação RYCRX

  • Um novo modo 'basic-no-ancilla' para mct.

  • As portas de rotação multicontroladas mcrx, mcry e mcrz como uma porta geral u3 não são compatíveis com a implementação do código cinza

  • Química: Suporte de concha aberta ROHF

    • Compatível com todos os drivers: Gaussian16, PyQuante, PySCF e PSI4
    • HartreeFock o estado inicial, a forma variacional UCCSD e a redução de dois qubits para mapeamento de paridade agora suportam diferentes números de partículas alfa e beta para suporte de casca aberta

  • Química: Suporte de concha aberta UHF

    • Compatível com todos os drivers: Gaussian16, PyQuante, PySCF e PSI4
    • QMolecule ampliado para incluir integrais, coeficientes etc. para beta separado

  • Química: QMolecule estendido com integrais na base orbital atômica para facilitar o acesso comum a elas para experimentação

    • Compatível com todos os drivers: Gaussian16, PyQuante, PySCF e PSI4

  • Química: Configuração adicional dos drivers PyQuante e PySCF

    • Controles de tolerância de convergência e de iteração de convergência máxima.
    • Para PySCF escolha do palpite inicial

  • Química: Saída de processamento adicionada ao registro de depuração dos cálculos de PyQuante e PySCF (as saídas de Gaussian16 e PSI4 já foram adicionadas ao registro de depuração)

  • Química: Fusão do qiskit-chemistry com o qiskit-aqua

  • Adicione as classes MatrixOperator, WeightedPauliOperator e TPBGroupedPauliOperator .

  • Adicione a função evolution_instruction para obter instruções sem registro da evolução do tempo.

  • Adicione o módulo op_converter para unificar o local responsável pela conversão de diferentes tipos de operadores.

  • Adicione a classe Z2Symmetries para encapsular as informações de simetrias do Z2 e tenha métodos auxiliares para afunilar um Operador.

  • Estimativa de amplitude: adicionados o pós-processamento de máxima verossimilhança e o cálculo do intervalo de confiança.

  • Estimativa de amplitude de máxima verossimilhança (MLAE): Implementou um novo algoritmo para estimativa de amplitude com base na estimativa de máxima verossimilhança, o que reduz o número de qubits necessários e a profundidade do circuito.

  • Adicionados circuitos de rotação de Paul (por partes) controlados linearmente e polinomialmente.

  • Adicione q_equation_of_motion para estudar o estado excitado de uma molécula e adicione dois algoritmos para preparar o estado de referência.

Alterado

  • Aprimore o modo 'basic' do mctusando portas Toffoli de fase relativa para criar resultados intermediários.
  • Adapte-se à recém-introduzida classe Qubit da Qiskit Terra.
  • Impedir que o site QPE/IQPE modifique os objetos de entrada Operator .
  • A dependência de PyEDA foi removida; as operações lógicas subjacentes dos oráculos correspondentes agora são tratadas por SymPy.
  • Refatorar a classe Operator , cada representação tem sua própria classe MatrixOperator, WeightedPauliOperator e TPBGroupedPauliOperator.
  • O power em evolution_instruction foi aplicado diretamente no theta da porta CRZ; a nova versão repete os circuitos para implementar a potência.
  • CircuitCache é OFF por padrão e pode ser definido por meio da variável de ambiente now QISKIT_AQUA_CIRCUIT_CACHE.

Correções de bugs

  • Um erro que fazia com que o site TruthTableOracle criasse circuitos incorretos para tabelas verdadeiras com apenas um único valor 1 .
  • Um bug causado pelo indeterminismo do PyEDA.
  • Um erro no cálculo de tradução e extensão do site QPE/IQPE.
  • Química: Mapeamento de Bravyi-Kitaev corrigido quando o número de qubits não era uma potência de 2
  • Configure initial_layout em QuantumInstance por meio de uma lista.

Removido

  • A porta de rotação geral multicontrolada mcu3 é removida e substituída por portas de rotação multicontrolada mcrx, mcry, e mcrz

Descontinuado

  • A classe Operator está obsoleta, em favor do uso de MatrixOperator, WeightedPauliOperator e TPBGroupedPauliOperator.

IBM 0.3

Nenhuma mudança

Esta página foi útil?
Relate um bug, erro de digitação ou solicite conteúdo no GitHub.