Skip to main content
IBM Quantum Platform

키스킷 0.40 릴리즈 노트

0.40.0

이 릴리스는 키스킷 메타패키지의 일부인 키스킷 IBMQ 공급자 프로젝트를 공식적으로 더 이상 지원하지 않습니다. 즉, 향후 릴리스에서는 pip install qiskit 에 qiskit-ibmq-provider 이 더 이상 자동으로 포함되지 않습니다. 현재 qiskit-ibmq-provider 을 얻기 위해 qiskit 을 설치하거나 종속성으로 나열하고 있는 경우 qiskit-ibmq-provider 도 명시적으로 포함하도록 업데이트해야 합니다. 이는 키스킷 프로젝트가 qiskit 패키지에 양자 회로, 프로그램 및 애플리케이션을 구축하고 컴파일하는 데 필요한 공통 핵심 기능만 포함하는 모델로 이동함에 따라 이루어지고 있습니다. 해당 코어를 기반으로 하거나 키스킷을 하드웨어 또는 시뮬레이터에 연결하는 패키지는 별도의 패키지로 설치할 수 있습니다.

테라 0.23.0

Prelude

키스킷 테라 0.23.0 는 여러 가지 새로운 기능과 버그 수정이 포함된 주요 기능 릴리스입니다. 이번 릴리스의 주요 내용은 다음과 같습니다:

이 릴리스에서는 Python 3.7 으로 실행하는 기능도 더 이상 지원되지 않습니다. 이제 Python 3.7 으로 키스킷을 실행하면 DeprecationWarning 이 출력됩니다. Python 3.7 에 대한 지원은 0.25.0 릴리스(현재 2023년 7월 릴리스 예정)의 일부로 제거되며, 이 시점에서 키스킷을 사용하려면 Python 3.8 이상이 필요합니다.

새 기능

  • 의 펄스 qiskit.pulse.library

    를 새 매개변수 angle 로 초기화할 수 있으므로 두 개의 플로트 매개변수 amp 와 angle 를 제공할 수 있습니다. 복잡한 amp 초기화는 계속 지원됩니다.

  • 클래스에는 AdaptVQE 클래스에는 새로운 어트리뷰트가 있습니다, eigenvalue_history라는 새로운 속성이 있는데, 이는 AdaptVQE 의 반복당 달성된 최저 에너지를 추적하는 데 사용됩니다. 예를 들어,

    from qiskit.algorithms.minimum_eigensolvers import VQE
from qiskit.algorithms.minimum_eigensolvers.adapt_vqe import AdaptVQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import EvolvedOperatorAnsatz
from qiskit.opflow import PauliSumOp
from qiskit.primitives import Estimator
from qiskit.quantum_info import SparsePauliOp
from qiskit.utils import algorithm_globals

excitation_pool = [
    PauliSumOp(
        SparsePauliOp(["IIIY", "IIZY"], coeffs=[0.5 + 0.0j, -0.5 + 0.0j]), coeff=1.0
    ),
    PauliSumOp(
        SparsePauliOp(["ZYII", "IYZI"], coeffs=[-0.5 + 0.0j, 0.5 + 0.0j]), coeff=1.0
    ),
    PauliSumOp(
        SparsePauliOp(
            ["ZXZY", "IXIY", "IYIX", "ZYZX", "IYZX", "ZYIX", "ZXIY", "IXZY"],
            coeffs=[
                -0.125 + 0.0j,
                0.125 + 0.0j,
                -0.125 + 0.0j,
                0.125 + 0.0j,
                0.125 + 0.0j,
                -0.125 + 0.0j,
                0.125 + 0.0j,
                -0.125 + 0.0j,
            ],
        ),
        coeff=1.0,
    ),
]
ansatz = EvolvedOperatorAnsatz(excitation_pool, initial_state=self.initial_state)
optimizer = SLSQP()
h2_op = PauliSumOp.from_list(
    [
        ("IIII", -0.8105479805373266),
        ("ZZII", -0.2257534922240251),
        ("IIZI", +0.12091263261776641),
        ("ZIZI", +0.12091263261776641),
        ("IZZI", +0.17218393261915543),
        ("IIIZ", +0.17218393261915546),
        ("IZIZ", +0.1661454325638243),
        ("ZZIZ", +0.1661454325638243),
        ("IIZZ", -0.2257534922240251),
        ("IZZZ", +0.16892753870087926),
        ("ZZZZ", +0.17464343068300464),
        ("IXIX", +0.04523279994605788),
        ("ZXIX", +0.04523279994605788),
        ("IXZX", -0.04523279994605788),
        ("ZXZX", -0.04523279994605788),
    ]
)

algorithm_globals.random_seed = 42
calc = AdaptVQE(VQE(Estimator(), ansatz, self.optimizer))
res = calc.compute_minimum_eigenvalue(operator=h2_op)

print(calc.eigenvalue_history)

    calc.history 의 반환 값은 단일 반복이 있으므로 대략 [-1.85727503] 이 되어야 합니다.

  • 를 실행할 때 런타임 로깅이 AdaptVQE 가 개선되었습니다. 지금 클래스를 실행하면 클래스가 실행되면서 DEBUG 및 INFO 레벨 로그 메시지가 전송됩니다.

  • 새로운 트랜스파일러 패스( CollectAndCollapse)를 추가하여 회로의 노드 블록을 수집하고 통합할 수 있습니다. 이 패스는 결합된 블록 수집 및 통합을 위한 일반적인 기본 클래스로 설계되었습니다. 완전히 일반적으로 블록을 수집하고 축소하는 작업은 패스를 인스턴스화하는 동안 제공되는 함수를 통해 이루어집니다. 예를 들어 CollectLinearFunctions 에서 상속하도록 업데이트되어 CollectAndCollapse 에서 블록을 수집하고 CXGate 및 SwapGate 게이트 블록을 수집하고 각 블록을 LinearFunction. 의 CollectCliffords 는 현재 CollectAndCollapse 를 기반으로 하며, "클리포드" 게이트 블록을 수집하고 각 블록을 Clifford.

    이 인터페이스는 더 큰 노드 블록을 수집하기 위해 게이트 간의 정류성을 활용할 수 있는 do_commutative_analysis 옵션도 지원합니다. 예를 들어, 다음 회로에서 CX 게이트 블록을 수집합니다:

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

    do_commutative_analysis 을 사용하면 첫 번째 CX 게이트와 Z 게이트가 통근하기 때문에 두 개의 CX 게이트를 통합할 수 있습니다.

  • 다양한 수집 전략을 구현하는 새로운 클래스 BlockCollector 와 다양한 붕괴 전략을 구현하는 새로운 클래스 BlockCollapser 를 추가했습니다. 현재 BlockCollector 에는 주어진 필터 함수를 준수하는 모든 게이트를 탐욕스럽게 수집하는 전략(예: 모든 클리포드 게이트 수집)이 포함되어 있으며, BlockCollapser 에는 블록의 모든 게이트를 단일 객체로 통합하는 전략(예: 클리포드 게이트 블록을 단일 객체로 통합할 수 있음)이 포함되어 있습니다 Clifford).

  • 클리포드 게이트 블록을 수집하는 새로운 CollectCliffords 클리포드 게이트 블록을 수집하고 이 블록을 오브젝트로 통합하는 새로운 qiskit.quantum_info.Clifford 오브젝트로 통합합니다. 이 패스는 CollectAndCollapse 에서 상속되며 특히 do_commutative_analysis 옵션을 지원합니다. 또한 두 가지 추가 옵션 split_blocks 및 min_block_size 을 지원합니다. 자세한 내용은 릴리스 노트( CollectAndCollapse ) 및 CollectLinearFunctions 에서 자세한 내용을 확인하세요.

  • 트랜스파일러 패스의 CollectLinearFunctions 트랜스파일러 패스에는 생성자에 몇 가지 새로운 인수가 있습니다:

    • do_commutative_analysis를 사용하면 더 큰 노드 블록을 수집하기 위해 게이트 간의 정류성을 활용할 수 있습니다.

    • split_blocks를 사용하면 수집된 블록을 큐비트의 분리된 하위 집합에 대한 하위 블록으로 분할할 수 있습니다. 예를 들어 다음 회로를 살펴보겠습니다:

      qc = QuantumCircuit(4)
qc.cx(0, 2)
qc.cx(1, 3)
qc.cx(2, 0)
qc.cx(3, 1)
qc.cx(1, 3)

      큐비트에 대한 CX 게이트의 단일 블록 {0, 1, 2, 3} 은 두 개의 분리된 하위 블록, 즉 큐비트에 대한 {0, 2} 과 큐비트에 대한 {1, 3} 으로 분할될 수 있습니다.

    • min_block_size를 사용하면 통합할 블록의 최소 크기를 지정할 수 있으며, 게이트 수가 적은 블록은 수정되지 않습니다. 예를 들어 다음 회로를 살펴보겠습니다:

      qc = QuantumCircuit(4)
qc.cx(1, 2)
qc.cx(2, 1)

      min_block_size 이 1 또는 2이면 두 개의 CX 게이트가 통합되고 min_block_size 이 3 이상이면 변경되지 않습니다.

  • 깊이 효율적인 합성 알고리즘이 추가되었습니다 synth_cnot_depth_line_kms() 선형 가역 회로에 대한 LinearFunction 선형 최접근 이웃 아키텍처에 대한 깊이 효율적인 합성 알고리즘을 추가했습니다: https://arxiv.org/abs/quant-ph/0701194.

  • 메서드는 이제 DAGCircuit.replace_block_with_op() 메서드는 이제 블록을 교체할 때 생성된 새 DAGOpNode 블록이 교체될 때 생성됩니다. 이전에는 이 메서드를 호출해도 아무것도 반환하지 않았습니다.

  • 깊이 효율적인 합성 알고리즘 추가 synth_permutation_depth_lnn_kms() 에 대한 Permutation 에 대한 깊이 효율적인 합성 알고리즘을 추가했습니다: https://arxiv.org/abs/quant-ph/0701194

  • 순열 논리를 회로 요소로 표현하는 새로운 클래스 PermutationGate 클래스를 추가했습니다. 정적 정의가 있는 기존 Permutation 회로 라이브러리 요소의 정적 정의와 달리 이 새로운 클래스는 순열 회로가 선언될 때 합성을 피합니다. 이렇게 하면 실제 합성이 트랜스파일러로 지연됩니다. 또한 순열을 합성하는 데 여러 가지 알고리즘을 사용할 수 있으며, 이는 고급 합성 순열 플러그인으로도 사용할 수 있습니다.

    의 또 다른 주요 기능은 PermutationGate 의 또 다른 특징은 순열에 대한 단일 행렬을 효율적으로 반환하기 위해 __array__ 인터페이스를 구현한다는 것입니다.

  • 순열 합성을 위한 몇 가지 고수준 합성 플러그인을 추가했습니다:

    • BasicSynthesisPermutation는 완전히 연결된 아키텍처에 적용되며 정렬을 기반으로 합니다. 이것은 순열을 위한 양자 회로를 구성하는 데 이전에 사용된 알고리즘입니다.
    • ACGSynthesisPermutation는 완전 연결형 아키텍처에 적용되지만 Alon, Chung, Graham 방식을 기반으로 합니다. 모든 순열을 깊이 2(스왑으로 측정)로 합성합니다.
    • KMSSynthesisPermutation: 선형 최인접 아키텍처에 적용되며 최근에 추가된 쿠틴, 몰튼, 스미스라인 방식에 해당합니다.

    예를 들어,

    from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import PermutationGate
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes.synthesis.high_level_synthesis import HLSConfig, HighLevelSynthesis
from qiskit.transpiler.passes.synthesis.plugin import HighLevelSynthesisPluginManager

