Kita gunakan quantum Generative Adversarial Network (qGAN) untuk mempelajari distribusi random dari data yang diberikan dan memuatnya ke quantum state.

Tujuan dari qGAN training adalah untuk menghasilkan quantum state , yang menggambarkan distribusi probabilitas yang dekat dengan distribusi dari data training.

Dalam konsep GAN, 2 jaringan saraf (Discriminator & Generator) bersaing satu sama lain dalam game theory.
– Discriminator: Membedakan antara sampel data asli dan palsu
Dataset training digunakan sebagai data pelatihan awal untuk Discriminator.
– Generator: Menghasilkan sampel data “palsu”
Generator di training berdasarkan apakah ia berhasil menipu Discriminator.
Dengan data training, GAN dapat dilatih untuk menghasilkan data baru dengan statistik yang sama dengan set pelatihan.
Baca = https://en.wikipedia.org/wiki/Generative_adversarial_network

Lebih lanjut, baca = https://arxiv.org/abs/1904.00043
Tentang Qiskit qGAN, baca di = https://qiskit.org/documentation/stubs/qiskit.aqua.algorithms.QGAN.html

1. install cuda toolkit 10.1 kemudian pytorch (supaya bisa memanfaatkan kekuatan komputasi GPU dari Nvidia mu)
https://developer.nvidia.com/cuda-10.1-download-archive-update2
conda install pytorch torchvision cudatoolkit=10.1 -c pytorch

2. Buat new jupyter notebook:

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
import time
start = time.time()
from torch import optim
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.aqua.components.optimizers import ADAM
from qiskit.aqua.components.uncertainty_models import UniformDistribution, UnivariateVariationalDistribution
from qiskit.circuit.library import TwoLocal
from qiskit.aqua.algorithms import QGAN
from qiskit.aqua.components.neural_networks.quantum_generator import QuantumGenerator
from qiskit.aqua.components.neural_networks import NumPyDiscriminator
from qiskit.aqua import aqua_globals, QuantumInstance
from qiskit.aqua.components.initial_states import Custom
from qiskit import BasicAer

3. Load data training

Kita muat sampel data training k-dimensi (di contoh ini, k = 1).
Data kita generate dengan numpy random lognormal, baca = https://numpy.org/doc/1.16/reference/generated/numpy.random.lognormal.html
Tentang distribusi lognormal, baca = https://en.wikipedia.org/wiki/Log-normal_distribution

Kemudian kita set resolusi data, sebagai contoh nilai min/max data dan jumlah qubit yang digunakan untuk mewakili setiap dimensi data.

# Number training data samples
N = 1000
# Load data samples from log-normal distribution with mean=1 and standard deviation=1
mu = 1
sigma = 1
real_data = np.random.lognormal(mean = mu, sigma=sigma, size=N)
# Set the data resolution
# Set upper and lower data values as list of k min/max data values [[min_0,max_0],…,[min_k-1,max_k-1]]
bounds = np.array([0.,3.])
# Set number of qubits per data dimension as list of k qubit values[#q_0,…,#q_k-1]
num_qubits = [2]
k = len(num_qubits)

4. Inisialisasi qGAN

QGAN terdiri dari: quantum generator (G), variational quantum circuit, classical discriminator (D), dan neural network.

Dataset yang diketahui berfungsi sebagai data pelatihan awal untuk pembeda. Pelatihan itu melibatkan menyajikannya dengan sampel dari dataset pelatihan, sampai mencapai akurasi yang dapat diterima. Generator melatih berdasarkan apakah ia berhasil menipu pembeda.

Untuk mengimplementasikan generator kuantum, kita pilih bentuk variasional kedalaman-1 yang mengimplementasikan gate RY dan CZ yang menggunakan uniform distribution sebagai input state.
Untuk kasus k > 1, parameter generator harus dipilih dengan hati-hati.
Misalnya, kedalaman rangkaian sirkuit harus > 1 karena kedalaman sirkuit yang lebih tinggi memungkinkan representasi struktur yang lebih kompleks.

Classical discriminator diberikan oleh 3-layer neural network yang menerapkan linear transformations, fungsi leaky ReLU di hidden layer dan fungsi sigmoid di output layer.
Tentang leaky RELU baca di = https://en.wikipedia.org/wiki/Rectifier_(neural_networks)#Leaky_ReLU
Di sini, kedua jaringan diperbarui dengan algoritma optimasi ADAM.

# Set number of training epochs
# Note: The algorithm’s runtime can be shortened by reducing the number of training epochs.
num_epochs = 3000
# Batch size
batch_size = 100
# Initialize qGAN
qgan = QGAN(real_data, bounds, num_qubits, batch_size, num_epochs, snapshot_dir=None)
qgan.seed = 1
# Set quantum instance to run the quantum generator
quantum_instance = QuantumInstance(backend=BasicAer.get_backend(‘statevector_simulator’))
# Set entangler map
entangler_map = [[0, 1]]
# Set an initial state for the generator circuit
init_dist = UniformDistribution(sum(num_qubits), low=bounds[0], high=bounds[1])
q = QuantumRegister(sum(num_qubits), name=’q’)
qc = QuantumCircuit(q)
init_dist.build(qc, q)
init_distribution = Custom(num_qubits=sum(num_qubits), circuit=qc)
var_form = TwoLocal(int(np.sum(num_qubits)), ‘ry’, ‘cz’, entanglement=entangler_map,
reps=1, initial_state=init_distribution)
# Set generator’s initial parameters
init_params = aqua_globals.random.rand(var_form.num_parameters_settable) * 2 * np.pi
# Set generator circuit
g_circuit = UnivariateVariationalDistribution(int(sum(num_qubits)), var_form, init_params,
low=bounds[0], high=bounds[1])
# Set quantum generator
qgan.set_generator(generator_circuit=g_circuit)
# Set classical discriminator neural network
discriminator = NumPyDiscriminator(len(num_qubits))
qgan.set_discriminator(discriminator)

5. Jalankan Training

Selama training, parameter diskriminator dan generator di update secara bergantian menggunakan loss functions.

# Run qGAN
qgan.run(quantum_instance)
# Runtime
end = time.time()
print(‘qGAN training runtime: ‘, (end – start)/60., ‘ min’)

6. Outcome

Kita tampilkan beberapa hasil =
– gambar plot evolusi perubahan value dari loss functions pada generator dan diskriminator selama training,
– serta perubahan nilai relative entropy antara distribusi hasil training dan distribusi target.
– perbandingan nilai cumulative distribution function (CDF) dari distribusi terlatih dengan CDF dari target distribusi.
Tentang CDF, baca di = https://en.wikipedia.org/wiki/Cumulative_distribution_function

Sumber =

https://quantum-computing.ibm.com/jupyter/tutorial/advanced/aqua/machine_learning/qgans_for_loading_random_distributions.ipynbhttps://quantum-computing.ibm.com/jupyter/tutorial/advanced/aqua/machine_learning/qgans_for_loading_random_distributions.ipynb

Kode program tersedia di GitHub = https://github.com/keamanansiber/qiskit/blob/master/3QuantumMachineLearning/qGAN_LoadingRandomDistributions.ipynb

https://keamanansiber.id/blog/2020/06/03/algoritma-quantum-generative-adversarial-network-qgan-untuk-loading-random-distributions/