---
# System prepended metadata

title: modul-3-Introduction to Qiskit

---

# Modul 3: Introduction to Qiskit

## Objektif

1. Peserta memahami fungsi gerbang kuantum dasar (H, X, Z, CNOT).
2. Peserta memahami alur kerja umum pemrograman kuantum: membangun sirkuit, menjalankan simulasi, dan menganalisis hasil.
3. Peserta mampu menulis kode untuk membangun quantum circuit sederhana dengan Python menggunakan library Qiskit.
4. Peserta mampu menjalankan sirkuit pada simulator kuantum dan menginterpretasikan hasilnya dalam bentuk histogram.

## Dasar Teori
### Qiskit
Qiskit adalah sebuah *open-source Software Development Kit (SDK)* untuk bekerja dengan quantum computer pada tingkatan circuit level, pulse level, dan algorithm. Qiskit dikembangkan oleh IBM dan komunitas kontributor yang luas.

Tujuan utama Qiskit adalah membuat quantum computing dapat diakses oleh semua orang, dari pemula hingga peneliti ahli. Kita menggunakan bahasa pemrograman Python untuk membuat dan menjalankan quantum program di simulator berperforma tinggi maupun quantum hardware nyata melalui IBM Quantum Platform.

### Komponen Inti Qiskit
Qiskit terstruktur menjadi beberapa komponen utama untuk mendukung berbagai aspek pengembangan:
1. Qiskit SDK (Inti): Ini adalah jantung dari Qiskit. Komponen ini menyediakan tools untuk membangun, mentranspilasi (transpile), dan menjalankan quantum circuit. Kita mendefinisikan quantum circuit, gerbang (gate), dan pengukuran (measurement) menggunakan pustaka ini.
2. Qiskit Aer: Ini adalah kerangka kerja simulasi berkinerja tinggi. Hal ini memungkinkan kita untuk menguji quantum circuit di mesin lokal kita seolah-olah kita menjalankannya di quantum computer nyata (termasuk simulasi noise).
3. Qiskit Runtime: Ini adalah layanan yang memungkinkan kita menjalankan quantum program di perangkat keras kuantum berbasis cloud milik IBM. Ini dirancang untuk mengeksekusi pekerjaan hybrid quantum-classic secara efisien, meminimalkan latensi.
4. Qiskit Machine Learning: Modul khusus aplikasi yang menyediakan tools untuk membangun dan bereksperimen dengan algoritma quantum machine learning, seperti Quantum Support Vector Machines (QSVM) dan Variational Quantum Classifiers (VQC).

Alur kerja dasar di Qiskit adalah: Build -> Compile -> Run -> Analyze.

### Implementasi Dasar: Membuat Bell State
Bell State adalah contoh paling sederhana dari quantum entanglement, di mana state dua qubit saling terhubung.

Implementasi ini akan membuat state $\frac{|00\rangle + |11\rangle}{\sqrt{2}}$. State ini diartikan sebagai adanya probabilitas 50% untuk mengukur 00 dan probabilitas 50% untuk mengukur 11, tetapi tidak akan pernah terukur 01 atau 10.

Berikut akan dijelaskan langkah-langkah untuk membuat Bell State menggunakan Qiskit. Anda boleh mencobanya jika mau, tetapi hal yang sama akan kita lakukan pada pertemuan minggu ini dengan menggunakan hands-on secara lebih lengkap. Instalasi library pada langkah-langkah berikut akan dilakukan pada global environment Python Anda, sehingga Anda memerlukan storage yang cukup. Alternatifnya adalah menggunakan virtual environment atau Anaconda environment. Silahkan cari tau lebih lanjut dengan memanfaatkan platform chatbot yang Anda sukai.

#### Prasyarat Instalasi
Pastikan Python sudah terinstal di sistem Anda. Kemudian, instal Qiskit dan Qiskit Aer dengan perintah berikut:

```
pip install qiskit
pip install qiskit-aer
```

#### Contoh: Bell State Circuit
Berikut adalah kode Python lengkap dengan komentar untuk membangun, mensimulasikan, dan menganalisis Bell State.
```python
# --- 1. Import necessary libraries ---

from qiskit import QuantumCircuit, transpile
from qiskit_aer import Aer
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt

# --- 2. Build the Quantum Circuit ---

# Create a circuit with 2 quantum bits (qubits) and 2 classical bits (for measurement)
# We write qc = QuantumCircuit(qubits, classical_bits)
qc = QuantumCircuit(2, 2)

# All qubits start in the |0> state.
# To create the Bell state, we first apply a Hadamard (H) gate to qubit 0.
# This puts qubit 0 into a superposition state (|0> + |1>)/sqrt(2).
qc.h(0)

# Next, we apply a Controlled-NOT (CX or CNOT) gate.
# The control qubit is 0, and the target qubit is 1.
# - If qubit 0 is |0>, it does nothing to qubit 1.
# - If qubit 0 is |1>, it flips qubit 1 (from |0> to |1>).
qc.cx(0, 1)

# Now the state of the two qubits is entangled.
# - If qubit 0 was |0>, the state is |00>.
# - If qubit 0 was |1>, the state is |11>.
# The total state is (|00> + |11>)/sqrt(2).

# --- 3. Measure the Qubits ---

# We measure both qubits and store the results in the classical bits.
# Measure qubit 0 -> classical bit 0
# Measure qubit 1 -> classical bit 1
qc.measure([0, 1], [0, 1])

# You can now see what your circuit looks like!
print("Quantum Circuit Diagram:")
print(qc.draw())

# --- 4. Run (Simulate) the Circuit ---

# We'll use Qiskit's 'qasm_simulator' from Aer
simulator = Aer.get_backend('qasm_simulator')

# Transpile the circuit for the simulator (an optimization step)
transpiled_circuit = transpile(qc, simulator)

# Run the circuit on the simulator 1000 times (called "shots")
job = simulator.run(transpiled_circuit, shots=1000)

# Get the results from the job
result = job.result()

# --- 5. Analyze the Results ---

# Get the counts (how many times each outcome occurred)
counts = result.get_counts(qc)
print("\nSimulation Result Counts:", counts)

# Plot the results in a histogram
plot_histogram(counts)
plt.show()
```

