Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# 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.
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.
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)]
)
```
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]
)
```
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 mana yang qubits digunakan untuk algoritme 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)