Tamil
மொழிகள்
English
Bengali
French
Hindi
Italian
Japanese
Korean
Malayalam
Russian
Spanish
Tamil
Turkish
Vietnamese
Shortcuts

Note

இந்தப் பக்கம் docs/tutorials/04_qgans_for_loading_random_distributions.ipynb இலிருந்து உருவாக்கப்பட்டது.

சீரற்ற விநியோகங்களை ஏற்றுவதற்கான qGAN கள்

கொடுக்கப்பட்டவை \(k\) பரிமாண தரவு மாதிரிகள், தரவின் அடிப்படை சீரற்ற விநியோகத்தைக் கற்றுக்கொள்வதற்கும் அதை நேரடியாக ஒரு குவாண்டம் நிலைக்கு ஏற்றுவதற்கும் ஒரு குவாண்டம் ஜெனரேடிவ் அட்வர்சரியல் நெட்வொர்க்கை (qGAN) பயன்படுத்துகிறோம்:

\[\big| g_{\theta}\rangle = \sum_{j=0}^{2^n-1} \sqrt{p_{\theta}^{j}}\big| j \rangle\]

where \(p_{\theta}^{j}\) describe the occurrence probabilities of the basis states \(\big| j\rangle\).

Qgan பயிற்சியின் நோக்கம் ஒரு நிலையை உருவாக்குவது \(\big| g_{\theta}\rangle\) எங்கே:math:p_{theta}^{j}, இதற்கு \(j\in \left\{0, \ldots, {2^n-1} \right\}\), பயிற்சித் தரவின் அடிப்படையிலான விநியோகத்திற்கு நெருக்கமான நிகழ்தகவு விநியோகத்தை விவரிக்கவும்: \(X=\left\{x^0, \ldots, x^{k-1} \right\}\).

மேலும் விவரங்களுக்கு, Quantum Generative Adversarial Networks for Learning and Loading Random Distributions Zoufal, Lucchi, Woerner [2019] ஐப் பார்க்கவும்.

ஒரு பயன்பாட்டில் பயிற்சி பெற்ற qGAN ஐ எவ்வாறு பயன்படுத்துவது என்பதற்கான எடுத்துக்காட்டுக்கு, நிதி வழித்தோன்றல்களின் விலை, தயவுசெய்து `Option Pricing with qGANs <https://github.com/Qiskit/qiskit-finance/tree/main/docs/tutorials/10_qgan_option_pricing.ipynb>`__பயிற்சி.

[1]:
import numpy as np
seed = 71
np.random.seed = seed

import matplotlib.pyplot as plt
%matplotlib inline

from qiskit import QuantumRegister, QuantumCircuit, BasicAer
from qiskit.circuit.library import TwoLocal, UniformDistribution

from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit_machine_learning.algorithms import NumPyDiscriminator, QGAN

algorithm_globals.random_seed = seed

பயிற்சி தரவை ஏற்றவும்

முதலில், நாம்: கணிதத்தை ஏற்ற வேண்டும் \(k\) பரிமாண பயிற்சி தரவு மாதிரிகள் (இங்கே k = 1).

அடுத்து, தரவுத் தீர்மானம் அமைக்கப்பட்டுள்ளது, அதாவது நிமிடம் / அதிகபட்ச தரவு மதிப்புகள் மற்றும் ஒவ்வொரு தரவு பரிமாணத்தையும் குறிக்கப் பயன்படுத்தப்படும் குவிட்களின் எண்ணிக்கை.

[2]:
# 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)

qGAN ஐத் தொடங்கவும்

qGAN ஒரு குவாண்டம் ஜெனரேட்டரைக் கொண்டுள்ளது \(G_{\theta}\), அதாவது, ஒரு அன்சாட்ஸ் மற்றும் ஒரு கிளாசிக்கல் பாகுபாடு காண்பிப்பவர் \(D_{\phi}\), ஒரு நரம்பியல் வலைப்பின்னல்.

