Pengekodan data

Pengenalan dan tatatanda

Untuk menggunakan algoritma kuantum, data klasik mesti dibawa masuk ke dalam Circuit kuantum dengan cara tertentu. Proses ini biasanya dirujuk sebagai pengekodan data, tetapi juga disebut sebagai pemuatan data. Ingat kembali dari pelajaran sebelumnya tentang konsep pemetaan ciri, iaitu pemetaan ciri data dari satu ruang ke ruang yang lain. Memindahkan data klasik ke komputer kuantum semata-mata adalah satu jenis pemetaan, dan boleh disebut sebagai pemetaan ciri. Dalam amalan, pemetaan ciri terbina dalam Qiskit (seperti z_feature_map dan zz_feature_map) biasanya akan menyertakan lapisan putaran dan lapisan pengelitan yang mengembangkan keadaan ke banyak dimensi dalam ruang Hilbert. Proses pengekodan ini merupakan bahagian kritikal algoritma pembelajaran mesin kuantum dan secara langsung mempengaruhi keupayaan pengiraan mereka.

Beberapa teknik pengekodan di bawah boleh disimulasikan dengan cekap secara klasik; ini amat jelas kelihatan dalam kaedah pengekodan yang menghasilkan keadaan produk (iaitu, yang tidak mengelitkan qubit). Dan ingat bahawa kegunaan kuantum kemungkinan besar terletak di mana kerumitan seperti kuantum dalam set data sepadan dengan baik dengan kaedah pengekodan. Jadi sangat mungkin anda akan menulis litar pengekodan sendiri. Di sini, kami menunjukkan pelbagai strategi pengekodan yang mungkin supaya anda boleh membandingkan dan membezakannya, serta melihat apa yang boleh dilakukan. Ada beberapa pernyataan umum yang boleh dibuat tentang kegunaan teknik pengekodan. Contohnya, efficient_su2 (lihat di bawah) dengan skim pengelitan penuh jauh lebih berkemungkinan untuk menangkap ciri kuantum data berbanding kaedah yang menghasilkan keadaan produk (seperti z_feature_map). Tetapi ini tidak bermakna efficient_su2 mencukupi, atau sepadan dengan set data anda, untuk menghasilkan peningkatan kelajuan kuantum. Perkara itu memerlukan pertimbangan teliti terhadap struktur data yang dimodel atau diklasifikasikan. Ada juga pertimbangan keseimbangan dengan kedalaman litar, kerana banyak peta ciri yang mengelitkan sepenuhnya semua qubit dalam litar menghasilkan litar yang sangat dalam, terlalu dalam untuk mendapat keputusan berguna pada komputer kuantum hari ini.

Tatatanda

Set data ialah set $M$ vektor data: $\text{X} = \{\vec{x}^{(j)}\,|\,j\in [M]\}$, di mana setiap vektor berdimensi $N$, iaitu $\vec{x}^{(j)}=(\vec{x}^{(j)}_1,\ldots,\vec{x}^{(j)}_N)\in\mathbb{R}^N$. Ini boleh diperluaskan kepada ciri data kompleks. Dalam pelajaran ini, kami mungkin kadang-kadang menggunakan tatatanda ini untuk set penuh $(\text{X}),$ dan elemen spesifiknya seperti $\vec{x}^{(j)}$. Tetapi kami kebanyakannya akan merujuk kepada pemuatan satu vektor dari set data pada satu masa, dan sering merujuk kepada satu vektor tunggal dengan $N$ ciri sebagai $\vec{x}$.

Tambahan pula, adalah lazim menggunakan simbol $\Phi(\vec{x})$ untuk merujuk kepada pemetaan ciri $\Phi$ bagi vektor data $\vec{x}$. Dalam pengkomputeran kuantum khususnya, adalah lazim merujuk kepada pemetaan dalam pengkomputeran kuantum menggunakan $U(\vec{x}),$ satu tatatanda yang menekankan sifat unitari operasi tersebut. Seseorang boleh menggunakan simbol yang sama untuk kedua-duanya; keduanya adalah pemetaan ciri. Sepanjang kursus ini, kami cenderung menggunakan:

• $\Phi(\vec{x})$ apabila membincangkan pemetaan ciri dalam pembelajaran mesin secara umum, dan
• $U(\vec{x})$ apabila membincangkan pelaksanaan litar bagi pemetaan ciri.

Penormalan dan kehilangan maklumat

Dalam pembelajaran mesin klasik, ciri data latihan sering "dinormalkan" atau ditingkatkan semula skalanya, yang sering meningkatkan prestasi model. Satu cara lazim melakukan ini adalah dengan menggunakan penormalan min-maks atau piawai. Dalam penormalan min-maks, lajur ciri matriks data $\text{X}$ (katakan, ciri $k$) dinormalkan:

$$x^{'(i)}_k = \frac{x^{(i)}_k - \text{min}\{x^{(j)}_k\,|\,\vec{x}^{(j)}\in [\text{X}]\}}{\text{max}\{x^{(j)}_k\,|\,\vec{x}^{(j)}\in [\text{X}]\}-\text{min}\{x^{(j)}_k\,|\,\vec{x}^{(j)}\in [\text{X}]\}}$$

di mana min dan maks merujuk kepada minimum dan maksimum ciri $k$ merentasi $M$ vektor data dalam set data $\text{X}$. Semua nilai ciri kemudian jatuh dalam selang unit: $x^{'(i)}_k \in [0,1]$ untuk semua $i\in [M]$, $k\in[N]$.

Penormalan juga merupakan konsep asas dalam mekanik kuantum dan pengkomputeran kuantum, tetapi ia sedikit berbeza dari penormalan min-maks. Penormalan dalam mekanik kuantum memerlukan panjang (dalam konteks pengkomputeran kuantum, norma-2) vektor keadaan $|\psi\rangle$ bersamaan dengan satu: $\|\psi\|=\sqrt{\langle\psi|\psi\rangle} = 1$, memastikan kebarangkalian pengukuran berjumlah 1. Keadaan dinormalkan dengan membahagi dengan norma-2; iaitu dengan menskal semula

$$|\psi\rangle\rightarrow\|\psi\|^{-1}|\psi\rangle$$

Dalam pengkomputeran kuantum dan mekanik kuantum, ini bukan penormalan yang dikenakan oleh manusia ke atas data, tetapi sifat asas keadaan kuantum. Bergantung kepada skim pengekodan anda, kekangan ini mungkin mempengaruhi cara data anda diskalakan semula. Contohnya, dalam pengekodan amplitud (lihat di bawah), vektor data dinormalkan $\vert\vec{x}^{(j)}\vert = 1$ seperti yang dikehendaki oleh mekanik kuantum, dan ini mempengaruhi penskalaan data yang dikodkan. Dalam pengekodan fasa, nilai ciri disyorkan untuk diskalakan semula sebagai $\vec{x}^{(j)}_i \in (0,2\pi]$ supaya tiada kehilangan maklumat akibat kesan modulo-$2\pi$ daripada pengekodan ke sudut fasa qubit[1,2].

Kaedah pengekodan

Dalam beberapa bahagian seterusnya, kami akan merujuk kepada contoh set data klasik kecil $\text{X}_\text{ex}$ yang terdiri daripada $M=5$ vektor data, masing-masing dengan $N=3$ ciri:

$$\text{X}_{\text{ex}}=\{(4,8,5),(9,8,6),(2,9,2),(5,7,0),(3,7,5)\}$$

Dalam tatatanda yang diperkenalkan di atas, kita mungkin berkata ciri ke-$1$ dari vektor data ke-$4$ dalam set $\text{X}_{\text{ex}}$ ialah $\vec{x}^{(4)}_1 = 5,$ sebagai contoh.

Pengekodan basis

Pengekodan basis mengekodkan rentetan $P$-bit klasik ke dalam keadaan basis pengiraan sistem $P$-qubit. Ambil contoh $\vec{x}^{(1)}_3 = 5 = 0(2^3)+1(2^2)+0(2^1)+1(2^0).$ Ini boleh diwakili sebagai rentetan $4$-bit iaitu $(0101)$, dan oleh sistem $4$-qubit sebagai keadaan kuantum $|0101\rangle$. Secara lebih umum, untuk rentetan $P$-bit: $\vec{x}^{(j)}_k = (b_1, b_2, ... , b_P)$, keadaan $P$-qubit yang sepadan ialah $|x^{(j)}_k\rangle = | b_1, b_2, ... , b_P \rangle$ dengan $b_n \in \{0,1\}$ untuk $n = 1 , \dots , P$. Perhatikan bahawa ini hanya untuk satu ciri sahaja.

Pengekodan basis dalam pengkomputeran kuantum mewakili setiap bit klasik sebagai qubit berasingan, memetakan perwakilan binari data terus ke keadaan kuantum dalam basis pengiraan. Apabila pelbagai ciri perlu dikodkan, setiap ciri pertama ditukar ke bentuk binarinya, kemudian diberikan kepada kumpulan qubit yang berlainan — satu kumpulan bagi setiap ciri — di mana setiap qubit mencerminkan satu bit dalam perwakilan binari ciri tersebut.

Sebagai contoh, mari kita kodkan vektor (5, 7, 0).

Andaikan semua ciri disimpan dalam empat bit (lebih dari yang diperlukan, tetapi cukup untuk mewakili mana-mana integer digit tunggal dalam asas 10):

5 → binary 0101

7 → binary 0111

0 → binary 0000

Rentetan bit ini diberikan kepada tiga set empat qubit, jadi keseluruhan keadaan basis 12-qubit ialah:

$$∣0101 0111 0000⟩$$

Di sini, empat qubit pertama mewakili ciri pertama, empat qubit berikutnya mewakili ciri kedua, dan empat qubit terakhir mewakili ciri ketiga. Kod di bawah menukar vektor data (5,7,0) kepada keadaan kuantum, dan diumumkan untuk berbuat demikian bagi ciri digit tunggal yang lain.

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib numpy qiskit

from qiskit import QuantumCircuit

# Data point to encode
x = 5  # binary: 0101
y = 7  # binary: 0111
z = 0  # binary: 0000

# Convert each to 4-bit binary list
x_bits = [int(b) for b in format(x, "04b")]  # [0,1,0,1]
y_bits = [int(b) for b in format(y, "04b")]  # [0,1,1,1]
z_bits = [int(b) for b in format(z, "04b")]  # [0,0,0,0]

# Combine all bits
all_bits = x_bits + y_bits + z_bits  # [0,1,0,1,0,1,1,1,0,0,0,0]

# Initialize a 12-qubit quantum circuit
qc = QuantumCircuit(12)

# Apply x-gates where the bit is 1
for idx, bit in enumerate(all_bits):
    if bit == 1:
        qc.x(idx)

qc.draw("mpl")

Uji kefahaman anda

Baca soalan di bawah, fikirkan jawapan anda, kemudian klik segitiga untuk mendedahkan penyelesaian.

Tulis kod untuk mengekodkan vektor pertama dalam set data contoh $\text{X}_{\text{ex}}$:

$\vec{x}^{(1)}=(4,8,5)$

menggunakan pengekodan basis.

Jawapan:

import math
from qiskit import QuantumCircuit

# Data point to encode
x = 4  # binary: 0100
y = 8  # binary: 1000
z = 5  # binary: 0101

# Convert each to 4-bit binary list
x_bits = [int(b) for b in format(x, '04b')]  # [0,1,0,0]
y_bits = [int(b) for b in format(y, '04b')]  # [1,0,0,0]
z_bits = [int(b) for b in format(z, '04b')]  # [0,1,0,1]

# Combine all bits
all_bits = x_bits + y_bits + z_bits  # [0,1,0,0,1,0,0,0,0,1,0,1]

# Initialize a 12-qubit quantum circuit
qc = QuantumCircuit(12)

# Apply x-gates where the bit is 1
for idx, bit in enumerate(all_bits):
    if bit == 1:
        qc.x(idx)

qc.draw('mpl')

Pengekodan amplitud

Pengekodan amplitud mengekodkan data ke dalam amplitud keadaan kuantum. Ia mewakili vektor data klasik $N$-dimensi yang dinormalkan, $\vec{x}^{(j)}$, sebagai amplitud keadaan kuantum $n$-qubit, $|\psi_x\rangle$:

$$|\psi^{(j)}_x\rangle = \frac{1}{\alpha}\sum_{i=1}^N x^{(j)}_i |i\rangle$$

di mana $N$ ialah dimensi vektor data yang sama seperti sebelumnya, $\vec{x}^{(j)}_i$ ialah elemen ke-$i$ bagi $\vec{x}^{(j)}$ dan $|i\rangle$ ialah keadaan basis pengiraan ke-$i$. Di sini, $\alpha$ ialah pemalar penormalan yang ditentukan daripada data yang dikodkan. Ini adalah syarat penormalan yang dikenakan oleh mekanik kuantum:

$$\sum_{i=1}^N \left|x^{(j)}_i\right|^2 = \left|\alpha\right|^2.$$

Secara umum, ini adalah syarat yang berbeza daripada penormalan min/maks yang digunakan untuk setiap ciri merentasi semua vektor data. Cara menangani ini akan bergantung kepada masalah anda. Tetapi tiada cara untuk mengelakkan syarat penormalan mekanik kuantum di atas.

Dalam pengekodan amplitud, setiap ciri dalam vektor data disimpan sebagai amplitud keadaan kuantum yang berbeza. Memandangkan sistem $n$ qubit menyediakan $2^n$ amplitud, pengekodan amplitud bagi $N$ ciri memerlukan $n \ge \mathrm{log}_2(N)$ qubit.

Sebagai contoh, mari kita kodkan vektor pertama dalam set data contoh $\text{X}_\text{ex}$, $\vec{x}^{(1)} = (4,8,5)$ menggunakan pengekodan amplitud. Dengan menormalkan vektor yang terhasil, kita dapat:

$$\sum_{i=1}^N \left|x^{(1)}_i\right|^2 = 4^2+8^2+5^2 = 105 = \left|\alpha\right|^2 \rightarrow \alpha = \sqrt{105}$$

dan keadaan kuantum 2-qubit yang terhasil ialah:

$$|\psi(\vec{x}^{(1)})\rangle = \frac{1}{\sqrt{105}}(4|00\rangle+8|01\rangle+5|10\rangle+0|11\rangle)$$

Dalam contoh di atas, bilangan ciri dalam vektor $N=3$, bukan kuasa 2. Apabila $N$ bukan kuasa 2, kita hanya memilih nilai untuk bilangan qubit $n$ supaya $2^n\geq N$ dan mengisi vektor amplitud dengan pemalar tidak bermaklumat (di sini, sifar).

Seperti dalam pengekodan basis, setelah kita mengira keadaan yang akan mengekodkan set data kita, dalam Qiskit kita boleh menggunakan fungsi initialize untuk menyediakannya:

import math

desired_state = [
    1 / math.sqrt(105) * 4,
    1 / math.sqrt(105) * 8,
    1 / math.sqrt(105) * 5,
    1 / math.sqrt(105) * 0,
]

qc = QuantumCircuit(2)
qc.initialize(desired_state, [0, 1])

qc.decompose(reps=5).draw(output="mpl")

Kelebihan pengekodan amplitud ialah keperluan hanya $\mathrm{log}_2(N)$ qubit untuk mengekodkan. Walau bagaimanapun, algoritma seterusnya mesti beroperasi ke atas amplitud keadaan kuantum, dan kaedah untuk menyediakan serta mengukur keadaan kuantum cenderung tidak cekap.

Uji kefahaman anda

Baca soalan-soalan di bawah, fikirkan jawapan anda, kemudian klik segitiga untuk mendedahkan penyelesaian.

Tuliskan keadaan yang dinormalkan untuk mengekodkan vektor berikut (terdiri daripada dua vektor dari set data contoh):

$\vec{x}=(9,8,6,2,9,2)$

menggunakan pengekodan amplitud.

Jawapan:

Untuk mengekodkan 6 nombor, kita perlukan sekurang-kurangnya 6 keadaan yang tersedia di mana amplitudnya boleh dikodkan. Ini memerlukan 3 qubit. Menggunakan faktor penormalan yang tidak diketahui $\alpha$, kita boleh tulis ini sebagai:

$$|\psi\rangle = \alpha(9|000\rangle+8|001\rangle+6|010\rangle+2|011\rangle+9|100\rangle+2|101\rangle+0|110\rangle+0|111\rangle)$$

Perhatikan bahawa

$$\langle \psi|\psi\rangle = |\alpha|^2\times(9^2+8^2+6^2+2^2+9^2+2^2+0^2+0^2) = |\alpha|^2\times(270)=1 \rightarrow \alpha = \frac{1}{\sqrt{270}}$$

Jadi akhirnya,

$$|\psi\rangle = \frac{1}{\sqrt{270}}(9|000\rangle+8|001\rangle+6|010\rangle+2|011\rangle+9|100\rangle+2|101\rangle+0|110\rangle+0|111\rangle)$$

Untuk vektor data yang sama $\vec{x}=(9,8,6,2,9,2),$ tulis kod untuk mencipta litar yang memuatkan ciri-ciri data ini menggunakan pengekodan amplitud.

Jawapan:

desired_state = [
    9 / math.sqrt(270),
    8 / math.sqrt(270),
    6 / math.sqrt(270),
    2 / math.sqrt(270),
    9 / math.sqrt(270),
    2 / math.sqrt(270),
    0,
    0,
]

print(desired_state)

qc = QuantumCircuit(3)
qc.initialize(desired_state, [0, 1, 2])
qc.decompose(reps=8).draw(output="mpl")

[0.5477225575051662, 0.48686449556014766, 0.36514837167011077, 0.12171612389003691, 0.5477225575051662, 0.12171612389003691, 0, 0]

Anda mungkin perlu berurusan dengan vektor data yang sangat besar. Pertimbangkan vektor

$$\vec{x}=(4,8,5,9,8,6,2,9,2,5,7,0,3,7,5).$$

Tulis kod untuk mengautomasikan penormalan, dan hasilkan litar kuantum untuk pengekodan amplitud.

Jawapan:

Ada banyak jawapan yang mungkin. Berikut adalah kod yang mencetak beberapa langkah sepanjang perjalanan:

import numpy as np
from math import sqrt

init_list = [4, 8, 5, 9, 8, 6, 2, 9, 2, 5, 7, 0, 3, 7, 5]
qubits = round(np.log(len(init_list)) / np.log(2) + 0.4999999999)
need_length = 2**qubits
pad = need_length - len(init_list)
for i in range(0, pad):
    init_list.append(0)

init_array = np.array(init_list)  # Unnormalized data vector
length = sqrt(
    sum(init_array[i] ** 2 for i in range(0, len(init_array)))
)  # Vector length
norm_array = init_array / length  # Normalized array
print("Normalized array:")
print(norm_array)
print()

qubit_numbers = []
for i in range(0, qubits):
    qubit_numbers.append(i)
print(qubit_numbers)

qc = QuantumCircuit(qubits)
qc.initialize(norm_array, qubit_numbers)
qc.decompose(reps=7).draw(output="mpl")

Normalized array: [0.17342199 0.34684399 0.21677749 0.39019949 0.34684399 0.26013299 0.086711 0.39019949 0.086711 0.21677749 0.30348849 0. 0.1300665 0.30348849 0.21677749 0. ]

[0, 1, 2, 3]

Adakah anda nampak kelebihan pengekodan amplitud berbanding pengekodan basis? Jika ada, terangkan.

Jawapan:

Mungkin ada beberapa jawapan. Satu jawapan ialah, dengan susunan tetap keadaan basis, pengekodan amplitud ini mengekalkan susunan nombor yang dikodkan. Ia juga sering dikodkan dengan lebih padat.

Kelebihan pengekodan amplitud ialah hanya $\log_2(N)$ qubit diperlukan untuk vektor data $N$-dimensi ($N$-ciri) $\vec{x}\rightarrow|\vec{x}\rangle$. Walau bagaimanapun, pengekodan amplitud secara umumnya merupakan prosedur yang tidak cekap yang memerlukan penyediaan keadaan sembarangan, yang bersifat eksponen dalam bilangan get CNOT. Dengan kata lain, penyediaan keadaan mempunyai kerumitan masa jalan polinomial sebesar $\mathcal O(N)$ dalam bilangan dimensi, di mana $N = 2^n$, dan $n$ ialah bilangan qubit. Pengekodan amplitud "memberikan penjimatan eksponen dalam ruang dengan kos peningkatan eksponen dalam masa"[3]; walau bagaimanapun, peningkatan masa jalan kepada $\mathcal O(\log N)$ boleh dicapai dalam kes tertentu[4]. Untuk peningkatan kelajuan kuantum dari hujung ke hujung, kerumitan masa jalan pemuatan data perlu dipertimbangkan.

Pengekodan sudut

Pengekodan sudut mendapat perhatian dalam banyak model QML yang menggunakan peta ciri Pauli seperti mesin vektor sokongan kuantum (QSVM) dan litar kuantum variatif (VQC), antara lain. Pengekodan sudut berkait rapat dengan pengekodan fasa dan pengekodan sudut padat yang dibentangkan di bawah. Di sini kami akan menggunakan "pengekodan sudut" untuk merujuk kepada putaran dalam $\theta$, iaitu putaran jauh dari paksi $z$ yang dicapai misalnya oleh get $R_X$ atau get $R_Y$[1,3]. Sebenarnya, seseorang boleh mengekodkan data dalam mana-mana putaran atau gabungan putaran. Tetapi $R_Y$ adalah lazim dalam kesusasteraan, jadi kami menekankannya di sini.

Apabila digunakan pada satu qubit tunggal, pengekodan sudut memberikan putaran paksi-Y yang berkadar dengan nilai data. Pertimbangkan pengekodan satu ciri ke-$k$ dari vektor data ke-$j$ dalam set data, $\vec{x}^{(j)}_k$:

$$|\vec{x}^{(j)}_k\rangle = R_Y(\theta=\vec{x}^{(j)}_k)|0\rangle = \textstyle\cos\left(\frac{\vec{x}^{(j)}_k}{2}\right)|0\rangle + \sin\left(\frac{\vec{x}^{(j)}_k}{2}\right)|1\rangle.$$

Sebagai alternatif, pengekodan sudut boleh dilakukan menggunakan get $R_X(\theta)$, walaupun keadaan yang dikodkan akan mempunyai fasa relatif kompleks berbanding $R_Y(\theta)$.

Pengekodan sudut berbeza daripada dua kaedah sebelumnya dalam beberapa cara. Dalam pengekodan sudut:

• Setiap nilai ciri dipetakan ke qubit yang sepadan, $\vec{x}^{(j)}_k \rightarrow Q_k$, meninggalkan qubit dalam keadaan produk.
• Satu nilai berangka dikodkan pada satu masa, bukan keseluruhan set ciri dari satu titik data.
• $n$ qubit diperlukan untuk $N$ ciri data, di mana $n\leq N$. Selalunya kesamaan berlaku di sini. Kita akan lihat bagaimana $n<N$ mungkin dalam beberapa bahagian berikutnya.
• Litar kuantum yang terhasil mempunyai kedalaman tetap (biasanya kedalaman ialah 1 sebelum transpilasi).

Litar kuantum berkedalaman tetap menjadikannya amat sesuai untuk perkakasan kuantum semasa. Satu ciri tambahan daripada pengekodan data kita menggunakan $\theta$ (dan khususnya, pilihan kita untuk menggunakan pengekodan sudut paksi-Y) ialah ia mencipta keadaan kuantum bernilai nyata yang berguna untuk aplikasi tertentu. Untuk putaran paksi-Y, data dipetakan dengan get putaran paksi-Y $R_Y(\theta)$ melalui sudut bernilai nyata $\theta \in (0, 2\pi]$ (Qiskit RYGate). Seperti pengekodan fasa (lihat di bawah), kami mengesyorkan anda menskalakan data semula supaya $\vec{x}^{(j)}_k \in (0,2\pi]$, mengelakkan kehilangan maklumat dan kesan-kesan lain yang tidak diingini.

Kod Qiskit berikut memutar satu qubit dari keadaan awal $|0\rangle$ untuk mengekodkan nilai data $\vec{x}^{(j)}_k=\frac{1}{2}\pi$.

from qiskit.quantum_info import Statevector
from math import pi

qc = QuantumCircuit(1)
state1 = Statevector.from_instruction(qc)
qc.ry(pi / 2, 0)  # Phase gate rotates by an angle pi/2
state2 = Statevector.from_instruction(qc)
states = state1, state2

Kita akan mentakrifkan fungsi untuk menggambarkan tindakan ke atas vektor keadaan. Butiran definisi fungsi tidak penting, tetapi keupayaan untuk menggambarkan vektor keadaan dan perubahannya adalah penting.

import numpy as np
from qiskit.visualization.bloch import Bloch
from qiskit.visualization.state_visualization import _bloch_multivector_data

def plot_Nstates(states, axis, plot_trace_points=True):
    """This function plots N states to 1 Bloch sphere"""
    bloch_vecs = [_bloch_multivector_data(s)[0] for s in states]

    if axis is None:
        bloch_plot = Bloch()
    else:
        bloch_plot = Bloch(axes=axis)

    bloch_plot.add_vectors(bloch_vecs)

    if len(states) > 1:

        def rgba_map(x, num):
            g = (0.95 - 0.05) / (num - 1)
            i = 0.95 - g * num
            y = g * x + i
            return (0.0, y, 0.0, 0.7)

        num = len(states)
        bloch_plot.vector_color = [rgba_map(x, num) for x in range(1, num + 1)]

    bloch_plot.vector_width = 3
    bloch_plot.vector_style = "simple"

    if plot_trace_points:

        def trace_points(bloch_vec1, bloch_vec2):
            # bloch_vec = (x,y,z)
            n_points = 15
            thetas = np.arccos([bloch_vec1[2], bloch_vec2[2]])
            phis = np.arctan2(
                [bloch_vec1[1], bloch_vec2[1]], [bloch_vec1[0], bloch_vec2[0]]
            )
            if phis[1] < 0:
                phis[1] = phis[1] + 2 * pi
            angles0 = np.linspace(phis[0], phis[1], n_points)
            angles1 = np.linspace(thetas[0], thetas[1], n_points)

            xp = np.cos(angles0) * np.sin(angles1)
            yp = np.sin(angles0) * np.sin(angles1)
            zp = np.cos(angles1)
            pnts = [xp, yp, zp]
            bloch_plot.add_points(pnts)
            bloch_plot.point_color = "k"
            bloch_plot.point_size = [4] * len(bloch_plot.points)
            bloch_plot.point_marker = ["o"]

        for i in range(len(bloch_vecs) - 1):
            trace_points(bloch_vecs[i], bloch_vecs[i + 1])

    bloch_plot.sphere_alpha = 0.05
    bloch_plot.frame_alpha = 0.15
    bloch_plot.figsize = [4, 4]

    bloch_plot.render()

plot_Nstates(states, axis=None, plot_trace_points=True)

Itu hanyalah satu ciri dari satu vektor data. Apabila mengekodkan $N$ ciri ke dalam sudut putaran $n$ qubit, katakan untuk vektor data ke-$j$ $\vec{x}^{(j)} = (x_1,...,x_N),$ keadaan produk yang dikodkan akan kelihatan seperti ini:

$$|\vec{x}^{(j)}\rangle = \bigotimes^N_{k=1} \cos(\vec{x}^{(j)}_k)|0\rangle + \sin(\vec{x}^{(j)}_k)|1\rangle$$

Kami perhatikan bahawa ini setara dengan

$$|\vec{x}^{(j)}\rangle = \bigotimes^N_{k=1} R_Y(2\vec{x}^{(j)}_k)|0\rangle.$$

Uji kefahaman anda

Baca soalan-soalan di bawah, fikirkan jawapan anda, kemudian klik segitiga untuk mendedahkan penyelesaian.

Kodkan vektor data $\vec{x} = (0, \pi/4, \pi/2)$ menggunakan pengekodan sudut, seperti yang diterangkan di atas.

Jawapan:

qc = QuantumCircuit(3)
qc.ry(0, 0)
qc.ry(2 * math.pi / 4, 1)
qc.ry(2 * math.pi / 2, 2)
qc.draw(output="mpl")

Menggunakan pengekodan sudut seperti yang diterangkan di atas, berapa banyak qubit yang diperlukan untuk mengekodkan 5 ciri?

Jawapan: 5

Pengekodan fasa

Pengekodan fasa sangat serupa dengan pengekodan sudut yang diterangkan di atas. Sudut fasa sebuah qubit ialah sudut bernilai nyata $\phi$ di sekitar paksi $z$ dari paksi $+x$. Data dipetakan dengan putaran fasa, $P(\phi) = e^{i\phi/2}R_Z(\phi)$, di mana $\phi \in (0,2\pi]$ (lihat Qiskit PhaseGate untuk maklumat lanjut). Adalah disyorkan untuk menskalakan data semula supaya $\vec{x}^{(j)}_k \in (0,2\pi]$. Ini mencegah kehilangan maklumat dan kesan lain yang mungkin tidak diingini[1,2].

Sebuah qubit sering dimulakan dalam keadaan $|0\rangle$, yang merupakan eigenstate operator putaran fasa, bermakna keadaan qubit perlu diputar terlebih dahulu agar pengekodan fasa dapat dilaksanakan. Oleh itu masuk akal untuk memulakan keadaan dengan get Hadamard: $H|0\rangle = |+\rangle = \textstyle\frac{1}{\sqrt{2}}(|0\rangle + |1\rangle)$. Pengekodan fasa pada satu qubit bermakna memberikan fasa relatif yang berkadar dengan nilai data:

$$|\vec{x}^{(j)}_k\rangle = P(\phi=\vec{x}^{(j)}_k)|+\rangle = \textstyle\frac{1}{\sqrt{2}}\big(|0\rangle + e^{i\vec{x}^{(j)}_k}|1\rangle\big).$$

Prosedur pengekodan fasa memetakan setiap nilai ciri ke fasa qubit yang sepadan, $\vec{x}^{(j)}_k \rightarrow Q_k$. Secara keseluruhannya, pengekodan fasa mempunyai kedalaman litar sebanyak 2, termasuk lapisan Hadamard, menjadikannya skim pengekodan yang cekap. Keadaan berbilang qubit yang dikodkan fasa ($n$ qubit untuk $N=n$ ciri) adalah keadaan produk:

$$|\vec{x}^{(j)}\rangle = \bigotimes_{k=1}^{N} P_k(\phi = \vec{x}^{(j)}_k)|+\rangle^{\otimes N} = {\textstyle\frac{1}{\sqrt{2^N}}} \bigotimes_{k=1}^{N}\big(|0\rangle + e^{i\vec{x}^{(j)}_k}|1\rangle\big).$$

Kod Qiskit berikut pertama menyediakan keadaan awal satu qubit dengan memutar menggunakan get Hadamard, kemudian memutarnya semula menggunakan get fasa untuk mengekodkan ciri data $\vec{x}^{(j)}_k=\frac{1}{2}\pi$.

qc = QuantumCircuit(1)
qc.h(0)  # Hadamard gate rotates state down to Bloch equator
state1 = Statevector.from_instruction(qc)

qc.p(pi / 2, 0)  # Phase gate rotates by an angle pi/2
state2 = Statevector.from_instruction(qc)

states = state1, state2

qc.draw("mpl", scale=1)

Kita boleh menggambarkan putaran dalam $\phi$ menggunakan fungsi plot_Nstates yang kita takrifkan.

plot_Nstates(states, axis=None, plot_trace_points=True)

Plot sfera Bloch menunjukkan putaran paksi-Z $|+\rangle \rightarrow P(\frac{1}{2}\pi)|+\rangle$ di mana $\vec{x}^{(j)}_k=\frac{1}{2}\pi$. Anak panah hijau muda menunjukkan keadaan akhir.

Pengekodan fasa digunakan dalam banyak peta ciri kuantum, terutamanya peta ciri $Z$ dan $ZZ$, dan peta ciri Pauli umum, antara lain.

Uji kefahaman anda

Baca soalan-soalan di bawah, fikirkan jawapan anda, kemudian klik segitiga untuk mendedahkan penyelesaian.

Berapa banyak qubit yang diperlukan untuk menggunakan pengekodan fasa seperti yang diterangkan di atas bagi menyimpan 8 ciri?

Jawapan: 8

Tulis kod untuk vektor $\vec{x}^{(1)}=(4,8,5,9,8,6,2,9,2,5,7,0)$ menggunakan pengekodan fasa.

Jawapan:

Mungkin ada banyak jawapan. Berikut adalah satu contoh:

phase_data = [4, 8, 5, 9, 8, 6, 2, 9, 2, 5, 7, 0]
qc = QuantumCircuit(len(phase_data))
for i in range(0, len(phase_data)):
    qc.h(i)
    qc.rz(phase_data[i] * 2 * math.pi / float(max(phase_data)), i)
qc.draw(output="mpl")

Pengekodan sudut padat

Pengekodan sudut padat (DAE) adalah gabungan pengekodan sudut dan pengekodan fasa. DAE membolehkan dua nilai ciri dikodkan dalam satu qubit tunggal: satu sudut dengan sudut putaran paksi-Y, dan satu lagi dengan sudut putaran paksi-$z$: $\vec{x}^{(j)}_k,$ $\vec{x}^{(j)}_\ell \rightarrow \theta, \phi$. Ia mengekodkan dua ciri seperti berikut:

$$|\vec{x}^{(j)}_k,\vec{x}^{(j)}_\ell\rangle = R_Z(\phi=\vec{x}^{(j)}_\ell) R_Y(\theta=\vec{x}^{(j)}_k)|0\rangle = \cos\left(\frac{\vec{x}^{(j)}_k}{2}\right)|0\rangle + e^{i\vec{x}^{(j)}_\ell} \sin\left(\frac{\vec{x}^{(j)}_k}{2}\right)|1\rangle.$$

Pengekodan dua ciri data ke satu qubit menghasilkan pengurangan $2\times$ dalam bilangan qubit yang diperlukan untuk pengekodan. Dengan memperluaskan ini kepada lebih banyak ciri, vektor data $\vec{x} = (x_1,...,x_N)$ boleh dikodkan sebagai:

$$|\vec{x}\rangle = \bigotimes_{k=1}^{N/2} \cos(x_{2k-1})|0\rangle + e^{i x_{2k}}\sin(x_{2k-1})|1\rangle$$

DAE boleh diumumkan kepada fungsi arbitrari bagi dua ciri tersebut daripada fungsi sinusoid yang digunakan di sini. Ini dipanggil pengekodan qubit umum[7].

Sebagai contoh DAE, kod di bawah mengekodkan dan menggambarkan pengekodan ciri $x_1=\theta = 3\pi/8$ dan $x_2=\phi = 7\pi/4$.

qc = QuantumCircuit(1)
state1 = Statevector.from_instruction(qc)
qc.ry(3 * pi / 8, 0)
state2 = Statevector.from_instruction(qc)
qc.rz(7 * pi / 4, 0)
state3 = Statevector.from_instruction(qc)
states = state1, state2, state3

plot_Nstates(states, axis=None, plot_trace_points=True)

Uji kefahaman anda

Baca soalan-soalan di bawah, fikirkan jawapan anda, kemudian klik segitiga untuk mendedahkan penyelesaian.

Berdasarkan perbincangan di atas, berapa banyak qubit yang diperlukan untuk mengekodkan 6 ciri menggunakan pengekodan padat?

Jawapan: 3

Tulis kod untuk memuatkan vektor $\vec{x}^{(1)}=(4,8,5,9,8,6,2,9,2,5,7,0,3,7,5)$ menggunakan pengekodan sudut padat.

Jawapan:

Perhatikan bahawa kita telah mengisi senarai dengan "0" untuk mengelakkan masalah apabila ada satu parameter yang tidak digunakan dalam skim pengekodan kita.

dense_data = [4, 8, 5, 9, 8, 6, 2, 9, 2, 5, 7, 0, 3, 7, 5, 0]
qc = QuantumCircuit(int(len(dense_data) / 2))
entry = 0
for i in range(0, int(len(dense_data) / 2)):
    qc.ry(dense_data[entry] * 2 * math.pi / float(max(dense_data)), i)
    entry = entry + 1
    qc.rz(dense_data[entry] * 2 * math.pi / float(max(dense_data)), i)
    entry = entry + 1
qc.draw(output="mpl")

Pengekodan dengan peta ciri terbina dalam

Pengekodan pada titik arbitrari

Pengekodan sudut, pengekodan fasa, dan pengekodan padat menyediakan keadaan produk dengan satu ciri dikodkan pada setiap qubit (atau dua ciri bagi setiap qubit). Ini berbeza daripada pengekodan basis dan pengekodan amplitud, kerana kaedah-kaedah tersebut menggunakan keadaan terkait. Tiada perwakilan 1:1 antara ciri data dan qubit. Dalam pengekodan amplitud contohnya, anda mungkin mempunyai satu ciri sebagai amplitud keadaan $|01\rangle$ dan ciri lain sebagai amplitud untuk $|10\rangle$. Secara umum, kaedah yang mengekodkan dalam keadaan produk menghasilkan litar yang lebih cetek dan boleh menyimpan 1 atau 2 ciri pada setiap qubit. Kaedah yang menggunakan pengelitan dan mengaitkan ciri dengan keadaan berbanding qubit menghasilkan litar yang lebih dalam, dan boleh menyimpan lebih banyak ciri bagi setiap qubit secara purata.

Tetapi pengekodan tidak semestinya sepenuhnya dalam keadaan produk atau sepenuhnya dalam keadaan terkait seperti dalam pengekodan amplitud. Malah, banyak skim pengekodan yang terbina dalam Qiskit membenarkan pengekodan sebelum dan selepas lapisan pengelitan, berbanding hanya pada permulaan. Ini dikenali sebagai "pengunggahan semula data". Untuk karya berkaitan, lihat rujukan [5] dan [6].

Dalam bahagian ini, kami akan menggunakan dan menggambarkan beberapa skim pengekodan terbina dalam. Semua kaedah dalam bahagian ini mengekodkan $N$ ciri sebagai putaran pada $N$ get berparameter pada $n$ qubit, di mana $n \leq N$. Perhatikan bahawa memaksimumkan pemuatan data untuk bilangan qubit tertentu bukan satu-satunya pertimbangan. Dalam banyak kes, kedalaman litar mungkin merupakan pertimbangan yang lebih penting daripada bilangan qubit.

Efficient SU2

Contoh yang lazim dan berguna bagi pengekodan dengan pengelitan ialah litar efficient_su2 Qiskit. Secara mengagumkan, litar ini boleh, contohnya, mengekodkan 8 ciri pada hanya 2 qubit. Mari kita lihat ini, kemudian cuba fahami bagaimana ia mungkin.

from qiskit.circuit.library import efficient_su2

circuit = efficient_su2(num_qubits=2, reps=1, insert_barriers=True)
circuit.decompose().draw(output="mpl")

Semasa kita menulis keadaan kita, kita akan menggunakan konvensyen Qiskit di mana qubit paling tidak bererti disusun ke sebelah kanan paling jauh, seperti dalam $|q_2,q_1,q_0\rangle$ atau $|q_2\rangle\otimes|q_1\rangle\otimes|q_0\rangle.$ Keadaan-keadaan ini boleh menjadi sangat rumit dengan pantas, dan contoh yang jarang ini mungkin membantu menjelaskan mengapa keadaan sedemikian jarang ditulis secara eksplisit.

Sistem kita bermula dalam keadaan $|00\rangle.$ Sehingga halangan pertama (titik yang kita labelkan $b1$), keadaan kita ialah:

$$|\psi\rangle_{b1} = \left(\cos\left(\frac{\theta_1}{2}\right)|0\rangle+\sin\left(\frac{\theta_1}{2}\right)e^{i\theta_3}|1\rangle\right)\otimes\left(\cos\left(\frac{\theta_0}{2}\right)|0\rangle+\sin\left(\frac{\theta_0}{2}\right)e^{i\theta_2}|1\rangle\right)$$

Itu hanyalah pengekodan padat, yang telah kita lihat sebelumnya. Kini selepas get CNOT, pada halangan kedua ($b2$), keadaan kita ialah

$$\begin{aligned} |\psi\rangle_{b2} = & \cos\left(\frac{\theta_1}{2}\right)\cos\left(\frac{\theta_0}{2}\right)|00\rangle+\cos\left(\frac{\theta_1}{2}\right)\sin\left(\frac{\theta_0}{2}\right)e^{i\theta_2}|11\rangle\\ + & \sin\left(\frac{\theta_1}{2}\right)\cos\left(\frac{\theta_0}{2}\right)e^{i\theta_3}|10\rangle+\sin\left(\frac{\theta_1}{2}\right)\sin\left(\frac{\theta_0}{2}\right)e^{i\theta_2}e^{i\theta_3}|01\rangle \end{aligned}$$

Kita kini gunakan set putaran qubit tunggal terakhir dan kumpulkan keadaan yang serupa untuk mendapatkan:

$$\begin{align*} |\psi\rangle_{\text{final}} = & \left[\cos\left(\frac{\theta_0}{2}\right)\left(\cos\left(\frac{\theta_1}{2}\right)\cos\left(\frac{\theta_5}{2}\right)-\sin\left(\frac{\theta_1}{2}\right)\sin\left(\frac{\theta_5}{2}\right)e^{i\theta_3}\right)\cos\left(\frac{\theta_4}{2}\right)\right.\\ + & \left.\sin\left(\frac{\theta_0}{2}\right)\left(\cos\left(\frac{\theta_1}{2}\right)\sin\left(\frac{\theta_5}{2}\right)-\sin\left(\frac{\theta_1}{2}\right)\cos\left(\frac{\theta_5}{2}\right)e^{i\theta_3}\right)\sin\left(\frac{\theta_4}{2}\right)e^{i\theta_2}\right] |00\rangle\\ + & \left[\cos\left(\frac{\theta_0}{2}\right)\left(\cos\left(\frac{\theta_1}{2}\right)\cos\left(\frac{\theta_5}{2}\right)-\sin\left(\frac{\theta_1}{2}\right)\sin\left(\frac{\theta_5}{2}\right)e^{i\theta_3}\right)\sin\left(\frac{\theta_4}{2}\right)\right.\\ + & \left.\sin\left(\frac{\theta_0}{2}\right)\left(-\cos\left(\frac{\theta_1}{2}\right)\sin\left(\frac{\theta_5}{2}\right)+\sin\left(\frac{\theta_1}{2}\right)\cos\left(\frac{\theta_5}{2}\right)e^{i\theta_3}\right)\cos\left(\frac{\theta_4}{2}\right)e^{i\theta_2}\right] e^{i\theta_6}|01\rangle\\ + & \left[\cos\left(\frac{\theta_0}{2}\right)\left(\cos\left(\frac{\theta_1}{2}\right)\sin\left(\frac{\theta_5}{2}\right)+\sin\left(\frac{\theta_1}{2}\right)\cos\left(\frac{\theta_5}{2}\right)e^{i\theta_3}\right)\cos\left(\frac{\theta_4}{2}\right)\right.\\ - & \left.\sin\left(\frac{\theta_0}{2}\right)\left(\cos\left(\frac{\theta_1}{2}\right)\cos\left(\frac{\theta_5}{2}\right)+\sin\left(\frac{\theta_1}{2}\right)\sin\left(\frac{\theta_5}{2}\right)e^{i\theta_3}\right)\sin\left(\frac{\theta_4}{2}\right)e^{i\theta_2}\right] e^{i\theta_7}|10\rangle\\ + & \left[\cos\left(\frac{\theta_0}{2}\right)\left(\cos\left(\frac{\theta_1}{2}\right)\sin\left(\frac{\theta_5}{2}\right)+\sin\left(\frac{\theta_1}{2}\right)\cos\left(\frac{\theta_5}{2}\right)e^{i\theta_3}\right)\sin\left(\frac{\theta_4}{2}\right)\right.\\ + & \left.\sin\left(\frac{\theta_0}{2}\right)\left(\cos\left(\frac{\theta_1}{2}\right)\cos\left(\frac{\theta_5}{2}\right)+\sin\left(\frac{\theta_1}{2}\right)\sin\left(\frac{\theta_5}{2}\right)e^{i\theta_3}\right)\cos\left(\frac{\theta_4}{2}\right)e^{i\theta_2}\right] e^{i\theta_6}e^{i\theta_7}|11\rangle \end{align*}$$

Ini mungkin terlalu rumit untuk dihurai. Sebaliknya, undur selangkah dan fikirkan berapa banyak parameter yang kita muatkan ke keadaan tersebut: lapan. Tetapi kita hanya mempunyai empat keadaan basis pengiraan. Sekilas pandang, mungkin nampak seolah-olah kita memuatkan lebih banyak parameter daripada yang masuk akal, kerana keadaan akhir boleh ditulis sebagai $\psi_\text{final} = c_0|00\rangle+c_1|01\rangle+c_2|10\rangle+c_3|11\rangle$. Perhatikan, walau bagaimanapun, bahawa setiap faktor awalan adalah kompleks! Ditulis seperti ini:

$$\psi_\text{final} = (a_0+ib_0)|00\rangle+(a_1+ib_1)|01\rangle+(a_2+ib_2)|10\rangle+(a_3+ib_3)|11\rangle$$

Seseorang dapat melihat bahawa kita memang mempunyai lapan parameter pada keadaan untuk mengekodkan lapan ciri.

Dengan meningkatkan bilangan qubit dan bilangan pengulangan lapisan pengelitan dan putaran, seseorang boleh mengekodkan lebih banyak data. Penulisan fungsi gelombang dengan cepat menjadi tidak mudah. Tetapi kita masih boleh melihat pengekodan dalam tindakan. Di sini kita mengekodkan vektor data $\vec{x}$ dengan 12 ciri, pada litar efficient_su2 3-qubit, menggunakan setiap get berparameter untuk mengekodkan ciri yang berbeza.

$$\vec{x} = (0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2)$$

Dalam vektor data ini, ciri-ciri ditunjukkan dalam susunan tertentu. Secara berasingan, tidak kira jika ia dikodkan dalam susunan ini atau sebaliknya. Yang penting ialah menjejaki dan konsisten. Perhatikan dalam gambar rajah litar bahawa efficient_su2 mengandaikan susunan pengekodan tertentu, khususnya mengisi lapisan pertama get berparameter dari qubit 0 ke qubit 2, kemudian bergerak ke lapisan berikutnya. Ini bukan konsisten mahupun tidak konsisten dengan tatatanda little-endian, kerana di sini ciri data tidak boleh disusun mengikut qubit a priori, sebelum litar pengekodan ditentukan.

x = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2]
circuit = efficient_su2(num_qubits=3, reps=1, insert_barriers=True)
encode = circuit.assign_parameters(x)
encode.decompose().draw(output="mpl")

Daripada meningkatkan bilangan qubit, anda mungkin memilih untuk meningkatkan bilangan pengulangan lapisan pengelitan dan putaran. Tetapi ada had kepada berapa banyak pengulangan yang berguna. Seperti yang dinyatakan sebelumnya, ada pertukaran: litar dengan lebih banyak qubit atau lebih banyak pengulangan lapisan pengelitan dan putaran mungkin menyimpan lebih banyak parameter, tetapi berbuat demikian dengan kedalaman litar yang lebih besar. Kami akan kembali kepada kedalaman beberapa peta ciri terbina dalam, di bawah. Beberapa kaedah pengekodan seterusnya yang terbina dalam Qiskit mempunyai "peta ciri" sebagai sebahagian daripada namanya. Mari kita tegaskan semula bahawa mengekodkan data ke dalam litar kuantum adalah pemetaan ciri, dalam ertikata ia membawa data ke ruang baru: ruang Hilbert qubit yang terlibat. Hubungan antara dimensi ruang ciri asal dengan ruang Hilbert akan bergantung kepada litar yang anda gunakan untuk pengekodan.

Peta ciri $Z$

Peta ciri $Z$ (ZFM) boleh ditafsirkan sebagai sambungan semula jadi bagi pengekodan fasa. ZFM terdiri daripada lapisan silih berganti get qubit tunggal: lapisan get Hadamard dan lapisan get fasa. Biarkan vektor data $\vec{x}$ mempunyai $N$ ciri. Litar kuantum yang melaksanakan pemetaan ciri diwakili sebagai operator unitari yang bertindak ke atas keadaan awal:

$$\mathscr{U}_{\text{ZFM}}(\vec{x})|0\rangle^{\otimes N}=|\phi(\vec{x})\rangle$$

di mana $|0\rangle^{\otimes N}$ ialah keadaan asas $N$-qubit. Tatatanda ini digunakan untuk konsistensi dengan rujukan [4] Havlicek et al. Ciri data $x_i$ dipetakan secara satu-ke-satu dengan qubit yang sepadan. Contohnya, jika anda mempunyai 8 ciri dalam vektor data, maka anda akan menggunakan 8 qubit. Litar ZFM terdiri daripada $r$ pengulangan sublitar yang terdiri daripada lapisan get Hadamard dan lapisan get fasa. Lapisan Hadamard terdiri daripada get Hadamard yang bertindak ke atas setiap qubit dalam daftar $n$-qubit, $H \otimes H \otimes \dots \otimes H = H^{\otimes n}$, dalam peringkat yang sama dalam algoritma. Penerangan ini juga terpakai kepada lapisan get fasa di mana qubit ke-$i$ ditindaklakukan oleh $P(\vec{x}_i)$. Setiap get $P$ mempunyai satu ciri sebagai hujahnya, tetapi lapisan get fasa ($P(\vec{x}_1)\otimes\ldots P(\vec{x}_k)\otimes\ldots P(\vec{x}_N)$ adalah fungsi vektor data. Unitari litar ZFM penuh dengan satu pengulangan ialah:

$$\mathscr{U}_{\text{ZFM}}=\big(P(\vec{x}_1)\otimes\ldots P(\vec{x}_k)\otimes\ldots P(\vec{x}_N)H^{\otimes N}\big)=\left(\bigotimes_{k = 1}^N P(\vec{x}_k)\right)H^{\otimes N}$$

Kemudian $r$ pengulangan unitari ini ialah

$$\mathscr{U}^{(r)}_{\text{ZFM}}\left(\vec{x}\right)=\prod_{s=1}^{r}\left[\left(\bigotimes_{k = 1}^N P(\vec{x}_k)\right)H^{\otimes N}\right]$$

Ciri-ciri data, $x_k$, dipetakan ke get-get fasa dengan cara yang sama dalam semua $r$ pengulangan. Keadaan peta ciri ZFM adalah keadaan produk dan cekap untuk simulasi klasik[4].

Untuk bermula dengan contoh kecil, litar ZFM dua-qubit dikodkan menggunakan Qiskit dan dilukis untuk menunjukkan struktur litar yang mudah. Dalam contoh ini, satu pengulangan, $r=1$, dilaksanakan dengan vektor data $\vec{x} = \left(\textstyle\frac{1}{2}\pi, \textstyle\frac{1}{3}\pi\right)$. Perhatikan bahawa ini ditulis dalam susunan piawai vektor dalam Python, bermakna elemen ke-$0$ ialah $\textstyle\frac{1}{2}\pi.$ Kita bebas untuk mengekodkan ciri ke-$0$ ini ke qubit ke-$0$ kita, atau ke qubit ke-$N$ kita. Sekali lagi, tidak selalu ada pemetaan satu-ke-satu tunggal dari susunan ciri ke susunan qubit, kerana peta ciri yang berbeza mengekodkan bilangan ciri yang berbeza ke setiap qubit. Sekali lagi apa yang penting ialah kita sedar di mana setiap ciri dikodkan. Apabila menyediakan senarai parameter kepada peta ciri $Z$, ia akan mengekodkan ciri 0 dari senarai ke qubit paling tidak bererti dengan get berparameter, seperti qubit 0. Jadi kita akan mengikuti konvensyen tersebut apabila melakukan ini secara manual. Kita akan mengekodkan $\textstyle\frac{1}{2}\pi$ pada qubit ke-$0$, dan $\textstyle\frac{1}{3}\pi$ pada qubit ke-$1$.

Operator unitari litar ZFM bertindak ke atas keadaan awal dengan cara berikut:

$$\mathscr{U}_{\text{ZFM}}(\bar{x})|00\rangle = P(\bar{x})^{\otimes 2} H^{\otimes 2}|00\rangle = \left( P\left(\textstyle\frac{1}{3}\pi\right)H|0\rangle \right) \otimes \left(P\left(\textstyle\frac{1}{2}\pi\right)H|0\rangle\right).$$

Formula ini telah disusun semula di sekitar produk tensor untuk menekankan operasi pada setiap qubit. Kod Qiskit berikut menggunakan get Hadamard dan get fasa secara eksplisit untuk menunjukkan struktur ZFM:

qc0 = QuantumCircuit(1)
qc1 = QuantumCircuit(1)

qc0.h(0)
qc0.p(pi / 2, 0)

qc1.h(0)
qc1.p(pi / 3, 0)

# Combine circuits qc0 and qc1 into 1 circuit
qc = QuantumCircuit(2)
qc.compose(qc0, [0], inplace=True)
qc.compose(qc1, [1], inplace=True)

qc.draw("mpl", scale=1)

Kita kini mengekodkan vektor data yang sama $\vec{x} = \left(\textstyle\frac{1}{2}\pi, \textstyle\frac{1}{3}\pi\right)$ ke litar ZFM dengan tiga pengulangan, $r=3$, menggunakan kelas Qiskit z_feature_map, yang secara keseluruhannya memberi kita peta ciri kuantum $\mathscr{U}_{\text{ZFM}}(\vec{x})$. Secara lalai dalam kelas z_feature_map, parameter $\beta$ didarab dengan 2 sebelum dipetakan ke get fasa $\beta \rightarrow P(\theta = 2\beta)$. Untuk menghasilkan semula pengekodan yang sama seperti di atas, kita bahagi dengan 2.

from qiskit.circuit.library import z_feature_map

zfeature_map = z_feature_map(feature_dimension=2, reps=3)
zfeature_map = zfeature_map.assign_parameters([(1 / 2) * pi / 2, (1 / 2) * pi / 3])
zfeature_map.decompose().draw("mpl")

Ini jelas merupakan pemetaan yang berbeza daripada yang dilakukan secara manual di atas, tetapi perhatikan konsistensi dalam susunan parameter: $\textstyle\frac{1}{2}\pi$ sekali lagi dikodkan pada qubit ke-$0$.

Anda boleh menggunakan ZFM melalui kelas ZFM Qiskit; anda juga boleh menggunakan struktur ini sebagai inspirasi untuk membina pemetaan ciri sendiri.

Peta ciri $ZZ$

Peta ciri $ZZ$ (ZZFM) mengembangkan ZFM dengan penyertaan get pengelitan dua-qubit, khususnya get putaran $ZZ$, $R_{ZZ}(\theta)$. ZZFM disangka umumnya mahal untuk dikira pada komputer klasik, berbeza dengan ZFM.

$R_{ZZ}(\theta)$ melaksanakan interaksi $ZZ$ dan mengelitkan secara maksimum untuk $\theta = \textstyle{\frac{1}{2}}\pi$. $R_{ZZ}(\theta)$ boleh didekomposisikan kepada siri get pada dua qubit, seperti yang ditunjukkan dalam kod Qiskit berikut menggunakan get RZZ dan kaedah kelas QuantumCircuit decompose. Kita mengekodkan satu ciri vektor data $\vec{x}$: $\vec{x}_k=\pi.$

qc = QuantumCircuit(2)
qc.rzz(pi, 0, 1)
qc.draw("mpl", scale=1)

Seperti yang sering berlaku, kita melihat ini diwakili sebagai unit seperti get tunggal, sehingga kita menggunakan .decompose() untuk melihat semua get penyusunnya.

qc.decompose().draw("mpl", scale=1)

Data dipetakan dengan putaran fasa $P(\theta) = e^{i\theta/2}R_Z(\theta)$ pada qubit kedua. Get $R_{ZZ}(\theta)$ mengelitkan dua qubit yang ditindaklakukannya dengan darjah pengelitan yang ditentukan oleh nilai ciri yang dikodkan.

Litar ZZFM penuh terdiri daripada get Hadamard dan get fasa, seperti dalam ZFM, diikuti dengan pengelitan yang diterangkan di atas. Satu pengulangan litar ZZFM ialah:

$$\mathscr{U}_{\text{ZZFM}}(\vec{x}) = U_{ZZ}(\vec{x})\big(P(\vec{x}_1)\otimes\ldots P(\vec{x}_k)\otimes\ldots P(\vec{x}_N)H^{\otimes N}\big)=U_{ZZ}(\vec{x})\left(\bigotimes_{k = 1}^N P(\vec{x}_k)\right)H^{\otimes N},$$

di mana $U_{ZZ}(\vec{x})$ mengandungi lapisan get ZZ yang berstruktur mengikut skim pengelitan. Beberapa skim pengelitan ditunjukkan dalam blok kod di bawah. Struktur $U_{ZZ}(\vec{x})$ juga termasuk fungsi yang menggabungkan ciri data dari qubit yang dikaitkan melalui get ZZ dengan cara berikut. Katakanlah bahawa get $R_{ZZ}$ perlu digunakan pada qubit $p$ dan $q$. Dalam lapisan fasa, qubit-qubit ini mempunyai get fasa yang mengekodkan $\vec{x}_p$ dan $\vec{x}_q$ padanya, masing-masing. Hujah $\theta_{q,p}$ bagi $R_{ZZ,q,p}(\theta_{q,p})$ tidak akan hanya salah satu daripada ciri tersebut atau yang lain, tetapi satu fungsi yang sering dilambangkan dengan $\phi$ (jangan dikelirukan dengan sudut azimut):

$$\theta_{q,p} \rightarrow \phi(\vec{x}_q, \vec{x}_p) = 2(\pi-\vec{x}_q)(\pi-\vec{x}_p).$$

Kita akan melihat ini dalam beberapa contoh di bawah. Sambungan kepada pelbagai pengulangan adalah sama seperti dalam kes z_feature_map:

$$\mathscr{U}^{(r)}_{\text{ZZFM}}\left(\vec{x}\right)=\prod_{s=1}^{r}\left[U_{ZZ}(\vec{x})\left(\bigotimes_{k = 1}^N P(\vec{x}_k)\right)H^{\otimes N}\right].$$

Memandangkan operator telah meningkat dalam kerumitan, marilah kita pertama sekali mengekodkan vektor data $\vec{x} = (x_0, x_1)$ dengan ZZFM dua-qubit dan satu pengulangan menggunakan kod berikut:

from qiskit.circuit.library import zz_feature_map

feature_dim = 2
zzfeature_map = zz_feature_map(
    feature_dimension=feature_dim, entanglement="linear", reps=1
)
zzfeature_map.decompose(reps=1).draw("mpl", scale=1)

Secara lalai dalam Qiskit, ciri $(\vec{x}_1, \vec{x}_2)$ dipetakan bersama ke $R_{ZZ}(\theta)$ oleh fungsi pemetaan ini $\theta_{1,2} = \phi(\vec{x}_1, \vec{x}_2) = 2(\pi-\vec{x}_1)(\pi-\vec{x}_2)$. Qiskit membolehkan pengguna menyesuaikan fungsi $\phi$ (atau $\phi_S$ di mana $S$ ialah set pasangan qubit yang digandingkan melalui get $R_{ZZ}$) sebagai langkah pra-pemprosesan.

Beralih kepada vektor data empat dimensi $\vec{x} = (\vec{x}_1, \vec{x}_2, \vec{x}_3, \vec{x}_4)$ dan memetakan ke ZZFM empat-qubit dengan satu pengulangan, kita boleh mula melihat pemetaan $\phi$ untuk pelbagai pasangan qubit. Kita juga boleh melihat maksud pengelitan "linear":

feature_dim = 4
zzfeature_map = zz_feature_map(
    feature_dimension=feature_dim, entanglement="linear", reps=1
)
zzfeature_map.decompose().draw("mpl", scale=1)

Dalam skim pengelitan linear, pasangan qubit jiran (bernombor) dalam litar ini dikaitkan. Terdapat skim pengelitan terbina dalam lain dalam Qiskit, termasuk circular dan full.

Peta ciri Pauli

Peta ciri Pauli (PFM) adalah pengumuman ZFM dan ZZFM untuk menggunakan get Pauli yang sewenang-wenangnya. Peta ciri Pauli mengambil bentuk yang sangat serupa dengan dua peta ciri sebelumnya. Untuk $r$ pengulangan pengekodan $N$ ciri vektor $\vec{x},$

$$\mathscr{U}_{\text{PFM}}(\vec{x}) = \prod_{s=1}^{r} U(\vec{x}) H^{\otimes n}.$$

Untuk PFM, $U(\vec{x})$ diumumkan kepada operator unitari pengembangan Pauli. Di sini kami membentangkan bentuk peta ciri yang lebih umum yang dipertimbangkan setakat ini:

$$U(\vec{x}) = \exp\left(i \sum_{S \in\mathcal{I}} \phi_S(\vec{x}) \prod_{i \in S} \sigma_i \right),$$

di mana $\sigma_i$ ialah operator Pauli, $\sigma_i \in {I,X,Y,Z}$. Di sini $\mathcal{I}$ ialah set semua ketersambungan qubit seperti yang ditentukan oleh peta ciri, termasuk set qubit yang ditindaklakukan oleh get qubit tunggal. Iaitu, untuk peta ciri di mana qubit 0 ditindaklakukan oleh get fasa, dan qubit 2 dan 3 ditindaklakukan oleh get $R_{ZZ}$, set $\mathcal{I}$ akan merangkumi $\{\{0\},\{2,3\}\}$. $S$ mengalir melalui semua elemen set tersebut. Dalam peta ciri sebelumnya, fungsi $\phi_S(\vec{x})$ terlibat sama ada secara eksklusif dengan get qubit tunggal atau secara eksklusif dengan get dua-qubit. Di sini, kita mentakrifkannya secara umum:

$$\phi_S(\vec{x})= \begin{cases} x_i & \text{jika } S= \{i\} \text{ (qubit tunggal)}\\ \prod_{j\in{S}}(\pi-x_j) & \text{jika } |S|\ge2 \text{ (berbilang qubit)}\\ \end{cases}$$

Untuk dokumentasi, lihat dokumentasi kelas Pauli feature map Qiskit). Dalam ZZFM, operator $\sigma_i$ dihadkan kepada $Z_i$.

Satu cara untuk memahami unitari di atas ialah melalui analogi dengan propagator dalam sistem fizikal. Unitari di atas ialah operator evolusi unitari, $\exp(it\mathcal{H})$, untuk Hamiltonian, $\mathcal{H}$, serupa dengan model Ising, di mana parameter masa, $t$, digantikan dengan nilai data untuk memacu evolusi. Pengembangan operator unitari ini menghasilkan litar PFM. Ketersambungan pengelitan dalam $S$ boleh ditafsirkan sebagai gandingan Ising dalam kekisi spin. Mari kita pertimbangkan contoh operator Pauli $Y$ dan $XX$ yang mewakili interaksi jenis Ising tersebut. Qiskit menyediakan kelas pauli_feature_map untuk instantiasi PFM dengan pilihan get qubit tunggal dan $n$-qubit, yang dalam contoh ini akan dihantar sebagai rentetan Pauli 'Y' dan 'XX'. Biasanya, $n$ ialah 1 atau 2 untuk interaksi qubit tunggal dan dua-qubit, masing-masing. Skim pengelitan ialah "linear," bermakna hanya qubit jiran dalam litar kuantum yang digandingkan. Perhatikan bahawa ini tidak sepadan dengan qubit jiran pada komputer kuantum itu sendiri, kerana litar kuantum ini adalah lapisan abstraksi.

from qiskit.circuit.library import pauli_feature_map

feature_dim = 3
pfmap = pauli_feature_map(
    feature_dimension=feature_dim, entanglement="linear", reps=1, paulis=["Y", "XX"]
)

pfmap.decompose().draw("mpl", scale=1.5)

Qiskit menyediakan parameter $\alpha$ dalam peta ciri Pauli untuk mengawal penskalaan putaran Pauli.

$$U(\bar{x}) = \exp\left(i \alpha \sum_{S\subseteq[n]} \phi_S(\bar{x}) \prod_{i \in S} \sigma_i \right)$$

Nilai lalai $\alpha$ ialah $2$. Dengan mengoptimumkan nilainya dalam selang, misalnya, $[0,4],$ seseorang boleh menyelaraskan kernel kuantum dengan lebih baik kepada data.

Galeri peta ciri Pauli

Di sini kami menggambarkan pelbagai peta ciri Pauli untuk litar dua-qubit untuk mendapatkan gambaran yang lebih jelas tentang julat kemungkinan.

from qiskit.visualization import circuit_drawer
import matplotlib.pyplot as plt

feature_dim = 2
fig, axs = plt.subplots(9, 2)
i_plot = 0
for paulis in [
    ["I"],
    ["X"],
    ["Y"],
    ["Z"],
    ["XX"],
    ["XY"],
    ["XZ"],
    ["YY"],
    ["YZ"],
    ["ZZ"],
    ["X", "ZZ"],
    ["Y", "ZZ"],
    ["Z", "ZZ"],
    ["X", "YZ"],
    ["Y", "YZ"],
    ["Z", "YZ"],
    ["YY", "ZZ"],
    ["XY", "ZZ"],
]:
    pfmap = pauli_feature_map(feature_dimension=feature_dim, paulis=paulis, reps=1)
    circuit_drawer(
        pfmap.decompose(),
        output="mpl",
        style={"backgroundcolor": "#EEEEEE"},
        ax=axs[int((i_plot - i_plot % 2) / 2), i_plot % 2],
    )
    axs[int((i_plot - i_plot % 2) / 2), i_plot % 2].title.set_text(paulis)
    i_plot += 1

fig.set_figheight(16)
fig.set_figwidth(16)

Di atas boleh, sudah tentu, diperluaskan untuk merangkumi permutasi dan pengulangan matriks Pauli yang lain. Pelajar digalakkan untuk bereksperimen dengan pilihan-pilihan tersebut.

Ulasan peta ciri terbina dalam

Anda telah melihat beberapa skim untuk mengekodkan data ke dalam litar kuantum:

• Pengekodan basis
• Pengekodan amplitud
• Pengekodan sudut
• Pengekodan fasa
• Pengekodan padat

Anda telah melihat cara membina peta ciri sendiri menggunakan skim pengekodan ini, dan anda telah melihat empat peta ciri terbina dalam yang memanfaatkan pengekodan sudut dan fasa:

• Efficient SU2
• Peta ciri Z
• Peta ciri ZZ
• Peta ciri Pauli

Peta ciri terbina dalam ini berbeza antara satu sama lain dalam beberapa cara:

• Kedalaman untuk bilangan ciri yang dikodkan tertentu
• Bilangan qubit yang diperlukan untuk bilangan ciri tertentu
• Darjah pengelitan (jelas berkaitan dengan perbezaan lain)

Kod di bawah menggunakan empat peta ciri terbina dalam ini untuk mengekodkan set ciri, dan memplot kedalaman dua-qubit litar yang terhasil. Memandangkan kadar ralat dua-qubit jauh lebih tinggi daripada kadar ralat get qubit tunggal, seseorang mungkin paling berminat dengan kedalaman get dua-qubit. Dalam kod di bawah, kita mendapatkan kiraan semua get dalam litar dengan terlebih dahulu mendekomposisikan litar kemudian menggunakan count_ops(), seperti yang ditunjukkan di bawah. Di sini get dua-qubit yang kita minati ialah get 'cx':

# Initializing parameters and empty lists for depths
x = [0.1, 0.2]
n_data = []
zz2gates = []
su22gates = []
z2gates = []
p2gates = []

# Generating feature maps
for n in range(3, 10):
    x.append(n / 10)
    zzcircuit = zz_feature_map(n, reps=1, insert_barriers=True)
    zcircuit = z_feature_map(n, reps=1, insert_barriers=True)
    su2circuit = efficient_su2(n, reps=1, insert_barriers=True)
    pcircuit = pauli_feature_map(n, reps=1, paulis=["XX"], insert_barriers=True)
    # Getting the cx depths
    zzcx = zzcircuit.decompose().count_ops().get("cx")
    zcx = zcircuit.decompose().count_ops().get("cx")
    su2cx = su2circuit.decompose().count_ops().get("cx")
    pcx = pcircuit.decompose().count_ops().get("cx")

    # Appending the cx gate counts to the lists. We shift the zz and pauli data points, because they overlap.
    n_data.append(n)
    zz2gates.append(zzcx - 0.5)
    z2gates.append(0)
    su22gates.append(su2cx)
    p2gates.append(pcx + 0.5)

# Plot the output
plt.plot(n_data, p2gates, "bo")
plt.plot(n_data, zz2gates, "ro")
plt.plot(n_data, su22gates, "yo")
plt.plot(n_data, z2gates, "go")
plt.ylabel("CX Gates")
plt.xlabel("Data elements")
plt.legend(["Pauli", "ZZ", "SU2", "Z"])
# plt.suptitle('zz_feature_map(n)')
plt.show()

Secara umumnya, peta ciri Pauli dan ZZ akan menghasilkan kedalaman litar yang lebih besar dan bilangan get 2-qubit yang lebih tinggi berbanding efficient_su2 dan peta ciri Z.

Memandangkan peta ciri yang terbina dalam Qiskit boleh digunakan secara meluas, kita selalunya tidak perlu mereka bentuk sendiri, terutamanya dalam fasa pembelajaran. Namun, pakar dalam pembelajaran mesin kuantum mungkin akan kembali kepada subjek mereka bentuk pemetaan ciri sendiri, apabila mereka menangani dua cabaran yang rumit:

1. Perkakasan moden: kehadiran hingar dan overhead besar kod pembetulan ralat bermakna aplikasi hari ini perlu mempertimbangkan perkara seperti kecekapan perkakasan dan meminimumkan kedalaman get dua-qubit.

2. Pemetaan yang sesuai untuk masalah yang dihadapi: Adalah satu perkara untuk mengatakan bahawa zz_feature_map, misalnya, sukar untuk disimulasikan secara klasik, dan oleh itu menarik. Adalah perkara lain pula untuk zz_feature_map sesuai dengan tepat untuk tugas pembelajaran mesin anda atau set data anda. Prestasi litar kuantum berparameter yang berbeza pada jenis data yang berbeza merupakan kawasan penyelidikan yang aktif.

Kita tutup dengan nota tentang kecekapan perkakasan.

Pemetaan ciri cekap perkakasan

Pemetaan ciri cekap perkakasan ialah pemetaan yang mengambil kira kekangan komputer kuantum sebenar, demi mengurangkan hingar dan ralat dalam pengiraan. Apabila menjalankan litar kuantum pada komputer kuantum terdekat, ada banyak strategi untuk mengurangkan hingar yang wujud dalam perkakasan. Satu strategi utama untuk kecekapan perkakasan ialah meminimumkan kedalaman litar kuantum supaya hingar dan dekoherans mempunyai lebih sedikit masa untuk merosakkan pengiraan. Kedalaman litar kuantum ialah bilangan langkah get yang diselaraskan masa yang diperlukan untuk menyelesaikan keseluruhan pengiraan (selepas pengoptimuman litar)[5]. Ingat bahawa kedalaman litar abstrak yang logik mungkin jauh lebih rendah daripada kedalaman setelah litar ditranspilasi untuk komputer kuantum sebenar.

Transpilasi ialah proses menukar litar kuantum dari abstraksi peringkat tinggi kepada yang sedia untuk dijalankan pada komputer kuantum sebenar, dengan mengambil kira kekangan perkakasan. Komputer kuantum mempunyai set get asli qubit tunggal dan dua-qubit. Ini bermakna semua get dalam kod Qiskit perlu ditranspilasi ke set get perkakasan asli. Contohnya, dalam ibm_torino, QPU yang menampilkan pemproses Heron r1 dan siap pada 2023, get asli atau basis ialah \{CZ, ID, RZ, SX, X\}. Ini adalah get kawalan-Z dua-qubit, dan get qubit tunggal yang dipanggil identiti, putaran $Z$, punca kuasa dua NOT, dan NOT, masing-masing, yang menyediakan set universal. Apabila melaksanakan get berbilang qubit sebagai sublitar yang setara, get fizikal dua-qubit $CZ$ diperlukan, bersama get qubit tunggal lain yang tersedia dalam perkakasan. Di samping itu, untuk melaksanakan get dua-qubit pada sepasang qubit yang tidak digandingkan secara fizikal, get SWAP ditambah untuk memindahkan keadaan qubit antara qubit bagi membolehkan gandingan, yang menyebabkan sambungan litar yang tidak dapat dielakkan. Menggunakan hujah optimization yang boleh ditetapkan dari 0 hingga tahap tertinggi 3. Untuk kawalan dan penyesuaian yang lebih besar, saluran paip transpiler boleh diurus dengan Qiskit Pass Manager. Rujuk dokumentasi Qiskit Transpiler untuk maklumat lanjut tentang transpilasi.

Dalam Havlicek et al. 2019 [2], salah satu cara penulis mencapai kecekapan perkakasan ialah dengan menggunakan peta ciri $ZZ$ kerana ia merupakan pengembangan peringkat kedua (lihat bahagian "Peta ciri $ZZ$" di atas). Pengembangan peringkat $N$ mempunyai get $N$-qubit. Komputer kuantum IBM® tidak mempunyai get $N$-qubit asli, di mana $N>2$, jadi untuk melaksanakannya memerlukan penguraian kepada get CNOT dua-qubit yang tersedia dalam perkakasan. Cara kedua penulis meminimumkan kedalaman ialah dengan memilih topologi gandingan $ZZ$ yang dipetakan terus ke gandingan seni bina. Pengoptimuman selanjutnya yang mereka lakukan ialah menyasarkan sublitar perkakasan berprestasi tinggi yang terhubung dengan sesuai. Perkara tambahan yang perlu dipertimbangkan termasuk meminimumkan bilangan pengulangan peta ciri dan memilih skim pengelitan "linear" berkedalaman rendah yang disesuaikan berbanding skim "full" yang mengelitkan semua qubit.

Grafik di atas menunjukkan rangkaian nod dan tepi yang mewakili qubit fizikal dan gandingan perkakasan, masing-masing. Peta gandingan dan prestasi ibm_torino ditunjukkan dengan semua kemungkinan get gandingan CZ dua-qubit. Qubit dikodkan warna pada skala berdasarkan masa relaksasi T1 dalam mikrosaat (μs), di mana masa T1 yang lebih panjang adalah lebih baik dan dalam warna yang lebih cerah. Tepi gandingan dikodkan warna mengikut ralat CZ, di mana warna yang lebih gelap adalah lebih baik. Maklumat tentang spesifikasi perkakasan boleh diakses dalam skema konfigurasi Backend perkakasan IBMQBackend.configuration().

Rujukan

1. Maria Schuld and Francesco Petruccione, Supervised Learning with Quantum Computers, Springer 2018, doi:10.1007/978-3-319-96424-9.
2. Vojtech Havlicek et al., "Supervised Learning with Quantum Enhanced Feature Spaces." Nature, vol. 567 (2019): 209–212. https://arxiv.org/abs/1804.11326.
3. Ryan LaRose and Brian Coyle, "Robust data encodings for quantum classifiers", Physical Review A 102, 032420 (2020), doi:10.1103/PhysRevA.102.032420, arXiv:2003.01695.
4. Lou Grover and Terry Rudolph. "Creating Superpositions That Correspond to Efficiently Integrable Probability Distributions." arXiv:quant-ph/0208112, August 15, 2002, https://arxiv.org/abs/quant-ph/0208112.
5. Adrián Pérez-Salinas, Alba Cervera-Lierta, Elies Gil-Fuster, José I. Latorre, "Data re-uploading for a universal quantum classifier", Quantum 4, 226 (2020), ArXiv.org/abs/1907.02085.
6. Maria Schuld, Ryan Sweke, Johannes Jakob Meyer, "The effect of data encoding on the expressive power of variational quantum machine learning models", Phys. Rev. A 103, 032430 (2021), arxiv.org/abs/2008.08605

import qiskit

qiskit.version.get_version_info()