1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
|
%global _empty_manifest_terminate_build 0
Name: python-quple
Version: 0.9.2.7
Release: 1
Summary: A framework for quantum machine learning in high energy physics
License: MIT License
URL: https://gitlab.cern.ch/clcheng/quple
Source0: https://mirrors.nju.edu.cn/pypi/web/packages/f6/33/65b40c9a72ce1105540e43f14b2321973602bbf0d427659f1530713d9e55/quple-0.9.2.7.tar.gz
BuildArch: noarch
Requires: python3-cirq
Requires: python3-numpy
Requires: python3-imageio
Requires: python3-tensorflow-quantum
%description
[](https://opensource.org/licenses/MIT)
[](https://github.com/firstcontributions/open-source-badges)
[](https://badge.fury.io/py/quple)
[](https://badge.fury.io/py/quple)
Quple is a framework for quantum machine learning based on the Google [Cirq](https://quantumai.google/cirq) and [TensorFlow Quantum](https://www.tensorflow.org/quantum) libraries. It contains implementation of a wide range of quantum machine learning algorithms, including:
- Variational Quantum Classifier (VQC)
- Quantum Support Vector Machine (QSVM)
- Quantum Convolutional Neural Network (QCNN)
- Quantum Generative Adversarial Network (QGAN)
Quple was originally developed for applications in high energy physics (HEP) analyses. The letter "Q" refers to the use of quantum computational methods in this framework. The homophone to the word "couple" references the concept in HEP which refers to the interaction between two objects - machine learning and high energy physics in this case.
Quple started as a Google Summer of Code (GSoC) project in 2020 and 2021 for the [ML4Sci](https://ml4sci.org/) umbrella organization. References to related projects can be found in the descriptions below.
## Installing the package
To install the current release, simply do
```
pip install quple
```
## Tutorials
For GSoC 2020:
### Tutorial-01 Quantum Circuit
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T01-Quantum_Circuit.ipynb)
### Tutorial-02 Parameterised Quantum Circuit (PQC)
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T02-Parameterised_Circuit.ipynb)
### Tutorial-03 Interaction Graphs
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T03-Interaction_Graphs.ipynb)
### Tutorial-04 Encoding Function
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T04-Encoding_Map.ipynb)
### Tutorial-05 Encoding Circuit
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T05-Encoding_Circuit.ipynb)
### Tutorial-06 Variational Circuit
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T06-Variational_Circuit.ipynb)
### Tutorial-07 Circuit Descriptors
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T07-Circuit_Descriptors.ipynb)
### Tutorial-08 Variational Quantum Classifier
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T08-Variational_Quantum_Classifier.ipynb)
For GSoC 2021:
### Tutorial-09 Parameterized Quantum Circuit (PQC) layer
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T09-PQC_layer.ipynb)
### Tutorial-10 Quantum Convolution 2D (QConv2D) layer
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T10-QConv2D_layer.ipynb)
### Tutorial-11 Quantum Generative Adversarial Network (QGAN)
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T11-Quantum_Generative_Adversarial_Network.ipynb)
### Advanced Tutorial-01 QGAN High Energy Physics Application
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/A01-QGAN_HEP_application.ipynb)
## GSoC 2020 : Quple
The project archive can be found [here](https://summerofcode.withgoogle.com/archive/2020/projects/5091840300154880/).
For documentation and report, please check [here](https://gitlab.cern.ch/clcheng/quple/-/blob/master/docs/Quple_GSoC_report.pdf).
## GSoC 2021 : Quple - Quantum GAN
The proposed project **Quple - Quantum GAN** serves as an extension to the 2020 GSoC project with a major focus on the implementation of Quantum Generative Adversarial Networks (QGAN).
In this project, two major concepts are developed:
- Quantum convolution using quantum filters (QFilter)
- Quantum image generation and discrimination based on quantum convolution
### Quantum Convolution using Quantum Filters
Relevant tutorial notebooks: [Tutorial 09](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T09-PQC_layer.ipynb), [Tutorial 10](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T10-QConv2D_layer.ipynb).
Quantum convolution uses a **quantum filter** as the basic building block. It replaces the classical filter by a Parameterised Quantum Circuit (PQC) which scan across the local regions (the receptive field) of an image.
In the classical case, an output pixel value (neuron) that are connected to a local region in the input image is computed as the dot product between the kernel weights of the classical filter and the pixel values in the local region.
In the quantum case, a quantum filter transforms the pixel values in the local region into the quantum states of its data circuit via a suitable feature map, hence projecting the data into a higher dimensional quantum (Hilbert) space. The quantum states are then propagated to the model circuit of the quantum filter which undergoes a sequence parameterised gate operations and outputs the expectation value of a given measurement operator.
Implementation of the above concept is done via the `QConv2D` class with API similar to the `tf.keras.layers.Conv2D` class. It borrows common concepts in traditional convolution such as `filters`, `kernel_size`, `strides` and `padding`.
Note that the `kernel_size` of a quantum filter does not refer to the number of trainable weights in the quantum filter but instead to the dimensions of the receptive field passed to the data circuit.
### Quantum Image Generation and Discrimination
Relevant tutorial notebooks: [Tutorial 11](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T11-Quantum_Generative_Adversarial_Network.ipynb)
The essence of a quantum version of the Generative Adversarial Network (GAN) is to replace the generator and discriminator neural networks with quantum neural networks made up of parameterized quantum circuits (PQCs).
Both quantum generator and discriminator neural networks consist of two key components. The first component is a data encoding circuit (i.e. the **input layer**) that maps classical input data <img src="https://render.githubusercontent.com/render/math?math=x\in \mathbb{R}^N"> of <img src="https://render.githubusercontent.com/render/math?math=N"> variables into a quantum state <img src="https://render.githubusercontent.com/render/math?math=|\Phi(x)\rangle = U_{\Phi(x)}|0\rangle^N"> using a quantum feature map <img src="https://render.githubusercontent.com/render/math?math=\Phi(\mathbf{x})">. The quantum state is then passed to a PQC layer (represented by the circuit ($W(\theta)$) made up of a series of parameterized local single-qubit rotations <img src="https://render.githubusercontent.com/render/math?math=U_{\text{loc}}(\boldsymbol{\theta})"> and two-qubit entagling operations in which the circuit parameters represent the weights of a neural network.
A pure quantum neural network therefore represents the combined circuit operation <img src="https://render.githubusercontent.com/render/math?math=W(\boldsymbol{\theta}) | \Phi(\mathbf{x})\rangle">.
Finally a total of <img src="https://render.githubusercontent.com/render/math?math=R"> (repetitions) of measurements (via a measurement operator <img src="https://render.githubusercontent.com/render/math?math=M_i"> which usually is the Pauli <img src="https://render.githubusercontent.com/render/math?math=Z"> operator acting on the i-th qubit) is made on one or multiple qubits of the combined circuit to measure the expectation values <img src="https://render.githubusercontent.com/render/math?math=P_i(\mathbf{x}) = \langle \Phi(\mathbf{x}) | W(\theta)^\dagger M_i W(\boldsymbol{\theta})|\Phi(\mathbf{x})\rangle">.
### Application of GAN to HEP - Generation of Electromagnetic Calorimeter Energy Deposition
Relevant tutorial notebooks: [Advanced Tutorial 01](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/A01-QGAN_HEP_application.ipynb).
The dataset of interest is a set of 32 x 32 images that represent the energy deposition on the detector cells of an electromagnetic calorimeter (ECAL).
The local geometry of the energy deposition contains information about the properties of the particles that went through the detector cells which is crucial in identifying the particles of origin.
In this particular dataset, two class of particles are involved: photons (class label "0") and electrons (class label "1"). Each image correspond to a single particle of origin, either photon or electron. In total, there are 498,000 samples, equally distributed between the two classes.
The goal of a quantum GAN model in this case would be to generate images that simulate the given photon/electron images.
One potential application of this model would be to perform fast simulation of ECAL enery deposition which can be used as an alternative to standard Monte Carlo simulators like GEANT4. This is especially useful when the requirement on the quality of the generated samples are less stringent such as for evaluation of ECAL related systematics uncertainties.
Example photon images:
<img src="notebooks/images/image_photon_energy_32x32.png">
Example electron images:
<img src="notebooks/images/image_electron_energy_32x32.png">
The effective size of the images is roughly 8x8, so for demonstration purpose a cropped version of the images are used:
<img src="notebooks/images/image_photon_energy_8x8.png">
Some example training outputs using the `QGAN` class from Quple:
- GAN with quantum generator + quantum discriminator using the modified mini-max loss function:
<img src="notebooks/images/QGAN_Photon_8x8.gif">
- GAN with quantum generator + quantum discriminator using the Wasserstein loss function:
<img src="notebooks/images/QWGAN_Photon_8x8.gif">
%package -n python3-quple
Summary: A framework for quantum machine learning in high energy physics
Provides: python-quple
BuildRequires: python3-devel
BuildRequires: python3-setuptools
BuildRequires: python3-pip
%description -n python3-quple
[](https://opensource.org/licenses/MIT)
[](https://github.com/firstcontributions/open-source-badges)
[](https://badge.fury.io/py/quple)
[](https://badge.fury.io/py/quple)
Quple is a framework for quantum machine learning based on the Google [Cirq](https://quantumai.google/cirq) and [TensorFlow Quantum](https://www.tensorflow.org/quantum) libraries. It contains implementation of a wide range of quantum machine learning algorithms, including:
- Variational Quantum Classifier (VQC)
- Quantum Support Vector Machine (QSVM)
- Quantum Convolutional Neural Network (QCNN)
- Quantum Generative Adversarial Network (QGAN)
Quple was originally developed for applications in high energy physics (HEP) analyses. The letter "Q" refers to the use of quantum computational methods in this framework. The homophone to the word "couple" references the concept in HEP which refers to the interaction between two objects - machine learning and high energy physics in this case.
Quple started as a Google Summer of Code (GSoC) project in 2020 and 2021 for the [ML4Sci](https://ml4sci.org/) umbrella organization. References to related projects can be found in the descriptions below.
## Installing the package
To install the current release, simply do
```
pip install quple
```
## Tutorials
For GSoC 2020:
### Tutorial-01 Quantum Circuit
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T01-Quantum_Circuit.ipynb)
### Tutorial-02 Parameterised Quantum Circuit (PQC)
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T02-Parameterised_Circuit.ipynb)
### Tutorial-03 Interaction Graphs
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T03-Interaction_Graphs.ipynb)
### Tutorial-04 Encoding Function
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T04-Encoding_Map.ipynb)
### Tutorial-05 Encoding Circuit
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T05-Encoding_Circuit.ipynb)
### Tutorial-06 Variational Circuit
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T06-Variational_Circuit.ipynb)
### Tutorial-07 Circuit Descriptors
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T07-Circuit_Descriptors.ipynb)
### Tutorial-08 Variational Quantum Classifier
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T08-Variational_Quantum_Classifier.ipynb)
For GSoC 2021:
### Tutorial-09 Parameterized Quantum Circuit (PQC) layer
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T09-PQC_layer.ipynb)
### Tutorial-10 Quantum Convolution 2D (QConv2D) layer
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T10-QConv2D_layer.ipynb)
### Tutorial-11 Quantum Generative Adversarial Network (QGAN)
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T11-Quantum_Generative_Adversarial_Network.ipynb)
### Advanced Tutorial-01 QGAN High Energy Physics Application
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/A01-QGAN_HEP_application.ipynb)
## GSoC 2020 : Quple
The project archive can be found [here](https://summerofcode.withgoogle.com/archive/2020/projects/5091840300154880/).
For documentation and report, please check [here](https://gitlab.cern.ch/clcheng/quple/-/blob/master/docs/Quple_GSoC_report.pdf).
## GSoC 2021 : Quple - Quantum GAN
The proposed project **Quple - Quantum GAN** serves as an extension to the 2020 GSoC project with a major focus on the implementation of Quantum Generative Adversarial Networks (QGAN).
In this project, two major concepts are developed:
- Quantum convolution using quantum filters (QFilter)
- Quantum image generation and discrimination based on quantum convolution
### Quantum Convolution using Quantum Filters
Relevant tutorial notebooks: [Tutorial 09](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T09-PQC_layer.ipynb), [Tutorial 10](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T10-QConv2D_layer.ipynb).
Quantum convolution uses a **quantum filter** as the basic building block. It replaces the classical filter by a Parameterised Quantum Circuit (PQC) which scan across the local regions (the receptive field) of an image.
In the classical case, an output pixel value (neuron) that are connected to a local region in the input image is computed as the dot product between the kernel weights of the classical filter and the pixel values in the local region.
In the quantum case, a quantum filter transforms the pixel values in the local region into the quantum states of its data circuit via a suitable feature map, hence projecting the data into a higher dimensional quantum (Hilbert) space. The quantum states are then propagated to the model circuit of the quantum filter which undergoes a sequence parameterised gate operations and outputs the expectation value of a given measurement operator.
Implementation of the above concept is done via the `QConv2D` class with API similar to the `tf.keras.layers.Conv2D` class. It borrows common concepts in traditional convolution such as `filters`, `kernel_size`, `strides` and `padding`.
Note that the `kernel_size` of a quantum filter does not refer to the number of trainable weights in the quantum filter but instead to the dimensions of the receptive field passed to the data circuit.
### Quantum Image Generation and Discrimination
Relevant tutorial notebooks: [Tutorial 11](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T11-Quantum_Generative_Adversarial_Network.ipynb)
The essence of a quantum version of the Generative Adversarial Network (GAN) is to replace the generator and discriminator neural networks with quantum neural networks made up of parameterized quantum circuits (PQCs).
Both quantum generator and discriminator neural networks consist of two key components. The first component is a data encoding circuit (i.e. the **input layer**) that maps classical input data <img src="https://render.githubusercontent.com/render/math?math=x\in \mathbb{R}^N"> of <img src="https://render.githubusercontent.com/render/math?math=N"> variables into a quantum state <img src="https://render.githubusercontent.com/render/math?math=|\Phi(x)\rangle = U_{\Phi(x)}|0\rangle^N"> using a quantum feature map <img src="https://render.githubusercontent.com/render/math?math=\Phi(\mathbf{x})">. The quantum state is then passed to a PQC layer (represented by the circuit ($W(\theta)$) made up of a series of parameterized local single-qubit rotations <img src="https://render.githubusercontent.com/render/math?math=U_{\text{loc}}(\boldsymbol{\theta})"> and two-qubit entagling operations in which the circuit parameters represent the weights of a neural network.
A pure quantum neural network therefore represents the combined circuit operation <img src="https://render.githubusercontent.com/render/math?math=W(\boldsymbol{\theta}) | \Phi(\mathbf{x})\rangle">.
Finally a total of <img src="https://render.githubusercontent.com/render/math?math=R"> (repetitions) of measurements (via a measurement operator <img src="https://render.githubusercontent.com/render/math?math=M_i"> which usually is the Pauli <img src="https://render.githubusercontent.com/render/math?math=Z"> operator acting on the i-th qubit) is made on one or multiple qubits of the combined circuit to measure the expectation values <img src="https://render.githubusercontent.com/render/math?math=P_i(\mathbf{x}) = \langle \Phi(\mathbf{x}) | W(\theta)^\dagger M_i W(\boldsymbol{\theta})|\Phi(\mathbf{x})\rangle">.
### Application of GAN to HEP - Generation of Electromagnetic Calorimeter Energy Deposition
Relevant tutorial notebooks: [Advanced Tutorial 01](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/A01-QGAN_HEP_application.ipynb).
The dataset of interest is a set of 32 x 32 images that represent the energy deposition on the detector cells of an electromagnetic calorimeter (ECAL).
The local geometry of the energy deposition contains information about the properties of the particles that went through the detector cells which is crucial in identifying the particles of origin.
In this particular dataset, two class of particles are involved: photons (class label "0") and electrons (class label "1"). Each image correspond to a single particle of origin, either photon or electron. In total, there are 498,000 samples, equally distributed between the two classes.
The goal of a quantum GAN model in this case would be to generate images that simulate the given photon/electron images.
One potential application of this model would be to perform fast simulation of ECAL enery deposition which can be used as an alternative to standard Monte Carlo simulators like GEANT4. This is especially useful when the requirement on the quality of the generated samples are less stringent such as for evaluation of ECAL related systematics uncertainties.
Example photon images:
<img src="notebooks/images/image_photon_energy_32x32.png">
Example electron images:
<img src="notebooks/images/image_electron_energy_32x32.png">
The effective size of the images is roughly 8x8, so for demonstration purpose a cropped version of the images are used:
<img src="notebooks/images/image_photon_energy_8x8.png">
Some example training outputs using the `QGAN` class from Quple:
- GAN with quantum generator + quantum discriminator using the modified mini-max loss function:
<img src="notebooks/images/QGAN_Photon_8x8.gif">
- GAN with quantum generator + quantum discriminator using the Wasserstein loss function:
<img src="notebooks/images/QWGAN_Photon_8x8.gif">
%package help
Summary: Development documents and examples for quple
Provides: python3-quple-doc
%description help
[](https://opensource.org/licenses/MIT)
[](https://github.com/firstcontributions/open-source-badges)
[](https://badge.fury.io/py/quple)
[](https://badge.fury.io/py/quple)
Quple is a framework for quantum machine learning based on the Google [Cirq](https://quantumai.google/cirq) and [TensorFlow Quantum](https://www.tensorflow.org/quantum) libraries. It contains implementation of a wide range of quantum machine learning algorithms, including:
- Variational Quantum Classifier (VQC)
- Quantum Support Vector Machine (QSVM)
- Quantum Convolutional Neural Network (QCNN)
- Quantum Generative Adversarial Network (QGAN)
Quple was originally developed for applications in high energy physics (HEP) analyses. The letter "Q" refers to the use of quantum computational methods in this framework. The homophone to the word "couple" references the concept in HEP which refers to the interaction between two objects - machine learning and high energy physics in this case.
Quple started as a Google Summer of Code (GSoC) project in 2020 and 2021 for the [ML4Sci](https://ml4sci.org/) umbrella organization. References to related projects can be found in the descriptions below.
## Installing the package
To install the current release, simply do
```
pip install quple
```
## Tutorials
For GSoC 2020:
### Tutorial-01 Quantum Circuit
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T01-Quantum_Circuit.ipynb)
### Tutorial-02 Parameterised Quantum Circuit (PQC)
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T02-Parameterised_Circuit.ipynb)
### Tutorial-03 Interaction Graphs
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T03-Interaction_Graphs.ipynb)
### Tutorial-04 Encoding Function
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T04-Encoding_Map.ipynb)
### Tutorial-05 Encoding Circuit
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T05-Encoding_Circuit.ipynb)
### Tutorial-06 Variational Circuit
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T06-Variational_Circuit.ipynb)
### Tutorial-07 Circuit Descriptors
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T07-Circuit_Descriptors.ipynb)
### Tutorial-08 Variational Quantum Classifier
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T08-Variational_Quantum_Classifier.ipynb)
For GSoC 2021:
### Tutorial-09 Parameterized Quantum Circuit (PQC) layer
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T09-PQC_layer.ipynb)
### Tutorial-10 Quantum Convolution 2D (QConv2D) layer
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T10-QConv2D_layer.ipynb)
### Tutorial-11 Quantum Generative Adversarial Network (QGAN)
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T11-Quantum_Generative_Adversarial_Network.ipynb)
### Advanced Tutorial-01 QGAN High Energy Physics Application
* [](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/A01-QGAN_HEP_application.ipynb)
## GSoC 2020 : Quple
The project archive can be found [here](https://summerofcode.withgoogle.com/archive/2020/projects/5091840300154880/).
For documentation and report, please check [here](https://gitlab.cern.ch/clcheng/quple/-/blob/master/docs/Quple_GSoC_report.pdf).
## GSoC 2021 : Quple - Quantum GAN
The proposed project **Quple - Quantum GAN** serves as an extension to the 2020 GSoC project with a major focus on the implementation of Quantum Generative Adversarial Networks (QGAN).
In this project, two major concepts are developed:
- Quantum convolution using quantum filters (QFilter)
- Quantum image generation and discrimination based on quantum convolution
### Quantum Convolution using Quantum Filters
Relevant tutorial notebooks: [Tutorial 09](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T09-PQC_layer.ipynb), [Tutorial 10](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T10-QConv2D_layer.ipynb).
Quantum convolution uses a **quantum filter** as the basic building block. It replaces the classical filter by a Parameterised Quantum Circuit (PQC) which scan across the local regions (the receptive field) of an image.
In the classical case, an output pixel value (neuron) that are connected to a local region in the input image is computed as the dot product between the kernel weights of the classical filter and the pixel values in the local region.
In the quantum case, a quantum filter transforms the pixel values in the local region into the quantum states of its data circuit via a suitable feature map, hence projecting the data into a higher dimensional quantum (Hilbert) space. The quantum states are then propagated to the model circuit of the quantum filter which undergoes a sequence parameterised gate operations and outputs the expectation value of a given measurement operator.
Implementation of the above concept is done via the `QConv2D` class with API similar to the `tf.keras.layers.Conv2D` class. It borrows common concepts in traditional convolution such as `filters`, `kernel_size`, `strides` and `padding`.
Note that the `kernel_size` of a quantum filter does not refer to the number of trainable weights in the quantum filter but instead to the dimensions of the receptive field passed to the data circuit.
### Quantum Image Generation and Discrimination
Relevant tutorial notebooks: [Tutorial 11](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/T11-Quantum_Generative_Adversarial_Network.ipynb)
The essence of a quantum version of the Generative Adversarial Network (GAN) is to replace the generator and discriminator neural networks with quantum neural networks made up of parameterized quantum circuits (PQCs).
Both quantum generator and discriminator neural networks consist of two key components. The first component is a data encoding circuit (i.e. the **input layer**) that maps classical input data <img src="https://render.githubusercontent.com/render/math?math=x\in \mathbb{R}^N"> of <img src="https://render.githubusercontent.com/render/math?math=N"> variables into a quantum state <img src="https://render.githubusercontent.com/render/math?math=|\Phi(x)\rangle = U_{\Phi(x)}|0\rangle^N"> using a quantum feature map <img src="https://render.githubusercontent.com/render/math?math=\Phi(\mathbf{x})">. The quantum state is then passed to a PQC layer (represented by the circuit ($W(\theta)$) made up of a series of parameterized local single-qubit rotations <img src="https://render.githubusercontent.com/render/math?math=U_{\text{loc}}(\boldsymbol{\theta})"> and two-qubit entagling operations in which the circuit parameters represent the weights of a neural network.
A pure quantum neural network therefore represents the combined circuit operation <img src="https://render.githubusercontent.com/render/math?math=W(\boldsymbol{\theta}) | \Phi(\mathbf{x})\rangle">.
Finally a total of <img src="https://render.githubusercontent.com/render/math?math=R"> (repetitions) of measurements (via a measurement operator <img src="https://render.githubusercontent.com/render/math?math=M_i"> which usually is the Pauli <img src="https://render.githubusercontent.com/render/math?math=Z"> operator acting on the i-th qubit) is made on one or multiple qubits of the combined circuit to measure the expectation values <img src="https://render.githubusercontent.com/render/math?math=P_i(\mathbf{x}) = \langle \Phi(\mathbf{x}) | W(\theta)^\dagger M_i W(\boldsymbol{\theta})|\Phi(\mathbf{x})\rangle">.
### Application of GAN to HEP - Generation of Electromagnetic Calorimeter Energy Deposition
Relevant tutorial notebooks: [Advanced Tutorial 01](https://colab.research.google.com/github/AlkaidCheng/GSOC_MLHEP/blob/master/tutorials/A01-QGAN_HEP_application.ipynb).
The dataset of interest is a set of 32 x 32 images that represent the energy deposition on the detector cells of an electromagnetic calorimeter (ECAL).
The local geometry of the energy deposition contains information about the properties of the particles that went through the detector cells which is crucial in identifying the particles of origin.
In this particular dataset, two class of particles are involved: photons (class label "0") and electrons (class label "1"). Each image correspond to a single particle of origin, either photon or electron. In total, there are 498,000 samples, equally distributed between the two classes.
The goal of a quantum GAN model in this case would be to generate images that simulate the given photon/electron images.
One potential application of this model would be to perform fast simulation of ECAL enery deposition which can be used as an alternative to standard Monte Carlo simulators like GEANT4. This is especially useful when the requirement on the quality of the generated samples are less stringent such as for evaluation of ECAL related systematics uncertainties.
Example photon images:
<img src="notebooks/images/image_photon_energy_32x32.png">
Example electron images:
<img src="notebooks/images/image_electron_energy_32x32.png">
The effective size of the images is roughly 8x8, so for demonstration purpose a cropped version of the images are used:
<img src="notebooks/images/image_photon_energy_8x8.png">
Some example training outputs using the `QGAN` class from Quple:
- GAN with quantum generator + quantum discriminator using the modified mini-max loss function:
<img src="notebooks/images/QGAN_Photon_8x8.gif">
- GAN with quantum generator + quantum discriminator using the Wasserstein loss function:
<img src="notebooks/images/QWGAN_Photon_8x8.gif">
%prep
%autosetup -n quple-0.9.2.7
%build
%py3_build
%install
%py3_install
install -d -m755 %{buildroot}/%{_pkgdocdir}
if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
pushd %{buildroot}
if [ -d usr/lib ]; then
find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/lib64 ]; then
find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/bin ]; then
find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/sbin ]; then
find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst
fi
touch doclist.lst
if [ -d usr/share/man ]; then
find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst
fi
popd
mv %{buildroot}/filelist.lst .
mv %{buildroot}/doclist.lst .
%files -n python3-quple -f filelist.lst
%dir %{python3_sitelib}/*
%files help -f doclist.lst
%{_docdir}/*
%changelog
* Fri May 05 2023 Python_Bot <Python_Bot@openeuler.org> - 0.9.2.7-1
- Package Spec generated
|
