Skip to main content
IBM Quantum Platform

Note di rilascio di Qiskit 0.37

0.37.2

Terra 0.21.2

Preludio

Qiskit Terra 0.21.2 è una release che si occupa principalmente di correggere i bug e contiene anche diverse pagine di documentazione migliorate.

Correzioni di bug

  • aer_simulator_statevector_gpu sarà ora riconosciuto correttamente come metodo statevector in alcune funzioni quando si utilizzano i simulatori GPU di Qiskit Aer in QuantumInstance e altri runner di algoritmi.

  • Corretto il metodo UCGate.inverse() che in precedenza non invertiva la fase globale.

  • QuantumCircuit.compose() funzionerà correttamente se usato con l'argomento inplace=True all'interno di contesti di costruzione di flussi di controllo. In precedenza le istruzioni venivano aggiunte al di fuori dell'ambito del flusso di controllo. Corretto #8433.

  • È stato corretto un bug per cui un'espressione vincolata ParameterExpression non veniva identificato come reale se symengine era installato e l'espressione bound non era un semplice 1j. Ad esempio:

    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

  • Corretta la serializzazione e la deserializzazione di QPY per i controlli ControlledGate con controlli aperti (cioè quelli il cui ctrl_state non è tutto uno). Corretto #8549.

  • Tutti i falsi backend in qiskit.providers.fake_provider.backends sono stati aggiornati per restituire i corrispondenti oggetti canale di impulsi con le chiamate ai metodi drive_channel(), measure_channel(), acquire_channel(), control_channel().

  • Supporto fisso per l'esecuzione di Z2Symmetries.taper() su problemi più grandi. In precedenza, il metodo richiedeva un'elevata quantità di memoria, che in genere causava fallimenti per i problemi più grandi. Come effetto collaterale di questa correzione, le prestazioni sono notevolmente migliorate.

Aer 0.10.4

Nessuna modifica

IBM Q Fornitore 0.19.2

Nessuna modifica

0.37.1

Terra 0.21.1

Correzioni di bug

  • Corretto un problema nel metodo QuantumCircuit.decompose() quando si passa un elenco di classi Gate per l'argomento gates_to_decompose . Se una qualsiasi porta del circuito aveva un'etichetta impostata, questo argomento non veniva gestito correttamente e la decomposizione in uscita saltava erroneamente le porte esplicitamente presenti nell'elenco gates_to_decompose .

  • Correggere to_instruction() che in precedenza cercava di creare un operatore UnitaryGate senza esponenziare l'operatore da evolvere. Poiché questo operatore non è generalmente unitario, si è verificato un errore (e se per caso l'operatore fosse stato unitario, non sarebbe stato il risultato atteso).

    Ora, chiamando to_instruction() produce correttamente un gate che implementa l'evoluzione temporale dell'operatore che contiene:

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

  • Corretto un problema con la funzione marginal_distribution() : quando veniva passato un array numpy per l'argomento indices , la funzione sollevava un errore. Corretto #8283

  • In precedenza non era possibile unire un oggetto CircuitStateFn che è stato costruito a partire da a VectorStateFn. Questo perché il vettore di stato è stato convertito in un circuito con l'istruzione Initialize , che non è unitaria. Questo problema viene ora risolto utilizzando l'istruzione StatePreparation che può essere utilizzata poiché si presume che lo stato parta dallo stato di tutti 0.

    Ad esempio, ora possiamo fare:

    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!

  • Correzione di un bug nelle classi Optimizer in cui la ricostruzione di una nuova istanza di ottimizzatore da un'istanza precedentemente esistente settings ripristinava le impostazioni predefinite del nuovo e del precedente ottimizzatore. Questo ha portato a un bug se gli oggetti Optimizer fossero inviati come input ai programmi Qiskit Runtime.

    Ora gli oggetti dell'ottimizzatore sono ricostruiti correttamente:

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

  • È stato risolto un problema per cui l'argomento limit_amplitude su un singolo SymbolicPulse o Waveform non veniva riflesso correttamente dalla validazione dei parametri. Inoltre, il programma QPY dump() è stato corretto per memorizzare correttamente il valore di limit_amplitude legato all'istanza, invece di salvare la variabile globale della classe.

  • Fissare la struttura di entanglement a coppie per NLocal circuiti. Questo ha portato a un bug nel file ZZFeatureMapin cui l'uso di entanglement="pairwise" generava un errore. Ora produce correttamente la mappa delle caratteristiche desiderata:

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

    Le stampe di cui sopra:

         ┌───┐┌─────────────┐
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 ├──────────────────────────────────────────
     └───┘└─────────────┘└───┘└──────────────────────────────┘└───┘

  • Corretto un problema nella gestione della fase globale della classe UCGate classe.

Aer 0.10.4

Nessuna modifica

IBM Q Fornitore 0.19.2

