Malayalam
ഭാഷകൾ
English
Bengali
French
Hindi
Italian
Japanese
Korean
Malayalam
Russian
Spanish
Tamil
Turkish
Vietnamese
Shortcuts

Note

This page was generated from docs/tutorials/01_neural_networks.ipynb.

ക്വാണ്ടം ന്യൂറൽ നെറ്റ്‌വർക്കുകൾ

ഈ നോട്ട്ബുക്ക് ക്വിസ്കിറ്റ് മെഷീൻ ലേണിംഗിൽ നൽകിയിട്ടുള്ള വ്യത്യസ്ത ജനറിക് ക്വാണ്ടം ന്യൂറൽ നെറ്റ്‌വർക്ക് (QNN) നടപ്പാക്കലുകൾ കാണിക്കുന്നു. വ്യത്യസ്‌ത ഉപയോഗ കേസുകൾ‌ക്ക് ഉപയോഗിക്കാൻ‌ കഴിയുന്ന ആപ്ലിക്കേഷൻ‌-അജ്ഞ്ഞേയ കംപ്യൂട്ടേഷണൽ‌ യൂണിറ്റുകളാണ് നെറ്റ്‌വർ‌ക്കുകൾ‌. ആപ്ലിക്കേഷനെ ആശ്രയിച്ച്, ഒരു പ്രത്യേക തരം നെറ്റ്‌വർക്ക് കൂടുതലോ കുറവോ അനുയോജ്യമായേക്കാം, ഇവയെ ഒരു പ്രത്യേക രീതിയിൽ സജ്ജീകരിക്കേണ്ടതുണ്ട്. ലഭ്യമായ വ്യത്യസ്ത ന്യൂറൽ നെറ്റ്‌വർക്കുകൾ ഇപ്പോൾ കൂടുതൽ വിശദമായി ചർച്ചചെയ്യും:

  1. NeuralNetwork: ന്യൂറൽ നെറ്റ്‌വർക്കുകൾക്കായുള്ള ഇന്റർഫേസ്.

  2. OpflowQNN: ക്വാണ്ടം മെക്കാനിക്കൽ നിരീക്ഷണങ്ങളുടെ വിലയിരുത്തലിനെ അടിസ്ഥാനമാക്കിയുള്ള ഒരു നെറ്റ്‌വർക്ക്.

  3. TwoLayerQNN: സൗകര്യാർത്ഥം ഒരു പ്രത്യേക OpflowQNN നടപ്പാക്കൽ.

  4. CircuitQNN: ഒരു ക്വാണ്ടം സർക്യൂട്ട് അളക്കുന്നതിന്റെ ഫലമായ സാമ്പിളുകളെ അടിസ്ഥാനമാക്കിയുള്ള ഒരു നെറ്റ്‌വർക്ക്.

[1]:
import numpy as np

from qiskit import Aer, QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
from qiskit.opflow import StateFn, PauliSumOp, AerPauliExpectation, ListOp, Gradient
from qiskit.utils import QuantumInstance
[2]:
# set method to calculcate expected values
expval = AerPauliExpectation()

# define gradient method
gradient = Gradient()

# define quantum instances (statevector and sample based)
qi_sv = QuantumInstance(Aer.get_backend('aer_simulator_statevector'))

# we set shots to 10 as this will determine the number of samples later on.
qi_qasm = QuantumInstance(Aer.get_backend('aer_simulator'), shots=10)

1.``NeuralNetwork``

ക്വിസ്കിറ്റ് മെഷീൻ ലേണിംഗിൽ ലഭ്യമായ എല്ലാ ന്യൂറൽ നെറ്റ്‌വർക്കുകൾക്കുമായുള്ള ഇന്റർഫേസിനെ NeuralNetwork പ്രതിനിധീകരിക്കുന്നു. ഡാറ്റാ സാമ്പിളുകളും ട്രെയിനബിൾ വെയ്റ്റുകളും ഇൻപുട്ടായി എടുക്കുന്ന ഒരു ഫോർവേഡ്, ബാക്ക്വേർഡ് പാസ് ഇത് തുറന്നുകാട്ടുന്നു. ഒരു ``NeuralNetwork``യിൽ പരിശീലന ശേഷികളൊന്നും അടങ്ങിയിട്ടില്ല, ഇവയെ യഥാർത്ഥ അൽഗോരിതം / ആപ്ലിക്കേഷനുകളിലേക്ക് തള്ളപ്പെടുന്നു. അതിനാൽ, ``NeuralNetwork``ഒരുപരിശീലനയോഗ്യമായ വെയ്റ്റിംൻ്റെ മൂല്യങ്ങളൊന്നും സംഭരിക്കുന്നില്ല. ഇനിപ്പറയുന്നവയിൽ, ഈ ഇന്റർഫേസുകളുടെ വ്യത്യസ്ത നടപ്പാക്കലുകൾ അവതരിപ്പിക്കുന്നു.

nn എന്ന് വിളിക്കുന്ന ഒരു NeuralNetwork കരുതുക. തുടർന്ന്, nn.forward(input, weights) പാസ് യഥാക്രമം nn.num_inputs, nn.num_weights എന്നിവയുടെ വലുപ്പത്തിനും ഡാറ്റയ്‌ക്കുമുള്ള ഫ്ലാറ്റ് ഇൻ‌പുട്ടുകൾ‌ എടുക്കുന്നു. NeuralNetwork ഇൻപുട്ടുകൾ ബാച്ച് ചെയ്യുന്നതിനെ പിന്തുണയ്ക്കുകയും അനുബന്ധ ആകൃതിയുടെ (shape) ഔട്ട്‌പുട്ടിന്റെ ബാച്ചുകൾ നൽകുകയും ചെയ്യുന്നു.

2. OpflowQNN

OpflowQNN ക്വിസ്കിറ്റിൽ‌ നിന്നും ഒരു (പാരാമീറ്ററൈസ്ഡ്) ഓപ്പറേറ്ററെടുക്കുകയും ബാക്ക്‌വേർ‌ഡ് പാസ് നൽ‌കുന്നതിന് ക്വിസ്കിറ്റിന്റെ ഗ്രേഡിയൻറ് ഫ്രെയിംവർ‌ക്കിനെ പരമാവധി ഉപയോഗപെടുത്തുന്നു. അത്തരമൊരു ഓപ്പറേറ്ററിന് ഒരു പാരാമീറ്ററൈസ്ഡ് ക്വാണ്ടം അവസ്ഥയുമായി(Quantum State) ബന്ധപ്പെട്ട് നിരീക്ഷിക്കാവുന്ന ഒരു ക്വാണ്ടം മെക്കാനിക്കലിന്റെ പ്രതീക്ഷിത മൂല്യമാകാം. ക്ലാസിക്കൽ ഡാറ്റ ലോഡുചെയ്യുന്നതിനും പരിശീലിപ്പിക്കാവുന്ന ഭാരം പ്രതിനിധീകരിക്കുന്നതിനും പാരാമീറ്ററുകൾ ഉപയോഗിക്കാം. കൂടുതൽ‌ സങ്കീർ‌ണ്ണമായ QNN കൾ‌ നിർമ്മിക്കുന്നതിന് ഓപ്പറേറ്റർ‌മാരുടെ പട്ടികകളും കൂടുതൽ‌ സങ്കീർ‌ണ്ണ ഘടനകളും OpflowQNN അനുവദിക്കുന്നു.

[3]:
from qiskit_machine_learning.neural_networks import OpflowQNN
[4]:
# construct parametrized circuit
params1 = [Parameter('input1'), Parameter('weight1')]
qc1 = QuantumCircuit(1)
qc1.h(0)
qc1.ry(params1[0], 0)
qc1.rx(params1[1], 0)
qc_sfn1 = StateFn(qc1)

# construct cost operator
H1 = StateFn(PauliSumOp.from_list([('Z', 1.0), ('X', 1.0)]))