குவாண்டம் ஜெனரேட்டரை செயல்படுத்த, ஒரு ஆழம்- math \(1\) அன்சாட்ஸ் செயல்படுத்துகிறது \(R_Y\) சுழற்சிகள் மற்றும் \(CZ\) வாயில்கள் ஒரு சீரான விநியோகத்தை உள்ளீட்டு நிலையாக எடுத்துக்கொள்கின்றன. குறிப்பாக, இதற்கு \(k>1\) ஜெனரேட்டரின் அளவுருக்கள் கவனமாக தேர்ந்தெடுக்கப்பட வேண்டும். எடுத்துக்காட்டாக, சுற்று ஆழம் இருக்க வேண்டும் \(>1\) ஏனெனில் அதிக சுற்று ஆழங்கள் மிகவும் சிக்கலான கட்டமைப்புகளின் பிரதிநிதித்துவத்தை செயல்படுத்துகின்றன.

இங்கே பயன்படுத்தப்படும் கிளாசிக்கல் பாகுபாடு NumPy ஐப் பயன்படுத்தி ஒரு நரம்பியல் பிணைய செயலாக்கத்தை அடிப்படையாகக் கொண்டது. Qiskit-டை நிறுவும் போது இயல்பாக நிறுவப்படாத பைடார்ச்சின் அடிப்படையில் ஒரு பாகுபாடு காண்பிப்பவர் இருக்கிறார் - மேலும் தகவலுக்கு Optional Install ஐப் பார்க்கவும்.

இங்கே, இரண்டு நெட்வொர்க்குகளும் ADAM தேர்வுமுறை வழிமுறையுடன் புதுப்பிக்கப்படுகின்றன (ADAM என்பது qGAN உகப்பாக்கி இயல்புநிலை).

[3]:
# Set number of training epochs
# Note: The algorithm's runtime can be shortened by reducing the number of training epochs.
num_epochs = 10
# 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'),
                                   seed_transpiler=seed, seed_simulator=seed)

# Set entangler map
entangler_map = [[0, 1]]


# Set an initial state for the generator circuit
init_dist = UniformDistribution(sum(num_qubits))

# Set the ansatz circuit
ansatz = TwoLocal(int(np.sum(num_qubits)), 'ry', 'cz', entanglement=entangler_map, reps=1)

# Set generator's initial parameters - in order to reduce the training time and hence the
# total running time for this notebook
init_params = [3., 1., 0.6, 1.6]

# You can increase the number of training epochs and use random initial parameters.
# init_params = np.random.rand(ansatz.num_parameters_settable) * 2 * np.pi

# Set generator circuit by adding the initial distribution infront of the ansatz
g_circuit = ansatz.compose(init_dist, front=True)

# Set quantum generator
qgan.set_generator(generator_circuit=g_circuit, generator_init_params=init_params)
# The parameters have an order issue that following is a temp. workaround
qgan._generator._free_parameters = sorted(g_circuit.parameters, key=lambda p: p.name)
# Set classical discriminator neural network
discriminator = NumPyDiscriminator(len(num_qubits))
qgan.set_discriminator(discriminator)

qGAN பயிற்சியை இயக்கவும்

பயிற்சியின் போது பாகுபாடு காண்பிப்பவர் மற்றும் ஜெனரேட்டரின் அளவுருக்கள் மாறி மாறி புதுப்பிக்கப்படும் w.r.t பின்வரும் இழப்பு செயல்பாடுகள்:

\[L_G\left(\phi, \theta\right) = -\frac{1}{m}\sum\limits_{l=1}^{m}\left[\log\left(D_{\phi}\left(g^{l}\right)\right)\right]\]

மற்றும்

\[L_D\left(\phi, \theta\right) = \frac{1}{m}\sum\limits_{l=1}^{m}\left[\log D_{\phi}\left(x^{l}\right) + \log\left(1-D_{\phi}\left(g^{l}\right)\right)\right],\]

உடன் \(m\) தொகுதி அளவைக் குறிக்கிறது மற்றும் \(g^l\) குவாண்டம் ஜெனரேட்டரால் உருவாக்கப்பட்ட தரவு மாதிரிகளை விவரிக்கிறது.

இந்த நோட்புக்கின் நோக்கத்திற்காக, அறியப்பட்ட ஆரம்ப புள்ளியை (init_params) தேர்ந்தெடுப்பதன் மூலம் பயிற்சி சுருக்கமாக வைக்கப்பட்டுள்ளது என்பதை நினைவில் கொள்க. அத்தகைய முன் அறிவு இல்லாமல் விழிப்புணர்வு பயிற்சி சிறிது நேரம் ஆகலாம்.

[4]:
# Run qGAN
result = qgan.run(quantum_instance)
[5]:
print('Training results:')
for key, value in result.items():
    print(f'  {key} : {value}')
Training results:
  params_d : [ 0.03697158  0.61015372 -0.48103428 ... -0.1661673  -0.20186384
 -0.08584337]
  params_g : [2.95229918 0.9522102  0.55218478 1.64793094]
  loss_d : 0.6925
  loss_g : [0.7246]
  rel_entr : 0.107

பயிற்சி முன்னேற்றம் மற்றும் விளைவு

இப்போது, ​​ஜெனரேட்டரின் பரிணாம வளர்ச்சியையும், பயிற்சியின் போது பாகுபாடு காண்பவரின் இழப்பு செயல்பாடுகளையும், பயிற்சி பெற்ற மற்றும் இலக்கு விநியோகத்திற்கும் இடையிலான ஒப்பீட்டு என்ட்ரோபியின் முன்னேற்றத்தையும் நாங்கள் திட்டமிடுகிறோம்.

இறுதியாக, பயிற்சி பெற்ற விநியோகத்தின் ஒட்டுமொத்த விநியோக செயல்பாட்டை (சி. டி. எஃப்) இலக்கு விநியோகத்தின் சி. டி. எஃப் உடன் ஒப்பிடுகிறோம்.

[6]:
# Plot progress w.r.t the generator's and the discriminator's loss function
t_steps = np.arange(num_epochs)
plt.figure(figsize=(6,5))
plt.title("Progress in the loss function")
plt.plot(t_steps, qgan.g_loss, label='Generator loss function', color='mediumvioletred', linewidth=2)
plt.plot(t_steps, qgan.d_loss, label='Discriminator loss function', color='rebeccapurple', linewidth=2)
plt.grid()
plt.legend(loc='best')
plt.xlabel('time steps')
plt.ylabel('loss')
plt.show()
../_images/tutorials_04_qgans_for_loading_random_distributions_10_0.png
[7]:
# Plot progress w.r.t relative entropy
plt.figure(figsize=(6,5))
plt.title('Relative Entropy')
plt.plot(np.linspace(0, num_epochs, len(qgan.rel_entr)), qgan.rel_entr, color='mediumblue', lw=4, ls=':')
plt.grid()
plt.xlabel('time steps')
plt.ylabel('relative entropy')
plt.show()
../_images/tutorials_04_qgans_for_loading_random_distributions_11_0.png
[8]:
#Plot the CDF of the resulting distribution against the target distribution, i.e. log-normal
log_normal = np.random.lognormal(mean=1, sigma=1, size=100000)
log_normal = np.round(log_normal)
log_normal = log_normal[log_normal <= bounds[1]]
temp = []
for i in range(int(bounds[1] + 1)):
    temp += [np.sum(log_normal==i)]
log_normal = np.array(temp / sum(temp))

plt.figure(figsize=(6,5))
plt.title('CDF (Cumulative Distribution Function)')
samples_g, prob_g = qgan.generator.get_output(qgan.quantum_instance, shots=10000)
samples_g = np.array(samples_g)
samples_g = samples_g.flatten()
num_bins = len(prob_g)
plt.bar(samples_g,  np.cumsum(prob_g), color='royalblue', width= 0.8, label='simulation')
plt.plot( np.cumsum(log_normal),'-o', label='log-normal', color='deepskyblue', linewidth=4, markersize=12)
plt.xticks(np.arange(min(samples_g), max(samples_g)+1, 1.0))
plt.grid()
plt.xlabel('x')
plt.ylabel('p(x)')
plt.legend(loc='best')
plt.show()
../_images/tutorials_04_qgans_for_loading_random_distributions_12_0.png
[9]:
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit SoftwareVersion
QiskitNone
Terra0.17.0.dev0+346ffa8
Aer0.8.0
Ignis0.6.0.dev0+d6f1ad7
AquaNone
IBM Q Provider0.13.0.dev0+10f19e0
System information
Python3.8.8 (default, Feb 24 2021, 13:46:16) [Clang 10.0.0 ]
OSDarwin
CPUs6
Memory (Gb)16.0
Wed Mar 31 23:30:54 2021 CEST

This code is a part of Qiskit

© Copyright IBM 2017, 2021.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.