#### Expected Output
Saat Anda menjalankan kode ini, sebuah diagram sirkuit akan ditampilkan:
```
Quantum Circuit Diagram:
     ┌───┐     ┌─┐   
q_0: ┤ H ├──■──┤M├───
     └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
          └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
                0  1 
``` 

Jumlah hasil simulasi (counts) akan menunjukkan:
```
Simulation Result Counts: {'00': 502, '11': 498}
```

Plot histogram akan mengkonfirmasi secara visual bahwa hanya ada dua hasil, 00 dan 11, keduanya dengan probabilitas sekitar 50%.

### Implementasi Lanjutan: Quantum Machine Learning (VQC)
Untuk dapat membantu memahami aplikasi quantum computing dalam machine learning, anda bisa menonton penjelasan sederhana mengenai machine learning dari video berikut: https://youtu.be/PeMlggyqz0Y
Feel free untuk mencari tahu lebih lanjut tentang machine learning dari sumber-sumber lain.

Variational Quantum Classifier (VQC) adalah algoritma quantum machine learning yang sederhana namun kuat. Ini adalah algoritma hybrid, yang berarti menggunakan komputer klasik dan quantum computer (atau simulator).
- Komputer klasik menjalankan optimizer (seperti COBYLA).
- Komputer quantum menjalankan quantum circuit terparameter (parameterized quantum circuit, disebut ansatz) untuk membantu mengklasifikasikan data.

Kita akan melatih VQC untuk mengklasifikasikan dataset sintetis 2D yang sederhana.

#### Prasyarat Instalasi
Anda memerlukan qiskit-machine-learning dan scikit-learn:
```
pip install qiskit-machine-learning
pip install scikit-learn
```

#### Contoh implementasi
Kode ini akan:
1. Membuat dataset 2 kelas sederhana.
2. Mendefinisikan komponen VQC.
3. Melatih model VQC.
4. Menilai akurasi model.
```python
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from qiskit.primitives import Sampler
from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes
from qiskit_machine_learning.algorithms.classifiers import VQC
from qiskit_machine_learning.optimizers import COBYLA

# --- 1. Create a Simple Dataset ---
# We use scikit-learn to create a synthetic dataset with 2 features and 2 classes
X, y = make_classification(
    n_samples=100,
    n_features=2,
    n_redundant=0,
    n_informative=2,
    random_state=42,
    n_clusters_per_class=1,
)

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# Plot the training data to visualize it
plt.figure(figsize=(6, 4))
plt.scatter(X_train[y_train == 0][:, 0], X_train[y_train == 0][:, 1], label="Class 0")
plt.scatter(X_train[y_train == 1][:, 0], X_train[y_train == 1][:, 1], label="Class 1")
plt.title("Synthetic 2D Dataset")
plt.xlabel("Feature 0")
plt.ylabel("Feature 1")
plt.legend()
plt.show()


# --- 2. Define the VQC Components ---

# We need 2 qubits, one for each feature
num_features = X.shape[1]

# Use a Sampler primitive to get measurement results
sampler = Sampler()

# Define the "Feature Map" - how we encode our classical data into the quantum state
# ZZFeatureMap is a standard choice.
feature_map = ZZFeatureMap(feature_dimension=num_features, reps=1)

# Define the "Ansatz" - the parameterized quantum circuit that we will train
# RealAmplitudes is a common, effective choice.
ansatz = RealAmplitudes(num_qubits=num_features, reps=3)

# Define the classical optimizer that will train our circuit's parameters
optimizer = COBYLA(maxiter=100)

# --- 3. Instantiate and Train the VQC ---

print("Training VQC... This may take a moment.")

vqc = VQC(
    sampler=sampler,
    feature_map=feature_map,
    ansatz=ansatz,
    optimizer=optimizer,
)

# Train the model
vqc.fit(X_train, y_train)

# --- 4. Score the Model ---

# Use the trained VQC to score the test data
accuracy = vqc.score(X_test, y_test)

print(f"\nQuantum Machine Learning VQC Accuracy: {accuracy * 100:.2f}%")

# You can also predict new data points
# new_data = np.array([[0.5, 0.5], [-1, -1]])
# predictions = vqc.predict(new_data)
# print(f"Predictions for new data: {predictions}")
```

#### Expected Output
Pertama, Anda akan melihat plot data sintetis Anda, menunjukkan dua cluster yang jelas (meskipun tidak sempurna) terpisah.
Setelah proses pelatihan, Anda akan melihat akurasi akhirnya seperti berikut:
```
Training VQC... This may take a moment.
...
Quantum Machine Learning VQC Accuracy: 93.33%
```
Ini menunjukkan bahwa model quantum-classic sederhana kita berhasil "belajar" cara memisahkan kedua data class tersebut.