# combine operator and circuit to objective function
op1 = ~H1 @ qc_sfn1
print(op1)
ComposedOp([
  OperatorMeasurement(1.0 * Z
  + 1.0 * X),
  CircuitStateFn(
       ┌───┐┌────────────┐┌─────────────┐
  q_0: ┤ H ├┤ RY(input1) ├┤ RX(weight1) ├
       └───┘└────────────┘└─────────────┘
  )
])
[5]:
# construct OpflowQNN with the operator, the input parameters, the weight parameters,
# the expected value, gradient, and quantum instance.
qnn1 = OpflowQNN(op1, [params1[0]], [params1[1]], expval, gradient, qi_sv)
[6]:
# define (random) input and weights
input1 = np.random.rand(qnn1.num_inputs)
weights1 = np.random.rand(qnn1.num_weights)
[7]:
# QNN forward pass
qnn1.forward(input1, weights1)
[7]:
array([[0.81422018]])
[8]:
# QNN batched forward pass
qnn1.forward([input1, input1], weights1)
[8]:
array([[0.81422018],
       [0.81422018]])
[9]:
# QNN backward pass
qnn1.backward(input1, weights1)
[9]:
(array([[[-1.15629599]]]), array([[[0.0008565]]]))
[10]:
# QNN batched backward pass
qnn1.backward([input1, input1], weights1)
[10]:
(array([[[-1.15629599]],

        [[-1.15629599]]]),
 array([[[0.0008565]],

        [[0.0008565]]]))

ListOp -ൽ ഒന്നിലധികം നിരീക്ഷണങ്ങൾ സംയോജിപ്പിക്കുന്നത് കൂടുതൽ സങ്കീർണ്ണമായ QNN- കൾ സൃഷ്ടിക്കാൻ അനുവദിക്കുന്നു

[11]:
op2 = ListOp([op1, op1])
qnn2 = OpflowQNN(op2, [params1[0]], [params1[1]], expval, gradient, qi_sv)
[12]:
# QNN forward pass
qnn2.forward(input1, weights1)
[12]:
array([[0.81422018, 0.81422018]])
[13]:
# QNN backward pass
qnn2.backward(input1, weights1)
[13]:
(array([[[-1.15629599],
         [-1.15629599]]]),
 array([[[0.0008565],
         [0.0008565]]]))

3. TwoLayerQNN

TwoLayerQNN എന്നത് ഒരു പ്രത്യേക OpflowQNN എന്നതിലെ \(n\) ക്യൂബിറ്റുകൾ, അതിൽ ആദ്യം ഡാറ്റ ഉൾപ്പെടുത്തുന്നതിനുള്ള സവിശേഷത മാപ്പും രണ്ടാമത് പരിശീലനം ലഭിച്ച ഒരു അൻസാറ്റ്സും(ansatz) അടങ്ങിയിരിക്കുന്നു. സ്ഥിരസ്ഥിതിയായി നിരീക്ഷിക്കാനാകുന്നത് \(Z^{\otimes n}\), അതായത്, പാരിറ്റി.

[14]:
from qiskit_machine_learning.neural_networks import TwoLayerQNN
[15]:
# specify the number of qubits
num_qubits = 3
[16]:
# specify the feature map
fm = ZZFeatureMap(num_qubits, reps=2)
fm.draw(output='mpl')
[16]:
../_images/tutorials_01_neural_networks_20_0.png
[17]:
# specify the ansatz
ansatz = RealAmplitudes(num_qubits, reps=1)
ansatz.draw(output='mpl')
[17]:
../_images/tutorials_01_neural_networks_21_0.png
[18]:
# specify the observable
observable = PauliSumOp.from_list([('Z'*num_qubits, 1)])
print(observable)
1.0 * ZZZ
[19]:
# define two layer QNN
qnn3 = TwoLayerQNN(num_qubits,
                   feature_map=fm,
                   ansatz=ansatz,
                   observable=observable, quantum_instance=qi_sv)