# Create a permutation and add it to a quantum circuit
perm = PermutationGate([4, 6, 3, 7, 1, 2, 0, 5])
qc = QuantumCircuit(8)
qc.append(perm, range(8))

# Print available plugin names for synthesizing permutations
# Returns ['acg', 'basic', 'default', 'kms']
print(HighLevelSynthesisPluginManager().method_names("permutation"))

# Default plugin for permutations
# Returns a quantum circuit with size 6 and depth 3
qct = PassManager(HighLevelSynthesis()).run(qc)
print(f"Default: {qct.size() = }, {qct.depth() = }")

# KMSSynthesisPermutation plugin for permutations
# Returns a quantum circuit with size 18 and depth 6
# but adhering to the linear nearest-neighbor architecture.
qct = PassManager(HighLevelSynthesis(HLSConfig(permutation=[("kms", {})]))).run(qc)
print(f"kms: {qct.size() = }, {qct.depth() = }")

# BasicSynthesisPermutation plugin for permutations
# Returns a quantum circuit with size 6 and depth 3
qct = PassManager(HighLevelSynthesis(HLSConfig(permutation=[("basic", {})]))).run(qc)
print(f"basic: {qct.size() = }, {qct.depth() = }")

# ACGSynthesisPermutation plugin for permutations
# Returns a quantum circuit with size 6 and depth 2
qct = PassManager(HighLevelSynthesis(HLSConfig(permutation=[("acg", {})]))).run(qc)
print(f"acg: {qct.size() = }, {qct.depth() = }")

  • 퀀텀 피셔 정보(QFI) 및 퀀텀 기하학적 텐서(QGT) 알고리즘을 위한 새로운 클래스가 추가되었습니다 primitives, qiskit.algorithms.gradients.QFI 와 qiskit.algorithms.gradients.LinCombQGT를 그라디언트 모듈에 추가했습니다: qiskit.algorithms.gradients. 예를 들어,

    from qiskit.circuit import QuantumCircuit, Parameter
from qiskit.algorithms.gradients import LinCombQGT, QFI

estimator = Estimator()
a, b = Parameter("a"), Parameter("b")
qc = QuantumCircuit(1)
qc.h(0)
qc.rz(a, 0)
qc.rx(b, 0)

parameter_value = [[np.pi / 4, 0]]

qgt = LinCombQGT(estimator)
qgt_result = qgt.run([qc], parameter_value).result()

qfi = QFI(qgt)
qfi_result = qfi.run([qc], parameter_value).result()

  • 의 생성자에 새로운 키워드 인수 derivative_type 를 추가했습니다 LinCombEstimatorGradient. 이 인수는 그라데이션의 실수 또는 가상 부분만 계산하도록 지정할 수 있는 DerivativeType 열거형을 받습니다.

  • 사용자 구성 파일에 새 옵션 circuit_reverse_bits 을 추가했습니다. 이를 통해 사용자는 회로 서랍의 reverse_bits 인수에 대해 선호하는 기본 동작에 대한 부울을 설정할 수 있습니다 QuantumCircuit.draw() 와 circuit_drawer(). 예를 들어, 기본 위치 ~/.qiskit/settings.conf 에 있는 사용자 구성 파일에 섹션을 추가합니다:

    [default]
circuit_reverse_bits = True

    를 누르면 비트가 역순으로 표시되도록 기본값이 변경됩니다.

  • 새 클래스 추가 Z2Symmetries 에 qiskit.quantum_info 입력에서 Z2Z_2 대칭을 식별하는 데 사용됩니다 SparsePauliOp.

  • 새로운 펄스 지시어 추가 TimeBlockade. 이 지시어는 지연 지시어와 거의 동일하게 동작하지만 실행 전에 제거됩니다. 이 지시어는 펄스 빌더 내에서 내부적으로 사용하기 위한 것으로 다음과 같은 기능을 합니다 ScheduleBlock 명령어를 절대 시간 간격으로 표시하는 데 도움이 됩니다. 이렇게 하면 펄스 빌더가 Schedule 를 ScheduleBlock 로 변환하는 대신 Call 로 감싸는 대신

  • 양자 시간 진화를 위한 인터페이스를 구현하는 변형 양자 시간 진화를 위한 프리미티브 지원 알고리즘을 추가했습니다. 클래스는 qiskit.algorithms.VarQRTE 클래스는 실제에 사용되며 qiskit.algorithms.VarQITE 클래스는 전달된 변형 원리에 따라 가상의 양자 시간 진화에 사용됩니다.

    각 알고리즘은 추상적인 인터페이스인 ImaginaryVariationalPrinciple 추상 인터페이스를 구현합니다. 다음과 같은 구현이 포함되어 있습니다:

    예를 들어,

    from qiskit.algorithms import TimeEvolutionProblem, VarQITE
from qiskit.algorithms.time_evolvers.variational import ImaginaryMcLachlanPrinciple
from qiskit.circuit.library import EfficientSU2
from qiskit.quantum_info import SparsePauliOp
import numpy as np

observable = SparsePauliOp.from_list(
    [
        ("II", 0.2252),
        ("ZZ", 0.5716),
        ("IZ", 0.3435),
        ("ZI", -0.4347),
        ("YY", 0.091),
        ("XX", 0.091),
    ]
)

ansatz = EfficientSU2(observable.num_qubits, reps=1)
init_param_values = np.zeros(len(ansatz.parameters))
for i in range(len(ansatz.parameters)):
    init_param_values[i] = np.pi / 2
var_principle = ImaginaryMcLachlanPrinciple()
time = 1
evolution_problem = TimeEvolutionProblem(observable, time)
var_qite = VarQITE(ansatz, var_principle, init_param_values)
evolution_result = var_qite.evolve(evolution_problem)

  • 변환 규칙 추가 XXPlusYYGate 및 XXMinusYYGate 를 다른 게이트로 변환하는 규칙을 SessionEquivalenceLibrary 에 추가했습니다. 이를 통해 백엔드 또는 transpile() 백엔드를 타겟팅하거나 Target 를 타겟팅할 수 있습니다.

  • 두 개의 새로운 가짜 백엔드를 추가했습니다, FakePrague 와 FakeSherbrooke 모듈에 qiskit.providers.fake_provider 모듈에 FakePragueIBM 프라하 백로 R1 백엔드의 속성 스냅샷을 백엔드에 제공하고 FakeSherbrooke 는 IBM 셔브룩 이글 R3 백엔드에서 프로퍼티의 스냅샷이 포함된 백엔드를 제공합니다.

  • 에 새 키워드 인수 allow_unknown_parameters 를 추가했습니다 ParameterExpression.bind() 및 ParameterExpression.subs() 메서드에 추가했습니다. 이 새 인수를 설정하면 알 수 없는 매개변수가 포함된 사전을 오류 발생 없이 이러한 메서드에 전달할 수 있습니다. 이전에는 해당 동작을 비활성화할 방법 없이 항상 오류가 발생했습니다.

  • 메서드의 BaseEstimator.run() 메서드의 observables 인수는 이제 이미 허용된 다른 유형 외에도 str 또는 str 입력 유형 시퀀스를 허용합니다. 사용 시 입력 문자열 형식은 생성자가 객체에 대해 허용하는 폴리 문자열 표현과 일치해야 합니다 Pauli 객체에 대해 생성자가 허용하는 폴리 문자열 표현과 일치해야 합니다.

  • 새로운 생성자 메서드 추가 QuantumCircuit.from_instructions() 새로운 생성자 메서드 추가 QuantumCircuit 객체를 생성할 수 있는 새로운 생성자 메서드를 추가했습니다. 예를 들어,

    from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.circuit.quantumcircuitdata import CircuitInstruction
from qiskit.circuit import Measure
from qiskit.circuit.library import HGate, CXGate


qr = QuantumRegister(2)
cr = ClassicalRegister(2)
instructions = [
    CircuitInstruction(HGate(), [qr[0]], []),
    CircuitInstruction(CXGate(), [qr[0], qr[1]], []),
    CircuitInstruction(Measure(), [qr[0]], [cr[0]]),
    CircuitInstruction(Measure(), [qr[1]], [cr[1]]),
]
circuit = QuantumCircuit.from_instructions(instructions)
circuit.draw("mpl")
    _images/legacy_release_notes-3.png

  • 이제 Clifford 클래스는 이제 생성자에서 선택적 copy 키워드 인수를 받습니다. False 로 설정하면 입력으로 제공된 StabilizerTable 이 복사되지 않고 직접 사용됩니다. 테이블의 데이터가 다른 방법으로 변경되지 않는다면 성능상의 이점이 있을 수 있습니다.

  • 의 성능이 Clifford.compose() 의 성능이 모든 큐비트 수에서 크게 향상되었습니다. 20큐비트 연산자의 경우 속도가 100배 정도 빨라집니다.

  • 새로운 합성 기능 추가 synth_clifford_layers()를 합성하는 새로운 합성 함수 Clifford 를 레이어로 합성하는 새로운 합성 함수를 추가했습니다. 알고리즘은 S를 기반으로 합니다. 브라비, D. 마슬로프, 하다 마드가없는 회로는 클리포드 그룹의 구조를 드러냅니다, arxiv:2003.09412. 이렇게 하면 클리포드는 CZ 게이트 2개 레이어와 CX 게이트 1개 레이어를 포함한 8개의 게이트 레이어로 분해됩니다. 예를 들어, 5큐비트 클리포드 회로는 다음과 같은 계층으로 분해됩니다:

         ┌─────┐┌─────┐┌────────┐┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
