Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Menggunakan PennyLane dengan Amazon Braket
<a name="hybrid"></a>

Algoritma hibrida adalah algoritma yang berisi instruksi klasik dan kuantum. Instruksi klasik dijalankan pada perangkat keras klasik (instance EC2 atau laptop Anda), dan instruksi kuantum dijalankan baik pada simulator atau di komputer kuantum. Sebaiknya jalankan algoritma hybrid menggunakan fitur Hybrid Jobs. Untuk informasi selengkapnya, lihat [ Kapan menggunakan Amazon Braket Jobs](braket-jobs.md#braket-jobs-use).

Amazon Braket memungkinkan Anda untuk mengatur dan menjalankan algoritma kuantum hibrida dengan bantuan PennyLane plugin ** Amazon Braket**, atau dengan ** Amazon Braket Python SDK ** dan contoh repositori notebook. Notebook contoh Amazon Braket, berdasarkan SDK, memungkinkan Anda untuk mengatur dan menjalankan algoritma hibrida tertentu tanpa PennyLane plugin. Namun, kami merekomendasikan PennyLane karena memberikan pengalaman yang lebih kaya.

 **Tentang algoritma kuantum hibrida ** 

Algoritma kuantum hibrida penting bagi industri saat ini karena perangkat komputasi kuantum kontemporer umumnya menghasilkan kebisingan, dan karenanya, kesalahan. Setiap gerbang kuantum yang ditambahkan ke komputasi meningkatkan kemungkinan penambahan noise; oleh karena itu, algoritma yang berjalan lama dapat kewalahan oleh noise, yang menghasilkan perhitungan yang salah.

Algoritma kuantum murni seperti Shor [ (contoh Estimasi Fase Kuantum) ](https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/advanced_circuits_algorithms/Quantum_Phase_Estimation) atau Grover [ (contoh Grover) ](https://github.com/aws/amazon-braket-examples/tree/main/examples/advanced_circuits_algorithms/Grover) membutuhkan ribuan, atau jutaan, operasi. Karena alasan ini, mereka tidak praktis untuk perangkat kuantum yang ada, yang umumnya disebut perangkat (NISQ) *kuantum berisikskala menengah*.

Dalam algoritme kuantum hibrid, unit pemrosesan kuantum (QPU) bekerja sebagai co-prosesor untuk CPU klasik, khususnya untuk mempercepat penghitungan tertentu dalam algoritme klasik. Eksekusi sirkuit menjadi jauh lebih pendek, dalam jangkauan kemampuan perangkat saat ini.

**Topics**
+ [Amazon Braket dengan PennyLane](#pennylane-option)
+ [Algoritme hibrid di notebook contoh Amazon Braket](#braket-hybrid-workflow)
+ [Algoritma hibrida dengan PennyLane simulator tertanam](#hybrid-alorithms-pennylane)
+ [Gradien gabungan PennyLane dengan simulator Amazon Braket](#adjoint-gradient-pennylane)
+ [Menggunakan Hybrid Jobs dan PennyLane menjalankan algoritma QAOA](braket-jobs-run-qaoa-algorithm.md)
+ [Jalankan beban kerja hibrida dengan simulator PennyLane tertanam](pennylane-embedded-simulators.md)

## Amazon Braket dengan PennyLane
<a name="pennylane-option"></a>

Amazon Braket menyediakan dukungan untuk [ PennyLane](https://pennylane.ai), kerangka perangkat lunak sumber terbuka yang dibangun di sekitar konsep pemrograman diferensiabel ku * antum. * Anda dapat menggunakan kerangka kerja ini untuk melatih sirkuit kuantum dengan cara yang sama seperti Anda akan melatih jaringan saraf untuk menemukan solusi untuk masalah komputasi dalam kimia kuantum, pembelajaran mesin kuantum, dan pengoptimalan.

Per PennyLane pustakaan menyediakan antarmuka ke alat pembelajaran mesin yang sudah dikenal, termasuk PyTorch dan TensorFlow, untuk membuat pelatihan sirkuit kuantum cepat dan intuitif.
+  **Per PennyLane pustakaan ** -- PennyLane sudah diinstal sebelumnya di notebook Amazon Braket. Untuk akses ke Amazon perangkat Braket dari PennyLane, buka buku catatan dan impor per PennyLane pustakaan dengan perintah berikut.

```
import pennylane as qml
```

Notebook tutorial membantu Anda memulai dengan cepat. Atau, Anda dapat menggunakan PennyLane Amazon Braket dari IDE pilihan Anda.
+  ** PennyLane Plugin Amazon Braket ** - Untuk menggunakan IDE Anda sendiri, Anda dapat menginstal PennyLane plugin Amazon Braket secara manual. Plugin terhubung PennyLane dengan [ Amazon Braket Python SDK](https://github.com/aws/amazon-braket-sdk-python), sehingga Anda dapat menjalankan sirkuit PennyLane di perangkat Amazon Braket. Untuk menginstal PennyLane plugin, gunakan perintah berikut.

```
pip install amazon-braket-pennylane-plugin
```

Contoh berikut menunjukkan cara mengatur akses ke perangkat Amazon Braket di: PennyLane

```
# to use SV1
import pennylane as qml
sv1 = qml.device("braket.aws.qubit", device_arn="arn:aws:braket:::device/quantum-simulator/amazon/sv1", wires=2)

# to run a circuit:
@qml.qnode(sv1)
def circuit(x):
    qml.RZ(x, wires=0)
    qml.CNOT(wires=[0,1])
    qml.RY(x, wires=1)
    return qml.expval(qml.PauliZ(1))

result = circuit(0.543)


#To use the local sim:
local = qml.device("braket.local.qubit", wires=2)
```

Untuk contoh tutorial dan informasi selengkapnya PennyLane, lihat repositori [ contoh ](https://github.com/aws/amazon-braket-examples/tree/main/examples/pennylane) Amazon Braket.

 PennyLane Plugin Amazon Braket memungkinkan Anda untuk beralih antara Amazon Braket QPU dan perangkat simulator tertanam PennyLane dengan satu baris kode. Ini menawarkan dua perangkat kuantum Amazon Braket untuk bekerja dengan: PennyLane
+  `braket.aws.qubit`untuk berjalan dengan perangkat kuantum layanan Amazon Braket, termasuk QPU dan simulator
+  `braket.local.qubit`untuk berjalan dengan simulator Amazon lokal Braket SDK

 PennyLane Plugin Amazon Braket adalah open source. Anda dapat menginstalnya dari GitHub repositori [ PennyLane Plugin](https://github.com/amazon-braket/amazon-braket-pennylane-plugin-python).

Untuk informasi lebih lanjut tentang PennyLane, lihat dokumentasi di [ PennyLane situs web](https://pennylane.ai).

## Algoritme hibrid di notebook contoh Amazon Braket
<a name="braket-hybrid-workflow"></a>

Amazon Braket memang menyediakan berbagai contoh notebook yang tidak bergantung pada PennyLane plugin untuk menjalankan algoritma hibrida. Anda dapat memulai dengan salah satu dari [notebook contoh hibrid Amazon Braket](https://github.com/aws/amazon-braket-examples/tree/main/examples/hybrid_quantum_algorithms) yang menggambarkan *metode variasional*, seperti Algoritme Pengoptimuman Perkiraan Kuantum (QAOA) atau Variational Quantum Eigensolver (VQE).

Notebook contoh Amazon Braket tergantung pada [SDK Python Amazon Braket](https://github.com/aws/amazon-braket-sdk-python). SDK menyediakan kerangka kerja untuk berinteraksi dengan perangkat keras komputasi kuantum melalui Amazon Braket. Ini adalah perpustakaan sumber terbuka yang dirancang untuk membantu Anda dengan bagian kuantum dari alur kerja hibrida Anda.

Anda dapat menjelajahi Amazon Braket lebih lanjut dengan [ contoh notebook ](https://github.com/aws/amazon-braket-examples) kami.

## Algoritma hibrida dengan PennyLane simulator tertanam
<a name="hybrid-alorithms-pennylane"></a>

Amazon Braket Hybrid Jobs sekarang hadir dengan CPU berkinerja tinggi dan simulator GPU-based tertanam dari. [ PennyLane ](https://github.com/PennyLaneAI/pennylane-lightning) Keluarga simulator tertanam ini dapat disematkan langsung di dalam wadah pekerjaan hybrid Anda dan termasuk `lightning.qubit` simulator vektor keadaan cepat, simulator yang dipercepat menggunakan perpustakaan [ CUQuantum NVIDIA](https://developer.nvidia.com/cuquantum-sdk), dan lainnya. `lightning.gpu` Simulator tertanam ini sangat cocok untuk algoritma variasional seperti pembelajaran mesin kuantum yang dapat mengambil manfaat dari metode canggih seperti metode diferensiasi [ tambahan. ](https://docs.pennylane.ai/en/stable/introduction/interfaces.html#simulation-based-differentiation) Anda dapat menjalankan simulator tertanam ini pada satu atau beberapa instance CPU atau GPU.

Dengan Hybrid Jobs, Anda sekarang dapat menjalankan kode algoritma variasional Anda menggunakan kombinasi co-processor klasik dan QPU, simulator sesuai permintaan Amazon Braket sepertiSV1, atau langsung menggunakan simulator tertanam dari. PennyLane

Simulator tertanam sudah tersedia dengan wadah Hybrid Jobs, Anda perlu menghias fungsi Python utama Anda dengan `@hybrid_job` dekorator. Untuk menggunakan PennyLane `lightning.gpu` simulator, Anda juga perlu menentukan instance GPU seperti yang ditunjukkan dalam cuplikan kode berikut: `InstanceConfig`

```
import pennylane as qml
from braket.jobs import hybrid_job
from braket.jobs.config import InstanceConfig


@hybrid_job(device="local:pennylane/lightning.gpu", instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge"))
def function(wires):
    dev = qml.device("lightning.gpu", wires=wires)
    ...
```

Lihat [ contoh buku catatan ](https://github.com/aws/amazon-braket-examples/blob/main/examples/hybrid_jobs/4_Embedded_simulators_in_Braket_Hybrid_Jobs/Embedded_simulators_in_Braket_Hybrid_Jobs.ipynb) untuk memulai menggunakan simulator PennyLane tertanam dengan Hybrid Jobs.

## Gradien gabungan PennyLane dengan simulator Amazon Braket
<a name="adjoint-gradient-pennylane"></a>

Dengan PennyLane plugin untuk Amazon Braket, Anda dapat menghitung gradien menggunakan metode diferensiasi tambahan saat menjalankan simulator vektor status lokal atau SV1.

 **Catatan: ** Untuk menggunakan metode diferensiasi tambahan, Anda harus menentukan `diff_method='device'` dalam`qnode`, dan ** tidak **`diff_method='adjoint'`. Lihat contoh berikut ini.

```
device_arn = "arn:aws:braket:::device/quantum-simulator/amazon/sv1"
dev = qml.device("braket.aws.qubit", wires=wires, shots=0, device_arn=device_arn)
                
@qml.qnode(dev, diff_method="device")
def cost_function(params):
    circuit(params)
    return qml.expval(cost_h)

gradient = qml.grad(circuit)
initial_gradient = gradient(params0)
```

**catatan**  
Saat ini, PennyLane akan menghitung indeks pengelompokan untuk QAOA Hamiltonian dan menggunakannya untuk membagi Hamiltonian menjadi beberapa nilai ekspektasi. Jika Anda ingin menggunakan kemampuan diferensiasi tambahan SV1 saat menjalankan QAOA dariPennyLane, Anda perlu merekonstruksi biaya Hamiltonian dengan menghapus indeks pengelompokan, seperti: `cost_h, mixer_h = qml.qaoa.max_clique(g, constrained=False) cost_h = qml.Hamiltonian(cost_h.coeffs, cost_h.ops)`