[20]:
# define (random) input and weights
input3 = np.random.rand(qnn3.num_inputs)
weights3 = np.random.rand(qnn3.num_weights)
[21]:
# QNN forward pass
qnn3.forward(input3, weights3)
[21]:
array([[0.28520667]])
[22]:
# QNN backward pass
qnn3.backward(input3, weights3)
[22]:
(array([[[-0.2933431 , -0.78565729,  0.5416021 ]]]),
 array([[[-0.09093077,  0.02802006, -0.13559047,  0.1814619 ,
           0.11644461, -0.4073129 ]]]))

4. CircuitQNN

CircuitQNN ഒരു (പാരാമീറ്ററൈസ്ഡ്) QuantumCircuit അടിസ്ഥാനമാക്കിയുള്ളതാണ്. ഇത് ഇൻപുട്ടുകളും വെയിറ്റ് പാരാമീറ്ററുകളും എടുക്കുകയും ഇവയുടെ അളവുകളിൽ നിന്ന് സാമ്പിളുകൾ നിർമ്മിക്കുകയും ചെയ്യും. സാമ്പിളുകളെ ഒരു ബിറ്റ്സ്ട്രിംഗിന് സമാനമായ സംഖ്യ സൂചിക അളക്കുന്നതിനുള്ള സാധ്യതകളായി അല്ലെങ്കിൽ നേരിട്ട് ഒരു ബൈനറി ഔട്ട്പുട്ടായിട്ടും വ്യാഖ്യാനിക്കാം. സാധ്യതകളുടെ കാര്യത്തിൽ, ഗ്രേഡിയന്റുകളെ കാര്യക്ഷമമായി കണക്കാക്കാം, കൂടാതെ CircuitQNN ഒരു പിന്നാക്ക പാസും നൽകുന്നു. സാമ്പിളുകളുടെ കാര്യത്തിൽ, ഡിഫ്രൻസിയേശൻ (differentiation) സാധ്യമല്ല, പിന്നോക്ക പാസ്ന (None, None) നൽകുന്നു.

Further, the CircuitQNN allows to specify an interpret function to post-process the samples. This is expected to take a measured integer (from a bitstring) and map it to a new index, i.e. non-negative integer. In this case, the output shape needs to be provided and the probabilities are aggregated accordingly.

സ്പാർസും ഡെൻസ് പ്രോബബിലിറ്റി വെക്ടറുകളിലേക്കും മടങ്ങുന്നതിന് ഒരു CircuitQNN -ന് ക്രമീകരിക്കാൻ‌ കഴിയും. interpret -ൻ്റെ ഫംഗ്ഷനൊന്നും ഉപയോഗിക്കുന്നില്ലെങ്കിൽ, പ്രോബബിലിറ്റി വെക്റ്ററിന്റെ അളവ് ക്യൂബിറ്റുകളുടെ എണ്ണത്തിനനുസരിച്ച് എക്‌സ്‌പോണൻസലായി വർധിക്കുന്നു, അങ്ങനെ ഒരു സ്പാർസ് റെക്കമൻ്റേഷൻ സാധാരണയായി ശുപാർശ ചെയ്യുന്നു.ഒരു interpret ഫംഗ്ഷന്റെ കാര്യത്തിൽ അത് പ്രതീക്ഷിച്ച ഫലത്തെ ആശ്രയിച്ചിരിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു സൂചിക അനുബന്ധ ബിറ്റ്സ്ട്രിംഗിന്റെ തുല്യതയിലേക്ക് മാപ്പുചയ്തിട്ടുണ്ടെങ്കിൽ, അതായത്, 0 അല്ലെങ്കിൽ 1 ലേക്ക്, ഡെൻസ് ഔട്ട്‌പുട്ട് അർത്ഥമാക്കുന്നു, ഫലം 2 ദൈർഘ്യമുള്ള പ്രോബബിലിറ്റി വെക്ടറായിരുക്കും.

[23]:
from qiskit_machine_learning.neural_networks import CircuitQNN
[24]:
qc = RealAmplitudes(num_qubits, entanglement='linear', reps=1)
qc.draw(output='mpl')
[24]:
../_images/tutorials_01_neural_networks_29_0.png

4.1 ഔട്ട്‌പുട്ട്: സ്പാർസ് സംഖ്യാ പ്രോബബിലിറ്റികൾ

[25]:
# specify circuit QNN
qnn4 = CircuitQNN(qc, [], qc.parameters, sparse=True, quantum_instance=qi_qasm)
[26]:
# define (random) input and weights
input4 = np.random.rand(qnn4.num_inputs)
weights4 = np.random.rand(qnn4.num_weights)
[27]:
# QNN forward pass
qnn4.forward(input4, weights4).todense()  # returned as a sparse matrix
[27]:
array([[0.5, 0. , 0. , 0. , 0.3, 0. , 0. , 0.2]])
[28]:
# QNN backward pass, returns a tuple of sparse matrices
qnn4.backward(input4, weights4)
[28]:
(<COO: shape=(1, 8, 0), dtype=float64, nnz=0, fill_value=0.0>,
 <COO: shape=(1, 8, 6), dtype=float64, nnz=22, fill_value=0.0>)

4.2 ഔട്ട്‌പുട്ട്: ഡെൻസ് പാരിറ്റി പ്രോബബിലിറ്റികൾ

[29]:
# specify circuit QNN
parity = lambda x: '{:b}'.format(x).count('1') % 2
output_shape = 2  # this is required in case of a callable with dense output
qnn6 = CircuitQNN(qc, [], qc.parameters, sparse=False, interpret=parity, output_shape=output_shape,
                  quantum_instance=qi_qasm)
[30]:
# define (random) input and weights
input6 = np.random.rand(qnn6.num_inputs)
weights6 = np.random.rand(qnn6.num_weights)
[31]:
# QNN forward pass
qnn6.forward(input6, weights6)
[31]:
array([[0.8, 0.2]])
[32]:
# QNN backward pass
qnn6.backward(input6, weights6)
[32]:
(array([], shape=(1, 2, 0), dtype=float64),
 array([[[-1.00000000e-01,  5.55111512e-17, -5.00000000e-02,
           1.38777878e-17, -2.00000000e-01,  5.00000000e-02],
         [ 1.00000000e-01,  0.00000000e+00,  5.00000000e-02,
          -5.55111512e-17,  2.00000000e-01, -5.00000000e-02]]]))

4.3 ഔട്ട്‌പുട്ട്: സാമ്പിളുകൾ

[33]:
# specify circuit QNN
qnn7 = CircuitQNN(qc, [], qc.parameters, sampling=True,
                  quantum_instance=qi_qasm)
[34]:
# define (random) input and weights
input7 = np.random.rand(qnn7.num_inputs)
weights7 = np.random.rand(qnn7.num_weights)
[35]:
# QNN forward pass, results in samples of measured bit strings mapped to integers
qnn7.forward(input7, weights7)
[35]:
array([[[4.],
        [4.],
        [7.],
        [1.],
        [7.],
        [4.],
        [4.],
        [4.],
        [0.],
        [0.]]])
[36]:
# QNN backward pass
qnn7.backward(input7, weights7)
[36]:
(None, None)

4.4 ഔട്ട്‌പുട്ട്: പാരിറ്റി സാമ്പിളുകൾ

[37]:
# specify circuit QNN
qnn8 = CircuitQNN(qc, [], qc.parameters, sampling=True, interpret=parity,
                  quantum_instance=qi_qasm)
[38]:
# define (random) input and weights
input8 = np.random.rand(qnn8.num_inputs)
weights8 = np.random.rand(qnn8.num_weights)
[39]:
# QNN forward pass, results in samples of measured bit strings
qnn8.forward(input8, weights8)
[39]:
array([[[1.],
        [0.],
        [1.],
        [0.],
        [0.],
        [0.],
        [0.],
        [0.],
        [0.],
        [0.]]])
[40]:
# QNN backward pass
qnn8.backward(input8, weights8)
[40]:
(None, None)
[41]:
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:25:48 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.

[ ]: