Opflow இடம்பெயர்வு வழிகாட்டி

TL; DR

புதிய primitives, quantum_info தொகுதியுடன் இணைந்து, opflow இன் செயல்பாடுகளை மீறியுள்ளது. இதனால், பிந்தையது கைவிடப்படுகிறது.

இந்த இடம்பெயர்வு வழிகாட்டியில், உங்கள் குறியீட்டை opflow தொகுதியின் அடிப்படையில் primitives மற்றும் quantum_info தொகுதிகள்.

Note

opflow இன் பயன்பாடு QuantumInstance வகுப்போடு இறுக்கமாக இணைக்கப்பட்டது, இதுவும் நிராகரிக்கப்படுகிறது. QuantumInstance ஐ நகர்த்துவது பற்றிய கூடுதல் தகவலுக்கு, குவாண்டம் நிகழ்வு இடம்பெயர்வு வழிகாட்டி ஐப் படிக்கவும்.

Attention

இந்த வழிகாட்டியில் உள்ள qiskit.primitives.Sampler அல்லது qiskit.primitives.Estimator பற்றிய பெரும்பாலான குறிப்புகள், எந்தவொரு பழமையான செயலாக்கத்தின் நிகழ்வுகளாலும் மாற்றப்படலாம். எடுத்துக்காட்டாக ஏர் ப்ரிமிடிவ்ஸ் (qiskit_aer.primitives.Sampler/qiskit_aer.primitives.Estimator) அல்லது IBMன் Qiskit இயக்க நேர ப்ரிமிடிவ்கள் (qiskit_ibm_runtime.Sampler/sampler`/ ) பழமையான-இணக்கமான இடைமுகங்களையும் வழங்க, குறிப்பிட்ட பின்தளங்களை (qiskit.primitives.BackendSampler, qiskit.primitives.BackendEstimator) உடன் சுற்றலாம்.

சில வகுப்பு, :class:` ~ qiskit.opflow.opflow.expectations.AerPauliExpectation , can only be replaced by a specific primitive instance (in this case, :class: qiskit_aer.primitives.Estimator `), or தேவை ஒரு குறிப்பிட்ட தேர்வு வடிவமைப்பு. இது வழக்கமாக என்றால், அது ஒத்திசைவு பிரிவில் தெளிவாகக் குறிக்கப்படும்.

பின்னணி

opflow தொகுதியானது, குவாண்டம் அல்காரிதம் ஆராய்ச்சி மற்றும் மேம்பாட்டிற்கான ஒரு தொடர் கட்டுமானத் தொகுதிகள், சுற்றுகள் மற்றும் வழிமுறைகளுக்கு இடையேயான அடுக்காக முதலில் அறிமுகப்படுத்தப்பட்டது.

qiskit.primitives இன் சமீபத்திய வெளியீடு பின்தளங்களுடன் தொடர்புகொள்வதற்கான புதிய முன்னுதாரணத்தை அறிமுகப்படுத்தியது. இப்போது, ​​``backend.run()`` வகை முறை மூலம் இயக்க ஒரு சர்க்யூட்டைத் தயாரிப்பதற்குப் பதிலாக, அல்காரிதம்கள் Sampler மற்றும் Estimator ப்ரிமிட்டிவ்களைப் பயன்படுத்தி, அளவுருப்படுத்தப்பட்ட சுற்றுகளை அனுப்பலாம் மற்றும் கவனிக்கக்கூடியவை, மற்றும் நேரடியாக அரை-நிகழ்தகவு விநியோகங்கள் அல்லது எதிர்பார்ப்பு மதிப்புகள் (முறையே) பெறுகின்றன. இந்த பணிப்பாய்வு, முன்னர் இந்த தொகுதியை நம்பியிருந்த முன் செயலாக்க மற்றும் பிந்தைய செயலாக்க படிகளை கணிசமாக எளிதாக்குகிறது; opflow இலிருந்து விலகி, primitives இடைமுகம் மற்றும் quantum_info தொகுதியின் அடிப்படையில் அல்காரிதம்களை உருவாக்குவதற்கான புதிய பாதைகளைக் கண்டறிய எங்களை ஊக்குவிக்கிறது.

இந்த வழிகாட்டி opflow துணைமட்யூல்களைக் கடந்து ஒரு நேரடி மாற்று (அதாவது quantum_info ஐப் பயன்படுத்துதல்) அல்லது அல்காரிதங்களில் அவற்றின் செயல்பாட்டை எவ்வாறு மாற்றுவது என்பது பற்றிய விளக்கத்தை வழங்குகிறது.

செயல்பாட்டு சமநிலையை தோராயமாக பின்வருமாறு சுருக்கமாகக் கூறலாம்:

Opflow தொகுதி	மாற்று
ஆபரேட்டர்கள் (OperatorBase, Operator Globals, primitive_ops, list_ops)	` ` qiskit.quantum_info ` ` :ref: Operators <quantum_info_operators>`
:mod:` qiskit.opflow.state_ fns `	` ` qiskit.quantum_info ` ` :ref: States <quantum_info_states>`
:mod:` qiskit.opflow.converters `	:mod:` qiskit.primitives `
:mod:` qiskit.opflow.evolutions `.	` ` qiskit.synthesis ` ` :ref: Evolution <evolution_synthesis>`
qiskit.opflow.expectations	:class:` qiskit.primitives.Estimator `
qiskit.opflow.gradients	:mod:` qiskit.algorithms.gradients-action

உள்ளடக்கம்

இந்த ஆவணம் இந்த ஓப்ஃப்ளோ துணைத் தொகுதிகளிலிருந்து இடம்பெயர்வதை உள்ளடக்கியது:

ஆபரேட்டர்கள்

• ஆபரேட்டர் அடிப்படை வகுப்பு

• ஆபரேட்டர் குளோபல்ஸ்

• முதன்மை மற்றும் பட்டியல் ஆப்ஸ்

• நிலை செயல்பாடுகள்

** மாற்றிகள்**

• ` மாற்றிகள் `_

• பரிணாமங்கள்

• எதிர்பார்ப்புகள்

** க்ரேடியன்ட்டுகள்**

• க்ரேடியன்ட்டுகள்

ஆபரேட்டர் அடிப்படை வகுப்பு

மீண்டும் உள்ளடக்கங்கள்

qiskit.quantum_info.BaseOperator என்பதை மனதில் வைத்து, qiskit.opflow.OperatorBase சுருக்க வகுப்பை qiskit.quantum_info.BaseOperator உடன் மாற்றலாம்.

ஓப்ஃப்ளோ	மாற்று
:class:` qiskit.opflow.OperatorBase `	:class:` qiskit.quantum_info.BaseOperator `

Attention

ஒரே மாதிரியான வகுப்புப் பெயர்கள் இருந்தாலும், qiskit.opflow.OperatorBase மற்றும் qiskit.quantum_info.BaseOperator ஆகியவை ஒன்றுக்கொன்று முற்றிலும் சமமானவை அல்ல, மேலும் மாற்றத்தைக் கவனமாகக் கையாள வேண்டும். அதாவது:

1. qiskit.opflow.OperatorBase implements a broader algebra mixin. Some operator overloads that were commonly used opflow (for example ~ for .adjoint()) are not defined for qiskit.quantum_info.BaseOperator. You might want to check the specific quantum_info subclass instead.

2. qiskit.opflow.OperatorBase also implements methods such as .to_matrix() or .to_spmatrix(), which are only found in some of the qiskit.quantum_info.BaseOperator subclasses.

மேலும் தகவலுக்கு:class:~qiskit.opflow.OperatorBase மற்றும் BaseOperator API குறிப்புகளைப் பார்க்கவும்.

ஆபரேட்டர் குளோபல்ஸ்

மீண்டும் உள்ளடக்கங்கள்

Operator Globals தொகுதியில் பொதுவான ஒற்றை குவிட் நிலைகள், ஆபரேட்டர்கள் மற்றும் அளவுரு அல்லாத வாயில்களை வரையறுக்க Opflow குறுக்குவழிகளை வழங்கியது.

இவை முக்கியமாக செயற்கையான நோக்கங்களுக்காக அல்லது விரைவான முன்மாதிரிக்காகப் பயன்படுத்தப்பட்டன, மேலும் அவற்றுடன் தொடர்புடைய quantum_info class: Pauli, Clifford அல்லது Statevector.

1-Qubit Paulis

மீண்டும் உள்ளடக்கங்கள்

1-குபிட் பாலிஸ் பொதுவாக அல்காரிதம்களின் விரைவான சோதனைக்காகப் பயன்படுத்தப்பட்டது, ஏனெனில் அவை மிகவும் சிக்கலான ஆபரேட்டர்களை உருவாக்குவதற்கு ஒருங்கிணைக்கப்படலாம் (உதாரணமாக, 0.39 * (I ^ Z) 0.5 * (X ^ X)). இந்த செயல்பாடுகள் மறைமுகமாக PauliSumOp வகையின் ஆபரேட்டர்களை உருவாக்கியது, மேலும் கீழே உள்ள உதாரணங்களில் காட்டப்பட்டுள்ளபடி, தொடர்புடைய SparsePauliOp ஐ நேரடியாக உருவாக்குவதன் மூலம் மாற்றலாம்.

ஓப்ஃப்ளோ	மாற்று
:class:` ~ qiskit.opflow.X , :class: ~ qiskit.opflow.Y , :class: ~ qiskit.opflow.Z , :class: ~ qiskit.opflow.I `	:class:` ~ qiskit.quantum_info.Pauli ` Tip algorithms இல் உள்ள வகுப்புகளுடன் நேரடிப் பொருந்தக்கூடிய தன்மைக்கு, SparsePauliOp இல் மடிக்கவும்.

எடுத்துக்காட்டு 1: XX இயக்கியை ஏற்றுமதி செய்

** நுழைவு **

from qiskit.opflow import X

operator = X ^ X
print(repr(operator))

PauliOp(Pauli('XX'), coeff=1.0)

** மாற்று

from qiskit.quantum_info import Pauli, SparsePauliOp

operator = Pauli('XX')

# equivalent to:
X = Pauli('X')
operator = X ^ X
print("As Pauli Op: ", repr(operator))

# another alternative is:
operator = SparsePauliOp('XX')
print("As Sparse Pauli Op: ", repr(operator))

As Pauli Op:  Pauli('XX')
As Sparse Pauli Op:  SparsePauliOp(['XX'],
              coeffs=[1.+0.j])

எடுத்துக்காட்டு 2: அதிக சிக்கல் இயக்குநர்

** நுழைவு **

from qiskit.opflow import I, X, Z, PauliSumOp

operator = 0.39 * (I ^ Z ^ I) + 0.5 * (I ^ X ^ X)

# equivalent to:
operator = PauliSumOp.from_list([("IZI", 0.39), ("IXX", 0.5)])

print(repr(operator))

PauliSumOp(SparsePauliOp(['IZI', 'IXX'],
              coeffs=[0.39+0.j, 0.5 +0.j]), coeff=1.0)

** மாற்று

from qiskit.quantum_info import SparsePauliOp

operator = SparsePauliOp(["IZI", "IXX"], coeffs = [0.39, 0.5])

# equivalent to:
operator = SparsePauliOp.from_list([("IZI", 0.39), ("IXX", 0.5)])

# equivalent to:
operator = SparsePauliOp.from_sparse_list([("Z", [1], 0.39), ("XX", [0,1], 0.5)], num_qubits = 3)

print(repr(operator))

SparsePauliOp(['IZI', 'IXX'],
              coeffs=[0.39+0.j, 0.5 +0.j])

பொதுவான மற்ற வாயுக்கள் (Clifford)

மீண்டும் உள்ளடக்கங்கள்

ஓப்ஃப்ளோ

மாற்று

:class:` ~ qiskit.opflow.CX , :class: ~ qiskit.opflow.S , :class: ~ qiskit.opflow.H , :class: ~ qiskit.opflow.T , :class: ~ qiskit.opflow.CZ , :class: ~ qiskit.opflow.Swap `

தொடர்புடைய வாயிலை QuantumCircuit உடன் இணைக்கவும். தேவைப்பட்டால், qiskit.quantum_info.Operators குவாண்டம் சர்க்யூட்களில் இருந்து நேரடியாக உருவாக்கப்படும். மற்றொரு மாற்று:class:~qiskit.quantum_info.Clifford இல் சர்க்யூட்டை மடித்து Clifford.to_operator() என அழைக்கவும். Note Constructing :mod:` ~ qiskit.quantum_info ` செயல்களில் இருந்து இயக்குவோர் திறமையாகக் கொள்ளப்படாது, இது ஒரு அடர்த்தி செயற்பாடு மற்றும் உருக்களின் அளவு கொண்டு செல்லும் அளவு, கவனத்துடன் பயன்படும்.

எடுத்துக்காட்டு 1: HH இயக்குநர்

** நுழைவு **

from qiskit.opflow import H

operator = H ^ H
print(operator)

     ┌───┐
q_0: ┤ H ├
     ├───┤
q_1: ┤ H ├
     └───┘

** மாற்று

from qiskit import QuantumCircuit
from qiskit.quantum_info import Clifford, Operator

qc = QuantumCircuit(2)
qc.h(0)
qc.h(1)
print(qc)

     ┌───┐
q_0: ┤ H ├
     ├───┤
q_1: ┤ H ├
     └───┘

இந்த சுற்றுப்பாதை ஒரு இயக்கத்தில் திரும்ப வேண்டும் என்றால், நாம் செய்ய முடியும்:

operator = Clifford(qc).to_operator()

# or, directly
operator = Operator(qc)

print(operator)

Operator([[ 0.5+0.j,  0.5+0.j,  0.5+0.j,  0.5+0.j],
          [ 0.5+0.j, -0.5+0.j,  0.5+0.j, -0.5+0.j],
          [ 0.5+0.j,  0.5+0.j, -0.5+0.j, -0.5+0.j],
          [ 0.5+0.j, -0.5+0.j, -0.5+0.j,  0.5+0.j]],
         input_dims=(2, 2), output_dims=(2, 2))

1-Qubit States

மீண்டும் உள்ளடக்கங்கள்

ஓப்ஃப்ளோ	மாற்று
:class:` ~ qiskit.opflow.Zero , :class: ~ qiskit.opflow.One , :class: ~ qiskit.opflow.Plus , :class: ~ qiskit.opflow.Minus `	:class:` ~ qiskit.quantum_info.Statevector ` or simply :class:` ~ qiskit.circuit.QuantumCircuit `. Note நிலைப்படுத்தி நிலைகளின் திறமையான உருவகப்படுத்துதலுக்கு, quantum_info ஒரு StabilizerState வகுப்பை உள்ளடக்கியது. மேலும் தகவலுக்கு StabilizerState இன் API குறிப்பைப் பார்க்கவும்.

எடுத்துக்காட்டு 1: நிலைமை மாநிலங்களுடன் வேலை

** நுழைவு **

from qiskit.opflow import Zero, One, Plus, Minus

# Zero, One, Plus, Minus are all stabilizer states
state1 = Zero ^ One
state2 = Plus ^ Minus

print("State 1: ", state1)
print("State 2: ", state2)

State 1:  DictStateFn({'01': 1})
State 2:  CircuitStateFn(
     ┌───┐┌───┐
q_0: ┤ X ├┤ H ├
     ├───┤└───┘
q_1: ┤ H ├─────
     └───┘
)

** மாற்று

from qiskit import QuantumCircuit
from qiskit.quantum_info import StabilizerState, Statevector

qc_zero = QuantumCircuit(1)
qc_one = qc_zero.copy()
qc_one.x(0)
state1 = Statevector(qc_zero) ^ Statevector(qc_one)
print("State 1: ", state1)

qc_plus = qc_zero.copy()
qc_plus.h(0)
qc_minus = qc_one.copy()
qc_minus.h(0)
state2 = StabilizerState(qc_plus) ^ StabilizerState(qc_minus)
print("State 2: ", state2)

State 1:  Statevector([0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
            dims=(2, 2))
State 2:  StabilizerState(StabilizerTable: ['-IX', '+XI'])

பழமையான மற்றும் பட்டியல் ஆப்ஸ்

மீண்டும் உள்ளடக்கங்கள்

பெரும்பாலும் :mod:` ~ qiskit.opflow.primitive_ ops ` and :mod:` ~ qiskit.opflow.list_ ops ` can now leverage elements from :mod:` ~ qiskit.quiskit.quantum_info `tqiskit.quantum_info ` இவற்றில் சில வகுப்புகள் 1-1 மாற்றம் தேவைப்படுகிறது ஏனெனில் அவை மற்ற ஒளி பொருட்களுடன் இடைமுகத்துக்கு உருவாக்கப்பட்டன.

பழமையான Ops

மீண்டும் உள்ளடக்கங்கள்

PrimitiveOp என்பது primitive_ops தொகுதியின் அடிப்படை வகுப்பு. இது தொடங்குவதற்குப் பயன்படுத்தப்படும் கணக்கீட்டு முதற்பொருளைப் பொறுத்து தொடர்புடைய துணை-வகுப்பை உடனடியாக உருவாக்குவதற்கான ஒரு தொழிற்சாலையாகவும் செயல்படுகிறது.

Tip

:class:` ~ qiskit.opflow.primitive_ops.PrimitiveOp ` ஒரு தொழில் வகுப்பு:

வகுப்பு: class:~qiskit.opflow.primitive_ops.PrimitiveOp க்கு அனுப்பப்பட்டது	துணைப்பிரிவு திரும்பியது
:class:` ~ qiskit.quantum_info.Pauli `	:class:` ~ qiskit.opflow.primitive_ ops.PauliOp `
:class:` ~ qiskit.circuit.Instruction , :class: ~ qiskit.circuit.QuantumCircuit `	:class:` ~ qiskit.opflow.primitive_ ops.CircuitOp `
list, np.ndarray, scipy.sparse.spmatrix, Operator	:class:` ~ qiskit.opflow.primitive_ ops.MatrixOp `

எனவே, ஓப்ஃப்ளோ குறியீட்டை நகர்த்தும்போது, ​​அசல் குறியீட்டில் "ஹூட்டின் கீழ்" பயன்படுத்தப்படும் குறிப்பிட்ட துணைப்பிரிவுகளை மாற்றுவதற்கான மாற்றுகளைத் தேடுவது முக்கியம்:

ஓப்ஃப்ளோ	மாற்று
:class:` ~ qiskit.opflow.primitive_ ops.PrimitiveOp `	மேலே குறிப்பிடப்பட்டிருப்பதால், இந்த வகுப்பு கீழே ஒரு வகுப்பின் ஒரு நிகழ்வை உருவாக்க பயன்படுகிறது, அதனால் நேரடியான மாற்றம் இல்லை.
:class:` ~ qiskit.opflow.primitive_ ops.CircuitOp `	:class:` ~ qiskit.circuit.QuantumCircuit `
:class:` ~ qiskit.opflow.primitive_ ops.MatrixOp `	:class:` ~ qiskit.quantum_info.Operator `
:class:` ~ qiskit.opflow.primitive_ ops.PauliOp `	Pauli. qiskit.algorithms இல் உள்ள வகுப்புகளுடன் நேரடி இணக்கத்தன்மைக்கு, SparsePauliOp என்பதில் மடிக்கவும்.
:class:` ~ qiskit.opflow.primitive_ ops.PauliSumOp `	SparsePauliOp. உதாரணத்தைப் பார்க்கவும் கீழே.
:class:` ~ qiskit.opflow.primitive_ops.TaperedPauliSumOp `	இந்த வகுப்பு ஒரு பொருளில் அதன் அடையாளம் காணப்பட்ட சமச்சீர்களுடன் ஒரு PauliSumOp ஐ இணைக்கப் பயன்படுத்தப்பட்டது. இந்த செயல்பாடு தற்போது எந்த பணிப்பாய்வுகளிலும் பயன்படுத்தப்படவில்லை, மேலும் மாற்றியமைக்கப்படாமல் நிறுத்தப்பட்டது. புதுப்பிக்கப்பட்ட பணிப்பாய்வுக்கு:class:qiskit.quantum_info.analysis.Z2Symmetries உதாரணத்தைப் பார்க்கவும்.
:class:` qiskit.opflow.primitive_ops.Z2Symmetries `	qiskit.quantum_info.analysis.Z2Symmetries. உதாரணத்தைப் பார்க்கவும் கீழே.

எடுத்துக்காட்டு 1: ` PauliSumOp ` `

** நுழைவு **

from qiskit.opflow import PauliSumOp
from qiskit.quantum_info import SparsePauliOp, Pauli

qubit_op = PauliSumOp(SparsePauliOp(Pauli("XYZY"), coeffs=[2]), coeff=-3j)
print(repr(qubit_op))

PauliSumOp(SparsePauliOp(['XYZY'],
              coeffs=[2.+0.j]), coeff=(-0-3j))

** மாற்று

from qiskit.quantum_info import SparsePauliOp, Pauli

qubit_op = SparsePauliOp(Pauli("XYZY"), coeffs=[-6j])
print(repr(qubit_op))

SparsePauliOp(['XYZY'],
              coeffs=[0.-6.j])

எடுத்துக்காட்டு 2: Z2Symmetries மற்றும் TaperedPauliSumOp

** நுழைவு **

from qiskit.opflow import PauliSumOp, Z2Symmetries, TaperedPauliSumOp

qubit_op = PauliSumOp.from_list(
    [
    ("II", -1.0537076071291125),
    ("IZ", 0.393983679438514),
    ("ZI", -0.39398367943851387),
    ("ZZ", -0.01123658523318205),
    ("XX", 0.1812888082114961),
    ]
)
z2_symmetries = Z2Symmetries.find_Z2_symmetries(qubit_op)
print(z2_symmetries)

tapered_op = z2_symmetries.taper(qubit_op)
print("Tapered Op from Z2 symmetries: ", tapered_op)

# can be represented as:
tapered_op = TaperedPauliSumOp(qubit_op.primitive, z2_symmetries)
print("Tapered PauliSumOp: ", tapered_op)

Z2 symmetries:
Symmetries:
ZZ
Single-Qubit Pauli X:
IX
Cliffords:
0.7071067811865475 * ZZ
+ 0.7071067811865475 * IX
Qubit index:
[0]
Tapering values:
  - Possible values: [1], [-1]
Tapered Op from Z2 symmetries:  ListOp([
  -1.0649441923622942 * I
  + 0.18128880821149604 * X,
  -1.0424710218959303 * I
  - 0.7879673588770277 * Z
  - 0.18128880821149604 * X
])
Tapered PauliSumOp:  -1.0537076071291125 * II
+ 0.393983679438514 * IZ
- 0.39398367943851387 * ZI
- 0.01123658523318205 * ZZ
+ 0.1812888082114961 * XX

** மாற்று

from qiskit.quantum_info import SparsePauliOp
from qiskit.quantum_info.analysis import Z2Symmetries

qubit_op = SparsePauliOp.from_list(
    [
    ("II", -1.0537076071291125),
    ("IZ", 0.393983679438514),
    ("ZI", -0.39398367943851387),
    ("ZZ", -0.01123658523318205),
    ("XX", 0.1812888082114961),
    ]
)
z2_symmetries = Z2Symmetries.find_z2_symmetries(qubit_op)
print(z2_symmetries)

tapered_op = z2_symmetries.taper(qubit_op)
print("Tapered Op from Z2 symmetries: ", tapered_op)

Z2 symmetries:
Symmetries:
ZZ
Single-Qubit Pauli X:
IX
Cliffords:
SparsePauliOp(['ZZ', 'IX'],
              coeffs=[0.70710678+0.j, 0.70710678+0.j])
Qubit index:
[0]
Tapering values:
  - Possible values: [1], [-1]
Tapered Op from Z2 symmetries:  [SparsePauliOp(['I', 'X'],
              coeffs=[-1.06494419+0.j,  0.18128881+0.j]), SparsePauliOp(['I', 'Z', 'X'],
              coeffs=[-1.04247102+0.j, -0.78796736+0.j, -0.18128881+0.j])]

ListOps

மீண்டும் உள்ளடக்கங்கள்

list_ops தொகுதியில் primitive_ops அல்லது state_fns பட்டியல்களை கையாளும் வகுப்புகள் உள்ளன. இந்தச் செயல்பாட்டிற்கான quantum_info மாற்றுகள் PauliList மற்றும் SparsePauliOp (Paulis).

ஓப்ஃப்ளோ	மாற்று
:class:` ~ qiskit.opflow.list_ops.ListOp `	நேரடியான மாற்றம் இல்லை. இது இயக்குநர் பட்டியலுக்கான அடிப்படை வகுப்பு. பொதுவாக, இவை பைதான் ` ` பட்டியல் ` ` ` பட்டியலுடன் மாற்றமுடியும். :class:` ~ qiskit.quantum_info.Pauli ` இயக்குநர்கள், உபயோகத்தைப் பொறுத்து, சில மாற்றங்கள் உள்ளன. ஒரு மாற்று :class:` ~ qiskit.quantum_info.PauliList `.
:class:` ~ qiskit.opflow.list_ops.ComposedOp `	நேரடியான மாற்றம் இல்லை. தற்போதைய பணிபுரியும் மாநிலங்களின் தொகுப்பை தேவையிடுவதிலேயே ஒரு பொருள் (எல்லா மதிப்பீடுகள் இல்லை).
:class:` ~ qiskit.opflow.list_ops.SummedOp `	நேரடியான மாற்றம் இல்லை. :class:` ~ qiskit.quantum_info.Pauli ` இயக்குநர்கள், :class:` ~ qiskit.quantum_info.SparsePauliOp `.
:class:` ~ qiskit.opflow.list_ops.TensoredOp `	நேரடியான மாற்றம் இல்லை. :class:` ~ qiskit.quantum_info.Pauli ` இயக்குநர்கள், :class:` ~ qiskit.quantum_info.SparsePauliOp `.

நிலை செயல்பாடுகள்

மீண்டும் உள்ளடக்கங்கள்

:mod:` ~ qiskit.opflow.state_ fns ` module பொதுவாக :mod:` ~ qiskit.quantum_info 's :class: qiskit.quantum_info.QuantumState `.

அதே போல :class:` ~ qiskit.opflow.primitive_ ops.PrimitiveOp , :class: ~ qiskit.opflow.opflow.state_ fns.StateFn ` செயல்பாடு ஒரு தொழிற்சாலைகளாக செயல்படுகிறது.

Tip

:class:` ~ qiskit.opflow.opflow.state_ fns.StateFn ` ஒரு தொழில் வகுப்பு:

வகுப்பு :class:` ~ qiskit.opflow.state_ fns.StateFn	துணை வகுப்பு திரும்பி
str, dict, Result	:class:` ~ qiskit.opflow.state_fns.DictStateFn `
list, np.ndarray, Statevector	:class:` ~ qiskit.opflow.state_ fns.VectorStateFn `
:class:` ~ qiskit.circuit.QuantumCircuit , :class: ~ qiskit.circuit.Instruction `	:class:` ~ qiskit.opflow.state_ fns.CircuitStateFn `
:class:` ~ qiskit.opflow.OperatorBase `	:class:` ~ qiskit.opflow.state_ fns.OperatorStateFn `

அதாவது:class:~qiskit.opflow.state_fns.StateFn க்கான குறிப்புகள் ஆப்ஃப்ளோ குறியீட்டில் பயன்படுத்தப்படும் துணைப்பிரிவை அடையாளம் காண, பின்னர் ஒரு மாற்றீட்டைத் தேட வேண்டும்.

ஓப்ஃப்ளோ	மாற்று
:class:` ~ qiskit.opflow.state_ fns.StateFn `	பெரும்பாலான வழக்குகளில், எனினும், தயவு செய்து, :class: ~ qiskit.opflow.state_ fns.StateFn ` ஒரு தொழிற்சாலைகளாகும்.
:class:` ~ qiskit.opflow.state_ fns.CircuitStateFn `	:class:` ~ qiskit.quantum_info.Statevector `
:class:` ~ qiskit.opflow.state_fns.DictStateFn `	அரிதான அளவீட்டு முடிவுகளின் திறமையான பிரதிநிதித்துவங்களைச் சேமிக்க இந்த வகுப்பு பயன்படுத்தப்பட்டது. Sampler இப்போது அளவீடுகளை QuasiDistribution இன் உதாரணமாக வழங்குகிறது (உதாரணமாக Converters இல் பார்க்கவும்).
:class:` ~ qiskit.opflow.state_ fns.VectorStateFn `	இந்த வகுப்பை Statevector அல்லது StabilizerState (Clifford-அடிப்படையிலான திசையன்களுக்கு) என மாற்றலாம்.
:class:` ~ qiskit.opflow.state_ fns.SparseVectorStateFn `	நேரடியான மாற்றம் இல்லை. இந்த வகுப்பு வெப்பமடைதலுக்கு பயன்படுத்தப்பட்டது.
:class:` ~ qiskit.opflow.state_ fns.OperatorStateFn `	நேரடியான மாற்றம் இல்லை. இந்த வகுப்பு இயக்குநர்களுக்கு எதிரான அளவீடுகளைக் குறிக்கும்.
:class:` ~ qiskit.opflow.state_ fns.CVaRMeasurement `	CVaRExpectation இல் பயன்படுத்தப்பட்டது. செயல்பாடு இப்போது SamplingVQE ஆல் வழங்கப்படுகிறது. எதிர்பார்ப்புகள் இல் உதாரணத்தைப் பார்க்கவும்.

எடுத்துக்காட்டு 1: ஒரு மாநிலத்திற்கு ஒரு இயக்குநர் பயன்படுகிறது

** நுழைவு **

from qiskit.opflow import StateFn, X, Y
from qiskit import QuantumCircuit

qc = QuantumCircuit(2)
qc.x(0)
qc.z(1)
op = X ^ Y
state = StateFn(qc)

comp = ~op @ state
eval = comp.eval()

print(state)
print(comp)
print(repr(eval))

CircuitStateFn(
     ┌───┐
q_0: ┤ X ├
     ├───┤
q_1: ┤ Z ├
     └───┘
)
CircuitStateFn(
     ┌───┐┌────────────┐
q_0: ┤ X ├┤0           ├
     ├───┤│  Pauli(XY) │
q_1: ┤ Z ├┤1           ├
     └───┘└────────────┘
)
VectorStateFn(Statevector([ 0.0e+00+0.j,  0.0e+00+0.j, -6.1e-17-1.j,  0.0e+00+0.j],
            dims=(2, 2)), coeff=1.0, is_measurement=False)

** மாற்று

from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp, Statevector

qc = QuantumCircuit(2)
qc.x(0)
qc.z(1)
op = SparsePauliOp("XY")
state = Statevector(qc)

eval = state.evolve(op)

print(state)
print(eval)

Statevector([0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
            dims=(2, 2))
Statevector([0.+0.j, 0.+0.j, 0.-1.j, 0.+0.j],
            dims=(2, 2))

எதிர்பார்ப்புகள் மற்றும் மாற்றிகள் ஆகியவற்றில் பயன்படுத்தப்பட்ட கூடுதல் எடுத்துக்காட்டுகளைப் பார்க்கவும்.

மாற்றிகள்

மீண்டும் உள்ளடக்கங்கள்

qiskit.opflow.converters' துணைத் தொகுதியின் பங்கு, ஆபரேட்டர்களை மற்ற ஆப்ஃப்ளோ ஆபரேட்டர் வகுப்புகளாக மாற்றுவதாகும் (:class:`~qiskit.opflow.converters.TwoQubitReduction, PauliBasisChange...). CircuitSampler விஷயத்தில், அது ஒரு ஆபரேட்டரைக் கடந்து குவாண்டம் பின்தளத்தைப் பயன்படுத்தி அதன் நிலை செயல்பாடுகளின் தோராயங்களை வெளியிட்டது. குறிப்பிடத்தக்க வகையில், இந்த செயல்பாடு primitives மூலம் மாற்றப்பட்டது.

ஓப்ஃப்ளோ	மாற்று
:class:` ~ qiskit.opflow.converters.CircuitSampler `	Sampler அல்லது Estimator expectations உடன் பயன்படுத்தினால். எடுத்துக்காட்டுகளைப் பார்க்கவும் கீழே.
:class:` ~ qiskit.opflow.converters.AbelianGrouper `	பாலி ஆபரேட்டர்களின் தொகையை குழுவாக்க இந்த வகுப்பு அனுமதித்துள்ளது, அதேபோன்ற செயல்பாட்டை group_commuting() முறையின் மூலம் அடையலாம் qiskit.quantum_info.SparsePauliOp, இருப்பினும் இது 1-1 மாற்று அல்ல, நீங்கள் எடுத்துக்காட்டில் பார்க்க முடியும் கீழே.
:class:` ~ qiskit.opflow.converters.DictToCircuitSum `	நேரடி மாற்றீடு இல்லை. இந்த வகுப்பு DictStateFns அல்லது VectorStateFns இலிருந்து சமமான CircuitStateFns.
:class:` ~ qiskit.opflow.converters.PauliBasisChange `	நேரடி மாற்றீடு இல்லை. பாலிஸை மற்ற தளங்களாக மாற்ற இந்த வகுப்பு பயன்படுத்தப்பட்டது.
:class:` ~ qiskit.opflow.converters.TwoQubitReduction `	நேரடி மாற்றீடு இல்லை. இந்த வகுப்பு ParityMapper வகுப்பிற்கான வேதியியல் சார்ந்த குறைப்பை qiskit_nature இல் செயல்படுத்துகிறது. இந்த மேப்பர் சார்ந்திருக்கும் பொதுவான சமச்சீர் தர்க்கம் quantum_info இல் உள்ள மற்ற வகுப்புகளுக்கு மறுசீரமைக்கப்பட்டுள்ளது, எனவே இந்த குறிப்பிட்ட opflow செயல்படுத்தல் இனி தேவையில்லை.

எடுத்துக்காட்டு 1: அளவுருப்படுத்தப்பட்ட சுற்றுகளை மாதிரியாக்குவதற்கு சர்க்யூட் சாம்ப்ளர்

** நுழைவு **

from qiskit.circuit import QuantumCircuit, Parameter
from qiskit.opflow import ListOp, StateFn, CircuitSampler
from qiskit_aer import AerSimulator

x, y = Parameter("x"), Parameter("y")

circuit1 = QuantumCircuit(1)
circuit1.p(0.2, 0)
circuit2 = QuantumCircuit(1)
circuit2.p(x, 0)
circuit3 = QuantumCircuit(1)
circuit3.p(y, 0)

bindings = {x: -0.4, y: 0.4}
listop = ListOp([StateFn(circuit) for circuit in [circuit1, circuit2, circuit3]])

sampler = CircuitSampler(AerSimulator())
sampled = sampler.convert(listop, params=bindings).eval()

for s in sampled:
  print(s)

SparseVectorStateFn(  (0, 0)    1.0)
SparseVectorStateFn(  (0, 0)    1.0)
SparseVectorStateFn(  (0, 0)    1.0)

** மாற்று

from qiskit.circuit import QuantumCircuit, Parameter
from qiskit.primitives import Sampler

x, y = Parameter("x"), Parameter("y")

circuit1 = QuantumCircuit(1)
circuit1.p(0.2, 0)
circuit1.measure_all()     # Sampler primitive requires measurement readout
circuit2 = QuantumCircuit(1)
circuit2.p(x, 0)
circuit2.measure_all()
circuit3 = QuantumCircuit(1)
circuit3.p(y, 0)
circuit3.measure_all()

circuits = [circuit1, circuit2, circuit3]
param_values = [[], [-0.4], [0.4]]

sampler = Sampler()
sampled = sampler.run(circuits, param_values).result().quasi_dists

print(sampled)

[{0: 1.0}, {0: 1.0}, {0: 1.0}]

எடுத்துக்காட்டு 2: ` CircuitSampler ` ` கணினி எதிர்பார்ப்பு மதிப்புகள்

** நுழைவு **

from qiskit import QuantumCircuit
from qiskit.opflow import X, Z, StateFn, CircuitStateFn, CircuitSampler
from qiskit_aer import AerSimulator

qc = QuantumCircuit(1)
qc.h(0)
state = CircuitStateFn(qc)
hamiltonian = X + Z

expr = StateFn(hamiltonian, is_measurement=True).compose(state)
backend = AerSimulator(method="statevector")
sampler = CircuitSampler(backend)
expectation = sampler.convert(expr)
expectation_value = expectation.eval().real

print(expectation_value)

1.0000000000000002

** மாற்று

from qiskit import QuantumCircuit
from qiskit.primitives import Estimator
from qiskit.quantum_info import SparsePauliOp

state = QuantumCircuit(1)
state.h(0)
hamiltonian = SparsePauliOp.from_list([('X', 1), ('Z',1)])

estimator = Estimator()
expectation_value = estimator.run(state, hamiltonian).result().values.real

print(expectation_value)

[1.]

எடுத்துக்காட்டு 3: ` ` AbelianGrouper ` ` குழு இயக்குநர்கள்

** நுழைவு **

from qiskit.opflow import PauliSumOp, AbelianGrouper

op = PauliSumOp.from_list([("XX", 2), ("YY", 1), ("IZ",2j), ("ZZ",1j)])

grouped_sum = AbelianGrouper.group_subops(op)

print(repr(grouped_sum))

SummedOp([PauliSumOp(SparsePauliOp(['XX'],
              coeffs=[2.+0.j]), coeff=1.0), PauliSumOp(SparsePauliOp(['YY'],
              coeffs=[1.+0.j]), coeff=1.0), PauliSumOp(SparsePauliOp(['IZ', 'ZZ'],
              coeffs=[0.+2.j, 0.+1.j]), coeff=1.0)], coeff=1.0, abelian=False)

** மாற்று

from qiskit.quantum_info import SparsePauliOp

op = SparsePauliOp.from_list([("XX", 2), ("YY", 1), ("IZ",2j), ("ZZ",1j)])

grouped = op.group_commuting()
grouped_sum = op.group_commuting(qubit_wise=True)

print(repr(grouped))
print(repr(grouped_sum))

[SparsePauliOp(['IZ', 'ZZ'],
              coeffs=[0.+2.j, 0.+1.j]), SparsePauliOp(['XX', 'YY'],
              coeffs=[2.+0.j, 1.+0.j])]
[SparsePauliOp(['XX'],
              coeffs=[2.+0.j]), SparsePauliOp(['YY'],
              coeffs=[1.+0.j]), SparsePauliOp(['IZ', 'ZZ'],
              coeffs=[0.+2.j, 0.+1.j])]

பரிணாமங்கள்

மீண்டும் உள்ளடக்கங்கள்

qiskit.opflow.evolutions' துணைத் தொகுதியானது ஹாமில்டோனியன் உருவகப்படுத்துதல் வழிமுறைகளுக்கான கட்டுமானத் தொகுதிகளை வழங்குவதற்காக உருவாக்கப்பட்டது, இதில் டிராட்டரைசேஷனுக்கான பல்வேறு முறைகளும் அடங்கும். ஹாமில்டோனியன் உருவகப்படுத்துதலுக்கான அசல் ஒப்ஃப்ளோ ஒர்க்ஃப்ளோ, கேட்களின் தாமதமான தொகுப்பு அல்லது சுற்றுகளின் திறமையான டிரான்ஸ்பிலேஷனை அனுமதிக்கவில்லை, எனவே இந்த செயல்பாடு ``qiskit.synthesis` Evolution தொகுதிக்கு மாற்றப்பட்டது.

Note

qiskit.opflow.evolutions.PauliTrotterEvolution வகுப்பு, இசட் அடிப்படையில் மாற்றி, RZ உடன் சுழற்றுதல், பின்னோக்கி மாற்றுதல் மற்றும் ட்ராட்டரைசிங் செய்வதன் மூலம் பாலிஸின் அதிவேகத் தொகைகளுக்கான பரிணாமங்களைக் கணக்கிடுகிறது. .convert() என அழைக்கும் போது, ​​வர்க்கமானது:class:~qiskit.opflow.evolutions.EvolvedOp ஒதுக்கிடங்களை உருவாக்கி, ஆபரேட்டர்களுக்காக, PauliEvolutionGateகளை உருவாக்குவதை உள்ளடக்கிய ஒரு சுழல்நிலை உத்தியைப் பின்பற்றுகிறது. ஆபரேட்டர் ப்ரிமிடிவ்ஸ், மற்றும் ட்ரொட்டரைசேஷன் செய்ய விரும்பிய தொகுப்பு முறைகளில் ஒன்றை வழங்குதல். முறைகளை ஸ்ட்ரிங் மூலம் குறிப்பிடலாம், பின்னர் அது TrotterizationFactory இல் உள்ளிடப்படும், அல்லது qiskit.opflow.evolutions.Trotter இன் முறை நிகழ்வை வழங்குவதன் மூலம் `, :class:`qiskit.opflow.evolutions.Suzuki அல்லது qiskit.opflow.evolutions.QDrift.

qiskit.opflow.evolutions.TrotterizationBase`ஐ நீட்டிக்கும் வெவ்வேறு ட்ரொட்டரைசேஷன் முறைகள் :mod:`qiskit.synthesis க்கு நகர்த்தப்பட்டு, இப்போது qiskit.synthesis.ProductFormula அடிப்படை வகுப்பை விரிவுபடுத்துகிறது. அவை இனி தனித்த பயன்பாட்டிற்கான .convert() முறையைக் கொண்டிருக்காது, ஆனால் இப்போது PauliEvolutionGate இல் செருகப்பட்டு .synthesize() வழியாக அழைக்கப்படும் வகையில் வடிவமைக்கப்பட்டுள்ளது. இந்த சூழலில், qiskit.opflow.evolutions.PauliTrotterEvolution வகுப்பின் வேலையை இப்போது அல்காரிதம்கள் மூலம் நேரடியாகக் கையாள முடியும் (உதாரணமாக, TrotterQRTE) .

இதே முறையில், qiskit.opflow.evolutions.MatrixEvolution வகுப்பு கிளாசிக்கல் மேட்ரிக்ஸ் எக்ஸ்போனென்ஷியேஷன் மூலம் பரிணாமத்தை செய்கிறது, UnitaryGates அல்லது HamiltonianGates உடன் ஒரு சுற்று உருவாக்குகிறது. ஆபரேட்டரின் விரிவாக்கம். இந்த வகுப்பு இனி தேவையில்லை, ஏனெனில் HamiltonianGates நேரடியாக அல்காரிதம்களால் கையாள முடியும்.

சுழற்றுகிறது

மீண்டும் உள்ளடக்கங்கள்

ஓப்ஃப்ளோ	மாற்று
:class:` ~ qiskit.opflow.evolutions.TrotterizationFactory `	நேரடியான மாற்றம் இல்லை. இந்த வகுப்பு கீழே பட்டியலிடப்பட்ட ஒரு வகுப்புகளின் நிகழ்வுகளைக் உருவாக்க பயன்படுகிறது.
:class:` ~ qiskit.opflow.evolutions.Trotter `	:class:` qiskit.synthesis.SuzukiTrotter ` or :class:` qiskit.synthesis.LieTrotter `
:class:` ~ qiskit.opflow.evolutions.Suzuki `	:class:` qiskit.synthesis.SuzukiTrotter `
:class:` ~ qiskit.opflow.evolutions.QDrift `	:class:` qiskit.synthesis.QDrift `

பிற பரிணாம வகுப்புகள்

மீண்டும் உள்ளடக்கங்கள்

ஓப்ஃப்ளோ	மாற்று
:class:` ~ qiskit.opflow.evolutions.EvolutionFactory `	நேரடியான மாற்றம் இல்லை. இந்த வகுப்பு கீழே பட்டியலிடப்பட்ட ஒரு வகுப்புகளின் நிகழ்வுகளைக் உருவாக்க பயன்படுகிறது.
:class:` ~ qiskit.opflow.evolutions.EvolvedOp `	நேரடியான மாற்றம் இல்லை. பணிபுறம் இல்லையெனில் ஒரு குறிப்பிட்ட இயக்குநர் தேவைப்படுகிறது.
:class:` ~ qiskit.opflow.evolutions.MatrixEvolution `	:class:`. HamiltonianGate `
:class:` ~ qiskit.opflow.evolutions.PauliTrotterEvolution `	:class:`. PauliEvolutionGate `

எடுத்துக்காட்டு 1: டிராட்டர் பரிணாமம்

** நுழைவு **

from qiskit.opflow import Trotter, PauliTrotterEvolution, PauliSumOp

hamiltonian = PauliSumOp.from_list([('X', 1), ('Z',1)])
evolution = PauliTrotterEvolution(trotter_mode=Trotter(), reps=2)
evol_result = evolution.convert(hamiltonian.exp_i())
evolved_state = evol_result.to_circuit()

print(evolved_state)

   ┌─────────────────────┐
q: ┤ exp(-it (X + Z))(1) ├
   └─────────────────────┘

** மாற்று

from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.synthesis import SuzukiTrotter

hamiltonian = SparsePauliOp.from_list([('X', 1), ('Z',1)])
evol_gate = PauliEvolutionGate(hamiltonian, time=1, synthesis=SuzukiTrotter(reps=2))
evolved_state = QuantumCircuit(1)
evolved_state.append(evol_gate, [0])

print(evolved_state)

   ┌─────────────────────┐
q: ┤ exp(-it (X + Z))(1) ├
   └─────────────────────┘

எடுத்துக்காட்டு 2: காலத்தைச் சார்ந்த ஹாமில்டோனியனுடன் பரிணாமம்

** நுழைவு **

from qiskit.opflow import Trotter, PauliTrotterEvolution, PauliSumOp
from qiskit.circuit import Parameter

time = Parameter('t')
hamiltonian = PauliSumOp.from_list([('X', 1), ('Y',1)])
evolution = PauliTrotterEvolution(trotter_mode=Trotter(), reps=1)
evol_result = evolution.convert((time * hamiltonian).exp_i())
evolved_state = evol_result.to_circuit()

print(evolved_state)

   ┌─────────────────────────┐
q: ┤ exp(-it (X + Y))(1.0*t) ├
   └─────────────────────────┘

** மாற்று

from qiskit.quantum_info import SparsePauliOp
from qiskit.synthesis import LieTrotter
from qiskit.circuit.library import PauliEvolutionGate
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter

time = Parameter('t')
hamiltonian = SparsePauliOp.from_list([('X', 1), ('Y',1)])
evol_gate = PauliEvolutionGate(hamiltonian, time=time, synthesis=LieTrotter())
evolved_state = QuantumCircuit(1)
evolved_state.append(evol_gate, [0])

print(evolved_state)

   ┌─────────────────────┐
q: ┤ exp(-it (X + Y))(t) ├
   └─────────────────────┘

எடுத்துக்காட்டு 3: மேட்ரிக்ஸ் பரிணாமம்

** நுழைவு **

from qiskit.opflow import MatrixEvolution, MatrixOp

hamiltonian = MatrixOp([[0, 1], [1, 0]])
evolution = MatrixEvolution()
evol_result = evolution.convert(hamiltonian.exp_i())
evolved_state = evol_result.to_circuit()

print(evolved_state.decompose().decompose())

   ┌────────────────┐
q: ┤ U3(2,-π/2,π/2) ├
   └────────────────┘

** மாற்று

from qiskit.quantum_info import SparsePauliOp
from qiskit.extensions import HamiltonianGate
from qiskit import QuantumCircuit

evol_gate = HamiltonianGate([[0, 1], [1, 0]], 1)
evolved_state = QuantumCircuit(1)
evolved_state.append(evol_gate, [0])

print(evolved_state.decompose().decompose())

   ┌────────────────┐
q: ┤ U3(2,-π/2,π/2) ├
   └────────────────┘

எதிர்பார்ப்புகள்

மீண்டும் உள்ளடக்கங்கள்

எதிர்பார்ப்புகள் என்பது சில நிலைச் செயல்பாட்டைப் பொறுத்தமட்டில் கவனிக்கத்தக்க ஒன்றின் எதிர்பார்ப்பு மதிப்பைக் கணக்கிடுவதற்கு உதவும் மாற்றிகள் ஆகும். இந்தச் செயல்பாட்டை இப்போது Estimator primitive இல் காணலாம். இங்கு <attention_primitives>` குறிப்பிடப்பட்டுள்ளபடி வெவ்வேறு ``Estimator` செயலாக்கங்கள் உள்ளன என்பதை நினைவில் கொள்ளவும்

அல்காரிதம்-அக்னாஸ்டிக் எதிர்பார்ப்புகள்

மீண்டும் உள்ளடக்கங்கள்

ஓப்ஃப்ளோ	மாற்று
:class:` ~ qiskit.opflow.opflow.expectations.ExpectationFactory `	நேரடியான மாற்றம் இல்லை. இந்த வகுப்பு கீழே பட்டியலிடப்பட்ட ஒரு வகுப்புகளின் நிகழ்வுகளைக் உருவாக்க பயன்படுகிறது.
:class:` ~ qiskit.opflow.opflow.expectations.AerPauliExpectation `	Use qiskit_aer.primitives.Estimator with approximation=True, and then shots=None as run_options. See example below.
:class:` ~ qiskit.opflow.opflow.expectations.MatrixExpectation `	பயன்படுத்தவும் qiskit.primitives.Estimator primitive (காட்சிகள் எதுவும் அமைக்கப்படவில்லை என்றால், அது ஒரு துல்லியமான ஸ்டேட்வெக்டர் கணக்கீட்டைச் செய்கிறது). கீழே உள்ள உதாரணத்தைப் பார்க்கவும்.
:class:` ~ qiskit.opflow.opflow.expectations.PauliExpectation `	எந்த மதிப்பீட்டாளரின் ப்ரிமிட்டிவ் (qiskit.primitives.Estimator க்கு, ஷாட் அடிப்படையிலான உருவகப்படுத்துதலுக்கு shots!=None ஐ அமைக்கவும், qiskit_aer.primitives.Estimator, இது இயல்புநிலை).

எடுத்துக்காட்டு 1: ஏர் பாலி எதிர்பார்ப்பு

** நுழைவு **

from qiskit.opflow import X, Minus, StateFn, AerPauliExpectation, CircuitSampler
from qiskit.utils import QuantumInstance
from qiskit_aer import AerSimulator

backend = AerSimulator()
q_instance = QuantumInstance(backend)

sampler = CircuitSampler(q_instance, attach_results=True)
expectation = AerPauliExpectation()

state = Minus
operator = 1j * X

converted_meas = expectation.convert(StateFn(operator, is_measurement=True) @ state)
expectation_value = sampler.convert(converted_meas).eval()

print(expectation_value)

-1j

** மாற்று

from qiskit.quantum_info import SparsePauliOp
from qiskit import QuantumCircuit
from qiskit_aer.primitives import Estimator

estimator = Estimator(approximation=True, run_options={"shots": None})

op = SparsePauliOp.from_list([("X", 1j)])
states_op = QuantumCircuit(1)
states_op.x(0)
states_op.h(0)

expectation_value = estimator.run(states_op, op).result().values

print(expectation_value)

[0.-1.j]

எடுத்துக்காட்டு 2: மாட்ரிக்ஸ் எதிர்பார்ப்பு

** நுழைவு **

from qiskit.opflow import X, H, I, MatrixExpectation, ListOp, StateFn
from qiskit.utils import QuantumInstance
from qiskit_aer import AerSimulator

backend = AerSimulator(method='statevector')
q_instance = QuantumInstance(backend)
sampler = CircuitSampler(q_instance, attach_results=True)
expect = MatrixExpectation()

mixed_ops = ListOp([X.to_matrix_op(), H])
converted_meas = expect.convert(~StateFn(mixed_ops))

plus_mean = converted_meas @ Plus
values_plus = sampler.convert(plus_mean).eval()

print(values_plus)

[(1+0j), (0.7071067811865476+0j)]

** மாற்று

from qiskit.primitives import Estimator
from qiskit.quantum_info import SparsePauliOp
from qiskit.quantum_info import Clifford

X = SparsePauliOp("X")

qc = QuantumCircuit(1)
qc.h(0)
H = Clifford(qc).to_operator()

plus = QuantumCircuit(1)
plus.h(0)

estimator = Estimator()
values_plus = estimator.run([plus, plus], [X, H]).result().values

print(values_plus)

[1.         0.70710678]

CVaRExpectation

மீண்டும் உள்ளடக்கங்கள்

ஓப்ஃப்ளோ	மாற்று
:class:` ~ qiskit.opflow.opflow.expectations.CVaRExpectation `	செயல்பாடு புதிய VQE அல்காரிதத்திற்கு மாற்றப்பட்டது: SamplingVQE

எடுத்துக்காட்டு 1: CVR யுடன் VQE

** நுழைவு **

from qiskit.opflow import CVaRExpectation, PauliSumOp

from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
from qiskit_aer import AerSimulator

backend = AerSimulator(method="statevector")
ansatz = TwoLocal(2, 'ry', 'cz')
op = PauliSumOp.from_list([('ZZ',1), ('IZ',1), ('II',1)])
alpha = 0.2
cvar_expectation = CVaRExpectation(alpha=alpha)
opt = SLSQP(maxiter=1000)
vqe = VQE(ansatz, expectation=cvar_expectation, optimizer=opt, quantum_instance=backend)
result = vqe.compute_minimum_eigenvalue(op)

print(result.eigenvalue)

(-1+0j)

** மாற்று

from qiskit.quantum_info import SparsePauliOp

from qiskit.algorithms.minimum_eigensolvers import SamplingVQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
from qiskit.primitives import Sampler

ansatz = TwoLocal(2, 'ry', 'cz')
op = SparsePauliOp.from_list([('ZZ',1), ('IZ',1), ('II',1)])
opt = SLSQP(maxiter=1000)
alpha = 0.2
vqe = SamplingVQE(Sampler(), ansatz, opt, aggregation=alpha)
result = vqe.compute_minimum_eigenvalue(op)

print(result.eigenvalue)

-1.0

க்ரேடியன்ட்டுகள்

மீண்டும் உள்ளடக்கங்கள்

Opflow gradients கட்டமைப்பானது புதிய qiskit.algorithms.gradients தொகுதியால் மாற்றப்பட்டது. புதிய சாய்வுகள் முதன்மை அடிப்படையிலான சப்ரூட்டின்கள் பொதுவாக அல்காரிதம்கள் மற்றும் பயன்பாடுகளால் பயன்படுத்தப்படுகின்றன, இவை தனித்தனியாகவும் செயல்படுத்தப்படலாம். இந்த காரணத்திற்காக, அவர்கள் இப்போது qiskit.algorithms கீழ் வசிக்கின்றனர்.

முந்தைய கிரேடியன்ட் கட்டமைப்பில் அடிப்படை வகுப்புகள், மாற்றிகள் மற்றும் வழித்தோன்றல்கள் இருந்தன. "வழித்தோன்றல்கள்" ஒரு தொழிற்சாலை வடிவமைப்பு முறையைப் பின்பற்றின, இந்த வகுப்புகள் ஒவ்வொன்றிற்கும் சரம் அடையாளங்காட்டிகள் மூலம் வெவ்வேறு முறைகள் வழங்கப்படலாம். புதிய கிரேடியன்ட் கட்டமைப்பில் சப்ரூட்டின்களின் இரண்டு முக்கிய குடும்பங்கள் உள்ளன: ** கிரேடியன்ட்** மற்றும் QGT/QFI. கிரேடியன்ட்ஸ் மாதிரி அல்லது மதிப்பீட்டின் அடிப்படையிலானதாக இருக்கலாம், அதே சமயம் தற்போதைய QGT/QFI செயலாக்கங்கள் மதிப்பீட்டின் அடிப்படையிலானவை.

இது பணிப்பாய்வு மாற்றத்திற்கு வழிவகுக்கிறது, அதற்குப் பதிலாக:

from qiskit.opflow import Gradient

grad = Gradient(method="param_shift")

# task based on expectation value computations + gradients

இலக்கு பழமையான (மாதிரி/மதிப்பீட்டாளர்) மற்றும் இலக்கு முறையைப் பொறுத்து, விரும்பிய வகுப்பை இப்போது வெளிப்படையாக இறக்குமதி செய்கிறோம்:

from qiskit.algorithms.gradients import ParamShiftEstimatorGradient
from qiskit.primitives import Estimator

grad = ParamShiftEstimatorGradient(Estimator())

# task based on expectation value computations + gradients

இது QFI வகுப்பிற்கும் இதேபோல் வேலை செய்கிறது, இங்குச் செய்வதற்கு பதிலாக:

from qiskit.opflow import QFI

qfi = QFI(method="lin_comb_full")

# task based on expectation value computations + QFI

வெவ்வேறு QGT (குவாண்டம் கிரேடியன்ட் டென்சர்) செயலாக்கங்களுடன் தொடங்கக்கூடிய பொதுவான QFI செயல்படுத்தல் இப்போது உங்களிடம் உள்ளது:

from qiskit.algorithms.gradients import LinCombQGT, QFI
from qiskit.primitives import Estimator

qgt = LinCombQGT(Estimator())
qfi = QFI(qgt)

# task based on expectation value computations + QFI

Note

மிகவும் பொதுவான சாய்வு அமைப்புகளை நகர்த்துவதற்கான விரைவான வழிகாட்டி இங்கே உள்ளது. அனைத்து புதிய சாய்வு இறக்குமதிகளும் வடிவமைப்பைப் பின்பற்றுகின்றன என்பதை நினைவில் கொள்ளவும்:

from qiskit.algorithms.gradients import MethodPrimitiveGradient, QFI

க்ரேடியன்ட்டுகள்

ஓப்ஃப்ளோ	மாற்று
` Gradient (method = "lin_comb")` `	LinCombEstimatorGradient(estimator=estimator) அல்லது LinCombSamplerGradient(sampler=sampler)
` Gradient (method = "param_ shift")` `	ParamShiftEstimatorGradient(estimator=estimator) அல்லது ParamShiftSamplerGradient(sampler=sampler)
` Gradient (method = "fin_ diff")` `	FiniteDiffEstimatorGradient(estimator=estimator) அல்லது ParamShiftSamplerGradient(sampler=sampler)

QFI/QGT

ஓப்ஃப்ளோ	மாற்று
` QFI (method = "lin_comb_full")` `	` qgt=LinCombQGT (Estimator () ` ` QFI (qgt = qgt) ` `

மரபு கிரேடியன்ட் கட்டமைப்பில் உள்ள பிற துணை வகுப்புகள் இப்போது நிராகரிக்கப்பட்டுள்ளன. முழு இடம்பெயர்வு பட்டியல் இங்கே:

ஓப்ஃப்ளோ	மாற்று
:class:` ~ qiskit.opflow.gradients.DerivativeBase `	மாற்று இல்லை. இது கிரேடியன்ட், ஹெஸியன் மற்றும் QFI அடிப்படை வகுப்புகளுக்கான அடிப்படை வகுப்பாகும்.
GradientBase and Gradient	BaseSamplerGradient அல்லது BaseEstimatorGradient, மற்றும் ஒரு முறைக்குக் குறிப்பிட்ட துணைப்பிரிவுகள், மேலே விளக்கப்பட்டுள்ளது.
:class:` .HessianBase ` மற்றும் :class:` ~ qiskit.opflow.gradients.Hessian `	மாற்று இல்லை. புதிய கிரேடென்ட் கட்டமைப்பானது ஹெஸ்ஸியன்களுடன் சுயாதீனமான பொருட்களாக வேலை செய்யாது.
:class:` .QFIBase ` மற்றும் :class:` ~ qiskit.opflow.gradients.QFI `	புதிய QFI வகுப்பு நீட்டிக்கப்பட்டுள்ளது QGT, எனவே தொடர்புடைய அடிப்படை வகுப்பு BaseQGT
:class:` ~ qiskit.opflow.gradients.CircuitGradient `	மாற்று இல்லை. சர்க்யூட் மற்றும் கிரேடியன்ட் PrimitiveOp இடையே மாற்ற இந்த வகுப்பு பயன்படுத்தப்பட்டது, மேலும் இந்தச் செயல்பாடு இனி தேவையில்லை.
:class:` ~ qiskit.opflow.gradients.CircuitQFI `	மாற்று இல்லை. சர்க்யூட் மற்றும் QFI PrimitiveOp இடையே மாற்ற இந்த வகுப்பு பயன்படுத்தப்பட்டது, மேலும் இந்தச் செயல்பாடு இனி தேவையில்லை.
:class:` ~ qiskit.opflow.gradients.NaturalGradient `	மாற்று இல்லை. அதே செயல்பாட்டை QFI தொகுதி மூலம் அடையலாம்.

எடுத்துக்காட்டு 1: வரையறுக்கப்பட்ட வேறுபாடுகள் தொகுக்கப்பட்ட கிரேடியன்ட்

** நுழைவு **

from qiskit.circuit import Parameter, QuantumCircuit
from qiskit.opflow import Gradient, X, Z, StateFn, CircuitStateFn
import numpy as np

ham = 0.5 * X - 1 * Z

a = Parameter("a")
b = Parameter("b")
c = Parameter("c")
params = [a,b,c]

qc = QuantumCircuit(1)
qc.h(0)
qc.u(a, b, c, 0)
qc.h(0)

op = ~StateFn(ham) @ CircuitStateFn(primitive=qc, coeff=1.0)

# the gradient class acted similarly opflow converters,
# with a .convert() step and an .eval() step
state_grad = Gradient(grad_method="param_shift").convert(operator=op, params=params)

# the old workflow did not allow for batched evaluation of parameter values
values_dict = [{a: np.pi / 4, b: 0, c: 0}, {a: np.pi / 4, b: np.pi / 4, c: np.pi / 4}]
gradients = []
for i, value_dict in enumerate(values_dict):
     gradients.append(state_grad.assign_parameters(value_dict).eval())

print(gradients)

[[(0.35355339059327356+0j), (-1.182555756156289e-16+0j), (-1.6675e-16+0j)], [(0.10355339059327384+0j), (0.8535533905932734+0j), (1.103553390593273+0j)]]

** மாற்று

from qiskit.circuit import Parameter, QuantumCircuit
from qiskit.primitives import Estimator
from qiskit.algorithms.gradients import ParamShiftEstimatorGradient
from qiskit.quantum_info import SparsePauliOp
import numpy as np

ham = SparsePauliOp.from_list([("X", 0.5), ("Z", -1)])

a = Parameter("a")
b = Parameter("b")
c = Parameter("c")

qc = QuantumCircuit(1)
qc.h(0)
qc.u(a, b, c, 0)
qc.h(0)

estimator = Estimator()
gradient = ParamShiftEstimatorGradient(estimator)

# the new workflow follows an interface close to the primitives'
param_list = [[np.pi / 4, 0, 0], [np.pi / 4, np.pi / 4, np.pi / 4]]

# for batched evaluations, the number of circuits must match the
# number of parameter value sets
gradients = gradient.run([qc] * 2, [ham] * 2, param_list).result().gradients

print(gradients)

[array([ 3.53553391e-01,  0.00000000e+00, -1.80411242e-16]), array([0.10355339, 0.85355339, 1.10355339])]

எடுத்துக்காட்டு 2: QFI

** நுழைவு **

from qiskit.circuit import Parameter, QuantumCircuit
from qiskit.opflow import QFI, CircuitStateFn
import numpy as np

# create the circuit
a, b = Parameter("a"), Parameter("b")
qc = QuantumCircuit(1)
qc.h(0)
qc.rz(a, 0)
qc.rx(b, 0)

# convert the circuit to a QFI object
op = CircuitStateFn(qc)
qfi = QFI(qfi_method="lin_comb_full").convert(operator=op)

# bind parameters and evaluate
values_dict = {a: np.pi / 4, b: 0.1}
qfi = qfi.bind_parameters(values_dict).eval()

print(qfi)

[[ 1.00000000e+00+0.j -3.63575685e-16+0.j]
 [-3.63575685e-16+0.j  5.00000000e-01+0.j]]

** மாற்று

from qiskit.circuit import Parameter, QuantumCircuit
from qiskit.primitives import Estimator
from qiskit.algorithms.gradients import LinCombQGT, QFI
import numpy as np

# create the circuit
a, b = Parameter("a"), Parameter("b")
qc = QuantumCircuit(1)
qc.h(0)
qc.rz(a, 0)
qc.rx(b, 0)

# initialize QFI
estimator = Estimator()
qgt = LinCombQGT(estimator)
qfi = QFI(qgt)

# evaluate
values_list = [[np.pi / 4, 0.1]]
qfi = qfi.run(qc, values_list).result().qfis

print(qfi)

[array([[ 1.00000000e+00, -1.50274614e-16],
       [-1.50274614e-16,  5.00000000e-01]])]