Not
Bu sayfa, docs/tutorials/01_neural_networks.ipynb sayfasından oluşturulmuştur.
Kuantum Sinir Ağları¶
Bu not defteri, Qiskit Makine Öğrenmesi içinde sağlanan farklı kuantum sinirsel ağ (QNN) uygulamalarını gösterir. Ağlar, birçok farklı senaryo için kullanılabilen uygulama-agnostik hesaplama birimleri olarak ifade edilir. Uygulamaya bağlı olarak, belirli bir ağ tipi belirli bir şekilde kurulmak için daha çok ya da daha az uygun olabilir ve belirli bir şekilde ayarlanması gerekebilir. Aşağıdaki farklı kullanılabilir sinirsel ağlar artık daha ayrıntılı olarak ele alınacak:
NeuralNetwork
: Sinirsel ağlar için arayüz.OpflowQNN
: Kuantum mekaniksel gözlemlenebilirlerin değerlendirilmesine dayalı bir ağ.TwoLayerQNN
: Uygunluk için özel birOpflowQNN
uygulaması.CircuitQNN
: Bir kuantum devresinin ölçülmesinden kaynaklanan örneklere dayalı bir ağ.
[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, algorithm_globals
algorithm_globals.random_seed = 42
[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
Qiskit makine öğrenimindeki bütün sinir ağları için olan arayüzü temsil eder. Veri örneklerini ve öğretilebilir yükleri alarak ileri ve geri geçişe maruz bırakır. Bir NeuralNetwork
herhangi bir eğitim yeteneği içermez, bunlar gerçek algoritmalara / uygulamalara bırakılmıştır. Böylelikle bir NeuralNetwork
eğitilebilir yükler için değerleri de depo etmez. Aşağıda, bu arayüzün farklı yerine getirmeleri gösterilmiştir.
Bir NeuralNetwork
ün nn
diye adlandırıldığını varsayalım. Sonra, nn.forward(input, weights)
geçişi hem veri hem de nn.num_inputs
ve nn.num_weights
ın ağırlıklarının boyutu için sırasıyla düz girişler alır. NeuralNetwork
girdi toplulaştırmayı destekler ve karşılık gelen şeklin çıktı grubunu verir.
2. OpflowQNN
¶
OpflowQNN
Qiskit’ten (parametreli) bir operatör alır ve geriye doğru geçişi sağlamak için Qiskit’in gradyan çerçevesinden yararlanır. Böyle bir operatör örneğin parametreli bir kuantum durumuna göre gözlemlenebilir bir kuantum mekaniğinin beklenen değeri olabilir. Parametreler, klasik verileri yüklemek ve eğitilebilir ağırlıkları temsil etmek için kullanılabilir.``OpflowQNN``ayrıca daha karmaşık QNN’ler oluşturmak için operatör listelerine ve daha karmaşık yapılara izin verir.
[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 = algorithm_globals.random.random(qnn1.num_inputs)
weights1 = algorithm_globals.random.random(qnn1.num_weights)
[7]:
# QNN forward pass
qnn1.forward(input1, weights1)
[7]:
array([[0.08242345]])
[8]:
# QNN batched forward pass
qnn1.forward([input1, input1], weights1)
[8]:
array([[0.08242345],
[0.08242345]])
[9]:
# QNN backward pass
qnn1.backward(input1, weights1)
[9]:
(None, array([[[0.2970094]]]))
[10]:
# QNN batched backward pass
qnn1.backward([input1, input1], weights1)
[10]:
(None,
array([[[0.2970094]],
[[0.2970094]]]))
Çoklu gözlemlenebiliri bir ListOp
içinde birleştirmek, daha karmaşık QNN’ler oluşturmaya da olanak tanır
[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.08242345, 0.08242345]])
[13]:
# QNN backward pass
qnn2.backward(input1, weights1)
[13]:
(None,
array([[[0.2970094],
[0.2970094]]]))
3. TwoLayerQNN
¶
TwoLayerQNN
önce veri eklemek için bir öznitelik haritasından ve ikinci olarak eğitilmiş bir ansatzdan oluşan \(n\) kübitler üzerinde özel bir ``OpflowQNN``dir. Varsayılan gözlemlenebilir \(Z^{\otimes n}\), yani, paritedir.
[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]:

[17]:
# specify the ansatz
ansatz = RealAmplitudes(num_qubits, reps=1)
ansatz.draw(output="mpl")
[17]:

[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 = algorithm_globals.random.random(qnn3.num_inputs)
weights3 = algorithm_globals.random.random(qnn3.num_weights)
[21]:
# QNN forward pass
qnn3.forward(input3, weights3)
[21]:
array([[0.18276559]])
[22]:
# QNN backward pass
qnn3.backward(input3, weights3)
[22]:
(None,
array([[[ 0.10231208, 0.10656571, 0.41017902, 0.16528909,
-0.27780262, 0.41365763]]]))
4. CircuitQNN
¶
CircuitQNN
(parametreli olan) bir QuantumCircuit``i temel alır. Bu, ağırlık parametrelerinin yanı sıra girdi alabilir ve ölçümden örnekler üretebilmektedir. Örnekler, bir bit dizisine karşılık gelen tamsayı indeksini ölçme olasılıkları olarak veya doğrudan bir ikili çıktı partisi olarak yorumlanabilir. Olasılıklar durumunda, gradyanlar verimli bir şekilde tahmin edilebilir ve ``CircuitQNN
geriye doğru bir geçiş de sağlar. Örnekler söz konusu olduğunda, farklılaşma mümkün değildir ve geriye doğru geçiş (None, None)
değerini döndürür.
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.
Bir CircuitQNN
yoğun olasılık vektörlerinin yanı sıra seyrek şekilde de döndürecek şekilde yapılandırılabilir. Herhangi bir interpret
fonksiyonu kullanılmazsa, olasılık vektörünün boyutu, kübit sayısıyla üstel olarak ölçeklenir ve genellikle seyrek bir öneri önerilir. Bir interpret
fonksiyonu olması durumunda, beklenen sonuca bağlıdır. Örneğin, bir indeks karşılık gelen bit dizgisinin paritesine, yani 0 veya 1’e eşlenirse, yoğun bir çıktı anlamlıdır ve sonuç, uzunluk 2 olan bir olasılık vektörü olacaktır.
[23]:
from qiskit_machine_learning.neural_networks import CircuitQNN
[24]:
qc = RealAmplitudes(num_qubits, entanglement="linear", reps=1)
qc.draw(output="mpl")
[24]:

4.1 Çıktı: seyrek tamsayı olasılıkları¶
[25]:
# specify circuit QNN
qnn4 = CircuitQNN(qc, [], qc.parameters, sparse=True, quantum_instance=qi_qasm)
[26]:
# define (random) input and weights
input4 = algorithm_globals.random.random(qnn4.num_inputs)
weights4 = algorithm_globals.random.random(qnn4.num_weights)
[27]:
# QNN forward pass
qnn4.forward(input4, weights4).todense() # returned as a sparse matrix
[27]:
array([[0.6, 0.1, 0. , 0. , 0. , 0. , 0. , 0.3]])
[28]:
# QNN backward pass, returns a tuple of sparse matrices
qnn4.backward(input4, weights4)
[28]:
(None, <COO: shape=(1, 8, 6), dtype=float64, nnz=33, fill_value=0.0>)
4.2 Çıktı: yoğun eşlik olasılıkları¶
[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 = algorithm_globals.random.random(qnn6.num_inputs)
weights6 = algorithm_globals.random.random(qnn6.num_weights)
[31]:
# QNN forward pass
qnn6.forward(input6, weights6)
[31]:
array([[0.5, 0.5]])
[32]:
# QNN backward pass
qnn6.backward(input6, weights6)
[32]:
(None,
array([[[-0.2 , 0.1 , -0.15, -0.15, 0.15, -0.15],
[ 0.2 , -0.1 , 0.15, 0.15, -0.15, 0.15]]]))
4.3 Çıktı: Örnekler¶
[33]:
# specify circuit QNN
qnn7 = CircuitQNN(qc, [], qc.parameters, sampling=True, quantum_instance=qi_qasm)
[34]:
# define (random) input and weights
input7 = algorithm_globals.random.random(qnn7.num_inputs)
weights7 = algorithm_globals.random.random(qnn7.num_weights)
[35]:
# QNN forward pass, results in samples of measured bit strings mapped to integers
qnn7.forward(input7, weights7)
[35]:
array([[[0.],
[1.],
[0.],
[7.],
[0.],
[6.],
[0.],
[0.],
[1.],
[6.]]])
[36]:
# QNN backward pass
qnn7.backward(input7, weights7)
[36]:
(None, None)
4.4 Çıktı: Eşlik Örnekleri¶
[37]:
# specify circuit QNN
qnn8 = CircuitQNN(qc, [], qc.parameters, sampling=True, interpret=parity, quantum_instance=qi_qasm)
[38]:
# define (random) input and weights
input8 = algorithm_globals.random.random(qnn8.num_inputs)
weights8 = algorithm_globals.random.random(qnn8.num_weights)
[39]:
# QNN forward pass, results in samples of measured bit strings
qnn8.forward(input8, weights8)
[39]:
array([[[0.],
[1.],
[1.],
[0.],
[1.],
[0.],
[0.],
[0.],
[1.],
[1.]]])
[40]:
# QNN backward pass
qnn8.backward(input8, weights8)
[40]:
(None, None)
[43]:
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
Version Information
Qiskit Software | Version |
---|---|
qiskit-terra | 0.19.0 |
qiskit-aer | 0.9.0 |
qiskit-ignis | 0.7.0 |
qiskit-ibmq-provider | 0.17.0 |
qiskit-aqua | 0.10.0 |
qiskit-machine-learning | 0.3.0 |
System information | |
Python | 3.8.10 (default, Jun 2 2021, 10:49:15) [GCC 9.4.0] |
OS | Linux |
CPUs | 4 |
Memory (Gb) | 7.6849517822265625 |
Sat Aug 28 01:04:52 2021 IST |
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.
[ ]: