Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Membangun sirkuit pertama Anda
Setelah instans notebook Anda diluncurkan, buka instans dengan antarmuka Jupyter standar dengan memilih notebook yang baru saja Anda buat.
![\[Antarmuka notebook yang menunjukkan instance notebook yang ada bernama amazon-braket-test dengan status InService dan URL-nya.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/console-page.png)
Instans notebook Amazon Braket diinstal sebelumnya dengan SDK Amazon Braket dan semua dependensinya. Mulailah dengan membuat notebook baru dengan Kernel `conda_braket`.
![\[Antarmuka peluncur untuk Notebook, Konsol, dan alat lainnya seperti Terminal, File Teks, File Markdown, File Python, dengan lingkungan Python conda_braket yang disorot.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/jupyter-open.png)
Anda bisa mulai dengan yang sederhana seperti “Halo, dunia\$1” contoh. Pertama, bangun sirkuit yang mempersiapkan keadaan Bell, dan kemudian jalankan sirkuit pada perangkat yang berbeda untuk mendapatkan hasil.
Mulailah dengan mengimpor Begin dengan mengimpor modul SDK Amazon Braket dan mendefinisikan modul SDK BRAKETlong sederhana dan mendefinisikan sirkuit Bell State dasar.
```
import boto3
from braket.aws import AwsDevice
from braket.devices import LocalSimulator
from braket.circuits import Circuit
# Create the circuit
bell = Circuit().h(0).cnot(0, 1)
```
Anda dapat memvisualisasikan sirkuit dengan perintah ini:
```
print(bell)
```
```
T : │ 0 │ 1 │
┌───┐
q0 : ─┤ H ├───●───
└───┘ │
┌─┴─┐
q1 : ───────┤ X ├─
└───┘
T : │ 0 │ 1 │
```
**Jalankan sirkuit Anda di simulator lokal**
Selanjutnya, pilih perangkat kuantum untuk menjalankan sirkuit. SDK Amazon Braket dilengkapi dengan simulator lokal untuk prototyping dan pengujian cepat. Kami merekomendasikan menggunakan simulator lokal untuk sirkuit yang lebih kecil, yang bisa mencapai 25 qubits (tergantung pada perangkat keras lokal Anda).
Untuk membuat instance simulator lokal:
```
# Instantiate the local simulator
local_sim = LocalSimulator()
```
dan menjalankan sirkuit:
```
# Run the circuit
result = local_sim.run(bell, shots=1000).result()
counts = result.measurement_counts
print(counts)
```
Anda seharusnya melihat hasil seperti ini:
```
Counter({'11': 503, '00': 497})
```
Keadaan Lonceng spesifik yang telah Anda siapkan adalah superposisi yang sama dari \$100⟩ dan \$111⟩, dan distribusi 00 dan 11 yang hampir sama (hingga shot kebisingan) sebagai hasil pengukuran, seperti yang diharapkan.
**Jalankan sirkuit Anda pada simulator sesuai permintaan**
Amazon Braket juga menyediakan akses ke simulator berkinerja tinggi sesuai permintaanSV1, untuk menjalankan sirkuit yang lebih besar. SV1adalah simulator vektor negara sesuai permintaan yang memungkinkan simulasi sirkuit kuantum hingga 34. qubits Anda dapat menemukan informasi selengkapnya SV1 di bagian [Perangkat yang Didukung](braket-devices.md) dan di AWS konsol. Saat menjalankan tugas kuantum pada SV1 (dan di TN1 atau QPU apa pun), hasil tugas kuantum Anda disimpan dalam bucket S3 di akun Anda. Jika Anda tidak menentukan bucket, Braket SDK akan membuat bucket default `amazon-braket-{region}-{accountID}` untuk Anda. Untuk mempelajari lebih lanjut, lihat [Mengelola akses ke Amazon Braket](braket-manage-access.md).
**catatan**
Isi nama bucket sebenarnya yang ada di mana contoh berikut menunjukkan `amazon-braket-s3-demo-bucket` sebagai nama bucket Anda. Nama bucket untuk Amazon Braket selalu dimulai dengan `amazon-braket-` diikuti dengan karakter pengidentifikasi lain yang Anda tambahkan. Jika Anda memerlukan informasi tentang cara menyiapkan bucket S3, lihat [Memulai Amazon](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html) S3.
```
# Get the account ID
aws_account_id = boto3.client("sts").get_caller_identity()["Account"]
# The name of the bucket
my_bucket = "amazon-braket-s3-demo-bucket"
# The name of the folder in the bucket
my_prefix = "simulation-output"
s3_folder = (my_bucket, my_prefix)
```
Untuk menjalankan sirkuitSV1, Anda harus memberikan lokasi bucket S3 yang sebelumnya Anda pilih sebagai argumen posisi dalam panggilan. `.run()`
```
# Choose the cloud-based on-demand simulator to run your circuit
device = AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")
# Run the circuit
task = device.run(bell, s3_folder, shots=100)
# Display the results
print(task.result().measurement_counts)
```
Konsol Amazon Braket memberikan informasi lebih lanjut tentang tugas kuantum Anda. Arahkan ke tab **Quantum Tasks** di konsol dan tugas kuantum Anda harus berada di bagian atas daftar. Atau, Anda dapat mencari tugas kuantum Anda menggunakan ID tugas kuantum unik atau kriteria lainnya.
**catatan**
Setelah 90 hari, Amazon Braket secara otomatis menghapus semua tugas kuantum IDs dan metadata lain yang terkait dengan tugas kuantum Anda. Untuk informasi lebih lanjut, lihat [Retensi data](https://docs.aws.amazon.com/braket/latest/developerguide/security.html#braket-data-retention).
**Berjalan di QPU**
Dengan Amazon Braket, Anda dapat menjalankan contoh sirkuit kuantum sebelumnya pada komputer kuantum fisik hanya dengan mengubah satu baris kode. Amazon Braket menyediakan akses ke berbagai perangkat Quantum Processing Unit (QPU). Anda dapat menemukan informasi tentang berbagai perangkat dan jendela ketersediaan di bagian [Perangkat yang Didukung](braket-devices.md), dan di AWS konsol di bawah tab **Perangkat**. Contoh berikut menunjukkan cara membuat instance IQM perangkat.
```
# Choose the IQM hardware to run your circuit
device = AwsDevice("arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet")
```
Atau pilih IonQ perangkat dengan kode ini:
```
# Choose the Ionq device to run your circuit
device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/ionq/Aria-1")
```
Setelah memilih perangkat dan sebelum menjalankan beban kerja, Anda dapat menanyakan kedalaman antrian perangkat dengan kode berikut untuk menentukan jumlah tugas kuantum atau pekerjaan hibrida. Selain itu, pelanggan dapat melihat kedalaman antrian khusus perangkat di halaman Perangkat. Amazon Braket Management Console
```
# Print your queue depth
print(device.queue_depth().quantum_tasks)
# Returns the number of quantum tasks queued on the device
# {: '0', : '0'}
print(device.queue_depth().jobs)
# Returns the number of hybrid jobs queued on the device
# '2'
```
Saat Anda menjalankan tugas, SDK Amazon Braket melakukan polling untuk hasil (dengan batas waktu default 5 hari). Anda dapat mengubah default ini dengan memodifikasi `poll_timeout_seconds` parameter dalam `.run()` perintah seperti yang ditunjukkan pada contoh berikut. Perlu diingat bahwa jika batas waktu polling Anda terlalu pendek, hasil mungkin tidak dikembalikan dalam waktu polling, seperti ketika QPU tidak tersedia dan kesalahan batas waktu lokal dikembalikan. Anda dapat merestart pemungutan suara dengan memanggil fungsi `task.result()`.
```
# Define quantum task with 1 day polling timeout
task = device.run(bell, s3_folder, poll_timeout_seconds=24*60*60)
print(task.result().measurement_counts)
```
Selain itu, setelah mengirimkan tugas kuantum atau pekerjaan hibrida Anda, Anda dapat memanggil `queue_position()` fungsi untuk memeriksa posisi antrian Anda.
```
print(task.queue_position().queue_position)
# Return the number of quantum tasks queued ahead of you
# '2'
```
# Membangun algoritma kuantum pertama Anda
Pustaka algoritma Amazon Braket adalah katalog algoritma kuantum pra-bangun yang ditulis dengan Python. Jalankan algoritma ini apa adanya, atau gunakan sebagai titik awal untuk membangun algoritma yang lebih kompleks. Anda dapat mengakses pustaka algoritma dari konsol Braket. Untuk informasi selengkapnya, lihat pustaka [algoritma Braket Github](https://github.com/aws-samples/amazon-braket-algorithm-library).
![\[Halaman pustaka Algoritma Amazon Braket yang menampilkan daftar algoritma kuantum pra-bangun seperti Berstein Vazirani, Deutsch-Jozsa, algoritma Grover, dan Algoritma Pengoptimalan Perkiraan Kuantum dengan deskripsi singkat.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/AlgorithmLibrary.png)
Konsol Braket memberikan deskripsi dari setiap algoritma yang tersedia di perpustakaan algoritma. Pilih GitHub tautan untuk melihat detail setiap algoritme, atau pilih **Buka buku catatan** untuk membuka atau membuat buku catatan yang berisi semua algoritme yang tersedia. Jika Anda memilih opsi notebook, Anda kemudian dapat menemukan pustaka algoritma Braket di folder root notebook Anda.
# Membangun sirkuit di SDK
Bagian ini memberikan contoh mendefinisikan sirkuit, melihat gerbang yang tersedia, memperluas sirkuit, dan melihat gerbang yang didukung setiap perangkat. Ini juga berisi instruksi tentang cara mengalokasikan secara manualqubits, menginstruksikan kompiler untuk menjalankan sirkuit Anda persis seperti yang ditentukan, dan membangun sirkuit bising dengan simulator kebisingan.
Anda juga dapat bekerja pada tingkat pulsa di Braket untuk berbagai gerbang dengan tertentu QPUs. Untuk informasi selengkapnya, lihat [Kontrol Pulsa di Amazon Braket](braket-pulse-control.md).
**Topics**
+ [Gerbang dan sirkuit](#braket-gates)
+ [Set program](#braket-program-set)
+ [Pengukuran sebagian](#braket-partial-measurement)
+ [Alokasi manual qubit](#manual-qubit-allocation)
+ [Kompilasi kata demi kata](#verbatim-compilation)
+ [Simulasi kebisingan](#noise-simulation)
## Gerbang dan sirkuit
Gerbang dan sirkuit kuantum didefinisikan di [https://github.com/aws/amazon-braket-sdk-python/blob/main/src/braket/circuits/circuit.py](https://github.com/aws/amazon-braket-sdk-python/blob/main/src/braket/circuits/circuit.py)kelas Amazon Braket Python SDK. Dari SDK, Anda dapat memberi contoh objek sirkuit baru dengan memanggil `Circuit()`.
**Contoh: Tentukan sirkuit**
Contoh dimulai dengan mendefinisikan rangkaian sampel empat qubits (berlabel`q0`,,`q1`, dan`q3`) yang terdiri dari gerbang `q2` Hadamard qubit tunggal standar dan gerbang CNOT dua-qubit. Anda dapat memvisualisasikan rangkaian ini dengan memanggil `print` fungsi seperti yang ditunjukkan contoh berikut.
```
# Import the circuit module
from braket.circuits import Circuit
# Define circuit with 4 qubits
my_circuit = Circuit().h(range(4)).cnot(control=0, target=2).cnot(control=1, target=3)
print(my_circuit)
```
```
T : │ 0 │ 1 │
┌───┐
q0 : ─┤ H ├───●─────────
└───┘ │
┌───┐ │
q1 : ─┤ H ├───┼─────●───
└───┘ │ │
┌───┐ ┌─┴─┐ │
q2 : ─┤ H ├─┤ X ├───┼───
└───┘ └───┘ │
┌───┐ ┌─┴─┐
q3 : ─┤ H ├───────┤ X ├─
└───┘ └───┘
T : │ 0 │ 1 │
```
**Contoh: Tentukan sirkuit berparameter**
Dalam contoh ini, kami mendefinisikan sirkuit dengan gerbang yang bergantung pada parameter bebas. Kita dapat menentukan nilai parameter ini untuk membuat sirkuit baru, atau, saat mengirimkan sirkuit, untuk dijalankan sebagai tugas kuantum pada perangkat tertentu.
```
from braket.circuits import Circuit, FreeParameter
# Define a FreeParameter to represent the angle of a gate
alpha = FreeParameter("alpha")
# Define a circuit with three qubits
my_circuit = Circuit().h(range(3)).cnot(control=0, target=2).rx(0, alpha).rx(1, alpha)
print(my_circuit)
```
Anda dapat membuat sirkuit baru yang tidak berparameter dari rangkaian parametris dengan memasok satu `float` (yang merupakan nilai yang akan diambil semua parameter bebas) atau argumen kata kunci yang menentukan nilai setiap parameter ke rangkaian sebagai berikut.
```
my_fixed_circuit = my_circuit(1.2)
my_fixed_circuit = my_circuit(alpha=1.2)
print(my_fixed_circuit)
```
Perhatikan bahwa tidak `my_circuit` dimodifikasi, sehingga Anda dapat menggunakannya untuk membuat instance banyak sirkuit baru dengan nilai parameter tetap.
**Contoh: Memodifikasi gerbang di sirkuit**
Contoh berikut mendefinisikan sirkuit dengan gerbang yang menggunakan kontrol dan pengubah daya. Anda dapat menggunakan modifikasi ini untuk membuat gerbang baru, seperti `Ry` gerbang yang dikendalikan.
```
from braket.circuits import Circuit
# Create a bell circuit with a controlled x gate
my_circuit = Circuit().h(0).x(control=0, target=1)
# Add a multi-controlled Ry gate of angle .13
my_circuit.ry(angle=.13, target=2, control=(0, 1))
# Add a 1/5 root of X gate
my_circuit.x(0, power=1/5)
print(my_circuit)
```
Pengubah gerbang hanya didukung pada simulator lokal.
**Contoh: Lihat semua gerbang yang tersedia**
Contoh berikut menunjukkan bagaimana melihat semua gerbang yang tersedia di Amazon Braket.
```
from braket.circuits import Gate
# Print all available gates in Amazon Braket
gate_set = [attr for attr in dir(Gate) if attr[0].isupper()]
print(gate_set)
```
Output dari kode ini mencantumkan semua gerbang.
```
['CCNot', 'CNot', 'CPhaseShift', 'CPhaseShift00', 'CPhaseShift01', 'CPhaseShift10', 'CSwap', 'CV', 'CY', 'CZ', 'ECR', 'GPhase', 'GPi', 'GPi2', 'H', 'I', 'ISwap', 'MS', 'PRx', 'PSwap', 'PhaseShift', 'PulseGate', 'Rx', 'Ry', 'Rz', 'S', 'Si', 'Swap', 'T', 'Ti', 'U', 'Unitary', 'V', 'Vi', 'X', 'XX', 'XY', 'Y', 'YY', 'Z', 'ZZ']
```
Setiap gerbang ini dapat ditambahkan ke sirkuit dengan memanggil metode untuk jenis sirkuit. Misalnya, panggil`circ.h(0)`, untuk menambahkan gerbang Hadamard ke yang pertama. qubit
**catatan**
Gerbang ditambahkan di tempat, dan contoh yang mengikutinya menambahkan semua gerbang yang tercantum dalam contoh sebelumnya ke sirkuit yang sama.
```
circ = Circuit()
# toffoli gate with q0, q1 the control qubits and q2 the target.
circ.ccnot(0, 1, 2)
# cnot gate
circ.cnot(0, 1)
# controlled-phase gate that phases the |11> state, cphaseshift(phi) = diag((1,1,1,exp(1j*phi))), where phi=0.15 in the examples below
circ.cphaseshift(0, 1, 0.15)
# controlled-phase gate that phases the |00> state, cphaseshift00(phi) = diag([exp(1j*phi),1,1,1])
circ.cphaseshift00(0, 1, 0.15)
# controlled-phase gate that phases the |01> state, cphaseshift01(phi) = diag([1,exp(1j*phi),1,1])
circ.cphaseshift01(0, 1, 0.15)
# controlled-phase gate that phases the |10> state, cphaseshift10(phi) = diag([1,1,exp(1j*phi),1])
circ.cphaseshift10(0, 1, 0.15)
# controlled swap gate
circ.cswap(0, 1, 2)
# swap gate
circ.swap(0,1)
# phaseshift(phi)= diag([1,exp(1j*phi)])
circ.phaseshift(0,0.15)
# controlled Y gate
circ.cy(0, 1)
# controlled phase gate
circ.cz(0, 1)
# Echoed cross-resonance gate applied to q0, q1
circ = Circuit().ecr(0,1)
# X rotation with angle 0.15
circ.rx(0, 0.15)
# Y rotation with angle 0.15
circ.ry(0, 0.15)
# Z rotation with angle 0.15
circ.rz(0, 0.15)
# Hadamard gates applied to q0, q1, q2
circ.h(range(3))
# identity gates applied to q0, q1, q2
circ.i([0, 1, 2])
# iswap gate, iswap = [[1,0,0,0],[0,0,1j,0],[0,1j,0,0],[0,0,0,1]]
circ.iswap(0, 1)
# pswap gate, PSWAP(phi) = [[1,0,0,0],[0,0,exp(1j*phi),0],[0,exp(1j*phi),0,0],[0,0,0,1]]
circ.pswap(0, 1, 0.15)
# X gate applied to q1, q2
circ.x([1, 2])
# Y gate applied to q1, q2
circ.y([1, 2])
# Z gate applied to q1, q2
circ.z([1, 2])
# S gate applied to q0, q1, q2
circ.s([0, 1, 2])
# conjugate transpose of S gate applied to q0, q1
circ.si([0, 1])
# T gate applied to q0, q1
circ.t([0, 1])
# conjugate transpose of T gate applied to q0, q1
circ.ti([0, 1])
# square root of not gate applied to q0, q1, q2
circ.v([0, 1, 2])
# conjugate transpose of square root of not gate applied to q0, q1, q2
circ.vi([0, 1, 2])
# exp(-iXX theta/2)
circ.xx(0, 1, 0.15)
# exp(i(XX+YY) theta/4), where theta=0.15 in the examples below
circ.xy(0, 1, 0.15)
# exp(-iYY theta/2)
circ.yy(0, 1, 0.15)
# exp(-iZZ theta/2)
circ.zz(0, 1, 0.15)
# IonQ native gate GPi with angle 0.15 applied to q0
circ.gpi(0, 0.15)
# IonQ native gate GPi2 with angle 0.15 applied to q0
circ.gpi2(0, 0.15)
# IonQ native gate MS with angles 0.15, 0.15, 0.15 applied to q0, q1
circ.ms(0, 1, 0.15, 0.15, 0.15)
```
Terlepas dari gerbang set yang telah ditentukan sebelumnya, Anda juga dapat menerapkan gerbang kesatuan yang didefinisikan sendiri ke sirkuit. Ini bisa berupa gerbang qubit tunggal (seperti yang ditunjukkan pada kode sumber berikut) atau gerbang multi-qubit yang diterapkan pada yang qubits ditentukan oleh parameter. `targets`
```
import numpy as np
# Apply a general unitary
my_unitary = np.array([[0, 1],[1, 0]])
circ.unitary(matrix=my_unitary, targets=[0])
```
**Contoh: Perluas sirkuit yang ada**
Anda dapat memperpanjang sirkuit yang ada dengan menambahkan instruksi. An `Instruction` adalah direktif kuantum yang menggambarkan tugas kuantum yang harus dilakukan pada perangkat kuantum. `Instruction`operator menyertakan objek tipe `Gate` saja.
```
# Import the Gate and Instruction modules
from braket.circuits import Gate, Instruction
# Add instructions directly.
circ = Circuit([Instruction(Gate.H(), 4), Instruction(Gate.CNot(), [4, 5])])
# Or with add_instruction/add functions
instr = Instruction(Gate.CNot(), [0, 1])
circ.add_instruction(instr)
circ.add(instr)
# Specify where the circuit is appended
circ.add_instruction(instr, target=[3, 4])
circ.add_instruction(instr, target_mapping={0: 3, 1: 4})
# Print the instructions
print(circ.instructions)
# If there are multiple instructions, you can print them in a for loop
for instr in circ.instructions:
print(instr)
# Instructions can be copied
new_instr = instr.copy()
# Appoint the instruction to target
new_instr = instr.copy(target=[5, 6])
new_instr = instr.copy(target_mapping={0: 5, 1: 6})
```
**Contoh: Lihat gerbang yang didukung setiap perangkat**
Simulator mendukung semua gerbang di SDK Braket, namun perangkat QPU mendukung subset yang lebih kecil. Anda dapat menemukan gerbang perangkat yang didukung di properti perangkat. Berikut ini menunjukkan contoh dengan perangkat ionQ:
```
# Import the device module
from braket.aws import AwsDevice
device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/ionq/Aria-1")
# Get device name
device_name = device.name
# Show supportedQuantumOperations (supported gates for a device)
device_operations = device.properties.dict()['action']['braket.ir.openqasm.program']['supportedOperations']
print('Quantum Gates supported by {}:\n {}'.format(device_name, device_operations))
```
```
Quantum Gates supported by Aria 1:
['x', 'y', 'z', 'h', 's', 'si', 't', 'ti', 'v', 'vi', 'rx', 'ry', 'rz', 'cnot', 'swap', 'xx', 'yy', 'zz']
```
Gerbang yang didukung mungkin perlu dikompilasi ke gerbang asli sebelum mereka dapat berjalan pada perangkat keras kuantum. Saat Anda mengirimkan sirkuit, Amazon Braket melakukan kompilasi ini secara otomatis.
**Contoh: Secara terprogram mengambil kesetiaan gerbang asli yang didukung oleh perangkat**
Anda dapat melihat informasi kesetiaan di halaman **Perangkat konsol** Braket. Terkadang sangat membantu untuk mengakses informasi yang sama secara terprogram. Kode berikut menunjukkan cara mengekstrak kesetiaan dua qubit gerbang antara dua gerbang QPU.
```
# Import the device module
from braket.aws import AwsDevice
device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")
# Specify the qubits
a=10
b=11
edge_properties_entry = device.properties.standardized.twoQubitProperties['10-11'].twoQubitGateFidelity
gate_name = edge_properties_entry[0].gateName
fidelity = edge_properties_entry[0].fidelity
print(f"Fidelity of the {gate_name} gate between qubits {a} and {b}: {fidelity}")
```
## Set program
Set program secara efisien menjalankan beberapa sirkuit kuantum dalam satu tugas kuantum. Dalam satu tugas itu, Anda dapat mengirimkan hingga 100 sirkuit kuantum atau rangkaian parametrik tunggal dengan hingga 100 set parameter yang berbeda. Operasi ini meminimalkan waktu antara eksekusi sirkuit berikutnya dan mengurangi overhead pemrosesan tugas kuantum. Saat ini, set program didukung di Amazon Braket Local Simulator dan seterusnyaAQT, IQM dan Rigetti perangkat.
**Mendefinisikan a ProgramSet**
Contoh kode pertama berikut menunjukkan bagaimana membangun `ProgramSet` menggunakan sirkuit parameter dan sirkuit tanpa parameter.
```
from braket.aws import AwsDevice
from braket.circuits import Circuit, FreeParameter
from braket.program_sets.circuit_binding import CircuitBinding
from braket.program_sets import ProgramSet
# Initialize the quantum device
device = AwsDevice("arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet")
# Define circuits
circ1 = Circuit().h(0).cnot(0, 1)
circ2 = Circuit().rx(0, 0.785).ry(1, 0.393).cnot(1, 0)
circ3 = Circuit().t(0).t(1).cz(0, 1).s(0).cz(1, 2).s(1).s(2)
parameterize_circuit = Circuit().rx(0, FreeParameter("alpha")).cnot(0, 1).ry(1, FreeParameter("beta"))
# Create circuit bindings with different parameters
circuit_binding = CircuitBinding(
circuit=parameterize_circuit,
input_sets={
'alpha': (0.10, 0.11, 0.22, 0.34, 0.45),
'beta': (1.01, 1.01, 1.03, 1.04, 1.04),
})
# Creating the program set
program_set_1 = ProgramSet([
circ1,
circ2,
circ3,
circuit_binding,
])
```
Set program ini berisi empat program unik:`circ1`,`circ2`,`circ3`, dan`circuit_binding`. `circuit_binding`Program ini berjalan dengan lima binding parameter yang berbeda, menciptakan lima executable. Tiga program bebas parameter lainnya membuat satu executable masing-masing. Ini menghasilkan delapan total executable, seperti yang ditunjukkan pada gambar berikut.
![\[ProgramSet struktur dengan empat sirkuit, di mana c4 menggunakan CircuitBinding untuk memproses lima set input.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/program_set1.png)
Contoh kode kedua berikut menunjukkan bagaimana menggunakan `product()` metode untuk melampirkan set observable yang sama untuk setiap executable dari set program.
```
from braket.circuits.observables import I, X, Y, Z
observables = [Z(0) @ Z(1), X(0) @ X(1), Z(0) @ X(1), X(0) @ Z(1)]
program_set_2 = ProgramSet.product(
circuits=[circ1, circ2, circuit_binding],
observables=observables
)
```
Untuk program bebas parameter, setiap observable diukur untuk setiap rangkaian. Untuk program parametrik, setiap observable diukur untuk setiap set input, seperti yang ditunjukkan pada gambar berikut.
![\[ProgramSet.product menunjukkan eksekusi paralel dari tiga sirkuit, dengan c3 menggunakan CircuitBinding untuk memproses lima set input dengan masing-masing lima yang dapat diamati.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/program_set2.png)
Contoh kode ketiga berikut menunjukkan bagaimana menggunakan `zip()` metode untuk memasangkan individu yang dapat diamati dengan set parameter tertentu di. `ProgramSet`
```
program_set_3 = ProgramSet.zip(
circuits=circuit_binding,
observables=observables + [Y(0) @ Y(1)]
)
```
![\[ProgramSet.zip dengan CircuitBinding mendemonstrasikan lima eksekusi paralel menggunakan sirkuit bersama dengan individu yang dapat diamati per set input.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/program_set3.png)
Alih-alih`CircuitBinding()`, Anda dapat langsung zip daftar yang dapat diamati dengan daftar sirkuit dan set input.
```
program_set_4 = ProgramSet.zip(
circuits=[circ1, circ2, circ3],
input_sets=[{}, {}, {}],
observables=observables[:3]
)
```
![\[ProgramSet.zip menunjukkan eksekusi paralel dari tujuh sirkuit dengan set input individu yang sesuai dan yang dapat diamati individu.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/program_set4.png)
Untuk informasi selengkapnya dan contoh tentang set program, lihat [folder Set Program](https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/braket_features/program_sets) di amazon-braket-examples Github.
**Memeriksa dan menjalankan program yang ditetapkan pada perangkat**
Hitungan eksekusi set program sama dengan jumlah sirkuit terikat parameter uniknya. Hitung jumlah total sirkuit yang dapat dieksekusi dan tembakan menggunakan contoh kode berikut.
```
# Number of shots per executable
shots = 10
num_executables = program_set_1.total_executables
# Calculate total number of shots across all executables
total_num_shots = shots*num_executables
```
**catatan**
Dengan set program, Anda membayar satu biaya per tugas dan biaya per tembakan berdasarkan jumlah total tembakan di semua sirkuit dalam satu set program.
Untuk menjalankan set program, gunakan contoh kode berikut.
```
# Run the program set
task = device.run(
program_set_1, shots=total_num_shots,
)
```
Saat menggunakan Rigetti perangkat, set program Anda mungkin tetap dalam `RUNNING` status sementara tugas sebagian selesai dan sebagian antri. Untuk hasil yang lebih cepat, pertimbangkan untuk mengirimkan program Anda yang ditetapkan sebagai [Job](braket-jobs-first.md) Hybrid.
**Menganalisis hasil**
Jalankan kode berikut untuk menganalisis dan mengukur hasil executable dalam file. `ProgramSet`
```
# Get the results from a program set
result = task.result()
# Get the first executbable
first_program = result[0]
first_executable = first_program[0]
# Inspect the results of the first executable
measurements_from_first_executable = first_executable.measurements
print(measurements_from_first_executable)
```
## Pengukuran sebagian
Alih-alih mengukur semua qubit dalam rangkaian kuantum, gunakan pengukuran paral untuk mengukur qubit individu atau subset qubit.
**catatan**
Fitur tambahan seperti pengukuran sirkuit tengah dan operasi feed-forward tersedia sebagai Kemampuan Eksperimental, lihat [Akses ke sirkuit dinamis pada](braket-experimental-capabilities.md#braket-access-dynamic-circuits) perangkat IQM.
**Contoh: Ukur subset qubit**
Contoh kode berikut menunjukkan pengukuran sebagian dengan mengukur hanya qubit 0 dalam rangkaian keadaan Bell.
```
from braket.devices import LocalSimulator
from braket.circuits import Circuit
# Use the local state vector simulator
device = LocalSimulator()
# Define an example bell circuit and measure qubit 0
circuit = Circuit().h(0).cnot(0, 1).measure(0)
# Run the circuit
task = device.run(circuit, shots=10)
# Get the results
result = task.result()
# Print the circuit and measured qubits
print(circuit)
print()
print("Measured qubits: ", result.measured_qubits)
```
## Alokasi manual qubit
Ketika Anda menjalankan sirkuit kuantum pada komputer kuantum dariRigetti, Anda dapat secara opsional menggunakan qubit alokasi manual untuk mengontrol yang qubits digunakan untuk algoritma Anda. [Konsol Amazon Braket](https://console.aws.amazon.com/braket/home) dan SDK [Amazon Braket membantu Anda memeriksa data kalibrasi](https://github.com/aws/amazon-braket-sdk-python) terbaru dari perangkat unit pemrosesan kuantum (QPU) yang Anda pilih, sehingga Anda dapat memilih yang terbaik untuk eksperimen Anda. qubits
qubitAlokasi manual memungkinkan Anda untuk menjalankan sirkuit dengan akurasi yang lebih besar dan untuk menyelidiki qubit properti individu. Peneliti dan pengguna tingkat lanjut mengoptimalkan desain sirkuit mereka berdasarkan data kalibrasi perangkat terbaru dan dapat memperoleh hasil yang lebih akurat.
Contoh berikut menunjukkan bagaimana qubits mengalokasikan secara eksplisit.
```
# Import the device module
from braket.aws import AwsDevice
device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")
circ = Circuit().h(0).cnot(0, 7) # Indices of actual qubits in the QPU
# Set up S3 bucket (where results are stored)
my_bucket = "amazon-braket-s3-demo-bucket" # The name of the bucket
my_prefix = "your-folder-name" # The name of the folder in the bucket
s3_location = (my_bucket, my_prefix)
my_task = device.run(circ, s3_location, shots=100, disable_qubit_rewiring=True)
```
Untuk informasi selengkapnya, lihat [contoh Amazon Braket di GitHub](https://github.com/aws/amazon-braket-examples), atau lebih khusus lagi, buku catatan ini: [Mengalokasikan Qubit di Perangkat QPU](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Allocating_Qubits_on_QPU_Devices.ipynb).
## Kompilasi kata demi kata
Saat Anda menjalankan sirkuit kuantum pada komputer kuantum berbasis gerbang, Anda dapat mengarahkan kompiler untuk menjalankan sirkuit Anda persis seperti yang ditentukan tanpa modifikasi apa pun. Dengan menggunakan kompilasi kata demi kata, Anda dapat menentukan bahwa seluruh rangkaian dipertahankan tepat seperti yang ditentukan atau hanya bagian tertentu saja yang dipertahankan (hanya didukung olehRigetti). Saat mengembangkan algoritme untuk pembandingan perangkat keras atau protokol mitigasi kesalahan, Anda perlu memiliki opsi untuk menentukan dengan tepat gerbang dan tata letak sirkuit yang berjalan pada perangkat keras. Kompilasi verbatim memberi Anda kontrol langsung atas proses kompilasi dengan mematikan langkah-langkah pengoptimalan tertentu, sehingga memastikan bahwa sirkuit Anda berjalan persis seperti yang dirancang.
Kompilasi verbatim didukung padaAQT,, IonQIQM, dan Rigetti perangkat dan membutuhkan penggunaan gerbang asli. Saat menggunakan kompilasi kata demi kata, disarankan untuk memeriksa topologi perangkat untuk memastikan bahwa gerbang dipanggil terhubung qubits dan bahwa sirkuit menggunakan gerbang asli yang didukung pada perangkat keras. Contoh berikut menunjukkan cara mengakses daftar gerbang asli yang didukung oleh perangkat secara terprogram.
```
device.properties.paradigm.nativeGateSet
```
UntukRigetti, qubit rewiring harus dimatikan dengan pengaturan `disableQubitRewiring=True` untuk digunakan dengan kompilasi kata demi kata. Jika `disableQubitRewiring=False` disetel saat menggunakan kotak kata demi kata dalam kompilasi, rangkaian kuantum gagal validasi dan tidak berjalan.
Jika kompilasi kata demi kata diaktifkan untuk sirkuit dan dijalankan pada QPU yang tidak mendukungnya, kesalahan dihasilkan yang menunjukkan bahwa operasi yang tidak didukung telah menyebabkan tugas gagal. Karena semakin banyak perangkat keras kuantum yang secara native mendukung fungsi kompiler, fitur ini akan diperluas untuk menyertakan perangkat ini. Perangkat yang mendukung kompilasi kata demi kata menyertakannya sebagai operasi yang didukung saat ditanyakan dengan kode berikut.
```
from braket.aws import AwsDevice
from braket.device_schema.device_action_properties import DeviceActionType
device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")
device.properties.action[DeviceActionType.OPENQASM].supportedPragmas
```
Tidak ada biaya tambahan yang terkait dengan penggunaan kompilasi kata demi kata. [Anda terus dikenakan biaya untuk tugas kuantum yang dijalankan pada perangkat Braket QPU, instans notebook, dan simulator sesuai permintaan berdasarkan tarif saat ini sebagaimana ditentukan pada halaman Harga Amazon Braket.](https://aws.amazon.com/braket/pricing/) Untuk informasi selengkapnya, lihat buku catatan [contoh kompilasi Verbatim](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Verbatim_Compilation.ipynb).
**catatan**
Jika Anda menggunakan OpenQASM untuk menulis sirkuit Anda untuk IonQ perangkat AQT dan, dan Anda ingin memetakan sirkuit Anda langsung ke qubit fisik, Anda perlu menggunakan `#pragma braket verbatim` sebagai `disableQubitRewiring` bendera diabaikan oleh OpenQASM.
## Simulasi kebisingan
Untuk membuat instance simulator kebisingan lokal, Anda dapat mengubah backend sebagai berikut.
```
# Import the device module
from braket.aws import AwsDevice
device = LocalSimulator(backend="braket_dm")
```
Anda dapat membangun sirkuit berisik dengan dua cara:
1. Bangun sirkuit berisik dari bawah ke atas.
1. Ambil sirkuit bebas kebisingan yang ada dan suntikkan kebisingan ke seluruh bagian.
Contoh berikut menunjukkan pendekatan menggunakan sirkuit dasar dengan kebisingan depolarisasi dan saluran Kraus khusus.
```
import scipy.stats
import numpy as np
# Bottom up approach
# Apply depolarizing noise to qubit 0 with probability of 0.1
circ = Circuit().x(0).x(1).depolarizing(0, probability=0.1)
# Create an arbitrary 2-qubit Kraus channel
E0 = scipy.stats.unitary_group.rvs(4) * np.sqrt(0.8)
E1 = scipy.stats.unitary_group.rvs(4) * np.sqrt(0.2)
K = [E0, E1]
# Apply a two-qubit Kraus channel to qubits 0 and 2
circ = circ.kraus([0, 2], K)
```
```
from braket.circuits import Noise
# Inject noise approach
# Define phase damping noise
noise = Noise.PhaseDamping(gamma=0.1)
# The noise channel is applied to all the X gates in the circuit
circ = Circuit().x(0).y(1).cnot(0, 2).x(1).z(2)
circ_noise = circ.copy()
circ_noise.apply_gate_noise(noise, target_gates=Gate.X)
```
Menjalankan sirkuit adalah pengalaman pengguna yang sama seperti sebelumnya, seperti yang ditunjukkan dalam dua contoh berikut.
**Contoh 1**
```
task = device.run(circ, shots=100)
```
Atau
**Contoh 2**
```
task = device.run(circ_noise, shots=100)
```
Untuk contoh lainnya, lihat [contoh simulator bising pengantar Braket](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Simulating_Noise_On_Amazon_Braket.ipynb)
# Memeriksa sirkuit
Sirkuit kuantum di Amazon Braket memiliki konsep pseudo-time yang disebut `Moments`. Masing-masing qubit dapat mengalami satu gerbang per`Moment`. Tujuannya `Moments` adalah untuk membuat sirkuit dan gerbangnya lebih mudah diatasi dan menyediakan struktur temporal.
**catatan**
Momen umumnya tidak sesuai dengan waktu nyata di mana gerbang dieksekusi di QPU.
Kedalaman sirkuit diberikan oleh jumlah total Momen di sirkuit tersebut. Anda dapat melihat kedalaman sirkuit memanggil metode `circuit.depth` seperti yang ditunjukkan pada contoh berikut.
```
from braket.circuits import Circuit
# Define a circuit with parametrized gates
circ = Circuit().rx(0, 0.15).ry(1, 0.2).cnot(0, 2).zz(1, 3, 0.15).x(0)
print(circ)
print('Total circuit depth:', circ.depth)
```
```
T : │ 0 │ 1 │ 2 │
┌──────────┐ ┌───┐
q0 : ─┤ Rx(0.15) ├───●────────────────┤ X ├─
└──────────┘ │ └───┘
┌──────────┐ │ ┌──────────┐
q1 : ─┤ Ry(0.20) ├───┼───┤ ZZ(0.15) ├───────
└──────────┘ │ └────┬─────┘
┌─┴─┐ │
q2 : ──────────────┤ X ├──────┼─────────────
└───┘ │
┌────┴─────┐
q3 : ────────────────────┤ ZZ(0.15) ├───────
└──────────┘
T : │ 0 │ 1 │ 2 │
Total circuit depth: 3
```
Kedalaman rangkaian total rangkaian di atas adalah 3 (ditunjukkan sebagai momen`0`,`1`, dan`2`). Anda dapat memeriksa operasi gerbang untuk setiap momen.
`Moments`berfungsi sebagai kamus pasangan *kunci-nilai*.
+ Kuncinya adalah`MomentsKey()`, yang berisi pseudo-time dan qubit informasi.
+ Nilai yang ditetapkan pada jenis `Instructions()`.
```
moments = circ.moments
for key, value in moments.items():
print(key)
print(value, "\n")
```
```
MomentsKey(time=0, qubits=QubitSet([Qubit(0)]), moment_type=, noise_index=0, subindex=0)
Instruction('operator': Rx('angle': 0.15, 'qubit_count': 1), 'target': QubitSet([Qubit(0)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)
MomentsKey(time=0, qubits=QubitSet([Qubit(1)]), moment_type=, noise_index=0, subindex=0)
Instruction('operator': Ry('angle': 0.2, 'qubit_count': 1), 'target': QubitSet([Qubit(1)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)
MomentsKey(time=1, qubits=QubitSet([Qubit(0), Qubit(2)]), moment_type=, noise_index=0, subindex=0)
Instruction('operator': CNot('qubit_count': 2), 'target': QubitSet([Qubit(0), Qubit(2)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)
MomentsKey(time=1, qubits=QubitSet([Qubit(1), Qubit(3)]), moment_type=, noise_index=0, subindex=0)
Instruction('operator': ZZ('angle': 0.15, 'qubit_count': 2), 'target': QubitSet([Qubit(1), Qubit(3)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)
MomentsKey(time=2, qubits=QubitSet([Qubit(0)]), moment_type=, noise_index=0, subindex=0)
Instruction('operator': X('qubit_count': 1), 'target': QubitSet([Qubit(0)]), 'control': QubitSet([]), 'control_state': (), 'power': 1)
```
Anda juga dapat menambahkan gerbang ke sirkuit melalui `Moments`.
```
from braket.circuits import Instruction, Gate
new_circ = Circuit()
instructions = [Instruction(Gate.S(), 0),
Instruction(Gate.CZ(), [1, 0]),
Instruction(Gate.H(), 1)
]
new_circ.moments.add(instructions)
print(new_circ)
```
```
T : │ 0 │ 1 │ 2 │
┌───┐ ┌───┐
q0 : ─┤ S ├─┤ Z ├───────
└───┘ └─┬─┘
│ ┌───┐
q1 : ─────────●───┤ H ├─
└───┘
T : │ 0 │ 1 │ 2 │
```
# Daftar jenis hasil
Amazon Braket dapat mengembalikan berbagai jenis hasil ketika sirkuit diukur menggunakan `ResultType`. Sirkuit dapat mengembalikan jenis hasil berikut.
+ `AdjointGradient`mengembalikan gradien (turunan vektor) dari nilai ekspektasi dari observable yang disediakan. Observable ini bekerja pada target yang diberikan sehubungan dengan parameter yang ditentukan menggunakan metode diferensiasi adjoint. Anda hanya dapat menggunakan metode ini ketika shots=0.
+ `Amplitude`mengembalikan amplitudo keadaan kuantum tertentu dalam fungsi gelombang keluaran. Ini hanya tersedia di simulator lokal SV1 dan lokal.
+ `Expectation`mengembalikan nilai ekspektasi dari observable yang diberikan, yang dapat ditentukan dengan `Observable` kelas diperkenalkan nanti dalam chapter ini. Target yang qubits digunakan untuk mengukur yang dapat diamati harus ditentukan, dan jumlah target yang ditentukan harus sama dengan jumlah qubits tindakan yang dapat diamati. Jika tidak ada target yang ditentukan, observable harus beroperasi hanya pada 1 qubit dan diterapkan ke semua secara qubits paralel.
+ `Probability`mengembalikan probabilitas pengukuran keadaan basis komputasi. Jika target tidak ditentukan, `Probability` mengembalikan probabilitas mengukur semua keadaan dasar. Jika target ditentukan, hanya probabilitas marjinal dari vektor dasar pada yang ditentukan yang dikembalikan. qubits Simulator terkelola dan QPUs dibatasi hingga maksimum 15 qubit, dan simulator lokal terbatas pada ukuran memori sistem.
+ `Reduced density matrix`mengembalikan matriks kepadatan untuk subsistem target tertentu qubits dari sistem. qubits Untuk membatasi ukuran jenis hasil ini, Braket membatasi jumlah target qubits hingga maksimal 8.
+ `StateVector`mengembalikan vektor status penuh. Ini tersedia di simulator lokal.
+ `Sample`mengembalikan jumlah pengukuran dari qubit set target tertentu dan dapat diamati. Jika tidak ada target yang ditentukan, observable harus beroperasi hanya pada 1 qubit dan diterapkan ke semua secara qubits paralel. Jika target ditentukan, jumlah target yang ditentukan harus sama dengan jumlah qubits tindakan yang dapat diamati.
+ `Variance`mengembalikan varians (`mean([x-mean(x)]2)`) dari qubit set target yang ditentukan dan dapat diamati sebagai jenis hasil yang diminta. Jika tidak ada target yang ditentukan, observable harus beroperasi hanya pada 1 qubit dan diterapkan ke semua secara qubits paralel. Jika tidak, jumlah target yang ditentukan harus sama dengan jumlah qubits yang dapat diamati dapat diterapkan.
**Jenis hasil yang didukung untuk penyedia yang berbeda:**
| | | | | | | | | |
| --- |--- |--- |--- |--- |--- |--- |--- |--- |
| | Sim lokal | SV1 | DM1 | TN1 | AQT | IonQ | IQM | Rigetti |
| Gradien bersebelahan | T | Y | T | T | T | T | T | T |
| Amplitudo | Y | Y | T | T | T | T | T | T |
| Perkiraan | Y | Y | Y | Y | Y | Y | Y | Y |
| probabilitas | Y | Y | Y | T | Y | Y | Y | Y |
| Mengurangi matriks kepadatan | Y | T | Y | T | T | T | T | T |
| Vektor keadaan | Y | T | T | T | T | T | T | T |
| Sampel | Y | Y | Y | Y | Y | Y | Y | Y |
| Varians | Y | Y | Y | Y | Y | Y | Y | Y |
Anda dapat memeriksa jenis hasil yang didukung dengan memeriksa properti perangkat, seperti yang ditunjukkan pada contoh berikut.
```
from braket.aws import AwsDevice
device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")
# Print the result types supported by this device
for iter in device.properties.action['braket.ir.openqasm.program'].supportedResultTypes:
print(iter)
```
```
name='Sample' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=50000
name='Expectation' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=50000
name='Variance' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=50000
name='Probability' observables=None minShots=10 maxShots=50000
```
Untuk memanggil a`ResultType`, tambahkan ke sirkuit, seperti yang ditunjukkan pada contoh berikut.
```
from braket.circuits import Circuit, Observable
circ = Circuit().h(0).cnot(0, 1).amplitude(state=["01", "10"])
circ.probability(target=[0, 1])
circ.probability(target=0)
circ.expectation(observable=Observable.Z(), target=0)
circ.sample(observable=Observable.X(), target=0)
circ.state_vector()
circ.variance(observable=Observable.Z(), target=0)
# Print one of the result types assigned to the circuit
print(circ.result_types[0])
```
**catatan**
Perangkat kuantum yang berbeda memberikan hasil dalam berbagai format. Misalnya, Rigetti perangkat mengembalikan pengukuran, sementara IonQ perangkat memberikan probabilitas. Amazon Braket SDK menawarkan properti pengukuran untuk semua hasil. Namun, untuk perangkat yang mengembalikan probabilitas, pengukuran ini dihitung pasca-perhitungan dan berdasarkan probabilitas, karena pengukuran per tembakan tidak tersedia. Untuk menentukan apakah suatu hasil telah dihitung setelah dihitung, periksa `measurements_copied_from_device` pada objek hasil. Operasi ini dirinci dalam file [gate\$1model\$1quantum\$1task\$1result.py di repositori](https://github.com/aws/amazon-braket-sdk-python/blob/ca5b08dada4839ca31c012ff50aa20b656fd1879/src/braket/tasks/gate_model_quantum_task_result.py#L70-L72) SDK GitHub Amazon Braket.
## Hasil pengamatan
`Observable`Kelas Amazon Braket memungkinkan Anda mengukur pengamatan tertentu.
Anda hanya dapat menerapkan satu non-identitas unik yang dapat diamati untuk masing-masing. qubit Terjadi kesalahan Jika Anda menentukan dua atau lebih yang dapat diamati non-identitas yang berbeda untuk hal yang sama. qubit Untuk tujuan ini, setiap faktor produk tensor dihitung sebagai individu yang dapat diamati. Ini berarti Anda dapat memiliki beberapa produk tensor yang samaqubit, selama faktor-faktor yang bekerja pada itu qubit tetap sama.
Observable dapat diskalakan dan menambahkan observable lainnya (diskalakan atau tidak). Ini menciptakan `Sum` yang dapat digunakan dalam tipe `AdjointGradient` hasil.
`Observable`Kelas ini mencakup observable berikut.
```
import numpy as np
Observable.I()
Observable.H()
Observable.X()
Observable.Y()
Observable.Z()
# Get the eigenvalues of the observable
print("Eigenvalue:", Observable.H().eigenvalues)
# Or rotate the basis to be computational basis
print("Basis rotation gates:", Observable.H().basis_rotation_gates)
# Get the tensor product of the observable for the multi-qubit case
tensor_product = Observable.Y() @ Observable.Z()
# View the matrix form of an observable by using
print("The matrix form of the observable:\n", Observable.Z().to_matrix())
print("The matrix form of the tensor product:\n", tensor_product.to_matrix())
# Factorize an observable in the tensor form
print("Factorize an observable:", tensor_product.factors)
# Self-define observables, given it is a Hermitian
print("Self-defined Hermitian:", Observable.Hermitian(matrix=np.array([[0, 1], [1, 0]])))
print("Sum of other (scaled) observables:", 2.0 * Observable.X() @ Observable.X() + 4.0 * Observable.Z() @ Observable.Z())
```
```
Eigenvalue: [ 1. -1.]
Basis rotation gates: (Ry('angle': -0.7853981633974483, 'qubit_count': 1),)
The matrix form of the observable:
[[ 1.+0.j 0.+0.j]
[ 0.+0.j -1.+0.j]]
The matrix form of the tensor product:
[[ 0.+0.j 0.+0.j 0.-1.j 0.+0.j]
[ 0.+0.j -0.+0.j 0.+0.j 0.+1.j]
[ 0.+1.j 0.+0.j 0.+0.j 0.+0.j]
[ 0.+0.j 0.-1.j 0.+0.j -0.+0.j]]
Factorize an observable: (Y('qubit_count': 1), Z('qubit_count': 1))
Self-defined Hermitian: Hermitian('qubit_count': 1, 'matrix': [[0.+0.j 1.+0.j], [1.+0.j 0.+0.j]])
Sum of other (scaled) observables: Sum(TensorProduct(X('qubit_count': 1), X('qubit_count': 1)), TensorProduct(Z('qubit_count': 1), Z('qubit_count': 1)))
```
## Parameter
Sirkuit dapat menggabungkan parameter gratis. Parameter gratis ini hanya perlu dibangun sekali untuk dijalankan beberapa kali, dan dapat digunakan untuk menghitung gradien.
Setiap parameter gratis menggunakan nama yang disandikan string yang digunakan untuk:
+ Tetapkan nilai parameter
+ Identifikasi parameter mana yang akan digunakan
```
from braket.circuits import Circuit, FreeParameter, observables
from braket.parametric import FreeParameter
theta = FreeParameter("theta")
phi = FreeParameter("phi")
circ = Circuit().h(0).rx(0, phi).ry(0, phi).cnot(0, 1).xx(0, 1, theta)
```
## Gradien bersebelahan
SV1Perangkat menghitung gradien berdampingan dari nilai ekspektasi yang dapat diamati, termasuk Hamiltonian multi-term. Untuk membedakan parameter, tentukan namanya (dalam format string) atau dengan referensi langsung.
```
from braket.aws import AwsDevice
from braket.devices import Devices
device = AwsDevice(Devices.Amazon.SV1)
circ.adjoint_gradient(observable=3 * Observable.Z(0) @ Observable.Z(1) - 0.5 * observables.X(0), parameters = ["phi", theta])
```
Melewati nilai parameter tetap sebagai argumen ke sirkuit berparameter akan menghapus parameter bebas. Menjalankan sirkuit ini dengan `AdjointGradient` menghasilkan kesalahan, karena parameter bebas tidak ada lagi. Contoh kode berikut menunjukkan penggunaan yang benar dan salah:
```
# Will error, as no free parameters will be present
#device.run(circ(0.2), shots=0)
# Will succeed
device.run(circ, shots=0, inputs={'phi': 0.2, 'theta': 0.2})
```