q_0: ┤0    ├┤0    ├┤0       ├┤0    ├┤0    ├┤0    ├┤0    ├┤0       ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_1: ┤1    ├┤1    ├┤1       ├┤1    ├┤1    ├┤1    ├┤1    ├┤1       ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_2: ┤2 S2 ├┤2 CZ ├┤2 CX_dg ├┤2 H2 ├┤2 S1 ├┤2 CZ ├┤2 H1 ├┤2 Pauli ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_3: ┤3    ├┤3    ├┤3       ├┤3    ├┤3    ├┤3    ├┤3    ├┤3       ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_4: ┤4    ├┤4    ├┤4       ├┤4    ├┤4    ├┤4    ├┤4    ├┤4       ├
     └─────┘└─────┘└────────┘└─────┘└─────┘└─────┘└─────┘└────────┘

    이 방법을 사용하면 Clifford 를 2쿼비트 깊이 7n+27n+2 로 분해하여 선형 최인접 이웃(LNN) 연결에 사용할 수 있습니다.

  • 여러 표준 라이브러리 게이트 클래스의 power() 메서드의 반환 유형이 보다 구체적인 게이트 객체를 반환하여 손실이 적고 효율적인 출력을 생성하도록 업데이트되었습니다. 예를 들어, 이제 power() 를 실행하면 이제 IGate 인스턴스가 아닌 UnitaryGate 대신 인스턴스를 반환합니다.

    개선된 출력 유형의 전체 목록은 다음과 같습니다:

    게이트 클래스
    출력 클래스 power()
    CPhaseGateCPhaseGate
    CSGateCPhaseGate
    CSdgGateCPhaseGate
    IGateIGate.
    PhaseGatePhaseGate
    RGateRGate
    RXGateRXGate
    RXXGateRXXGate
    RYGateRYGate
    RYYGateRYYGate
    RZGateRZGate
    RZXGateRZXGate
    RZZGateRZZGate
    SdgGatePhaseGate
    SGatePhaseGate
    TdgGatePhaseGate
    TGatePhaseGate
    XXMinusYYGateXXMinusYYGate
    XXPlusYYGateXXPlusYYGate
    ZGatePhaseGate
    iSwapGateXXPlusYYGate

  • 는 이제 EquivalenceLibrary 는 이제 내부적으로 PyDiGraph 로 표시되며, 이 기본 그래프 객체는 새로운 graph 어트리뷰트에서 액세스할 수 있습니다. 이 속성은 키스킷 내부에서 사용하기 위한 것이므로 사용자가 수정하기 전에 항상 복사하여 내부 등가 그래프가 손상되는 것을 방지해야 합니다.

  • 생성자 메서드의 Operator.from_circuit() 생성자 메서드는 이제 트랜스파일러의 라우팅/스왑 매핑 단계에서 발생하는 출력 순열을 역전시킵니다. 기본적으로 트랜스파일된 회로에 스왑 게이트가 삽입된 경우 출력 행렬은 해당 순열이 반전되어 반환되는 행렬이 원래 트랜스파일되지 않은 회로와 동일하게 됩니다. 이 기본 동작을 비활성화하려면 ignore_set_layout 키워드 인수를 True 으로 설정하면 됩니다(번역에서 초기 레이아웃을 무시하는 이전 동작과 더불어). 최종 레이아웃을 수동으로 설정하려면 새로운 final_layout 키워드 인수를 사용하여 출력 순열에 사용할 Layout 객체를 전달할 수 있습니다.

  • 대칭을 처리하는 GateDirection 트랜스파일러 패스에 대한 지원이 추가되었습니다 RXXGate, RYYGate및 RZZGate 게이트. 이제 패스는 이러한 게이트를 올바르게 처리하고 다른 수정 없이 단순히 qarg 순서를 제자리로 되돌립니다.

  • Python 지수 연산자( **)를 사용하는 기능이 추가되었습니다 Gate 객체가 이제 지원됩니다. 이는 객체에서 Gate.power() 메서드를 실행하는 것과 같습니다.

    예를 들어,

    from qiskit.circuit.library import XGate

sx = XGate() ** 0.5

  • 모듈에 새로운 GaussianSquareDrag 펄스 모양을 추가했습니다 qiskit.pulse.library 모듈에 추가했습니다. 이 펄스 모양은 GaussianSquare 와 유사하지만 상승 및 하강 시 Drag 모양을 사용합니다. DRAG 펄스 모양의 보정은 펄스의 상승 및 하강 주파수 스펙트럼의 일부를 억제하여 펄스의 구동 주파수에 가까운 주파수에서 흥미로운 스펙트럼 큐비트를 피하는 데 도움이 될 수 있습니다.

  • 의 생성자에 새로운 키워드 인수 method 를 추가했습니다 FiniteDiffEstimatorGradient 및 FiniteDiffSamplerGradient 클래스의 생성자에 추가했습니다. method 인수는 그라데이션에 사용할 계산 방법을 나타내는 문자열을 허용합니다. "central", "forward", "backward" 의 세 가지 방법을 사용할 수 있습니다. 메소드의 정의는 다음과 같습니다:

    방법
    계산
    "central"f(x+e)−f(x−e)2e\frac{f(x+e)-f(x-e)}{2e}
    "forward"f(x+e)−f(x)e\frac{f(x+e) - f(x)}{e}
    "backward"f(x)−f(x−e)e\frac{f(x)-f(x-e)}{e}

    여기서 ee 은 오프셋 엡실론입니다.

  • 의 모든 그라데이션 클래스는 qiskit.algorithms.gradients 의 모든 그라데이션 클래스는 이제 파라미터화되지 않은 연산을 언롤링하는 대신 보존합니다. 이를 통해 개별 프리미티브가 처리할 수 있는 커스텀 불투명 게이트에서 그레이디언트를 평가할 수 있으며, 그레이디언트 회로가 구성된 후에도 최적화된 합성 및 컴파일을 위해 더 높은 수준의 추상화를 유지할 수 있습니다.

  • 패스를 추가하여 TranslateParameterizedGates 패스를 추가하여 회로에서 파라미터화된 게이트만 지정된 기준으로 매핑하고 파라미터화되지 않은 게이트는 그대로 둡니다. 패스는 먼저 언롤링을 시도하고 매개변수화된 게이트를 더 이상 언롤링할 수 없는 경우 최종적으로 변환합니다.

  • 트랜스파일러 패스가 CollectCliffords 트랜스파일러 패스가 확장되어 "클리포드 게이트" 블록을 수집하고 결합하여 Clifford 오브젝트로 결합할 수 있도록 확장되었으며, 여기서 "클리포드 게이트"는 이제 유형 LinearFunction, Clifford및 PauliGate. 예를 들어,

    from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import LinearFunction, PauliGate
from qiskit.quantum_info.operators import Clifford
from qiskit.transpiler.passes import CollectCliffords
from qiskit.transpiler import PassManager

# Create a Clifford
cliff_circuit = QuantumCircuit(2)
cliff_circuit.cx(0, 1)
cliff_circuit.h(0)
cliff = Clifford(cliff_circuit)

# Create a linear function
lf = LinearFunction([[0, 1], [1, 0]])

# Create a pauli gate
pauli_gate = PauliGate("XYZ")

# Create a quantum circuit with the above and also simple clifford gates.
qc = QuantumCircuit(4)
qc.cz(0, 1)
qc.append(cliff, [0, 1])
qc.h(0)
qc.append(lf, [0, 2])
qc.append(pauli_gate, [0, 2, 1])
qc.x(2)

# Run CollectCliffords transpiler pass
qct = PassManager(CollectCliffords()).run(qc)

    모든 게이트가 수집되어 하나의 Clifford. 따라서 최종 회로는 단일 Clifford 객체로 구성됩니다.

  • CouplingMap 는 이제 암시적으로 반복할 수 있으며, 이 반복은 CouplingMap.get_edges(). 즉，

    from qiskit.transpiler import CouplingMap
coupling = CouplingMap.from_line(3)
list(coupling) == list(coupling.get_edges())

    는 이제 다른 반복과 마찬가지로 예상대로 작동합니다. 이것은 순전히 구문상의 편의를 위한 것입니다.

  • 새로운 기능 추가 synth_cnot_count_full_pmh() 파텔, 마르코프, 헤이즈 방식을 사용하여 올투올 아키텍처를 위한 선형 가역 회로를 합성하는 데 사용되는 새로운 함수를 추가했습니다. 이 함수는 사용 가능한 qiskit.transpiler.synthesis.cnot_synth() 함수와 동일하지만 더 설명적인 이름을 가지며 패키지 트리에 더 논리적으로 배치됩니다. 이 새로운 기능은 향후 릴리스에서 더 이상 사용되지 않을 가능성이 있는 레거시 기능을 대체합니다.

  • InstructionScheduleMap 는 백엔드 보정 데이터를 PulseQobj JSON 형식으로 저장하고 데이터가 처음 액세스될 때 변환을 호출하도록 업데이트되었습니다(즉, 지연 변환). 이 내부 로직 업데이트는 특히 보정 항목이 많은 백엔드 로딩 성능을 크게 개선합니다.

  • 새 모듈 qiskit.pulse.calibration_entries 이 추가되었습니다. 여기에는 다양한 펄스 스케줄 표현을 위한 여러 래퍼 클래스가 포함되어 있습니다.

    • ScheduleDef
    • CallableDef
    • PulseQobjDef

    이 클래스는 각각 할당할 펄스 스케줄과 매개변수 이름을 반환하는 get_schedule() 및 get_signature() 메서드를 구현합니다. 이러한 클래스는 내부적으로 InstructionScheduleMap 또는 백엔드 Target에 의해 내부적으로 관리되므로 일반적인 사용자 프로그램에는 나타나지 않습니다.

  • 의 서브클래스로 새로운 서브클래스 ScalableSymbolicPulse 를 도입했습니다 SymbolicPulse. 새 서브 클래스는 다음과 동일하게 동작합니다 SymbolicPulse와 동일하게 동작하지만, 펄스의 엔벨로프에 amp∗ei×angle\text{amp} * e^{i \times \text{angle}} 형태의 복소 진폭 사전 인자가 포함되어 있다고 가정합니다. 이 엔벨로프 모양은 키스킷 펄스 라이브러리의 모든 펄스(이번 릴리스에서는 amp, angle 표현으로 변환됨)를 포함한 많은 일반적인 펄스와 일치합니다.

    새로운 서브클래스는 amp, angle 표현의 고유하지 않은 특성을 제거하고 복잡한 진폭에 따라 펄스를 올바르게 비교합니다.

  • 메서드에 새로운 키워드 인수 dtype 를 추가했습니다 PauliSumOp.from_list() 메서드에 새로운 키워드 인수를 추가했습니다. dtype 이 인수를 지정하면, 이 인수를 사용하여 구성된 객체에서 내부적으로 사용되는 SparsePauliOp 에 내부적으로 사용되는 PauliSumOp.

  • OpenQASM 3 프로그램을 키스킷으로 가져오기 지원이 추가되었습니다. 이 기능은 가장 쉽게 액세스할 수 있습니다 qasm3.loads() 과 qasm3.load()를 사용하여 각각 문자열에서 직접 프로그램을 로드하고 파일 이름에서 간접적으로 로드할 수 있습니다. 예를 들어, 이제 할 수 있습니다:

    from qiskit import qasm3

circuit = qasm3.loads("""
  OPENQASM 3.0;
  include "stdgates.inc";

  qubit q;
  qubit[5] qr;
  bit c;
  bit[5] cr;

  h q;
  c = measure q;

  if (c) {
    h qr[0];
    cx qr[0], qr[1];
    cx qr[0], qr[2];
    cx qr[0], qr[3];
    cx qr[0], qr[4];
  } else {
    h qr[4];
    cx qr[4], qr[3];
    cx qr[4], qr[2];
    cx qr[4], qr[1];
    cx qr[4], qr[0];
  }
  cr = measure qr;
""")

    이렇게 하면 프로그램이 변수의 QuantumCircuit 변수의 인스턴스로 로드됩니다 circuit.

    키스킷에는 아직 고급 클래식 데이터 처리를 표현할 방법이 없기 때문에 처음에는 OpenQASM 3 기능이 모두 지원되지는 않습니다. 임포터의 기능은 나머지 키스킷의 기능과 함께 증가하게 됩니다. 임포터의 초기 기능 세트는 내보내기에 의해 출력되는 기능 세트와 거의 동일합니다(qasm3.dump() 및 qasm3.dumps()).

    키스킷의 OpenQASM 3 지원은 다음을 완전히 무손실로 표현하기 위한 것이 아님을 유의하십시오 QuantumCircuits. 이를 위해 qiskit.qpy.

  • 기반 그라데이션 클래스는 primitives-기반 그라데이션 클래스는 BaseEstimatorGradient 및 BaseSamplerGradient 추상 클래스가 업데이트되어 기본 인터페이스 확장을 간소화했습니다. _preprocess(), _postprocess(), _run_unique() 의 세 가지 새로운 내부 재정의 가능한 메서드가 있습니다. _preprocess() 는 입력 그래디언트 회로와 파라미터를 사용자 정의하는 서브클래스, _postprocess 는 출력 결과를 사용자 정의하는 서브클래스, _run_unique 는 고유한 파라미터를 사용하여 회로의 그래디언트를 계산하는 서브클래스를 사용할 수 있습니다.

  • 트랜스파일러 패스의 SabreLayout 트랜스파일러 패스는 Rust에서 다시 작성되어 성능이 크게 향상되었습니다. 이 재작성의 일환으로 패스는 분석 패스에서 레이아웃과 라우팅을 모두 실행하는 변환 패스로 전환되었습니다. 이는 런타임 성능을 개선할 뿐만 아니라 결과물의 품질도 개선하기 위해 수행되었습니다. routing_pass 인수를 수동으로 설정하거나 새로운 skip_routing 인수를 사용하여 분석 패스로서의 이전 기능을 유지할 수 있습니다.

  • 트랜스파일러의 SabreLayout 트랜스파일러 패스에는 새로운 생성자 인수 layout_trials 가 있습니다. 이 인수는 실행을 시도할 난수 생성기 시드 수를 제어하는 데 사용됩니다 SabreLayout 를 실행할지 제어합니다. 설정 시 SABRE 레이아웃 알고리즘이 layout_trials 횟수만큼 실행되고 최고 품질 출력(추가된 가장 낮은 스왑 게이트 수로 측정)이 선택됩니다. 이러한 시드 트라이얼은 멀티스레딩을 사용하여 병렬로 실행되므로 레이아웃을 여러 번 실행할 때 발생할 수 있는 성능 오버헤드를 최소화할 수 있습니다. 이 값을 지정하지 않으면 기본적으로 SabreLayout 패스는 기본적으로 로컬 시스템에서 사용 가능한 물리적 CPU 수를 사용합니다.

  • 두 개의 새로운 클래스 추가 SciPyRealEvolver 와 SciPyImaginaryEvolver 양자 상태의 시간 진화에 대한 적분 방법을 구현하는 클래스 두 개를 추가했습니다. 관측값의 값과 표준 편차, 평가 시점은 다음과 같이 쿼리할 수 있습니다 TimeEvolutionResult.observables 및 TimeEvolutionResult.times. 예를 들어,

    from qiskit.algorithms.time_evolvers.time_evolution_problem import TimeEvolutionProblem
from qiskit.quantum_info import SparsePauliOp
from qiskit.quantum_info.states.statevector import Statevector
from qiskit.algorithms import SciPyImaginaryEvolver

initial_state = Statevector.from_label("+++++")
hamiltonian = SparsePauliOp("ZZZZZ")
evolution_problem = TimeEvolutionProblem(hamiltonian, 100, initial_state, {"Energy":hamiltonian})
classic_evolver = SciPyImaginaryEvolver(num_timesteps=300)
result = classic_evolver.evolve(evolution_problem)
print(result.observables)

  • 트랜스파일러 패스를 추가하여 SolovayKitaev 트랜스파일러 패스를 추가하여 이산 게이트 세트를 사용하여 단일 큐비트 단항식을 근사화하기 위한 Solovay-Kitaev 알고리즘을 실행합니다. 기본 변환기와 함께 사용하면 모든 단일 회로를 내결함성 구현이 가능한 범용 개별 게이트 세트로 변환할 수 있습니다.

    이 패스는 예를 들어 U 및 CX 게이트에 컴파일한 후에 사용할 수 있습니다:

    from qiskit import transpile
from qiskit.circuit.library import QFT
from qiskit.transpiler.passes.synthesis import SolovayKitaev

qft = QFT(3)

# optimize to general 1-qubit unitaries and CX
transpiled = transpile(qft, basis_gates=["u", "cx"], optimization_level=1)

skd = SolovayKitaev()  # uses T Tdg and H as default basis
discretized = skd(transpiled)

print(discretized.count_ops())

    분해는 단일 합성 플러그인과 함께 사용할 수도 있습니다 UnitarySynthesis 트랜스파일러 패스로도 사용할 수 있습니다:

    from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
from qiskit.transpiler.passes import UnitarySynthesis

circuit = QuantumCircuit(1)
circuit.rx(0.8, 0)
unitary = Operator(circuit).data

unitary_circ = QuantumCircuit(1)
unitary_circ.unitary(unitary, [0])

synth = UnitarySynthesis(basis_gates=["h", "s"], method="sk")
out = synth(unitary_circ)

out.draw('mpl')
    _images/legacy_release_notes-4.png

  • 를 사용한 무작위 회로 생성 qiskit.circuit.random.random_circuit() 을 사용한 무작위 회로 생성은 이제 대규모 회로에서 훨씬 더 빠릅니다.

  • 를 사용한 무작위 회로 생성 qiskit.circuit.random.random_circuit() 은 이제 키스킷의 회로 라이브러리에 있는 모든 "표준" 게이트를 출력합니다(qiskit.circuit.library). 여기에는 두 개의 4-큐비트 게이트 C3SXGate 와 RC3XGate가 포함되며, max_operands 의 허용 값도 그에 따라 확장되었습니다.

  • 트랜스파일러 패스의 Optimize1qGatesDecomposition 트랜스파일러 패스는 생성자에 새로운 키워드 인자 target 를 추가합니다. 이 인수는 컴파일 대상을 나타내는 Target 객체를 지정하는 데 사용할 수 있습니다. 이 인수를 사용하면 basis 인수를 대체하여 회로의 명령어가 대상 백엔드에 있는지 확인합니다.

  • 트랜스파일러 패스의 UnrollCustomDefinitions 트랜스파일러 패스는 생성자에 새로운 키워드 인자 target 를 추가합니다. 이 인수는 컴파일 대상을 나타내는 Target 객체를 지정하는 데 사용할 수 있습니다. 이 인수를 사용하면 basis_gates 인수를 대체하여 회로의 명령어가 대상 백엔드에 있는지 확인합니다.

  • 클래스를 추가했습니다 ReverseEstimatorGradient 클래스를 추가하여 역전파 또는 역모드 그래디언트를 기반으로 한 기대값 그래디언트를 고전적이고 빠르게 평가할 수 있습니다. 이 클래스는 스테이트 벡터를 사용하므로 정확한 그라데이션을 제공하지만 시스템 크기가 기하급수적으로 확장됩니다. 작은 시스템 크기의 빠른 참조 계산을 위해 설계되었습니다. 예를 들어 다음과 같이 사용할 수 있습니다:

    from qiskit.circuit.library import EfficientSU2
from qiskit.quantum_info import SparsePauliOp
from qiskit.algorithms.gradients import ReverseEstimatorGradient

observable = SparsePauliOp.from_sparse_list([("ZZ", [0, 1], 1)], num_qubits=10)
circuit = EfficientSU2(num_qubits=10)
values = [i / 100 for i in range(circuit.num_parameters)]
gradient = ReverseEstimatorGradient()

result = gradient.run([circuit], [observable], [values]).result()

  • 클래스의 생성자에 새 키워드 인수 use_dag 를 추가했습니다 OneQubitEulerDecomposer 클래스의 생성자에 추가했습니다. use_dag 가 True 로 설정되면 디코더의 출력은 DAGCircuit 객체가 아닌 QuantumCircuit 객체가 됩니다. 이 기능은 트랜스파일러 패스에 유용합니다 OneQubitEulerDecomposer (예 Optimize1qGatesDecomposition)를 직접 사용하는 트랜스파일러 패스에 유용합니다 DAGCircuit 로 작업하면 QuantumCircuit 와 DAGCircuit.

  • 분석 패스에 사용자 지정 휴리스틱 가중치를 설정하는 기능이 추가되었습니다 VF2Layout 및 VF2PostLayout 트랜스파일러 패스에 커스텀 휴리스틱 가중치를 설정할 수 있는 기능이 추가되었습니다. 분석 패스가 속성 집합에서 vf2_avg_error_map 키를 설정하면 백엔드의 오류율 대신 해당 값이 오류 가중치에 사용됩니다 Target (또는 BackendProperties for BackendV1). 값은 ErrorMap 인스턴스여야 하며, 각 값은 해당 큐비트에 대한 모든 1 또는 2 큐비트 연산에 대한 평균 오류율을 나타냅니다. 값이 NaN 인 경우 해당 에지는 이상적인 에지( 1q 연산의 경우 큐비트)로 취급됩니다. 예를 들어 오류 맵을 다음과 같이 만들었습니다:

    from qiskit.transpiler.passes.layout.vf2_utils import ErrorMap

error_map = ErrorMap(3)
error_map.add_error((0, 0), 0.0024)
error_map.add_error((0, 1), 0.01)
error_map.add_error((1, 1), 0.0032)

    는 2큐비트 타겟을 설명하며, 평균 1q 오류율은 0큐비트에서 0.0024 , 1큐비트에서 0.0032 이고, (0, 1)에서 작동하는 게이트의 평균 2q 오류율은 0.01 이며, (1, 0)은 타겟에서 지원되지 않습니다. 속성 세트의 vf2_avg_error_map 키에 설정되어 있는 경우 채점에 사용됩니다 VF2Layout 및 VF2PostLayout 가 실행될 때 사용됩니다. 예를 들어,

    from qiskit.transpiler import AnalysisPass, PassManager, Target
from qiskit.transpiler.passes import VF2Layout
from qiskit.transpiler.passes.layout.vf2_utils import ErrorMap
from qiskit.circuit.library import CZGate, UGate
from qiskit.circuit import Parameter

class CustomVF2Scoring(AnalysisPass):
  """Set custom score for vf2."""

  def run(self, dag):
    error_map = ErrorMap(3)
    error_map.add_error((0, 0), 0.0024)
    error_map.add_error((0, 1), 0.01)
    error_map.add_error((1, 1), 0.0032)
    self.property_set["vf2_avg_error_map"] = error_map


target = Target(num_qubits=2)
target.add_instruction(
    UGate(Parameter('theta'), Parameter('phi'), Parameter('lam')),
    {(0,): None, (1,): None}
)
target.add_instruction(
    CZGate(), {(0, 1): None}
)

vf2_pass = VF2Layout(target=target, seed=1234568942)
pm = PassManager([CustomVF2Scoring(), vf2_pass])

    그것은 실행됩니다 VF2Layouterror_map 의 사용자 지정 스코어링을 사용하여 2 큐비트에 대한 사용자 지정 점수 Target 에 대해 오류율이 포함되지 않은 사용자 정의 스코어링으로 실행됩니다.

업그레이드 주의사항

  • 에서 펄스 클래스를 초기화할 때 qiskit.pulse.library:

    복잡한 amp 인수를 유한한 angle 과 함께 제공하면 다음과 같이 됩니다 PulseError 지금. 예를 들어 Gaussian(duration=100,sigma=20,amp=0.5j) 대신 이제 Gaussian(duration=100,sigma=20,amp=0.5,angle=np.pi/2) 을 사용해야 합니다. amp * ... 으로 정의되었던 펄스 엔벨로프는 이제 amp * exp(1j * angle) * ... 으로 정의됩니다. 이 변경은 별도의 실험에서 펄스의 진폭과 각도를 보정하는 키스킷 실험을 더 잘 지원하기 위해 이루어졌습니다.

  • Python 3.7 단일 패치 메서드는 이제 종속성입니다. 이 기능은 최신 버전의 Python 의 표준 라이브러리에서 메서드 디스패치 메커니즘을 활용할 수 있도록 하기 위해 추가되었습니다. Python >= 3.8 을 사용하는 경우 추가 종속성이 필요하지 않습니다.

  • 이전에 더 이상 사용되지 않는 MSBasisDecomposer 트랜스파일러 패스는 qiskit.transpiler.passes 모듈이 제거되었습니다. 이 기능은 원래 키스킷 테라 0.16.0 릴리스(2020-10-16)의 일부로 더 이상 사용되지 않습니다. 대신 BasisTranslator 트랜스파일러 패스를 대신 사용하여 회로를 적절한 기준으로 변환해야 합니다 RXXGate

  • EquivalenceLibrarybase 속성으로 초기화된 객체는 더 이상 전달된 EquivalenceLibrary 와 공유 참조를 갖지 않습니다. 이전 릴리스에서는 새 인스턴스를 만드는 데 사용된 후 base 을 변경하면 EquivalenceLibrary 인스턴스를 생성했다면 두 인스턴스 모두 해당 변경 사항을 반영했습니다. 이는 더 이상 해당되지 않으며 base 에 대한 업데이트는 더 이상 새로운 EquivalenceLibrary. 예를 들어 다음과 같은 동등성 라이브러리를 만든 경우:

    import math

from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import XGate
from qiskit.circuit.equivalence import EquivalenceLibrary

original_lib = EquivalenceLibrary()
qc = QuantumCircuit(1)
qc.rx(math.pi, 0)
original_lib.add_equivalence(XGate(), qc)
new_lib = EquivalenceLibrary(base=original_lib)

    로 수정한 경우 original_lib :

    import from qiskit.circuit.library import SXGate

qc = QuantumCircuit(1)
qc.rx(math.pi / 2, 0)
original_lib.add_equivalence(SXGate(), qc)

    이전 릴리스에서는 new_lib 에 SXGate 의 정의가 original_lib 에 추가된 후에도 포함되었지만, 이번 릴리스에서는 더 이상 포함되지 않습니다. 이 변경은 내부 데이터 구조가 그래프로 변경되어 클래스의 성능이 향상되었기 때문에 이루어졌습니다 EquivalenceLibrary 클래스의 성능을 향상시켰습니다 BasisTranslator 트랜스파일러 패스를 여러 번 실행할 때 특히 그렇습니다.

  • 클래스의 생성자에 대한 initial_state 인수는 NLocal 클래스의 생성자 인수는 NLocal.initial_state 어트리뷰트에 직접 할당하는 것과 함께 QuantumCircuit 여야 합니다. 이 인수 및 속성에 다른 유형을 사용하는 것은 더 이상 지원되지 않습니다. 다른 유형에 대한 지원은 키스킷 테라 0.18.0 릴리스(2021년 7월)의 일부로 더 이상 사용되지 않습니다.

  • LaTeX 배열 서랍(예: array_to_latex, Statevector.draw('latex'))은 이제 ket-convention 서랍과 동일한 sympy 함수를 사용합니다. 즉, 일부 숫자가 이전 릴리스와 다르게 렌더링될 수 있지만 보다 일관된 경험을 제공할 수 있습니다. 예를 들어, 새로운 요인을 파악하거나 이전에는 없었던 분모를 합리화할 수 있습니다. 기본값 precision 이 5에서 10으로 변경되었습니다.

  • 에서 내보내는 QPY 버전 포맷 버전이 dump() 이 버전 6으로 증가했습니다. 이 새 형식 버전은 이전 버전과 호환되지 않으며, QPY 버전 6을 처리할 수 없는 역직렬화기로 로드하려고 할 때 오류가 발생합니다. 이 변경은 덤프된 객체의 헤더에 class_name_size 속성을 추가하여 처리되는 ScalableSymbolicPulse 의 도입을 지원하기 위해 필요했습니다 SymbolicPulse 객체의 헤더에 추가하기 위해서였습니다.

  • 에 대한 __hash__ 메서드가 SymbolicPulse 메서드가 제거되었습니다. 이는 이 클래스의 변경 가능한 특성(매개변수 할당을 통한)을 반영하기 위한 것으로, 해시 가능한 객체가 필요한 상황에서 사용할 때 오류가 발생할 수 있습니다 SymbolicPulse 를 사용할 때 오류가 발생할 수 있는 상황을 반영한 것입니다. 즉, 기본 제공 hash() 메서드 및 SymbolicPulse 를 사전이나 집합 멤버의 키로 사용하는 것은 더 이상 작동하지 않습니다.

  • 인스턴스의 이름 Register 인스턴스( QuantumRegister 및 ClassicalRegigster)은 더 이상 유효한 OpenQASM 2 식별자로 제한되지 않습니다. 이는 키스킷이 OpenQASM 2에서 더 분리되고 OpenQASM 3 사양도 그렇게 제한적이지 않기 때문에 제한이 지나치게 엄격해졌기 때문입니다. 유효한 OpenQASM 2 식별자 이름을 가진 레지스터에 의존하고 있었다면 이름 이스케이프를 시작해야 합니다. 예를 들어 간단한 버전은 다음과 같이 할 수 있습니다:

    import re
import string

def escape(name: str) -> str:
  out = re.sub(r"\W", "_", name, flags=re.ASCII)
  if not out or out[0] not in string.ascii_lowercase:
    return "reg_" + out
  return out

  • 메서드 QuantumCircuit 메서드 u1, u2, u3 와 그 제어 변형 cu1, cu3 , mcu1 은 키스킷 테라 0.16.0 에서 더 이상 사용되지 않음에 따라 제거되었습니다. 이는 일반적으로 IBM -특정 게이트 이름을 제거하여 보다 일반적인 방법인 p(), u(), cp() 와 cu(). 게이트 클래스 U1Gate, U2Gate 와 U3Gate 와 함께 계속 사용할 수 있습니다 QuantumCircuit.append()와 함께 사용할 수 있으므로 백엔드는 이러한 게이트가 명시적으로 지정된 베이스를 계속 지원할 수 있습니다.

  • 메서드 QuantumCircuit 메서드 combine 와 extend 는 키스킷 테라 0.17.0 에서 더 이상 사용되지 않음에 따라 제거되었습니다. 이는 이러한 기능이 단순히 덜 강력한 버전의 QuantumCircuit.compose()대신 사용해야 합니다.

    extend 제거는 또한 + 및 += 연산자가 더 이상 정의되지 않음을 의미합니다 QuantumCircuit. 대신 각각 & 및 &= 연산자를 사용할 수 있습니다 QuantumCircuit.compose().

  • 이전에 더 이상 사용되지 않는 기능: qiskit.circuit.measure.measure() 및 qiskit.circuit.reset.reset() 이 제거되었습니다. 이러한 기능은 키스킷 테라 0.19.0 릴리스(2021년 12월)에서 더 이상 사용되지 않습니다. 대신 QuantumCircuit.measure() 및 QuantumCircuit.reset() 메서드를 사용해야 합니다 QuantumCircuit 객체를 추가하려는 Measure 또는 Reset 연산을 사용해야 합니다.

  • set 에서 상속된 이전에 사용되지 않는 ParameterView 메서드는 ParameterView 에서 제거되었으며, 에서 반환되는 유형은 QuantumCircuit.parameters. 제거된 구체적인 방법은 다음과 같습니다:

    • add()
    • difference()
    • difference_update()
    • discard()
    • intersection()
    • intersection_update()
    • issubset()
    • issuperset()
    • symmetric_difference()
    • symmetric_difference_update()
    • union()
    • update()

    Python 운영자에 대한 지원과 함께

    • ixor: ^=
    • isub: -=
    • ior: |=

    이는 키스킷 테라 0.17.0 릴리스(2021년 4월)에서 더 이상 사용되지 않습니다. ParameterView 유형은 이제 일반 시퀀스 보기 유형이며 더 이상 이러한 set 작업을 지원하지 않습니다.

  • 이전에 더 이상 사용되지 않는 NetworkX 변환기 메서드에 대한 DAGCircuit 와 DAGDependency 클래스 DAGCircuit.to_networkx(), DAGCircuit.from_networkx(), DAGDependency.to_networkx() 이 제거되었습니다. 이러한 방법은 원래 키스킷 테라 0.21.0 릴리스(2022년 6월)의 일부로 더 이상 사용되지 않습니다. 키스킷은 qiskit-terra 0.12.0 릴리스 이후 그래프 라이브러리로 rustworkx를 사용해 왔으며, 그 이후 NetworkX 변환기 기능은 손실이 발생했습니다. 이 라이브러리는 원래 사용자가 NetworkX’s 알고리즘 라이브러리를 활용하여 알고리즘 라이브러리를 활용하여 DAGCircuit 및/또는 rustworkx에 없는 기능을 활용하기 위해 추가되었습니다. 그러나 그 이후로 DAGCircuit 와 러스트워크엑스가 성숙해지면서 더 많은 기능을 제공하게 되었고 DAGCircuit 는 작동을 위해 러스트워크엑스에 긴밀하게 결합되어 있으며, 이러한 변환기 메서드는 제한된 기능을 제공하므로 제거되었습니다.

  • tweedledum 키스킷 테라의 핵심 요구 사항에서 제거되었습니다. 제공되는 기능(qiskit.circuit.classicalfunction)은 tweedledum 등을 통해 수동으로 설치한 경우에도 계속 사용할 수 있습니다:

    pip install tweedledum

    이 변경은 tweedledum 개발이 새로운 Python 및 OS 릴리스를 따라가지 못할 정도로 느려져 일부 키스킷 사용자가 키스킷을 설치하는 것을 차단하고 있기 때문에 이루어졌습니다.

  • 게으른 옵션 체커 HAS_MATPLOTLIB, HAS_PIL, HAS_PYLATEX 와 HAS_PDFTOCAIRO 에서 더 이상 노출되지 않습니다 qiskit.visualization에서 더 이상 노출되지 않습니다. 0.21. 이 객체(및 다른 많은 게으른 체커)의 정식 위치는 qiskit.utils.optionals이며, 네 가지 객체 모두 그곳에서 찾을 수 있습니다.

  • 이전에 더 이상 사용되지 않는 gate 인수는 트랜스파일러 패스의 생성자에 대한 Decompose 트랜스파일러 패스의 생성자에 대한 이전 사용되지 않는 Decompose.gate 어트리뷰트가 제거되었습니다. 이 인자와 어트리뷰트는 키스킷 테라 0.19.0 릴리스(2021년 12월)에서 더 이상 사용되지 않습니다. 대신 Decompose.gates_to_decompose 속성과 함께 생성자에 대한 gates_to_decompose 인수를 사용해야 합니다. gates_to_decompose 인자와 속성은 동일한 기능을 하지만 이름이 더 명시적이며 단일 게이트만 지원하는 대신 게이트 목록을 지정할 수도 있습니다.

  • 이전에 더 이상 사용되지 않는 label 인수는 MCMT 및 MCMTVChain 클래스의 생성자 인수가 제거되었습니다. 이 기능은 키스킷 테라 0.19.0 릴리스(2021년 12월)부터 사용되지 않습니다. 이러한 클래스에서 label 인수를 사용하는 것은 정의되지 않은 동작이었습니다 QuantumCircuit 의 서브 클래스이기 때문에 Instruction. 이렇게 하면 할당된 레이블이 일반적으로 무시됩니다. label 를 인스턴스에 할당해야 하는 경우 MCMT 또는 MCMTVChain 인스턴스로 변환해야 하는 경우 Gate 인스턴스로 to_gate() 로 변환한 다음 원하는 레이블을 label 속성에 할당해야 합니다. 예를 들어,

    from qiskit.circuit.library import MCMT, XGate

mcmt_circuit = MCMT(XGate(), 3, 2)
mcmt_gate = mcmt_circuit.to_gate()
mcmt_gate.label = "Custom MCMT X"

  • 키스킷에 대한 retworkx 종속성이 제거되고 rustworkx 라이브러리로 대체되었습니다. 이 패키지는 동일한 패키지이지만 rustworkx 은 retworkx 의 새 이름으로, 통합된 0.12.0 릴리스의 일부로 이름이 변경되었습니다. 이전에 키스킷과 함께 retworkx 0.12.0 를 사용했다면 이미 rustworkx를 설치한 것입니다(retworkx 0.12.0 는 이전 버전과의 호환성을 위한 리디렉션 심일 뿐입니다). 이 변경은 향후 지원되는 유일한 패키지가 될 새 패키지 이름으로 마이그레이션하기 위해 이루어졌습니다.

  • 컴파일러 패스의 기본 동작이 SabreLayout 컴파일러 패스의 기본 동작이 변경되었습니다. 패스는 더 이상 AnalysisPass 가 아니며 기본적으로 초기 레이아웃을 계산하여 회로에 적용하고 내부적으로 SabreSwap 을 내부적으로 실행하여 스왑 매핑을 적용하고 스왑 삽입으로 인한 순열로 final_layout 프로퍼티 세트를 설정합니다. 즉, 사용자 정의의 일부로 SabreLayout 사용자 정의의 일부로 PassManager 에 routing_pass 인수를 설정하지 않는 한 이를 고려하도록 패스 관리자를 조정해야 합니다( SabreLayout). 이 변경은 레이아웃과 라우팅 품질이 밀접하게 연관되어 있으며, 품질 결과물을 개선하기 위해 이루어졌습니다 SabreLayout 는 이제 여러 개의 병렬 시드 트라이얼을 실행하고 어떤 시드가 최상의 결과를 제공하는지 계산하기 위해 레이아웃과 라우팅을 함께 수행해야 합니다. 사용자 지정 패스 관리자에서 세 가지 방법으로 사용량을 조정할 수 있습니다. 첫 번째는 사전 설정된 패스 관리자에서 임베딩을 사용하지 않는 것입니다. 이전에 다음과 같은 것을 실행하고 있었다면

    from qiskit.transpiler import PassManager
from qiskit.transpiler.preset_passmanagers import common
from qiskit.transpiler.passes.SabreLayout

pm = PassManager()
pm.append(SabreLayout(coupling_map)
pm += common.generate_embed_passmanager(coupling_map)

    를 사용하여 레이아웃을 계산한 다음 적용(일반적으로 라우팅이 뒤따랐음)하면 사용법을 간단히 조정할 수 있습니다:

    from qiskit.transpiler import PassManager
from qiskit.transpiler.preset_passmanagers import common
from qiskit.transpiler.passes.SabreLayout

pm = PassManager()
pm.append(SabreLayout(coupling_map)

    로 설정하면 SabreLayout 로 설정하면 레이아웃이 적용되므로 임베딩 단계가 더 이상 필요하지 않습니다. 또는 routing_pass 인수를 지정하여 이전 동작으로 되돌릴 수 있습니다 SabreLayout 를 이전 동작으로 되돌릴 수 있습니다. 예를 들어 이전 릴리스에서 실행한 것처럼 SabreLayout 을 이전 릴리스에서 실행한 것처럼 실행하려면 다음과 같이 할 수 있습니다:

    from qiskit.transpiler.passes import SabreSwap, SabreLayout
routing_pass = SabreSwap(
    coupling_map, "decay", seed=seed, fake_run=True
)
layout_pass = SabreLayout(coupling_map, routing_pass=routing_pass, seed=seed)

    를 SabreLayout 를 분석 패스로 실행하고 layout 속성 집합을 설정하기만 하면 됩니다. 마지막 방법은 SabreLayout 에서 skip_routing 인수를 활용하는 것인데, 이 인수를 True 로 설정하면 라우팅에서 찾은 레이아웃을 적용하고 스왑 게이트를 삽입하는 것을 건너뜁니다. 그러나 이렇게 하면 SabreLayout 이 여전히 라우팅을 계산하고 이 데이터를 사용하지 않을 뿐이므로 런타임 페널티가 발생합니다. 설명한 처음 두 가지 접근 방식에는 추가 오버헤드가 발생하지 않습니다.

  • 고정 시드 값을 사용하여 SabreLayout 전달( routing_pass 인수 없이 실행되는 경우)에 의해 계산된 레이아웃은 고정 시드 값으로 이전 릴리스와 변경될 수 있습니다. 이는 새로운 난수 생성기가 Rust에서 패스를 다시 작성하는 과정에서 SabreLayout 패스를 재작성하여 성능을 크게 개선했기 때문입니다. 일관된 출력에 의존하는 경우 이전 버전의 키스킷에서 패스를 실행하고 qiskit.qpy 를 사용하여 회로를 저장한 다음 현재 버전을 사용하여 로드할 수 있습니다. 또는 routing_pass 인수를 명시적으로 인스턴스로 설정할 수 있습니다 SabreSwap 의 이전 동작을 미러링하기 위해 SabreLayout:

    from qiskit.transpiler.passes import SabreSwap, SabreLayout


routing_pass = SabreSwap(
    coupling_map, "decay", seed=seed, fake_run=True
)
layout_pass = SabreLayout(coupling_map, routing_pass=routing_pass, seed=seed)

    이전 릴리스의 패스 동작을 반영합니다. 이전 릴리스에서 swap_trials 인수를 사용했다면 SabreLayout 에 trials 인수를 사용했다면, 이 형태로 사용법을 조정할 때 이전 시드를 유지하려면 SabreSwap 생성자에서 고정 시드로 이전 출력을 유지하려면 인수를 설정해야 합니다.

  • 주어진 시드에 대해 qiskit.circuit.random.random_circuit 에서 반환하는 정확한 회로가 변경되었습니다. 이는 함수에 대한 내부 난수 생성의 효율성이 개선되었기 때문입니다.

  • pip install qiskit-terra[toqm] 을 통해 설치할 수 있는 옵션 기능 패키지 qiskit-toqm 의 버전 요구 사항이 버전 0.0.4 에서 0.1.0 으로 업그레이드되었습니다. toqm 라우팅 방법을 사용하려면 transpile() 를 사용하려면 이제 qiskit-toqm 버전 0.1.0 이상을 사용해야 합니다. 이전 버전은 더 이상 트랜스파일러에서 검색할 수 없습니다.

  • 출력 QuasiDistribution 메서드의 출력( Sampler.run )은 확률이 0인 상태를 필터링하도록 업데이트되었습니다. 이제 사전 출력에서 유효한 상태가 누락된 경우 확률이 0인 것으로 간주할 수 있습니다. 이전에는 주어진 비트 수에 대해 가능한 모든 결과(예: 3비트 결과의 경우 000, 001, 010, 011, 100, 101, 110, 111)는 주어진 상태의 확률이 0이더라도 표시되었습니다. 비트 수가 많을수록 출력 크기가 상당히 커질 수 있으므로 출력 크기를 줄이기 위해 변경되었습니다. 또한 0 확률 결과를 필터링하면 다른 구현의 BaseSampler.

  • 가 호출될 때 펄스 빌더의 동작이 Schedule 가 호출될 때의 동작이 업그레이드되었습니다. 호출된 스케줄은 내부적으로 다음과 같이 변환됩니다 ScheduleBlock 표현으로 변환되며, 이제 명령어로 래핑된 스케줄을 추가하는 대신 항상 참조 메커니즘이 적용됩니다 Call 인스트럭션으로 감싸는 대신 항상 참조 메커니즘이 적용됩니다. 변환된 블록은 원래 정렬 컨텍스트를 복구할 필요가 없다는 점에 유의하세요. 이는 절대 시간 간격을 두고 최대한 빨리 정렬된 펄스 명령어 시퀀스입니다. 이는 호출된 펄스 프로그램의 내부 표현을 업그레이드한 것이므로 API는 변경되지 않습니다. 그러나 Call 명령과 Schedule 명령어가 더 이상 빌더의 펄스 프로그램에 나타나지 않습니다. 이 변경으로 생성된 스케줄 블록은 항상 QPY와 호환됩니다. 출력 일정 지침을 기준으로 필터링하는 경우 Call로 필터링하는 경우 ScheduleBlock.references 를 대신 사용하여 호출된 프로그램을 검색할 수 있습니다.

  • RZXCalibrationBuilder 및 RZXCalibrationBuilderNoEcho 트랜스파일러 패스를 생성하도록 업그레이드되었습니다 ScheduleBlock. 이 변경은 트랜스파일된 회로가 항상 QPY와 호환되도록 보장합니다. 다른 프로그램이나 패스 서브클래스에서 직접 rescale_cr_inst()메서드를 다른 프로그램이나 패스 하위 클래스에서 직접 사용하여 장치의 교차 공진 펄스를 재조정하는 경우 이제 이 메서드가 펄스 빌더 매크로로 전환되며, 새 릴리스에 적용하려면 펄스 빌더 컨텍스트 내에서 이 메서드를 사용해야 합니다. 메서드 호출은 컨텍스트 펄스 프로그램에 재생 인스트럭션을 주입합니다 Play 인스트럭션을 반환하는 대신 컨텍스트 펄스 프로그램에 주입합니다.

지원 중단 노트

  • Python 3.7 지원으로 키스킷 실행에 대한 지원은 더 이상 사용되지 않으며, qiskit-terra 0.25.0 릴리스에서 제거될 예정입니다. 즉, 0.25.0 릴리스부터는 사용 중인 Python 버전을 Python 3.8 이상으로 업그레이드해야 합니다.

  • 클래스 LinearFunctionsSynthesis 클래스는 이제 더 이상 사용되지 않으며 향후 릴리스에서 제거될 예정입니다. 대신 사용해야 하는 더 일반적인 HighLevelSynthesis 클래스로 대체되었습니다. 예를 들어, 다음과 같이 인스턴스를 인스턴스화할 수 있습니다 HighLevelSynthesis 의 인스턴스를 인스턴스화하여 LinearFunctionSynthesis 와 동일한 방식으로 동작할 수 있습니다:

    from qiskit.transpiler.passes import HighLevelSynthesis
from qiskit.transpiler.passes.synthesis.high_level_synthesis import HLSConfig

HighLevelSynthesis(
    HLSConfig(
        linear_function=[("default", {})],
        use_default_on_unspecified=False,
    )
)

  • 함수에 인수 값 목록 전달에 대한 지원은 더 이상 사용되지 않습니다 transpile() 함수에 대한 인자 값 목록 전달 지원은 더 이상 사용되지 않으며 0.25.0 릴리스에서 제거될 예정입니다. 이는 여러 회로를 한 번에 트랜스파일링할 때 병렬 실행에 대한 오버헤드를 크게 줄이기 위한 것입니다. 현재 이 기능을 사용 중인 경우에는 대신 transpile() 를 여러 번 호출할 수 있습니다. 예를 들어 이전에 다음과 같은 작업을 수행한 경우입니다:

    from qiskit.transpiler import CouplingMap
from qiskit import QuantumCircuit
from qiskit import transpile

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
cmaps = [CouplingMap.from_heavy_hex(d) for d in range(3, 15, 2)]
results = transpile([qc] * 6, coupling_map=cmaps)

    대신 다음과 같이 실행해야 합니다:

    from itertools import cycle
from qiskit.transpiler import CouplingMap
from qiskit import QuantumCircuit
from qiskit import transpile

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
cmaps = [CouplingMap.from_heavy_hex(d) for d in range(3, 15, 2)]

results = []
for qc, cmap in zip(cycle([qc]), cmaps):
    results.append(transpile(qc, coupling_map=cmap))

    또는 parallel_map() 또는 Python 표준 라이브러리에서 multiprocessing 를 활용할 수도 있습니다.

  • qiskit.visualization.pulse 에 있는 펄스 서랍의 레거시 버전은 더 이상 사용되지 않으며 향후 릴리스에서 제거될 예정입니다. 여기에는 ScheduleDrawer 및 :class`WaveformDrawer` 클래스가 포함됩니다. 이 모듈은 qiskit.visualization.pulse_v2 서랍으로 대체되었으며 일반적인 사용자 API pulse_drawer() 와 PulseBlock.draw() 은 이미 qiskit.visualization.pulse_v2 을 사용하도록 내부적으로 업데이트되었습니다.

  • pulse.Instruction.draw() 메서드는 더 이상 사용되지 않으며 향후 릴리스에서 제거될 예정입니다. 이 메서드의 필요성은 Instrucion 객체에 자체 그리기 메서드가 필요하지 않은 qiskit.visualization.pulse_v2 서랍으로 대체되었습니다. 펄스 인스트럭션을 그려야 하는 경우 대신 pulse_drawer() 대신

  • QPY가 최상위 레벨로 승격되었으므로 qiskit.circuit.qpy_serialization 가져오기는 더 이상 사용되지 않습니다. 에서 동일한 개체를 가져와야 합니다 qiskit.qpy 에서 동일한 개체를 가져와야 합니다. 기존 경로는 향후 키스킷 테라에서 제거될 예정입니다.

  • qiskit.IBMQ 개체는 더 이상 사용되지 않습니다. 이 별칭 객체는 어트리뷰트 액세스를 qiskit.providers.ibmq.IBMQ 로 느리게 리디렉션합니다. qiskit-ibmq-provider 패키지가 자체 네임스페이스를 유지하는 qiskit-ibm-provider 패키지로 대체되었으므로 이 별칭을 유지하는 것은 더 이상 새 패키지와 관련이 없습니다. qiskit.IBMQ 별칭을 사용 중이라면 qiskit.providers.ibmq.IBMQ 을 직접 사용하도록 사용법을 업데이트해야 합니다(자세한 내용은 마이그레이션 가이드를 참조하여 qiskit-ibm-provider 으로 마이그레이션하는 것도 고려하세요).

  • 펄스 Qobj 변환기의 몇몇 공개 메서드는 더 이상 사용되지 않으며 향후 릴리스에서는 더 이상 직접 호출할 수 없게 됩니다. 메소드 목록은 다음과 같습니다:

    InstructionToQobjConverter 에서,

    • convert_acquire()
    • convert_bundled_acquires()
    • convert_set_frequency()
    • convert_shift_frequency()
    • convert_set_phase()
    • convert_shift_phase()
    • convert_delay()
    • convert_play()
    • convert_snapshot()

    QobjToInstructionConverter 에서,

    • convert_acquire()
    • convert_set_phase()
    • convert_shift_phase()
    • convert_set_frequency()
    • convert_shift_frequency()
    • convert_delay()
    • bind_pulse()
    • convert_parametric()
    • convert_snapshot()

    이러한 메서드를 직접 호출하는 대신 변환기 인스턴스가 직접 호출될 때 암시적으로 선택됩니다. 예를 들어,

    converter = QobjToInstructionConverter()
converter(pulse_qobj)

  • qiskit.visualization.state_visualization.num_to_latex_ket() 및 qiskit.visualization.state_visualization.num_to_latex_terms() 함수는 더 이상 사용되지 않으며 향후 릴리스에서 제거될 예정입니다. 이 함수는 주로 LaTeX 출력에서 내부적으로 사용되었습니다 Statevector.draw() 와 DensityMatrix.draw() 에서 주로 사용되었으나 더 이상 이 함수를 사용하지 않고 대신 심파이를 활용하고 있습니다. 이러한 함수를 사용하는 경우 Sympy의 nsimplify() latex() 함수를 사용하여 코사인더를 사용해야 합니다.

  • Register.qasm() 메서드는 더 이상 사용되지 않으며 향후 릴리스에서 제거될 예정입니다. 이 메서드는 하위 클래스인 QuantumRegister 와 ClassicalRegister. qasm() 메서드는 OpenQASM 2로 안전하게 변환할 책임이 있는 당사자에 대한 잘못된 시각을 조장하고, 단일 객체만으로는 유효한 식별자를 생성하기 위해 이스케이프한 후 이름이 충돌하는지 등 안전한 변환을 제공하기 위한 컨텍스트가 없기 때문에 더 이상 사용되지 않습니다.

  • 클래스 변수 정규식 Register.name_format 은 더 이상 사용되지 않으며 향후 릴리스에서 제거될 예정입니다. 이제 레지스터 이름은 유효한 모든 Python 문자열을 사용할 수 있으므로 정규식은 더 이상 사용할 수 없습니다.

  • qiskit.quantum_info.synthesis.decompose_clifford() 및 qiskit.quantum_info.synthesis.decompose_cnot_dihedral() 함수는 더 이상 사용되지 않으며 향후 릴리스에서 제거될 예정입니다. 두 가지 함수로 대체됩니다 qiskit.synthesis.synth_clifford_full() 와 qiskit.synthesis.synth_cnotdihedral_full() 로 각각 대체됩니다.

버그 수정

  • 메서드의 문제를 수정했습니다 PauliOp.adjoint() 메서드에서 복잡한 계수가 있는 폴리스에 대해 올바른 값을 반환하는 문제를 수정했습니다(예: PauliOp(Pauli("iX"))). 수정 #9433.

  • qiskit.algorithms.amplitude_estimators 모듈의 진폭 추정 알고리즘 관련 문제를 수정했습니다 ( amplitude_estimators 참조 ) 추상 프리미티브에서 빌드된 프리미티브와 함께 사용하는 경우 BaseSampler 프리미티브(예 Sampler 및 BackendSampler). 이전에는 측정 결과가 실제 측정된 것보다 더 많은 비트로 확장되어 큐비트가 하나 이상인 오라클의 경우 오라클의 "양호한" 양자 상태를 감지하는 데 잠재적인 오류가 발생했습니다.

  • QuantumCircuit.add_calibrations() 및 DAGCircuit.add_calibrations() 메서드의 매개변수 서식 지정 로직 동작이 불일치하는 문제를 수정했습니다. 이전에는 DAGCircuit.add_calibrations() 에서 모든 매개변수를 float 으로 캐스팅하려고 시도했지만, QuantumCircuit.add_calibrations() 에서는 주어진 매개변수를 그대로 사용했습니다. 이 경우 실행 시 오류가 발생할 수 있습니다 transpile() 를 실행할 때 오류가 발생할 수 있습니다 QuantumCircuit 펄스 게이트가 있는 경우 캘리브레이션의 매개 변수가 ParameterExpresion 객체로 유지될 수 있으므로 오류가 발생할 수 있습니다.

  • QPY의 (qiskit.qpy) load() 함수의 클래스 게이트가 포함된 회로에서 MCXGate, MCXGrayCode, MCXRecursive및 MCXVChain 는 역직렬화에 실패합니다. 수정 #9390.

  • 연산자 전역 계수가 최종 행렬에 두 번 이상 곱해지는 문제를 수정했습니다 TensoredOp.to_matrix() 에서 연산자의 전역 계수가 최종 행렬에 두 번 이상 곱해지던 문제를 수정했습니다. 이제 텐서드 연산자 또는 상태의 수에 관계없이 전역 계수가 올바르게 적용됩니다. 수정 #9398.

  • 메서드의 출력은 run() 메서드의 출력은 BackendSampler 클래스의 메서드 출력은 이제 반환된 shots 및 stddev_upper_bound 속성을 설정합니다 QuasiDistribution. 이전에는 이러한 속성이 누락되어 출력을 사용한 일부 사후 처리가 불가능했습니다. 수정 #9311

  • OpenQASM 2 익스포터 메서드 QuantumCircuit.qasm() 는 이제 기본적으로 게이트 파라미터에 대해 더 높은 정밀도의 부동 소수점 숫자를 출력합니다. 또한 주어진 매개변수가 π\pi 의 소수/제곱에 가까운지 확인할 때 더 엄격한 바운드( 1e−61e-6 대신 1e−121e-12 )가 사용됩니다. 수정 #7166.

  • 모듈의 지원 수정 primitives 모듈의 지원 수정 QuantumCircuit 객체를 실행하는 모듈의 지원이 수정되었습니다(예 IfElseOp). 이전에는 BaseSampler 및 BaseEstimator 기본 클래스가 이러한 회로를 올바르게 정규화할 수 없었습니다. 그러나 이러한 회로를 실행하는 것은 기본 지원 제어 흐름 명령어의 특정 구현에 따라 달라집니다. BaseSampler 또는 BaseEstimator 의 특정 구현이 제어 흐름 지침을 사용할 수 있도록 지원을 수정했습니다.

  • PauliOp.matmul() 메서드가 iI 으로 잘못된 결과를 반환하는 문제를 수정했습니다. 8680을 수정했습니다.

  • 근사 양자 컴파일러(AQC) 클래스에서 입력 단위에 결정자가 -1 인 경우 잘못된 회로를 반환하는 문제를 수정했습니다. 수정 #9327

  • 메서드 관련 문제를 수정했습니다 QuantumCircuit.compose() 메서드가 유효한 큐비트 또는 클럭비트 지정자를 잘못 거부하는 문제를 수정했습니다. 이제 메서드가 다른 메서드와 동일한 쿼비트 및 클럭비트 지정자 집합을 허용하도록 수정되었습니다 QuantumCircuit 메서드와 같은 append(). 수정 #8691.

  • 베이스의 레지스터를 완성하기 위해 주어진 회로 조건에 레지스터를 잘못 매핑하는 QuantumCircuit.compose() 메서드가 주어진 회로의 조건에서 레지스터를 잘못 매핑하여 베이스의 레지스터를 완성하는 문제를 수정했습니다. 이전에는 매핑이 매우 부정확하여 각 조건 내에서 사용되는 비트가 매핑의 대상이 아니었고, 대신 해당 레지스터를 찾으려고 부정확한 시도가 이루어졌습니다. 또한 작은 레지스터의 조건이 더 큰 레지스터로 확장되어 유효한 변환이 아닌 결과가 발생할 수도 있습니다. 이제 단일 비트 또는 레지스터에 대한 조건은 clbits 인수가 정의한 비트에 정확히 위치하도록 구성됩니다. 필요한 경우 이를 용이하게 하기 위해 기본 회로에 새로운 앨리어싱 레지스터가 추가됩니다. 수정 #6583.

  • 함수 관련 문제를 수정했습니다 transpile()optimization_level 함수를 1, 2, 또는 3 로 설정하고 backend, basis_gates, 또는 target 인수를 지정하지 않은 상태에서 실행할 때 발생하는 문제를 수정했습니다. 입력 회로에 단순화할 수 있는 단일 큐비트 게이트가 있다면 단일 큐비트 게이트가 제거되지 않았기 때문에 출력 회로가 최적화되지 않았을 것입니다. 이전에는 backend, basis_gates, 또는 target 인수를 지정하여 이 문제를 해결할 수 있었지만 transpile() 호출에 인수를 지정하여 수정할 수 있었지만, 이제 허용되는 대상 게이트를 몰라도 출력이 최대한 단순화됩니다. 수정 #9217

  • 함수 관련 문제를 수정했습니다 transpile()optimization_level=3 함수를 backend, basis_gates, 또는 target 인수를 지정하지 않고 실행할 때 발생하는 문제를 수정했습니다. 입력 회로에 아이덴티티 행렬과 동일한 2개의 큐비트 블록이 포함되어 있으면 출력 회로가 최적화되지 않고 여전히 해당 아이덴티티 블록을 포함하게 됩니다. 이전에는 backend, basis_gates, 또는 target 인수를 지정하여 이 문제를 해결할 수 있었지만 transpile() 호출에 인수를 지정하여 수정할 수 있었지만, 이제 허용되는 대상 게이트를 몰라도 출력이 최대한 단순화됩니다. 수정 #9217

  • 다음과 관련된 문제를 수정했습니다 LinCombSamplerGradient 와 함께 실행될 때 잠재적으로 오류가 발생할 수 있는 문제를 수정했습니다 Samplerqiskit-aer 클래스로 실행할 때 오류가 발생할 수 있는 문제를 수정했습니다.

  • 관련 문제를 수정했습니다 NumPyEigensolver 및 확장자 NumPyMinimumEigensolver 에서 Operator 이외의 BaseOperator 하위 클래스에 대해 해결하면 오류가 발생하는 문제를 수정했습니다.

  • 에서 메타데이터 출력의 문제를 수정했습니다 primitives 의 메타데이터 출력에서 목록이 참조로 복사본을 만들고 모든 요소가 반복할 때마다 동일한 값으로 업데이트되는 문제를 수정했습니다.

  • 여러 백엔드가 호출되고 실수로 펄스 라이브러리에서 동일한 펄스 이름을 가질 때 QobjToInstructionConverter 관련 문제를 수정했습니다. 이는 변환기 인스턴스가 여러 백엔드에서 재사용될 때만 발생할 수 있는 에지 케이스였습니다(일반적인 사용 패턴은 아니었습니다).

  • 클래스 관련 문제를 수정했습니다 PVQD 클래스의 손실 함수가 충실도를 잘못 제곱하던 문제를 수정했습니다. 손실 함수가 원래 알고리즘 정의의 정의와 일치하도록 수정되었습니다.

  • QPY의 버그(qiskit.qpy)에서 비트가 느슨하게 발생한 레지스터가 포함된 회로가 역직렬화에 실패하는 버그가 수정되었습니다. 9094번을 참조하세요.

  • TwoQubitWeylDecomposition 클래스는 이제 pickle 프로토콜과 호환됩니다. 이전에는 역직렬화에 실패하고 TypeError. 7312번을 참조하세요.

  • 메서드에서 LocalReadoutMitigator.quasi_probabilities() 메서드에서 shots 인수가 사용되지 않는 문제를 수정했습니다. 이제 반환 오브젝트의 샷 수를 설정하는 데 사용됩니다.

  • 객체 구성의 회귀를 수정했습니다 Clifford 다른 객체를 포함하는 QuantumCircuits 의 Clifford 객체를 포함하는 문제를 수정했습니다.

  • Python 표준 라이브러리 pickle 에서 이러한 클래스를 직렬화할 수 있도록 TwoQubitWeylDecomposition 클래스(및 그 하위 클래스)의 문제를 수정했습니다. 부분적으로 수정된 #7312

  • QuantumCircuit.qasm() 이제 게이트가 올바르게 이스케이프되고 예약된 OpenQASM 2 키워드와 충돌하는 이름을 등록합니다. 5043 수정.

  • 의 문제를 수정했습니다 RZXCalibrationBuilder 에서 ECR 펄스 시퀀스가 잘못 정렬되는 문제를 수정했습니다. 수정 #9013.

  • 일정 시각화에서 일부 채널이 누락되는 문제를 수정했습니다 pulse_drawer() 출력 시각화에서 일정의 일부 채널이 누락되는 문제를 수정했습니다. 수정 #8981.

에어 0.11.2

변경 없음

IBM Q 제공자 0.19.2

변경 없음

이 페이지가 도움이 되었습니까?
GitHub에서 버그, 오타를 보고하거나 컨텐츠를 요청하십시오.