Nessuna modifica

0.37.0

Questo rilascio segna ufficialmente la fine del supporto al progetto Qiskit Ignis da parte di Qiskit. È stato originariamente deprecato nella release 0.33.0 e, come documentato in quella release, il pacchetto qiskit-ignis è stato rimosso dal metapacchetto Qiskit, il che significa che nella futura release pip install qiskit non includerà più qiskit-ignis. Tuttavia, a causa di limitazioni nella pacchettizzazione di python, non possiamo rimuovere automaticamente un'installazione preesistente di qiskit-ignis. Se si effettua l'aggiornamento da una versione precedente, si consiglia di disinstallare manualmente Qiskit Ignis con pip uninstall qiskit-ignis o di installare il metapacchetto in un ambiente python nuovo.

Qiskit Ignis è stato superato dal progetto Qiskit Experiments. Per i dettagli su come passare da Qiskit Ignis a Qiskit Experiments, puoi fare riferimento alla guida alla migrazione.

Terra 0.21.0

Preludio

I punti salienti del rilascio di Qiskit 0.21.0 sono:

  • Supporto per la serializzazione di un impulso ScheduleBlock tramite qiskit.qpy. Il formato QPY è stato aggiornato alla versione 5, che include una definizione per l'inclusione delle tabelle degli impulsi. A supporto di ciò, è stata introdotta una nuova classe SymbolicPulse per consentire la definizione di forme d'onda parametriche tramite espressioni simboliche.
  • Miglioramenti al lavoro con i gestori di pass preimpostati. Una nuova funzione generate_preset_pass_manager() consente di generare facilmente un gestore di passaggi equivalente a quello che transpile() verrà utilizzato internamente. Inoltre, i gestori dei passaggi preimpostati sono ora istanze di StagedPassManager il che rende più facile la modifica delle sezioni.
  • Una rifattorizzazione della struttura dati interna dell'attributo QuantumCircuit.data dell'attributo. Prima era un elenco di tuple nella forma (instruction, qubits, clbits) e ora è un elenco di CircuitInstruction oggetti. L'accesso agli CircuitInstruction è retrocompatibile con il precedente accesso basato sulle tuple, ma con un costo di overhead in fase di esecuzione.

Inoltre, il transpiler è stato migliorato per consentire output di migliore qualità. Questo include l'introduzione di nuovi passaggi come VF2PostLayout e ToqmSwap.

Nuove funzioni

  • Aggiunta una nuova classe, qiskit.transpiler.StagedPassManager, che è una PassManager che ha una pipeline con fasi definite per eseguire la compilazione dei circuiti. Ogni fase è un PassManager che verrà eseguito in un ordine prestabilito. Ad esempio:

    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)

  • Sono stati aggiunti i metodi PauliList.group_commuting() e SparsePauliOp.group_commuting()che suddividono questi operatori in sottoelenchi in cui ogni elemento commuta con tutti gli altri. Ad esempio:

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

  • Aggiunta una nuova funzione, marginal_distribution()che viene utilizzata per marginalizzare un dizionario di bitstring in ingresso a un numero intero (come ad esempio Counts). La funzionalità è simile a quella della funzione marginal_counts() con tre differenze fondamentali. Il primo è che marginal_counts() funziona sia con un dizionario di conteggi che con un oggetto Results , mentre marginal_distribution() funziona solo con un dizionario. Il secondo è che marginal_counts() non rispetta l'ordine degli indici nel suo argomento indices , mentre lo fa e cambia i bit in uscita in base all'ordine di marginal_distribution() invece lo rispetta e permuta i bit di uscita in base all'ordine di indices . La terza differenza è che marginal_distribution() dovrebbe essere più veloce, poiché la sua implementazione è scritta in Rust e ottimizzata per la marginalizzazione di un dizionario.

  • Aggiunto l'operatore binario @ (__matmul__) alle sottoclassi di BaseOperator nel modulo qiskit.quantum_info modulo. Si tratta di un'abbreviazione per chiamare il metodo dot delle classi (A @ B == A.dot(B)).

  • Aggiunto un nuovo argomento opzionale, reps, a QuantumCircuit.decompose()che consente la scomposizione ripetuta del circuito. Ad esempio:

    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)

  • Aggiunta di una nuova classe base per gli impulsi SymbolicPulse. Questo è un sostituto del convenzionale ParametricPulseche sarà deprecato. Nella nuova classe base, le funzioni di inviluppo degli impulsi e di validazione dei parametri sono rappresentate da oggetti di espressione simbolica. La nuova classe fornisce dati sugli impulsi autonomi e portatili, poiché queste equazioni simboliche possono essere facilmente serializzate attraverso le librerie di calcolo simbolico.

  • Aggiunto il supporto per gli operatori non hermitiani in AerPauliExpectation. Ciò consente di utilizzare i rapidi calcoli dell'aspettativa istantanea di Aer in algoritmi come QEOM.

  • È stato aggiunto un nuovo stile di disegno dei circuiti, textbook, che utilizza lo schema di colori del libro di testo Qiskit.

  • Un nuovo attributo QuantumCircuit.op_start_times viene popolato quando viene eseguito uno dei passaggi di analisi di schedulazione sul circuito. Può essere utilizzato, ad esempio, per ottenere le istruzioni del circuito con il tempo di istruzione:

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

  • Aggiunto un nuovo metodo QuantumCircuit.clear() che viene utilizzato per rimuovere tutte le istruzioni da un file QuantumCircuit.

  • Aggiunto un nuovo metodo QuantumCircuit.copy_empty_like() che viene utilizzato per ottenere una copia cancellata di un'istanza di QuantumCircuit istanza. È logicamente equivalente a qc.copy().clear(), ma è molto più veloce e più efficiente in termini di memoria. Questo è utile quando si ha bisogno di un nuovo circuito vuoto con tutte le stesse risorse (qubit, bit classici, metadati e così via) già aggiunte.

  • Il metodo Target.instruction_supported() supporta ora due nuovi argomenti di parole chiave, operation_class e parameters. Utilizzando questi argomenti, il metodo instruction_supported() può essere utilizzato per verificare che una specifica operazione con i valori dei parametri sia supportata da un oggetto Target oggetto. Ad esempio, se si vuole verificare se un file Target chiamato target supporta l'esecuzione di un file RXGate con θ=π2\theta = \frac{\pi}{2}, dovreste fare qualcosa di simile:

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

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

    che restituirà True se target supporta l'esecuzione di RXGate con θ=π2\theta = \frac{\pi}{2} e False in caso contrario.

  • Aggiunto un algoritmo di evoluzione quantistica in tempo reale basato sulla Trotterizzazione qiskit.algorithms.TrotterQRTE. È conforme al nuovo quadro di evoluzione del tempo quantistico e fa uso dei parametri ProductFormula e PauliEvolutionGate implementazioni.

    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

  • Aggiunta di una nuova funzione generate_preset_pass_manager() che può essere usata per generare rapidamente un oggetto preimpostato PassManager che rispecchia l'oggetto PassManager utilizzato internamente dalla funzione transpile() funzione. Ad esempio:

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

  • Aggiunta una nuova funzione marginal_memory() che viene utilizzata per marginalizzare gli array di memoria shot. Fornita la matrice di memoria dei pallini e gli indici di interesse, la funzione restituisce una matrice di memoria dei pallini maginizzata. Questa funzione differisce dal supporto della memoria nel metodo marginal_counts() che funziona solo sul campo memory in un oggetto Results .

  • L'interfaccia delle primitive è stata estesa per accettare oggetti oltre agli indici come argomenti del metodo __call__ . L'argomento parameter_values può ora essere opzionale.

  • L'esportatore di OpenQASM 3 (qiskit.qasm3) supporta ora l'esportazione di circuiti con ritardi espliciti, come quelli di QuantumCircuit.delay().

  • Aggiunto un nuovo metodo di layout e routing a transpile() basato sul documento "Time-optimal qubit mapping". Per utilizzarlo, è necessario installare il pacchetto opzionale Qiskit TOQM. Il kwarg routing_method di transpile() supporta un valore aggiuntivo, 'toqm' , utilizzato per abilitare il layout e l'instradamento tramite TOQM.

    Per installare qiskit-toqm insieme a Terra, eseguire:

    pip install qiskit-terra[toqm]

  • Aggiunto un nuovo modulo qiskit.quantum_info.synthesis.qsd per applicare la Decomposizione quantistica di Shannon a unitari arbitrari. Questa funzionalità sostituisce il precedente approccio basato sull'isometria nel passaggio predefinito del transpiler di sintesi unitaria, nonché quando si aggiungono unitari a un circuito utilizzando un file UnitaryGate.

    La decomposizione quantistica di Shannon utilizza circa la metà delle porte cnot rispetto all'implementazione dell'isometria per la decomposizione di matrici unitarie con più di due qubit.

  • Le classi del modulo quantum_info che supportano la moltiplicazione scalare possono ora essere moltiplicate per uno scalare sia da sinistra che da destra. In precedenza, accettavano solo moltiplicatori scalari da sinistra.

  • Il passo del transpiler LookaheadSwap (usato da transpile() quando routing_method="lookahead") ha subito alcuni miglioramenti nelle prestazioni e ora sarà circa tre volte più veloce. Si tratta solo di una maggiore efficienza nei calcoli e non cambia la complessità dell'algoritmo. Nella maggior parte dei casi, un algoritmo di routing più moderno come SabreSwap (routing_method="sabre") sarà molto più performante.

  • Sono stati aggiunti nuovi passaggi per il transpiler. Il passaggio del transpiler Commuting2qGateRouter utilizza strategie di scambio per indirizzare un blocco di porte pendolari alla mappa di accoppiamento. In effetti, l'instradamento è un problema difficile, ma è significativamente più semplice quando le porte si interscambiano, come nelle reti CZ. Anche i blocchi di cancelli pendolari sono tipicamente presenti nel QAOA. Questi casi possono essere affrontati utilizzando strategie di swap che applicano una serie predefinita di strati di porte SWAP. Inoltre, il nuovo passaggio del transpiler FindCommutingPauliEvolutions identifica blocchi di evoluzioni di Pauli costituiti da termini commutativi a due qubit. In questo caso, una strategia di swap è specificata dalla classe SwapStrategy. Per ottenere i migliori risultati, le strategie di scambio devono essere adattate alla mappa di accoppiamento e, idealmente, al circuito.

  • Introdotto un nuovo ottimizzatore nella libreria Qiskit, che aggiunge il supporto all'ottimizzazione dei parametri degli algoritmi quantistici variazionali. Si tratta dell'algoritmo di distribuzione marginale univariata (UMDA), che è un tipo specifico di algoritmi di stima della distribuzione. Ad esempio:

    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)

  • Il costruttore per il passaggio Unroll3qOrMore ha due nuovi argomenti opzionali, target e basis_gates. Queste opzioni consentono di specificare rispettivamente le porte di base Target o i gate di base supportati per descrivere il backend di destinazione. Se una qualsiasi operazione del circuito si trova in target o basis_gates , non verrà srotolata dal passaggio perché il dispositivo di destinazione ha un supporto nativo per l'operazione.

  • La serializzazione di QPY è stata aggiornata per supportare i file ScheduleBlock. Ora è possibile salvare il programma di impulsi in formato binario e caricarlo in un secondo momento:

    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]

    Utilizza l'interfaccia QPY comune a QuantumCircuit. Vedere SCHEDULE_BLOCK per i dettagli sulla struttura dei dati.

  • Aggiunto un nuovo passaggio di transpiler, VF2PostLayout. Questo passaggio è di tipo nuovo per eseguire una nuova fase/funzione nella pipeline di compilazione, la selezione dei qubit postlayout o post ottimizzazione. L'idea alla base di questo passaggio è che, una volta terminato il ciclo di ottimizzazione in transpiler, sappiamo quali saranno i conteggi finali dei gate su ogni qubit del circuito, in modo da poter trovare un sottoinsieme di qubit con prestazioni migliori su un backend per eseguire il circuito. Il passaggio cercherà un sottografo isomorfo nel grafo di connettività del backend di destinazione ed esaminerà il tasso di errore completo del circuito completo su qualsiasi sottografo trovato e restituirà il layout trovato con il tasso di errore più basso per il circuito.

    Questo passaggio è simile al passaggio VF2Layout ed entrambi utilizzano internamente la stessa implementazione di VF2 di retworkx. Tuttavia, VF2PostLayout è progettato per essere eseguito dopo l'esecuzione del layout iniziale, dell'instradamento, della traduzione delle basi e di qualsiasi passaggio di ottimizzazione e funziona solo se è già stato applicato un layout, il circuito è stato instradato e tutte le porte sono nella base di destinazione. Ciò è necessario affinché, quando si applica un nuovo layout, il circuito possa essere eseguito sul dispositivo di destinazione. VF2Layout è invece progettato per trovare un layout iniziale perfetto e può funzionare con qualsiasi circuito.

  • Il passaggio ApplyLayout supporta ora l'aggiornamento di un layout su un circuito dopo che il layout è stato applicato una volta. Se il campo post_layout è presente (oltre al campo obbligatorio layout ) il campo property_set quando il passaggio viene eseguito il passaggio aggiornerà il layout per applicare il nuovo layout ApplyLayout viene eseguito, il passaggio aggiornerà il layout per applicare il nuovo layout. Questo restituirà un oggetto DAGCircuit con i qubit nel nuovo ordine fisico e l'insieme di proprietà layout verrà aggiornato in modo da mappare i qubit virtuali del layout originale con i qubit fisici nel nuovo campo post_layout .

  • I gestori di passaggi preimpostati generati da level_1_pass_manager(), level_2_pass_manager(), e level_3_pass_manager() che corrispondono rispettivamente a optimization_level 1, 2 e 3 sulla funzione transpile() eseguono ora il passaggio VF2PostLayout dopo aver eseguito il passaggio di instradamento. Ciò consente al transpiler di trovare potenzialmente un diverso set di qubit fisici sul backend di destinazione su cui far girare il circuito, con tassi di errore inferiori. Il passaggio VF2PostLayout non verrà eseguito se si specificano manualmente gli argomenti layout_method, routing_method o initial_layout a transpile(). Se il passaggio riesce a trovare un sottoinsieme di qubit con prestazioni migliori sul backend per far funzionare il circuito fisico, regolerà il layout del circuito in modo da utilizzare i qubit alternativi.

  • L'algoritmo calcola iterativamente ogni autostato partendo dallo stato fondamentale (che viene calcolato come nel VQE) e ottimizzando una funzione di costo modificata che cerca di calcolare gli autostati ortogonali agli stati calcolati nelle iterazioni precedenti e che hanno l'energia più bassa quando vengono calcolati sull'ansatz. L'interfaccia implementata è molto simile a quella di VQE e ha la forma:

    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)

    Questo particolare frammento di codice genera 2 autovalori (stato terreno e primo stato eccitato) Sono stati implementati anche i test.

Note sull'aggiornamento

  • Le classi di impulsi in qiskit.pulse.library sono ora sottoclassi di SymbolicPulse anziché ParametricPulse. Le classi disponibili rimangono invariate come Gaussian, GaussianSquare, Drag, e Constant. SymbolicPulse ha la piena compatibilità all'indietro e non dovrebbe esserci alcuna perdita di funzionalità.

  • Il tipo di dati di ciascun elemento in QuantumCircuit.data è cambiato. Una volta si trattava di una semplice 3-tupla di an Instruction, un elenco di Qubite un elenco di Clbits, mentre ora è un'istanza di CircuitInstruction.

    Gli attributi di questa nuova classe sono operation, qubits e clbits, corrispondenti agli elementi della tupla precedente. Tuttavia, qubits e clbits sono ora istanze di tuple , non di list.

    Questa nuova classe si comporterà esattamente come la vecchia 3-tupla se si tenta di accedere al suo indice, ai suoi elementi o di iterare attraverso di essa. Questo include il lancio degli elementi qubits e clbits in liste. Questo per favorire la retrocompatibilità. A partire da Qiskit Terra 0.21, questo non è più il modo preferito per accedere a questi elementi. Si deve invece utilizzare la forma di accesso agli attributi descritta sopra.

    Questo è stato fatto per consentire ulteriori sviluppi della struttura dei dati di QuantumCircuit struttura dei dati in Terra, senza interrompere costantemente la compatibilità all'indietro. Gli sviluppi previsti includono circuiti dinamici parametrizzati e una riduzione complessiva dell'uso della memoria nei circuiti profondi.

  • La dipendenza python-constraint , che viene utilizzata esclusivamente dal passo CSPLayout non è più presente nell'elenco dei requisiti del pacchetto Qiskit Terra. Questo perché il CSPLayout non è più utilizzato per impostazione predefinita in nessuno dei gestori di passaggi preimpostati per transpile(). Il pass è ancora disponibile, ma se lo si utilizza è necessario installare manualmente python-contraint oppure, quando si installa qiskit-terra , si può utilizzare l'extra csp-layout , ad esempio:

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

  • La versione del formato QPY emessa da qpy.dump() è stata portata alla versione 5. Questa nuova versione del formato è incompatibile con le versioni precedenti e genera un errore quando si cerca di caricarla con un deserializzatore che non è in grado di gestire la versione 5 di QPY. Questa modifica si è resa necessaria per correggere il supporto per la rappresentazione corretta dei varchi controllati e per la rappresentazione degli stati di controllo non predefiniti.

  • Le estensioni Rust compilate di Qiskit Terra hanno ora una versione Rust minima supportata (MSRV) di 1.56.1. Questo significa che quando si costruisce Qiskit Terra dai sorgenti, la versione più vecchia del compilatore Rust supportata è 1.56.1. Se si utilizza una versione precedente del compilatore Rust, è necessario aggiornare a una versione più recente per continuare a compilare Qiskit dai sorgenti. Questa modifica si è resa necessaria perché anche alcune dipendenze upstream hanno aggiornato le loro versioni minime supportate.

  • Lo scheduling dei circuiti viene ora eseguito in parallelo quando viene fornito più di un circuito a schedule(). Per maggiori dettagli, consultare il numero 2695.

  • Le classi BaseBackend, BaseJob e BaseProvider , precedentemente deprecate, sono state tutte rimosse. Sono stati originariamente deprecati nella versione 0.18.0. Al posto di queste classi si dovrebbero usare le classi di interfaccia dei provider in versione, le più recenti delle quali sono BackendV2, JobV1, e ProviderV1.

  • L'argomento backend , precedentemente deprecato, per il costruttore del passaggio di transpiler RZXCalibrationBuilder è stato rimosso. È stato originariamente deprecato nella versione 0.19.0. Si dovrebbe invece interrogare l'oggetto Backend per instruction_schedule_map e qubit_channel_mapping e passarli direttamente al costruttore. Ad esempio, con un 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,
)

    o con un 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,
)

  • Il limite dei colpi di misura per il backend BasicAer è stato rimosso.

  • Per DAGNode, i kwarg e gli attributi type, op, qargs, cargs e wire , precedentemente deprecati, sono stati rimossi. Questi sono stati originariamente deprecati nella versione 0.19.0. I kwarg e gli attributi op, qargs e cargs sono accessibili solo alle istanze di DAGOpNode, mentre il kwarg e l'attributo wire sono accessibili solo alle istanze di DAGInNode o DAGOutNode.

  • La funzione deprecata pauli_group() è stata rimossa. Originariamente era deprecato in Qiskit Terra 0.17.

  • Sono stati rimossi diversi metodi deprecati in Pauli sono stati rimossi, originariamente deprecati in Qiskit Terra 0.17. Questi erano:

    sgn_prod

    Utilizzare Pauli.compose() o Pauli.dot() al suo posto.

    to_spmatrix

    Utilizzare Pauli.to_matrix() con l'argomento sparse=True .

    kron

    Utilizzare Pauli.expand()ma attenzione, questo restituisce un nuovo oggetto, invece di mutare quello esistente.

    update_z e update_x

    Impostare direttamente gli attributi z e x dell'oggetto.

    insert_paulis

    Utilizzare Pauli.insert().

    append_paulis

    Utilizzare Pauli.expand().

    delete_qubits

    Utilizzare Pauli.delete().

    pauli_single

    Costruire manualmente l'etichetta e passarla direttamente all'inizializzatore, come ad esempio:

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

    random

    Utilizzare quantum_info.random_pauli() invece.

  • Rimosso il metodo optimize dalle classi Optimizer che viene sostituito dal metodo minimize() in sostituzione diretta. L'unica eccezione è SPSAdove l'avviso di deprecazione non è stato attivato, quindi il metodo è ancora mantenuto.

  • Result è stato modificato in modo che contenga sempre gli attributi date, status e header (impostato su None se non specificato).

  • Per Python 3.7 shared-memory38 è ora una dipendenza. È stato aggiunto come dipendenza a Python 3.7 per consentire di sfruttare i costrutti di memoria condivisa nella libreria standard delle nuove versioni di Python. Se si utilizza Python >= 3.8 non è necessaria alcuna dipendenza aggiuntiva.

  • Instruction le etichette vengono ora controllate alla creazione dell'istruzione.

  • La serializzazione di QPY è stata aggiornata in modo da serializzare QuantumCircuit con QuantumCircuit.calibrations. A partire dalla versione 5 di QPY, possono essere serializzate solo le voci di calibrazione di ScheduleBlock possono essere serializzate.

  • La definizione di XXPlusYYGate è stata modificata. Per i dettagli, vedere il numero 7969.

  • I gestori di passaggi preimpostati generati da level_1_pass_manager(), level_2_pass_manager(), e level_3_pass_manager() e utilizzati dall'argomento transpile() della funzione optimization_level , rispettivamente a 1, 2 e 3, non stabiliscono più un limite di tempo rigido per il passaggio del transpiler VF2Layout del transpiler. Ciò significa che il passaggio non si fermerà più nel tentativo di trovare un layout perfetto alternativo fino a un limite di tempo prestabilito ( 100ms per il livello 1, 10 sec per il livello 2 e 60 sec per il livello 3), in quanto ciò limitava la riproducibilità della compilazione quando era disponibile un layout perfetto. Ciò significa che l'output quando si utilizza il pass potrebbe essere diverso da quello precedente, anche se in tutti i casi cambierebbe solo se è possibile trovare un insieme di qubit a rumore inferiore rispetto all'output precedente. Se si desidera mantenere il comportamento precedente, si può creare un parametro personalizzato PassManager che imposta l'argomento time_limit nel costruttore per il passaggio VF2Layout .

Note di deprecazione

  • Chiamata timeline_drawer() con un circuito non programmato è stata deprecata. Tutti i circuiti, anche quelli costituiti da sole istruzioni di ritardo, devono essere transpilati con l'argomento scheduling_method della parola chiave transpile() set, per generare le informazioni di programmazione memorizzate in QuantumCircuit.op_start_times.

  • Le funzioni di NetworkX per i metodi DAGCircuit.to_networkx() e from_networkx() e per il metodo DAGDependency.to_networkx() sono stati deprecati e saranno rimossi in una prossima versione. Qiskit utilizza retworkx come libreria di grafi fin dalla release qiskit-terra 0.12.0 e da allora le funzioni di conversione di networkx sono state caratterizzate da perdite. Sono stati aggiunti originariamente per consentire agli utenti di sfruttare le funzionalità della libreria di algoritmi NetworkX’s non presenti in retworkx. Da allora, retworkx è maturato e offre più funzionalità, e il programma DAGCircuit è strettamente legato a retworkx per il suo funzionamento. La presenza di questi metodi di conversione fornisce un valore limitato in futuro e pertanto saranno rimossi in una versione futura.

  • L'accesso a diversi vecchi toggle (HAS_MATPLOTLIB, HAS_PDFTOCAIRO, HAS_PYLATEX e HAS_PIL) dal modulo qiskit.visualization è ormai deprecato e questi percorsi di importazione saranno rimossi in una versione futura di Qiskit Terra. Gli stessi oggetti dovrebbero invece essere accessibili attraverso qiskit.utils.optionalsche contiene i tester per quasi tutte le dipendenze opzionali di Terra.

  • Il modulo qiskit.test.mock è ora deprecato. Le classi di fake backend e fake provider, precedentemente disponibili in qiskit.test.mock , sono accessibili in qiskit.providers.fake_provider da Terra 0.20.0. Questo cambiamento rappresenta un vero e proprio impegno a supportare le classi backend false come parte di Qiskit, mentre in precedenza erano solo parte della suite di test interni e venivano esposte agli utenti come effetto collaterale.

  • I nomi degli argomenti quando si chiama un metodo Estimator o Sampler come funzione sono rinominati da circuit_indices e observable_indices a circuits e observables.

  • Gli argomenti delle parole chiave qobj_id e qobj_header per la funzione execute() sono stati deprecati e saranno rimossi in una prossima versione. Da quando è stata rimossa la classe BaseBackend , questi argomenti non hanno alcun effetto, poiché nessun backend supporta l'esecuzione con un oggetto Qobj direttamente e invece lavora solo con gli oggetti QuantumCircuit direttamente.

  • Gli argomenti x, z e label per l'inizializzatore di Pauli sono stati documentati come deprecati in Qiskit Terra 0.17, ma un bug ha impedito di mostrare l'avviso previsto in fase di esecuzione. L'avviso verrà visualizzato correttamente e gli argomenti verranno rimossi in Qiskit Terra 0.23 o successivi. Una coppia di x e z deve essere passata in posizione come una singola tupla (Pauli((z, x))). Una stringa label deve essere passata in posizione nel primo argomento (Pauli("XYZ")).

  • Il metodo SPSA.optimize() è deprecato a favore di SPSA.minimize()che può essere utilizzato come sostituto diretto. Si noti che questo metodo restituisce un oggetto risultato completo con più informazioni di quelle disponibili in precedenza.

  • L'argomento circuits di qpy.dump() è stato deprecato e sostituito con programs , poiché ora QPY supporta più tipi di dati diversi dai circuiti.

  • AlignmentKind.to_dict() è stato deprecato e sarà rimosso.

Correzioni di bug

  • È stata aggiunta una validazione supplementare a DiagonalGate per verificare che l'argomento abbia modulo uno.

  • Gli indici di qubit duplicati dati a SparsePauliOp.from_sparse_list() solleverà correttamente un errore, invece di sovrascrivere silenziosamente i valori precedenti. Si può accedere al vecchio comportamento passando l'argomento della nuova parola chiave do_checks=False.

  • La timeline_drawer() non disallineerà più gli slot dei registri classici.

  • La convalida dei parametri per GaussianSquare è ora coerente prima e dopo la costruzione. Per maggiori dettagli, consultare il numero 7882.

  • Il BackendV2-basato su falsi backend nel modulo qiskit.providers.fake_provider come ad esempio FakeMontrealV2supportano ora l'operazione Delay nei loro attributi target nei loro attributi. In precedenza, QuantumCircuit che contenevano ritardi non potevano essere compilati in questi backend.

  • Corretto un bug in TridiagonalToeplitz.eigs_bounds(), che causava la restituzione di limiti di autovalori errati in alcuni casi con autovalori negativi. Per maggiori dettagli, consultare il documento #7939.

  • Corretto un bug per cui il cassetto di stato LaTeX ignorava il parametro max_size .

  • Supporto fisso nel metodo PassManagerConfig.from_backend() per costruire un oggetto PassManagerConfig da un oggetto BackendV2 istanza. In precedenza questo non era gestito correttamente e falliva quando veniva eseguito con un oggetto BackendV2 oggetto.

  • Supporto fisso per la serializzazione (qpy.dump()) e la deserializzazione (qpy.load()) di un QuantumCircuit contenente oggetti ControlledGate personalizzati. In precedenza, veniva sollevata un'eccezione da qpy.load() quando si cercava di ricostruire il file personalizzato ControlledGate. Corretto #7999.

  • Supporto fisso per la serializzazione (qpy.dump()) e la deserializzazione (qpy.load()) di un QuantumCircuit contenente oggetti MCPhaseGate personalizzati. In precedenza, veniva sollevata un'eccezione da qpy.load() quando cercava di ricostruire il file MCPhaseGate.

  • Supporto fisso per la serializzazione (qpy.dump()) e la deserializzazione (qpy.load()) di un QuantumCircuit contenente porte controllate con uno stato di controllo aperto. In precedenza, lo stato di controllo aperto veniva perso dal processo di serializzazione e dal circuito ricostruito.

  • Fissato QuantumCircuit.reverse_bits() con circuiti che contengono registri senza Qubit e Clbit. Ad esempio, ora funziona quanto segue:

    from qiskit.circuit import QuantumCircuit, Qubit, Clbit

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

  • È stato corretto l'attributo ConfigurableFakeBackend.t2 , che in precedenza veniva impostato in modo errato in base al valore t1 fornito.

  • Corretto un problema con BackendV2-basato su classi backend false del modulo qiskit.providers.fake_provider come il modulo FakeMontrealV2 dove il valore dell'attributo dt (e l'attributo Target.dt non venivano convertiti correttamente in secondi. Questo causerebbe problemi quando si utilizzano questi backend falsi con la schedulazione.

  • Corretto un bug in plot_histogram() quando l'argomento number_to_keep era inferiore al numero di chiavi. Il codice seguente non darà più errori e sarà allineato correttamente:

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

  • Miglioramento delle prestazioni della costruzione e del lavoro con istanze parametrizzate QuantumCircuit con molte porte che condividono un numero relativamente piccolo di parametri.

  • L'esportatore di OpenQASM 3 (qiskit.qasm3) non tenterà più di produrre definizioni per porte non standard nell'opzione basis_gates .

  • Corretto il getter di OptimizerResult.nitche in precedenza restituiva il numero di valutazioni jacobiane invece del numero di iterazioni.

  • Corretto un bug nella rappresentazione delle stringhe degli oggetti Result che causava l'errata specificazione degli attributi.

  • È stato risolto un problema con transpile() per cui in alcuni casi la fornitura di un elenco di stringhe di porte di base con l'argomento della parola chiave basis_gates o implicitamente tramite un input di tipo Target tramite l'argomento della parola chiave target non veniva interpretato correttamente e risultava che per ogni circuito veniva utilizzato un sottoinsieme delle porte elencate.

  • Corretto un problema nel passaggio UnitarySynthesis che dava luogo a un errore quando un oggetto Target che non aveva alcuna restrizione di qubit sulle operazioni (ad esempio nel caso di un target di simulatore ideale) veniva specificato con l'argomento della parola chiave target per il costruttore.

  • Il metodo qiskit.result.marginal_counts()quando gli viene passato un oggetto Result da un backend a impulsi, fallirebbe, perché contiene un array di oggetti ExperimentResult , ognuno dei quali ha un QobjExperimentHeader, e a questi ExperimentHeaders mancano le variabili di istanza creg_sizes. Se il sito Result proviene da un backend del simulatore (ad esempio Aer), la variabile istanza sarà presente. Correggiamo marginal_counts in modo che salti la logica che richiede creg_sizes se il campo non è presente o non è nullo.

  • L'esportatore di OpenQASM 2 (QuantumCircuit.qasm()) ora definirà correttamente i parametri dei qubit per le operazioni UnitaryGate che non hanno effetto su tutti i qubit su cui sono definiti. Corretto #8224.

  • È stato risolto un problema di riproducibilità della funzione transpile() quando viene eseguita con optimization_level 1, 2 e 3. In precedenza, in alcune condizioni in cui erano disponibili più layout perfetti (un layout che non richiede alcuna porta SWAP), il layout e il circuito di uscita selezionati potevano variare indipendentemente dall'impostazione dell'argomento seed_transpiler .

Aer 0.10.4

Nessuna modifica

IBM Q Fornitore 0.19.2

Correzioni di bug

  • Nel prossimo rilascio di terra ci sarà una release candidate taggata prima del rilascio finale. Tuttavia, la modifica della stringa di versione del pacchetto è bloccata da qiskit-ibmq-provider in questo momento, perché cerca di analizzare la versione e presuppone che non ci sia il suffisso prelease nella stringa di versione (vedere #8200 per i dettagli). Il PR #1135 corregge il parsing della versione in modo da usare la regex del progetto pypa/packaging, che gestisce tutte le versioni dei pacchetti PEP440 includendo i suffissi pre-release. Questo permetterà a terra di rilasciare un tag 0.21.0rc1 senza rompere il qiskit-ibmq-provider.
  • threading.currentThread e notifyAll sono stati deprecati in Python 3.10 (ottobre 2021) e saranno rimossi in Python 3.12 (ottobre 2023). Il PR #1133 li sostituisce con threading.current_thread, notify_all aggiunto a Python 2.6 (ottobre 2008).
Questa pagina è stata utile?
Segnala un bug, un errore di battitura o richiedi contenuti su GitHub.