crtc.cs.odu.edu - User contributions [en]

Internal:Hybrid Computing

2024-09-10T21:01:12Z

Ebillias:

= Distributed Noisy Intermediate-Scale Quantum Computers (D-NISQ) =

The D-NISQ model presented by [1] describes a hierarchical architecture of hybrid classical/quantum processors to break up large computations into smaller sub problems. Resource management of limited qubits and noisy quantum computation make domain decomposition a necessary method to practically use many quantum algorithms. The D-NISQ model has four layers. Consider the application to Quantum Hadamard Edge Detection[2] qHED:

=== Decomposition Layer ===

The first layer is performed classically. Consider a 1024x1024 medical image. This comes out to 1,048,576 pixels requiring 20 (2^20) qubits plus 1 ancillary qubit for the QHED algorithm. Additionally, the amplitude encoding process expands exponentially with regards to qubit number. We can divide the image into separate sub images and solve either iteratively or in parallel (multithreading). Each sub image is now considered to be a sub input of the overall problem.

[[File:NaF-PROSTATE-01-0001_22.png|500px|thumb|none|Figure 1 Example of 1024x1024 Medical image decomposed into 256x256 sub images.]]

=== Classical to Quantum Layer ===

The second layer performs a mapping of classical input data to quantum. In this case, we wish to encode the pixel values into the amplitudes of basis states where those basis states act as the pixels position in 1D space[3]. The circuit is constructed classically (mathematically determining a series of gates which will produce the highest probable desired output) with the actual execution performed on the newly constructed quantum circuit itself.

=== Quantum Computation Layer ===

The states created in the second layer now act as the input to the quantum algorithm itself. If carried out in parallel, each quantum device will execute their respective inputs across the qHED circuit. If performed iteratively, the quantum devices will have to be reset after each execution.

[[File:Qhed circuit.png|500px|thumb|none|Figure 1 Generalized qHED Circuit with input vector f and output vector g.]]

=== Quantum Information Fusion ===

The D-NISQ model considers the measurement portion of the circuit as the first part of the quantum information layer. Multiple measurements of output states are collected to develop a probability distribution for each sub problem. That probability distribution is mapped as a solution to the respective sub problem. In the case of qHED, the probability amplitudes (pixel values) of basis states (pixels mapped to 1D space) represent the image edge values. In this case, a reverse mapping of 1D to 2D is required. From there, the sub problems are recombined into the final result.

= Quantum Utility Scale Repository =
https://github.com/ebill007/Quantum-Utility-Scale

= References =
[1] Acampora, Giovanni, et al. “D-NISQ: A Reference Model for Distributed Noisy Intermediate-Scale Quantum Computers.” Information Fusion, vol. 89, 2023, pp. 16–28., https://doi.org/10.1016/j.inffus.2022.08.003.

[2] .-W. Yao, H. Wang, Z. Liao, M.-C. Chen, J. Pan, J. Li, K. Zhang, X. Lin, Z. Wang, Z. Luo,
et al., Quantum image processing and its application to edge detection: Theory and experiment,
Physical Review X 7 (3) (2017). doi:10.1103/physrevx.7.031041.

[3]I. F. Araujo, D. K. Park, F. Petruccione, A. J. da Silva, A divide-and-conquer algo-
rithm for quantum state preparation, Scientific Reports 11 (1) (2021). doi:10.1038/
s41598-021-85474-1.

Software

2024-09-10T21:00:55Z

Ebillias: /* Quantum Utility Scale */

=CRTC I2M Software Suite=
[[CRTC_I2M]]

= Single layer of Telescopic Approach =

[[PDR.TetGen | Parallel Data Refinement using TetGen ]]

https://crtc.cs.odu.edu/PsC.AFLR

= Software Communications Protocol =
[[Software Communications Protocol]]

Internal:Hybrid Computing

2024-09-10T21:00:44Z

Ebillias:

= Distributed Noisy Intermediate-Scale Quantum Computers (D-NISQ) =

The D-NISQ model presented by [1] describes a hierarchical architecture of hybrid classical/quantum processors to break up large computations into smaller sub problems. Resource management of limited qubits and noisy quantum computation make domain decomposition a necessary method to practically use many quantum algorithms. The D-NISQ model has four layers. Consider the application to Quantum Hadamard Edge Detection[2] qHED:

=== Decomposition Layer ===

The first layer is performed classically. Consider a 1024x1024 medical image. This comes out to 1,048,576 pixels requiring 20 (2^20) qubits plus 1 ancillary qubit for the QHED algorithm. Additionally, the amplitude encoding process expands exponentially with regards to qubit number. We can divide the image into separate sub images and solve either iteratively or in parallel (multithreading). Each sub image is now considered to be a sub input of the overall problem.

[[File:NaF-PROSTATE-01-0001_22.png|500px|thumb|none|Figure 1 Example of 1024x1024 Medical image decomposed into 256x256 sub images.]]

=== Classical to Quantum Layer ===

The second layer performs a mapping of classical input data to quantum. In this case, we wish to encode the pixel values into the amplitudes of basis states where those basis states act as the pixels position in 1D space[3]. The circuit is constructed classically (mathematically determining a series of gates which will produce the highest probable desired output) with the actual execution performed on the newly constructed quantum circuit itself.

=== Quantum Computation Layer ===

The states created in the second layer now act as the input to the quantum algorithm itself. If carried out in parallel, each quantum device will execute their respective inputs across the qHED circuit. If performed iteratively, the quantum devices will have to be reset after each execution.

[[File:Qhed circuit.png|500px|thumb|none|Figure 1 Generalized qHED Circuit with input vector f and output vector g.]]

=== Quantum Information Fusion ===

The D-NISQ model considers the measurement portion of the circuit as the first part of the quantum information layer. Multiple measurements of output states are collected to develop a probability distribution for each sub problem. That probability distribution is mapped as a solution to the respective sub problem. In the case of qHED, the probability amplitudes (pixel values) of basis states (pixels mapped to 1D space) represent the image edge values. In this case, a reverse mapping of 1D to 2D is required. From there, the sub problems are recombined into the final result.

= Quantum Utility Scale Repository =
https://github.com/ebill007/Quantum-Utility-Scale

== References ==
[1] Acampora, Giovanni, et al. “D-NISQ: A Reference Model for Distributed Noisy Intermediate-Scale Quantum Computers.” Information Fusion, vol. 89, 2023, pp. 16–28., https://doi.org/10.1016/j.inffus.2022.08.003.

[2] .-W. Yao, H. Wang, Z. Liao, M.-C. Chen, J. Pan, J. Li, K. Zhang, X. Lin, Z. Wang, Z. Luo,
et al., Quantum image processing and its application to edge detection: Theory and experiment,
Physical Review X 7 (3) (2017). doi:10.1103/physrevx.7.031041.

[3]I. F. Araujo, D. K. Park, F. Petruccione, A. J. da Silva, A divide-and-conquer algo-
rithm for quantum state preparation, Scientific Reports 11 (1) (2021). doi:10.1038/
s41598-021-85474-1.

Software

2024-09-03T22:54:55Z

Ebillias:

Internal:Quantum Natural Language Processing

2023-09-28T21:59:08Z

Ebillias: Created page with "= Background = Much of modern NLP seems to stem from the parsing then subsequent vectorization of natural language inputs. As is the common case with quantum computing, if we..."

= Background =

Much of modern NLP seems to stem from the parsing then subsequent vectorization of natural language inputs. As is the common case with quantum computing, if we can frame our input data as a vector then we can process that data using unitary operations. With vectorized data, linear operations can be performed on that data. This leaves an obvious opening for the application of QML techniques.

This semester's project has the following goals:

*Apply a QNLP framework to the DNISQ model. This first step should not be too rigorous as the distribution of decomposed domains is something with which we already have experience.
*Find a way to contribute to a model on the quantum side of a framework (an optimized ansatz, encoding methodology, application to noisy circuits, etc.)

Apart from the distribution, I will more or less shy away from any contribution on the classical side of the framework (such as tokenization or parsing).

= Literature =
== [1] lambeq: An Efficient High-Level Python Library for Quantum NLP ==
Dimitri Kartsaklis, Ian Fan, Richie Yeung, Anna Pearson, Robin Lorenz, Alexis Toumi, Giovanni de Felice, Konstantinos Meichanetzidis, Stephen Clark, Bob Coecke
https://arxiv.org/pdf/2110.04236.pdf

lambeq is a high-level, open source python library used for experimental QNLP which can be found here[https://github.com/CQCL/lambeq/tree/main#lambeq].

Internal:Student Reports

2023-09-28T21:43:12Z

Ebillias: /* Emmanuel */

== Current Students ==

=== Polykarpos ===
[[PREMA Shared Memory]]

[[Internal:IMR_2018_Runtime_Systems | IMR 2018 Runtime Systems]]

[[Intel Xeon Phi and High Bandwidth Memory]]

[[CNF:Machine_Learning | CNF Machine Learning Project]]

[[CNF:ML_Data_Denoise | Track denoising with ML]]

[https://docs.google.com/presentation/d/1rF3rElnBCsKR_Z_66nTCmMqSZa3b51mEzswiLz_3d3Q/edit?usp=sharing CNF HPC Workshop Slides]

[[PREMA SW4| SW4 Benchmark with PREMA]]

[[PDR.PODM Distributed Memory| PDR.PODM.PREMA]]

[https://www.overleaf.com/read/vgwrypshrkqp PREMA-Argobots Paper]

[https://olddominion-my.sharepoint.com/:b:/g/personal/pthom001_odu_edu/EYiL4h5xKThJgjyvbsFbZe4BH_4pr3rR-9x-gvErpDaq3A?e=hdy7ii Heterogeneousarchitecturesforcomputationalintensiveapplications:Acost-effectivenessanalysis]

[[Internal:TAPAS]]

=== Kevin ===
[[Internal:PDR_AFLR |PDR.AFLR Stability and Scalability]]

[[Internal:PDR_AFLR_Progress_Report |PDR.AFLR Progress Report]]

[[AFLR_Point_Spacing/Distribution_Function_Parameters | AFLR Point Spacing/Distribution Function Parameters]]

[[Internal:PDR_AFLR_Performance_Testing |PDR.AFLR Performance Testing]]

[[Internal:PDR_AFLR_Performance_AIAA |AIAA PDR.AFLR Performance Data]]

[[Internal:Report_Status |Report Status]]

[[Internal:PsC_AFLR_Performance |PsC.AFLR Performance Data]]

[[Internal:Next_Generation_Boundary_Layer |Next Generation Boundary Layer]]

[[Internal:CDT3D_GPU_Smoothing | CDT3D GPU Smoothing]]

[[Internal:Distributed_CDT3D_Notes | Distributed CDT3D Notes]]

[[Internal:Weekly_Notes | Weekly Notes]]

[[Internal:I2M_Notes | Image-to-Mesh Conversion Project Notes]]

=== Emmanuel ===
[[Internal:Quantum Information Science (QIS General) |Quantum Information Science (QIS General)]]

[[Internal:Quantum_Edge_Detection |Quantum Edge Detection]]

[[Internal:Hybrid Computing |Hybrid Computing]]

[[Internal:Quantum Machine Learning |Quantum Machine Learning]]

[[Internal:Quantum Natural Language Processing |Quantum Natural Language Processing]]

=== Chris ===

[[Internal:QHD | Quantum Hausdorff Distance (QHD)]]

[[Internal:QED | Quantum Edge Detection (QED)]]

[[Internal:DQHED |Distributed Hadamard Quantum Edge Detection (DQHED)]]

[[Internal:QNEM |Quantum Nested Expectation Maximization (QNEM)]]

[[Internal:QCED |Quantum Canny Edge Detection (QCED)]]

[[Internal:Quantum_PDEs |Quantum PDEs]]

[[Internal:weekly_report_rector |Weekly Report]]

=== Devon ===
[[Internal:Quantum_Clustering |Quantum Clustering]]

== Former Students ==

=== Angelos ===

[[Internal:GPCD | GPCD]]

[[Internal:APBNRRExecutionStatus | APBNRR Execution Status]]

[[Internal:PAPBNRRComparison | Pristine vs New PAPBNRR]]

[[Internal:APBNRRMachineLearning | APBNRR Machine Learning]]

[[Internal: SlicerExtensions | Slicer Extensions]]

=== Christos ===
'''[https://olddominion-my.sharepoint.com/:f:/r/personal/nchrisoc_odu_edu/Documents/From_Box/CRTC_Students/ChristosT/papers All papers]'''

'''[https://olddominion-my.sharepoint.com/:f:/r/personal/nchrisoc_odu_edu/Documents/From_Box/CRTC_Students/ChristosT/presentations All presentations]'''

<hr>

[https://olddominion-my.sharepoint.com/:b:/r/personal/nchrisoc_odu_edu/Documents/From_Box/CRTC_Students/ChristosT/dissertation/christos_dissertation.pdf Dissertation .pdf]

[https://www.overleaf.com/6438559258mdmsnbpffztx speculative meshing operations using tasks paper - overleaf]

[https://www.overleaf.com/3459466599cnnfkhzmkczs Adaptive CDT3D paper - overleaf]

[https://www.overleaf.com/8242192311zntgrtsphkvv Parallel Grid Adaptation Paper (UGAWG) - overleaf ]

[[Internal:Adaptive_Meshing_For_APBNRR]]

[https://docs.google.com/presentation/d/1Fjt5PoDPXa715nOAjn0F4IJpdhscIGnlaQvweqFnB0U Adaptivity PPoSS slides]

[https://docs.google.com/presentation/d/1RDtQufImuo5J1pKioIYDuTWCeX1UtjKyx7kQ2i24Tmo/edit?usp=sharing CNF HPC slides]

[https://git-community.cs.odu.edu/nikos/SciTech_2019/blob/draft/main.pdf Scitech Journal paper latest draft]

[https://olddominion-my.sharepoint.com/:b:/r/personal/nchrisoc_odu_edu/Documents/From_Box/CRTC_Students/ChristosT/candidacy_exam/cand_exam.pdf Candidacy exam (document)]
[https://olddominion-my.sharepoint.com/:p:/r/personal/nchrisoc_odu_edu/Documents/From_Box/CRTC_Students/ChristosT/candidacy_exam/PhD_Candidacy_presentation.pptx (presentation .pptx)]
[https://olddominion-my.sharepoint.com/:b:/r/personal/nchrisoc_odu_edu/Documents/From_Box/CRTC_Students/ChristosT/candidacy_exam/PhD_Candidacy%20_presentation.pdf (presentation pdf)]

[[Internal:Adaptive_CDT3D_Results | Metric Adaptive CDT3D results]]

[[Internal:Argobots_and_CDT3D | Argobots and CDT3D]]

[[Internal:4D_Predicates_Benchmark | 4D predicates benchmark]]

[[CNF:Mesh Sizing for CNF data]]

[[Internal:ACDT3D | Metric Adaptive CDT3D Notes ]]

[https://olddominion-my.sharepoint.com/:b:/r/personal/nchrisoc_odu_edu/Documents/frombox/CRTC_Students/ChristosT/candidacy_exam/paper.pdf Parallel Mesh Generation review paper]

[https://lbpw.larc.nasa.gov/ AIAA Sonic Boom Prediction Workshop (next in 2020)]

[[Internal:CDT3D_SU2 | SU2 and grid requirements ]]

[[Internal:Boundary_Layer_References | Boundary Layer References ]]

[[External:Mesh_Generation_Articles_In_Journals | Some Mesh Generation Journal papers]]

[https://docs.google.com/document/d/1txyCu6ibheH19hi3nZ10LgHm-WzglUrT5y0AaO__VYk/edit?usp=sharing PhD Tentative Shedule]

[https://odu.box.com/s/sfkd5l3d9r5865qbsovx0eo6gwlaiask Poster IMR]

[https://odu.box.com/s/1sok1edideblq4nctbufg79vud0oiu8f NIA presentation (September 2018) ]

[[Internal:IMR_2018_Short_Course | IMR 2018 Short Course notes]]

[[Internal:ACDT3D_Scitech2018 | SciTech 2018]]

[[Internal:Machine_Learning_CDT3D | Machine Learning and CDT3D]]

[[Internal:AIAA_2018_CDT3D | CDT3D AIAA Aviation Paper ]]

[[Internal:PODM4D_predicates | PODM4D fine grain concurrency benchmark ]]

[[Internal:AIAA_Geometry_and_Mesh_Generation_Workshop | Geometry and Mesh Generation Workshop ]]

[[Internal:CDT3D_RoadMap |CDT3D RoadMap]]

[[Internal:Computational_Resources | High capacity Computational Resources ]]

[[NDAM:Main | PODM 4D and Anisotropy ]]

[https://docs.google.com/document/d/1jzTiohDA51VHXc65tfIFkmjrKM_8yQn7YYj2txEyhyU MPI PDR.PODM 16,000 cores data and other]

=== Spiros ===
'''Image-To-Mesh Conversion Projects'''

[[Internal:Tessellate_2D | Tessellate 2D]]

[[Internal:PODM_3D | PODM 3D]]

[[Internal:PODM_4D | PODM 4D]]

'''BioInformatics Projects'''

[[Internal:GPCD | GPCD]]

'''Contrained Mesh Refinement Projects'''

[[Internal:CDT3D_GPU_Smoothing | CDT3D GPU Smoothing]]

'''CNF Related Projects'''

[[CNF:CNF_Data_Generation | CNF Data Generation]]

[[CNF:Monte_Carlo_Event_Generator_using_a_Tessellation | Monte Carlo Event Generator using a Tessellation]]

[[CNF:Smart_LookUp_Table_Utilities | Smart LookUp Table Utilities]]

[[CNF:PartonsToNRRD | PartonsToNRRD]]

[[CNF:Weighted_Mesh_To_Image | Weighted Mesh To Image]]

[[Internal:TetGen_CNF | TetGen CNF]]

'''Utilities Projects'''

[[Internal:Synthetical_Image_Data_Generator | Synthetical Image Data Generator]]

[[Internal:MeshIO | MeshIO]]

'''Other Projects'''

[[Internal:PDM_ND | PDM ND]]

[[Internal:GPU_Usage | GPU Usage]]

=== Medical Imaging SubGroup (Eleni, Thomas , Angelos) ===
[[Internal:ReportCloud | Cloud Report]]

[[Internal:Preprocess_Medical_Images | Preprocessing of Medical Images]]

[[Internal:Execution_And_Evaluation_Medical_Images | Execution and Evaluation of Medical Imaging data]]

=== Joi ===
[[Tasks | Tasks ]]

[[I2M_Conversion_Tool | Image-to-Mesh (I2M) Conversion Tool]]

[[3D_Slicer_CBC3D_Extension | 3D Slicer CBC3D Extension ]]

'''Reports'''

[[CNF:CNF_Adaptivity | CNF Adaptivity]]

== General ==

===Conference Slides ===
[https://odu.box.com/s/vev5nqudpd5yq143xfq99y7b8uyf0j4e AI in Nuclear Physics 2020]

=== Proposal Resources ===
[[Internal:NSF_PPOSS_Funded_Proposals]]

===Notes ===
[[Internal:CNF_Workshop]]

[[Internal:CNF_HPC_Workshop_2019]]

[[Internal:Kokkos_Tutorial_2020_02_19]]

[[Internal:Intel_OneAPI_Tutorial_2020_02_20]]

=== Papers ===
[http://www.cs.odu.edu/crtc/internal/papers/O'Connell_et_al._-_2018_-_Application_of_the_Dependency_Inversion_Principle_.pdf T-infinity: The Dependency Inversion Principle for Rapid and Sustainable Multidisciplinary Software Development]

[https://hal.inria.fr/hal-01927559 Meshless Voronoi on the GPU, Nicolas Ray,Dmitry Sokolov,Sylvain Lefebvre,Bruno Lévy]

[http://pages.saclay.inria.fr/frederic.alauzet/TetrahedronVI/Slides_Tetrahedron_VI/Thursday/Mike_Park_ugawg-tet-talk.pdf Democratizing Mesh Adaptation forComputational Fluid Dynamics Michael Park]

[[Internal:Hashing_Meshes]]

=== Videos ===
[https://www.youtube.com/watch?v=pn7IqhOEGpY Using Graphs for Unstructured Data (Keshav Pingali)]

[https://www.youtube.com/watch?v=RZ09uZs1ynA Big Data Brain Maps at Argonne National Laboratory (Bobby Kasthuri), ATPESC 2017]

=== Other ===
http://livingreview.in.tum.de/welcome/

=== CRTC lab Virtual meetings ===
* 2020.01.18 - Christos
:* Unified Approach for Speculative Operations, [https://docs.google.com/presentation/d/1haL6NVwZzRVG0W71KoWmqLKgxkf6to2sUsdTH5Xn4kw (presentation)], [https://olddominion-my.sharepoint.com/:f:/r/personal/ctsol001_odu_edu/Documents/Parallel_Operations?csf=1&web=1&e=hQ8rPg (shared directory)]

* 2021.02.03 - Kevin & Spiros
:* Introduction to GPU Parallelism, [https://drive.google.com/file/d/1vW3VJXi04JB2N7XpVoNnXXSNv4i1Pnet/view?usp=sharing (presentation)]

* 2021.02.10 - Kevin & Spiros
:* GPU Architecture, [https://drive.google.com/file/d/1LfDwsbdscSpTk3eBT74lfIlSyD-W_Zwh/view?usp=sharing (presentation)]

Internal:Quantum Machine Learning

2023-08-02T20:18:23Z

Ebillias: /* March 27, 2023 */

= Progress =

== March 21, 2023 ==

Many of these models require a hybrid approach. Brookhaven, for example, uses a distributed series of VQC's which then feed data to a classical NN to attain results. Others use a method more in line with Cirq where the input parameters are fed into a classical NN which then produces the parameters required for the VQC. This seems almost redundant UNLESS the input data is so large that classification via classical CNN is so computationally expensive that a regular NN plus VQC is somehow "cheaper". I am not sure if our 4,032 pixel data constitutes. I am required to accomplish two distinct goals with this project:

1. Distinguish myself by using a Quantum particle data classifier which has not been seen before.

2. The product of 1. must have some utility

In regards to the Qiskit QCNN method of attaining results on the particle data we find two main problems:

* The 36x112 feature particle data is too large to use any pauli mapping so we are reliant on a 12 qubit amplitude encoding circuit. This circuit trains extremely slow even with the use of GPU's. Optimizations need to be discovered in order to make progress with this area. With that being said, for small sample sizes we achieve good results (+90%).

* The 6 feature data encoded with the same Pauli methods attain very poor results as shown below.

There exists a few solutions to the 36x112 feature problem number:

* We can interpolate the data to smaller amplitude encoded circuits such as 8 qubits. Doing so achieves respectable results (+80% accuracy) for smaller datasets (under 1000 samples). For larger datasets training time is drastically increased and progress towards a minimum is slowed and we are back to the first problem again.

* We find ways of optimizing the circuits for training. Qiskit allegedly has several "fast" sampling methods. Learning the modules and applying a few test runs should determine if the full 12 qubits can be encoded correctly.

I propose a series of problems to solve where, if solved, any one of them will be both distinguishable and possess utility:

* We can optimize training the Qiskit circuits. There are other ways to produce the required results.
** Seen here[https://qiskit.org/documentation/tutorials/simulators/7_matrix_product_state_method.html] a 50 qubit EPR state is sampled in 0.1 seconds. There are fast sampling methods built in. If these can be sent to the optimizer as a Quantum_Instance (in the same way we use the GPU) then I can simulate a wide variety of large circuits very quickly. This will allow for a more "pure" QCNN than those seen in other papers as well as having the utility of being run on real hardware (in the near future maybe!).

* The dissertation written by Jonas Landman from University of Paris proposes intersting QNN architectures such as the NISQ algorithm for Orthogonal Neural Networks. This uses a connected series of quantum VQC's which replicate a classical neural network. Using this architecture could very well provide real results on the 6 feature data (or interpolated 36x112 feature).

* Much like a combination of Jonas Landman and the Brookhaven paper, I could construct my own series of Quantum circuits which act as a distributed Neural network. A layer of circuits produce an output which are then fed into the next layer of circuits. In this case, the circuits act as both the Nodes and carry the weights in a classical sense. This gives far more parameters to work with using "less" qubits per circuit. This means, with a sufficient distribution, every datapoint will be encoded into it's own qubit even for the 36x112 feature data. +4,000 qubits won't be an issue if they're broken up into sufficiently small circuits with distributed calculations.

== March 27, 2023 ==

From last week, two major problems are solved:

1. The 6 feature data will not produce reasonable results (possibly due to the loss of locality?). However, the 4032 feature data can be resized using:

cv2.resize(samples, dsize=(n, len(samples)), interpolation=cv2.INTER_AREA)

See [https://medium.com/@wenrudong/what-is-opencvs-inter-area-actually-doing-282a626a09b3] for INTER_AREA

This allows for resizing of the image to fit some n number of pixels without loosing any of the data points to full degredation (all 0 pixel values). This resizing will allow for the training of networks using pauli feature mapping (because cv2.INTER_AREA preserves some of the locality?). This not only greatly decreases training times and quickens convergence, but also increases the accuracy of result.

2. The GPU implementation only requires a few lines of code to be optimized:

try:
simulator_gpu = Aer.get_backend('aer_simulator')
simulator_gpu.set_options(device='GPU', precision='single')
except AerError as e:
print('GPU Err:\n',e)

Take note that for certain feature mapping and ansatz implementations the GPU may be slower than a CPU if an insufficient number of qubits is used.

Using the following we are able to produce a very rudimentary VQC with two parts; a feature mapping and ansatz. Using everything we learned we can achieve an accuracy of +98% for previously unseen testing data in 30 iterations, training time under 2 minutes, 0.01% of the data used for training. This is done with n number of qubits/features to be 6 or 8.

So far, there is no need for a complex distributed network, hybridization, or complex QCNN classification models. The following goal is to either discover or create a more "complete" ansatz which can cover as much of the hilbert space as possible. Doing so should bump us up to +99% with a mere few minutes of training time

== March 31, 2023 ==

Heavily influenced by REfs. [1, 2, 3] as well as Jonas Landman, we can create a distributed Quantum Neural Network for particle classification. The image below, from Ref. [1], can be thought of a two layer QNN.

[[File:Scalable_qnn.png|600px]]

=== Encoding ===
The first layer is encoded directly using the data sample. That encoding will be done with either the Qiskit Pauli feature mappings or the ones used in Ref. [3] (arctan mapping). In the subsequent layers, the inputs will be the Pauli Z expectation from the previous layers individual circuit. Example, Feature extractor 1 from the image above will yield some value [-1, 1]. That value will be input into the first qubit of the "Predictor" in the second layer. Likewise, the value yielded from feature extractor 4 will be input into the last qubit of the predictor. So we know that our predictor will be 4 qubits wide. The expectation value calculations come directly from Ref. [2] and are easily implemented in qiskit.

=== VQC's ===
Every VQC in each layer, U(θ), will be an independent ansatz with parameters p[0], p[1]... p[n]. Note, a back propagation algorithm could be relatively simple to implement since each layer of the network can be represented by a parameterized weight matrix. For layer 1 in the image we have:

p_1[0] p_1[1]... p_1[n]

p_2[0] p_2[1]... p_2[n]

p_3[0] p_3[1]... p_3[n]

p_4[0] p_4[1]... p_4[n]

And for the predictor layer we will have only one row of parameters since there is only one circuit:

p_pre[0] p_pre[1]... p_pre[n]

Note the reduction in dimensionality between the two layers. Also note that this is NOT a fully connected QCNN. Moving to that model should not be too difficult depending on the results gained from this experiment. This could be implemented by the techniques described in Landman's dissertation.

=== Classical Device ===

Upon measurement of the predictor we have our classification again as a value of [-1, 1]. From here, we implement a loss function and back propagation algorithm on our parameter matrices.

== April 9, 2023 ==

[[File:FCQNN_diagram.png|1500px]]

A Fully Connected Quantum Neural Network can be seen above. The closes approximation to this that I can find in the current literature is found here [https://link.springer.com/article/10.1007/s42484-021-00046-w] (see Ref. 8). They use amplitude encoded circuits for the MNIST dataset where the ansatz used look like circularly entangled pauli two design gates. The main mechanics of a forward pass are shown in the diagram. The encoding portions of the circuits, F(X), act as the analogous neurons while the VQC's, U(θ), act as the weight matrices. It can be thought of more as a connected series of smaller classical Neural networks.

Things to consider/progress to be made:

1. As far as quantum classifiers for nuclear physics goes I have not found this network architecture applied yet.
2. Outside of a few "toy" example datasets (MNIST) and those used for dissipative quantum neural networks, these networks seem to be rare.
3. Nobody has utilized this architecture in a distributive manner.
4. I will continue using qiskit for now but I must consider c++ or cuda based applications for a quicker expectation measurements.
5. I am dedicating approximately 30 minutes to 1 hour of literature review every day to ensure that 1-3 are true.

If this works out then my goals stated here[https://crtc.cs.odu.edu/Internal:Quantum_Machine_Learning#March_21.2C_2023] will be achieved.

1. Creating a scalable quantum classification network for high energy particle physics which has not been seen before.
2. The network has real utility in the future.

= Code : =

Download the notebooks here[https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2FQML%20Course%2Fqml%5Fnotebooks&view=0]

= Literature : Quantum Classifiers =
== [1] Scalable Quantum Neural Networks for Classification ==
Jindi Wu, Zeyi Tao, Qun Li
https://arxiv.org/abs/2208.07719

Relies on a hybrid classical-quantum architecture. Each subdomain has the following:

1. Encoding Unit
* Authors utilize angle encoding (N qubits for N features) because it can support gradient calculations
* Amplitude encoding not used due to error rate and difficulty in computing gradients

2. VQC
* They follow the VQC introduced in https://www.tensorflow.org/quantum/tutorials/mnist#21_build_the_model_circuit

3. Measurement
* Calculation of the expectation value, seemingly Pauli-Z operator giving [-1, 1]

4. The measurement of the sub domain is then encoded into a qubit in the next layer.

Seemingly, this process combines both convolutional and pooling layers in the same way that Iris Cong et al. performs calculations. Advantageous over the qiskit implementation in that the "pooling layers" are not parameterized since the pooling is the measurement itself. Additionally, we can run circuits in parallel.

== [2] Quantum convolutional neural networks ==
Iris Cong et al., Nature Physics
https://doi.org/10.1038/s41567-019-0648-8

N qubit input requires O(log(N)) variational parameters. "This corresponds to a double exponential reduction compared with a generic quantum circuit-based classifier..." hopefully leading to faster training times?

== [3] Quantum convolutional neural networks for high energy physics data analysis ==
Chen et al., Brookhaven National Labs
https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.013231

The (SIMULATED) QCNN follows the following protocol:

1. Feature mapped (Amplitude encoded?) particle images of size 30x30 are implemented in the encoding layer.

2. A VQC acts as a convolutional layer. Convolutional outputs are calculated via the expectation value of the Pauli-Z operator acting on the first qubit.

3. Pooling is done classically with nonlinear activation functions in between convolutional layers (look deeper into this).

4. Categorical Cross Entropy Loss Function is applied to the final output.

5. Back Prop to adjust the parameters in the VQC's (convolutional layers).

We can implement this "by hand" in qiskit using their approximate expectation function on a Wahab GPU node using simulator.set_options(device='GPU'). This is considerable because it may be a faster process (also for larger circuits) than available public access QML methods.

== [4] Quantum machine learning for particle physics using a variational quantum classifier ==
Andrew Blancea and Michael Spannowsky
https://link.springer.com/article/10.1007/JHEP02(2021)212

This method follows the same methodology as many others.

1. Angle Encoding the data
2. Generic VQC using universal single qubit gates and CNOTs producing layers of two entangled qubits
3. Measurement is performed by experimental repetitions to determine the expectation value of the Pauli-Z operator, not calculated deterministically

Rudimentary introduction to QNN classification.

== [5] Challenges and opportunities in quantum machine learning for high-energy physics ==
Sau Lan Wu and Shinjae Yoo2
https://www.nature.com/articles/s42254-022-00425-7

"Overall, the greatest challenge in using quantum computer hardware for machine learning at present... is the size of the event samples and the effective use of large num- bers of qubits... analyses will need to manage large event sample size and large data dimensionality...

... advanced quantum computers with large numbers of qubits, reduced noise and improved running time may outperform classical machine learn- ing in both classification power and in speed. QML may well be a new computational paradigm for big data analyses in HEP. For this reason, the HEP community should stay aware of what is happening in quantum technologies — improvements in the hardware, software ecosystem and algorithms — to bring a quantum advan- tage to the HEP data challenge. Conversely, the develop- ment of solutions for unique HEP data challenges could also lead to contributions to the development of quantum technologies."

== [6] Quantum machine learning in high energy physics ==
Guan et al.
https://iopscience.iop.org/article/10.1088/2632-2153/abc17d/pdf

Uses adiabatic quantum annealing as an optimizer. This methodology also uses angle encoding for particle track data, a general VQC, with different optimizers such as ADAM and COBYLA.

== [7] Hybrid Quantum-Classical Neural Network for Calculating Ground State Energies of Molecules ==
Xia, R.; Kais, S. Hybrid Quantum-Classical Neural Network for Calculating Ground State Energies of Molecules. Entropy 2020, 22, 828. https://arxiv.org/pdf/1912.06184.pdf

Although the problem set is not what we are looking for (to find a hamiltonian for potential energy curves) the architecture of this type of QNN can be used to create a fully connected QNN. We cans say that for the image in Ref. [1], each qubit from each circuit in the first layer is measured (the expectation value calculated) independently, we now have a value to pass to the next layer of circuits. I.E. if we have a two qubit circuit, that circuit will yield two expectation values meaning we can pass two different values to two different circuit in the next layer. The first circuit layer has some x number of qubits per circuit, we will have x number of circuits in the next layer.

== [8] QDNN: deep neural networks with quantum layers ==
Zhao, C., Gao, XS. QDNN: deep neural networks with quantum layers. Quantum Mach. Intell. 3, 15 (2021). https://doi.org/10.1007/s42484-021-00046-w

What distinguishes this model from others is that it utilizes non-linear activation functions within the quantum network. Just as well, it uses a very simple and effective gradient descent method to adjust the parameters of the network.

== [9] Precise Image Generation on Current Noisy Quantum Devices ==

At first glance from the abstract it seems to reproduce angle encoding VQC results for HEP data. We already have practical use cases from prior experience with this so no need to further sell me on the idea. HOWEVER, it seems to be a comprehensive study on the topic of angle encoding specifically for HEP data on real NISQ hardware. The extra information can be invaluable to our future work.

Stored in the OneDrive here[https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fqml%5Fpapers%2F604198%2Epdf&parent=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fqml%5Fpapers].

== [10] Application of quantum computing techniques in particle tracking at LHC ==

Slides found here[https://indico.jlab.org/event/459/contributions/11836/attachments/9331/13532/20230509_CHEP_v2.pdf].

The main difference between this model and those which were previously studied seems to be the use of a quantum annealer as opposed to a quantum computer. To my understanding, annealers work by initializing a quantum superposition with equal weights. From there, it evolves via the time-dependent Schrodinger equation slowly allowing itself to exist in the ground state of some transverse field ising model. Effectively, this is the ground state hamiltonian for the system. That hamiltonian represents the global minimum of some objective function. I need to read much further into this at some point to ensure this is all correct.

To summarize, this conference presentation utilizes a form of quantum computation which is specific to a particular system of quantum superpositions. The methodology of quantum computing we have been working with is more akin to a "general" quantum computer. This presentation does not directly apply to our past VQC work but opens doors to many more possibilities.

== [11] First Measurements With A Quantum Vision Transformer: A Naive Approach ==

Cannot find a publication for this one. It seems that this [https://indico.jlab.org/event/459/contributions/11832/] will be the first introduction to this research.

Awaiting the presentation...

== [12] The Role of Data in Projected Quantum Kernels: the Higgs Boson Discrimination ==

Full publication found here[http://kth.diva-portal.org/smash/get/diva2:1718318/FULLTEXT02.pdf].

This seems to be a more robust classification model in that it explicitly describes quantum advantage over classical in terms of ML. The full pub is over 90 pages so it will take some time to parse through. But if what they say in the abstract is true then their expressions of HEP data in hilbert space will be extremely important. QML advantage over classical ML seems to be relatively rare...

== [13] Hybrid actor-critic algorithm for quantum reinforcement learning at CERN beam lines ==

Full publication is found here[https://www.researchgate.net/publication/363765523_Hybrid_actor-critic_algorithm_for_quantum_reinforcement_learning_at_CERN_beam_lines]. This ML model utilizes annealing and something called a Quantum Boltzman Machine [https://arxiv.org/pdf/1601.02036.pdf]. I have little to no experience with both of these so I will update this once I complete my readings and formulate a better image of these methods.

== [14] Improving Noisy Hybrid Quantum Graph Neural Networks for Particle Decay Tree Reconstruction ==

Slides found here[https://indico.jlab.org/event/459/contributions/11837/attachments/9417/13658/chep23.pdf].

As a hybrid model this is something I am trying to avoid for my own project. However, for the convenience of working around unavoidable noise on NISQ hardware the optimizations used for the VQC portion of the network will be of great interest. Awaiting the actual presentation/publication...

== [15] Symmetry Invariant Quantum Machine Learning models for classification problems in Particle Physics ==

No publication or slides as of yet[https://indico.jlab.org/event/459/contributions/11831/].

Opening sentence of the abstract summarizes my plight the past semester to perfection:

"In the search for advantage in Quantum Machine Learning, appropriate encoding of the underlying classical data into a quantum state is a critical step."

There are self admitted scaling issues for their encoding methodology. However, I am always finding new ways to avoid this with respectable results on some occasions (see March 27, 2023 update above).

Internal:Quantum Information Science (QIS General)

2023-07-07T19:56:42Z

Ebillias: /* Qiskit */

= QIS General =

I will use this page to keep a general progression and categorization about QIS ranging from theory to useful code.

== Notebooks ==
=== QIS General ===
Custom built QIS notebooks (some modeled after Nielsen's lectures) can be found here[https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2FBasics%5FQC%2Fnotebooks%2Fgeneral&view=0].

== Code ==
=== Qiskit ===

==== CPU ====

We can multithread the execution of circuits on Wahab to expedite measurement. An easy way is by using the following:

<syntaxhighlight lang="python">
ideal_backend = AerSimulator(method='density_matrix')
ideal_backend.set_options(precision="single", max_parallel_threads=0)
</syntaxhighlight>

Setting max_parallel_threads to 0 enables the simulator to utilize all allocated cores. So, our .sh file may look something like:
<syntaxhighlight lang="python">
#!/bin/bash -l

#SBATCH --job-name=DENSITY_MATRIX_CPU
#SBATCH --output=CPU.out
#SBATCH --ntasks=512

cat << EOF
this job is called $SLURM_JOB_NAME and its ID is $SLURM_JOB_ID
job $SLURM_JOB_ID has being allocated $SLURM_NTASKS cores across $SLURM_NNODES hosts
job $SLURM_JOB_ID will be running on the following machines:

EOF

echo $SLURM_NODELIST

enable_lmod
module load container_env python3

crun -p ~/envs/python3.10 python3 -u ./main.py
</syntaxhighlight>

Which yields the output file CPU.out:
<syntaxhighlight lang="python">
this job is called DENSITY_MATRIX_CPU and its ID is 1846321
job 1846321 has being allocated 512 cores across 27 hosts
job 1846321 will be running on the following machines:

d1-w6420a-[03,05-06,10,12,14-15,19,21-23],d4-w6420b-[01,03,05-06,08,10-11],e2-w6420b-[02-03,07,13-14,16,18-20]
</syntaxhighlight>

With, of course, maximized thread execution. Note, that it is possible to hinder performance on circuits if the number of qubits/depth is insufficient. It is also possible to execute multiple circuits simultaneously using the max_parallel_experiments option.

==== GPU ====

Calling a GPU to execute quantum circuits is relatively straight forward. First, choose your backend. This can be ideal, noisy, or a snapshot from a real qiskit quantum device. Once you have your simulator selected, use the *set_options* method to set the device:

<syntaxhighlight lang="python">
try:
simulator_gpu = Aer.get_backend('aer_simulator')
simulator_gpu.set_options(device='GPU')
except AerError as e:
print('Err:\n',e)
</syntaxhighlight>

When running the script on Wahab, a GPU must be allocated for this. The .sh file should look something like this:
<syntaxhighlight lang="python">
#!/bin/bash

#SBATCH -p gpu
#SBATCH --gres gpu:1

enable_lmod
module load container_env python3

crun -p ~/envs/python3.10 python3 -u ./main.py
</syntaxhighlight>

=== Matplotlib ===
==== Inset Plot ====

creating an inset plot requires defining inset axes within a pre defined larger plot. For example, if we create a regular lineplot:
<syntaxhighlight lang="python">
fig, ax = plt.subplots()
plt.plot(
qubits,
qc_cx_3,
"-o",
label="n+1 optimized",
linewidth=2,
color="grey",
markeredgecolor="k"
)
plt.plot(
qubits,
qc_cx_op_3,
"-o",
label="2n optimized",
linewidth=2,
color="mediumpurple",
markeredgecolor="k"
)
plt.ylabel("CX Count")
plt.xlabel("n Qubits")
plt.xticks(qubits)
plt.legend(framealpha=1)
plt.grid()
plt.title("QHED Number of CX Operations")
plt.savefig("test.png")
plt.show()
</syntaxhighlight>
[[File:Inset1.png]]

Import the following the modules for inset plots and define them underneath the original plt.plot() methods:

<syntaxhighlight lang="python">
# Original plots must be defined first
fig, ax = plt.subplots()
plt.plot(
qubits,
qc_cx_3,
"-o",
label="n+1 optimized",
linewidth=2,
color="grey",
markeredgecolor="k"
)
plt.plot(
qubits,
qc_cx_op_3,
"-o",
label="2n optimized",
linewidth=2,
color="mediumpurple",
markeredgecolor="k"
)

# Define length and height of inset box
# [x_start, y_start, x_len, y_len]
axins = ax.inset_axes([2.8,700, 2, 1000], transform=ax.transData)
axins.plot(
qubits,
qc_cx_3,
"-o",
label="n+1 optimized",
linewidth=2,
color="grey",
markeredgecolor="k"
)
axins.plot(
qubits,
qc_cx_op_3,
"-o",
label="2n optimized",
linewidth=2,
color="mediumpurple",
markeredgecolor="k"
)
axins.set_xlim(1.7, 4.5) # Limit the region for zoom
axins.set_ylim(1, 200)
axins.set_xticks([2,3,4])
axins.grid()

#
## draw a bbox of the region of the inset axes in the parent axes and
## connecting lines between the bbox and the inset axes area
mark_inset(ax, axins, loc1=3, loc2=4, fc="none", ec="0.5")

plt.ylabel("CX Count")
plt.xlabel("n Qubits")
plt.xticks(qubits)
plt.legend(framealpha=1)
plt.grid()
plt.title("QHED Number of CX Operations")
plt.savefig("test2.png")
plt.show()
</syntaxhighlight>
[[File:Inset2.png]]

== Papers ==
=== Pulse Control ===
A Categorical Order Theory of Pulse Scheduling in Gate-Based Quantum Computing[https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fqml%5Fpapers%2FA%20categorical%20order%20theory%20of%20pulse%20scheduling%20in%20gate%2Dbased%20quantum%20computing%2Epdf&parent=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fqml%5Fpapers]

Internal:Quantum Information Science (QIS General)

2023-05-23T11:10:46Z

Ebillias: /* Pulse Control */

= QIS General =

I will use this page to keep a general progression and categorization about QIS ranging from theory to useful code.

== Notebooks ==
=== QIS General ===
Custom built QIS notebooks (some modeled after Nielsen's lectures) can be found here[https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2FBasics%5FQC%2Fnotebooks%2Fgeneral&view=0].

== Code ==
=== Qiskit ===

==== GPU ====

Calling a GPU to execute quantum circuits is relatively straight forward. First, choose your backend. This can be ideal, noisy, or a snapshot from a real qiskit quantum device. Once you have your simulator selected, use the *set_options* method to set the device:

<syntaxhighlight lang="python">
try:
simulator_gpu = Aer.get_backend('aer_simulator')
simulator_gpu.set_options(device='GPU')
except AerError as e:
print('Err:\n',e)
</syntaxhighlight>

When running the script on Wahab, a GPU must be allocated for this. The .sh file should look something like this:
<syntaxhighlight lang="python">
#!/bin/bash

#SBATCH -p gpu
#SBATCH --gres gpu:1

enable_lmod
module load container_env python3

crun -p ~/envs/python3.10 python3 -u ./main.py
</syntaxhighlight>

=== Matplotlib ===
==== Inset Plot ====

creating an inset plot requires defining inset axes within a pre defined larger plot. For example, if we create a regular lineplot:
<syntaxhighlight lang="python">
fig, ax = plt.subplots()
plt.plot(
qubits,
qc_cx_3,
"-o",
label="n+1 optimized",
linewidth=2,
color="grey",
markeredgecolor="k"
)
plt.plot(
qubits,
qc_cx_op_3,
"-o",
label="2n optimized",
linewidth=2,
color="mediumpurple",
markeredgecolor="k"
)
plt.ylabel("CX Count")
plt.xlabel("n Qubits")
plt.xticks(qubits)
plt.legend(framealpha=1)
plt.grid()
plt.title("QHED Number of CX Operations")
plt.savefig("test.png")
plt.show()
</syntaxhighlight>
[[File:Inset1.png]]

Import the following the modules for inset plots and define them underneath the original plt.plot() methods:

<syntaxhighlight lang="python">
# Original plots must be defined first
fig, ax = plt.subplots()
plt.plot(
qubits,
qc_cx_3,
"-o",
label="n+1 optimized",
linewidth=2,
color="grey",
markeredgecolor="k"
)
plt.plot(
qubits,
qc_cx_op_3,
"-o",
label="2n optimized",
linewidth=2,
color="mediumpurple",
markeredgecolor="k"
)

# Define length and height of inset box
# [x_start, y_start, x_len, y_len]
axins = ax.inset_axes([2.8,700, 2, 1000], transform=ax.transData)
axins.plot(
qubits,
qc_cx_3,
"-o",
label="n+1 optimized",
linewidth=2,
color="grey",
markeredgecolor="k"
)
axins.plot(
qubits,
qc_cx_op_3,
"-o",
label="2n optimized",
linewidth=2,
color="mediumpurple",
markeredgecolor="k"
)
axins.set_xlim(1.7, 4.5) # Limit the region for zoom
axins.set_ylim(1, 200)
axins.set_xticks([2,3,4])
axins.grid()

#
## draw a bbox of the region of the inset axes in the parent axes and
## connecting lines between the bbox and the inset axes area
mark_inset(ax, axins, loc1=3, loc2=4, fc="none", ec="0.5")

plt.ylabel("CX Count")
plt.xlabel("n Qubits")
plt.xticks(qubits)
plt.legend(framealpha=1)
plt.grid()
plt.title("QHED Number of CX Operations")
plt.savefig("test2.png")
plt.show()
</syntaxhighlight>
[[File:Inset2.png]]

== Papers ==
=== Pulse Control ===
A Categorical Order Theory of Pulse Scheduling in Gate-Based Quantum Computing[https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fqml%5Fpapers%2FA%20categorical%20order%20theory%20of%20pulse%20scheduling%20in%20gate%2Dbased%20quantum%20computing%2Epdf&parent=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fqml%5Fpapers]

Internal:Quantum Information Science (QIS General)

2023-05-23T11:10:25Z

Ebillias:

= QIS General =

I will use this page to keep a general progression and categorization about QIS ranging from theory to useful code.

== Notebooks ==
=== QIS General ===
Custom built QIS notebooks (some modeled after Nielsen's lectures) can be found here[https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2FBasics%5FQC%2Fnotebooks%2Fgeneral&view=0].

== Code ==
=== Qiskit ===

==== GPU ====

Calling a GPU to execute quantum circuits is relatively straight forward. First, choose your backend. This can be ideal, noisy, or a snapshot from a real qiskit quantum device. Once you have your simulator selected, use the *set_options* method to set the device:

<syntaxhighlight lang="python">
try:
simulator_gpu = Aer.get_backend('aer_simulator')
simulator_gpu.set_options(device='GPU')
except AerError as e:
print('Err:\n',e)
</syntaxhighlight>

When running the script on Wahab, a GPU must be allocated for this. The .sh file should look something like this:
<syntaxhighlight lang="python">
#!/bin/bash

#SBATCH -p gpu
#SBATCH --gres gpu:1

enable_lmod
module load container_env python3

crun -p ~/envs/python3.10 python3 -u ./main.py
</syntaxhighlight>

=== Matplotlib ===
==== Inset Plot ====

creating an inset plot requires defining inset axes within a pre defined larger plot. For example, if we create a regular lineplot:
<syntaxhighlight lang="python">
fig, ax = plt.subplots()
plt.plot(
qubits,
qc_cx_3,
"-o",
label="n+1 optimized",
linewidth=2,
color="grey",
markeredgecolor="k"
)
plt.plot(
qubits,
qc_cx_op_3,
"-o",
label="2n optimized",
linewidth=2,
color="mediumpurple",
markeredgecolor="k"
)
plt.ylabel("CX Count")
plt.xlabel("n Qubits")
plt.xticks(qubits)
plt.legend(framealpha=1)
plt.grid()
plt.title("QHED Number of CX Operations")
plt.savefig("test.png")
plt.show()
</syntaxhighlight>
[[File:Inset1.png]]

Import the following the modules for inset plots and define them underneath the original plt.plot() methods:

<syntaxhighlight lang="python">
# Original plots must be defined first
fig, ax = plt.subplots()
plt.plot(
qubits,
qc_cx_3,
"-o",
label="n+1 optimized",
linewidth=2,
color="grey",
markeredgecolor="k"
)
plt.plot(
qubits,
qc_cx_op_3,
"-o",
label="2n optimized",
linewidth=2,
color="mediumpurple",
markeredgecolor="k"
)

# Define length and height of inset box
# [x_start, y_start, x_len, y_len]
axins = ax.inset_axes([2.8,700, 2, 1000], transform=ax.transData)
axins.plot(
qubits,
qc_cx_3,
"-o",
label="n+1 optimized",
linewidth=2,
color="grey",
markeredgecolor="k"
)
axins.plot(
qubits,
qc_cx_op_3,
"-o",
label="2n optimized",
linewidth=2,
color="mediumpurple",
markeredgecolor="k"
)
axins.set_xlim(1.7, 4.5) # Limit the region for zoom
axins.set_ylim(1, 200)
axins.set_xticks([2,3,4])
axins.grid()

#
## draw a bbox of the region of the inset axes in the parent axes and
## connecting lines between the bbox and the inset axes area
mark_inset(ax, axins, loc1=3, loc2=4, fc="none", ec="0.5")

plt.ylabel("CX Count")
plt.xlabel("n Qubits")
plt.xticks(qubits)
plt.legend(framealpha=1)
plt.grid()
plt.title("QHED Number of CX Operations")
plt.savefig("test2.png")
plt.show()
</syntaxhighlight>
[[File:Inset2.png]]

== Papers ==
=== Pulse Control ===
A Categorical Orde Theory of Pulse Scheduling in Gate-Based Quantum Computing [https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fqml%5Fpapers%2FA%20categorical%20order%20theory%20of%20pulse%20scheduling%20in%20gate%2Dbased%20quantum%20computing%2Epdf&parent=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fqml%5Fpapers]

Internal:Quantum Edge Detection

2023-05-17T21:59:39Z

Ebillias: /* Quantum Fidelity */

= Quantum Hadamard Edge Detection (QHED) =

A recent quantum edge detection algorithm called Quantum Hadamard Edge Detection[2] (QHED) provides a promising means of quantum image processing and experimentation. This is done by providing full boundary gradient across a 1D mapping of a 2D image. Due to fidelity issues on NISQ era hardware, we are required to divide our images into sub images (domain decomposition) for proper edge detection[1]. When doing this, we find a boundary error issue with the algorithm. In addition, we utilize a series of optimization techniques found in Ref. [6] to overcome the resultant hardware noise. The hardware limitations and the few issues with the QHED algorithm itself are reduced in order to produce simulated NISQ hardware results on large images.

The overall goal of this project is to produce high quality results via the QHED circuit on large medical images via REAL NISQ era hardware. Classically, we can use space filling curves or pixel buffers to improve results upon the decomposed image. As far as real hardware is concerned, areas of interest to achieve quality results are by implementing major improvements upon the decrement gate which seems to be the failure point. We can tackle this by a combination of efficient mathematics[7], NISQ error mitigation techniques[6], and VQC techniques. The combination of all of these applied to the three major sections of the circuit (ignoring the measurement phase) could very well result in accurate edge detection results on real quantum hardware. Without access to larger number of qubits (>7 qubits) we need to use the topology taken from noisy simulated hardware. The principles of CX error, single gate error, fidelity, and coherence normally found in real hardware are applicable to noisy simulations. Thus, this remains as a quality means of data analysis prior to execution on real hardware.

== Code ==
Download the Decrement and image encoding notebooks here [https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fquantum%5Fedge%5Fdetection%2Fnotebooks&view=0]

== Paper ==
Find the current version of paper here[https://www.overleaf.com/project/64341df873168e42fe8c2624]

== Quantum Fidelity ==

For most of this research project we have been using a fidelity metric from Ref. [https://arxiv.org/pdf/2209.02795.pdf]. This metric is a simple function dependent on the number of single qubit gates, CNOT gates, and their respective average error rates for some particular circuit on a pre specified backend. This is, in my opinion, analogous to a performance metric from the standpoint of an engineer (say miles per gallon on a car). The calculation itself yields a somewhat confusing unit of measurement (MPG is a cross sectional unit of area!). The metric of MPG still gives you insight into efficiency and performance. However, the results of MPG will depend entirely on the driver and the conditions that the vehicle is subject to. I believe that IBM did do a good job with this as it gives (seemingly) a predictable insight into the efficiency and performance of a circuit on some given hardware. If we want the real observed fidelity through sampling the circuit we are required to "drive" and test our circuit.

Fidelity in itself is not a strict metric. Rather, it is an abstract computation which can be used to predict the probability that one quantum state can pass as another [https://en.wikipedia.org/wiki/Fidelity_of_quantum_states]. Allegedly, Jozsa points out in the publication found here [https://www.tandfonline.com/doi/epdf/10.1080/09500349414552171?needAccess=true] that an overlap of pure quantum states on the geometry of hilbert space can easily be defined as:

|<ψ|χ>|

Which will be 1 where |χ> = |ψ> and 0 if they are perfectly orthogonal. This can be visualized as a simple overlap of two quantum states and the result is exactly how much they overlap. Since the QHED circuit produces pure quantum states we consider this as a fidelity option to calculate. Noisy circuits will yield (at the time of each individual measurement) a pure quantum state. However, the sum of those pure states will produce a density matrix which is most probably not pure. With that being said, Jozsa had produced a fidelity metric for one pure state (ideal) and one mixed state (noisy). Given two density operators where one is pure and the other mixed:

F(ρ,σ) = (tr √ (√ρ σ √ρ))²

There are other definitions for fidelity in the case of mixed states developed by Jozsa[https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fqml%5Fpapers%2F604015%20%281%29%2Epdf&parent=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fqml%5Fpapers], Nielsen[https://arxiv.org/pdf/quant-ph/0205035.pdf], and several others [http://www.physik.uni-leipzig.de/~uhlmann/PDF/Uh76a.pdf]. A more robust technique is called Quantum Tomography [https://en.wikipedia.org/wiki/Quantum_tomography]. This, I believe, falls out of the scope of QHED. QHED relies only on the output state of the circuit in the computational (Z) basis, therefore I believe that Josza's trace definition should suffice.

In short, the Qiskit definition of fidelity in their paper is not wrong, but rather incomplete in my opinion. There is no strict definition for fidelity. Rather, fidelity is used to give insight to the closeness between states in quantum information theory. The IBM paper predicts the "overlap" while Josza's metric requires sampling to determine fidelity through experimentation. I think that redefining this metric for ourselves within the scope of Jozsa's definition allows for a more robust representation of what we have actually accomplished with these optimizations since we are comparing the ideal output directly to the actual result.

== QHED Circuit ==

[[File:Qhed circuit.png|500px|thumb|none|Figure 1 Generalized qHED Circuit with input vector f and output vector g.]]

=== State Prep ===
[[File:Rcmo.png|500px|thumb|none|Figure 2 Row (left) and Column (right) major ordered mapping.]]

The image is first mapped as a 2D array to a 1D vector. Ref. [2] uses methodology known as row and column major ordering (RCMO). Each pixel is then normalized such that the sum of their squares is equal to 1, a necessary quality of quantum states. Using a module presented by Ref. [3] (or through Qiskit's StatePreparation), we can calculate a quantum circuit which achieves what is known as amplitude encoding. The normalized pixel values of the input vector will be returned as the probability amplitudes of computational basis states. Those computational basis states act as the indexing of the original vector. I.e. if we had a length 64 vector, the 7th element is represented as c_7|000111>. The resultant normalized image state can be written as:

[[File:Img state.png|200px]]

The Hadamard gate in the state prep acts on the Least Significant Bit (LSB) initialized to state |0> which outputs the |+> state. Application of the H-Gate on the LSB has the following tensor product on the input image state:

[[File:State prep.png|400px]]

=== Decrement ===

The decrement portion of the quantum algorithm can be represented by the matrix unitary:

[[File:Decrement unitary.png|400px]]

With application of that unitary gate to the state prepared vector yields the decrement state:

[[File:Decrement state.png|500px]]

To the best of our abilities, we find that references to the QHED method provide very little (if any) detail as to the architecture of the decrement gate. Refs. [4] and presumably [5] use a qiskit unitary class function to convert a numpy matrix into a circuit. Although quite useful for simulations, this type of construction fails on real hardware. We can find a far more reasonable design of the gate in Ref. [7] which is shown below.

[[File:decrement_gate.png|500px|thumb|none|Multi controlled NOT gates perform the decrement operation. q_0 being the least significant qubit.]]

Although it is known that multi qubit gates are highly error prone, we achieve reasonable results when we compare the two methodologies. We begin with a 4 qubit circuit initialized to the state |0000> = (1...0) which is to be decremented to state |1111> = (0...1). Shown below are the results of the more careful multi controlled qubit construction and the unitary class function executed on the real quantum device, ibmq_lima. Based on the results, we know that we must design our own decrement gates and cannot rely on any arbitrary unitary transformation algorithim.

[[File:Lima tl 3.png|500px|thumb|none| Although the results are far from perfect, we can clearly see the state 1111> has been formed from the state 0000>.]]

[[File:Lima np.png|500px|thumb|none| The results of our gate are lost in the noise of the output using the unitary class function.]]

We can improve upon the Decrement gate by using 2n total qubits by altering the increment gates in Ref. [8]. More simply, using open controls (bit flip in the case of the qubit being in the state |0>) alters the increment permutation to a decrement.

[[File:DecrementOp.png|500px]]

Looking at the CX counts and fidelity estimates for QHED circuits show promising results. The upcoming section "Methods of Optimization" will describe the optimizations themselves as they are labeled in the charts below.

[[File:Qhed cx.png|500px]]
[[File:Qhed fidelity.png|500px]]

=== Permutation ===
This is the portion of the circuit where the actual edge detection occurs. It can be thought of as a series of identity gates tensored together with an H-Gate in the LSB tensored last. The resultant unitary matrix can be written as:

[[File:Permutation unitary.png|500px]]

With application of the resultant decrement vector as:

[[File:Permutation state.png|500px]]

This is the final output state. Note that if the LSB is in the state |1> we retrieve all of the odd indexed states i.e. |...001> (1), |...011> (3), |...111> (5), ect. These states provide the boundary gradient across the 1D input image. An overview of the QHED algorithm can be visualized as having the following effect on the input of an image state:

[[File:QHED output.png|300px]]

== Methods of Optimization ==

The improved decrement gate was already discussed in the previous section so we will leave it there.

We then utilize Qiskit's transpiler. The optimal SWAP mapping is an NP-Hard problem which yields ambiguous results. "The choice of initial layout can mean the difference between getting a result, and getting nothing but noise." To compute the best low noise layout, we use an open source module called mapomatic. Mapomatic finds the best low noise sub-graph for some given hardware backend(s). The end result is that the module returns the best set of qubits and their appropriate ordering to execute your circuit with minimal noise. This qubit layout is sent to the transpiler. A heuristic fidelity estimate is taken from Ref. [6].

We now turn to a means of error reduction in the measurement output of the circuit. Researchers are able to perform a variety of experiments to measure a qubit's state preparation and measurement (SPAM) errors forming a relationship of noisy probabilities to ideal probabilities in the form of a matrix transformation. The correction matrix can be measured by using a variety of circuits with known outcomes and finding the noisy outcome of every possible bit-string for a particular piece of hardware. From this, it is possible to reconstruct our desired output.

There are obvious scaling issues when it comes to building 2^n x 2^n matricies. There are alternatives to this which do not require such scaling or computational overhead. We make use of such a module called mthree. An excellent demonstration of this can be found in the Qiskit Textbook.

In the case of large images, we must perform domain decomposition to preserve fidelity and reduce noise. However, we find that when applying the suggested RMO and CMO indexed 2D to 1D mapping on decomposed sub images there is a non negligible quality reduction to the output edge detected image. This is due to the fact that this use of mapping does not preserve locality. It can be seen from Fig. [2] how these methods of indexing will provide errors across the boundaries of the image/sub images. Consider the output state |g>. It can be seen how non adjacent pixels of the original image will be compared with each other e.g. c_{3} - c_{4} in the Fig. [2] RMO mapping or c_{12} - c_{1} in the CMO mapping. This may lead to detected edges where there are none. To avoid these discrepancies we apply buffer cells to our decomposed images. We choose to do a row by row decomposition for the horizontal scan as shown below. This leaves 2 redundant pixels per sub image, no matter the decomposition size.

[[File:Boundary buffer.png|500px|thumb|none|Buffer pixels of value 0 are applied to the boundary of the overall image.]]

[[File:Buffer cells.png|500px|thumb|none|Further decomposition is then possible by adding neighboring pixels to be used as a buffer due to QHED error. The red cells are ultimately disposed in the final output.]]

With the decrement gate optimization, the more NISQ-era friendly QHED circuit takes the form shown below.

[[File:Qhed op.png|500px|thumb|none|QHED circuit with expanded, noise mitigated, decrement gate]]

== Domain Decomposition ==

Consider a 1024x1024 medical image. This comes out to 1,048,576 pixels requiring 20 (2^20) qubits plus 1 ancillary qubit for the QHED algorithm. Additionally, the amplitude encoding process expands exponentially with regards to qubit number. We can divide the image into separate sub images and solve either iteratively or in parallel (multithreading). Each sub image is now considered to be a sub input of the overall problem.

[[File:NaF-PROSTATE-01-0001_22.png|500px|thumb|none|Example of 1024x1024 Medical image decomposed into 256x256 sub images.]]

Errors begin to occur with the 2D to 1D mapping of subdomains. Consider the row major ordering in figure 1. Elements c_3 and c_4 will provide gradient detection for the output pixel at location 3. This is because the RCMO mappings do not preserve locality at the boarders of multi dimensional arrays. In a full image pass of the algorithm this would hardly be noticeable and leave little error on the output image. It becomes readily apparent in decomposed domains, however:

[[File:Rcmo example.png|1000px|thumb|none|RCMO 2D to 1D mapping applied prior to the output of QHED (simulated) shown above. RCMO mapping does not preserve locality and thus non neighboring pixels are calculated to have edges between them where no such edges exist.]]

=== Space Filling Curves ===

One way to solve this issue without the addition of extra qubits is to use space filling curves as a means of 2D to 1D mapping. Space filling curves preserve locality in that the final output of the algorithm will provide boundary detection across exclusively neighboring pixels (with the exception of one pixel per domain in certain cases).

[[File:QHED space filling curves.png|1200px|thumb|none|Example of 1024x1024 Medical image decomposed into 64x64 sub images. In the domain decomposed images (bottom row) a different space filling curve is used for mapping. A laplacian (far left column) edge detection stenciling is used as a classical analog for comparisons.]]

=== QHED in 3 Dimensions ===

We can apply the same principles to 3D. The main difference is that instead of performing a vertical and horizontal detection we need to add in a third in order to achieve a full boundary about each pixel. We consider a "scan" about the x, y, and z planes.

[[File:3d model.png|1200px|thumb|none|Example of 3D Medical image to be edge detected.]]
[[File:3d model rcmo.png|1200px|thumb|none|3D Medical image passed through the QHED algorithm (simulated) 3 times (x,y,z plane). The entire image was passed through each plane.]]
[[File:3d model rcmo dd.png|1200px|thumb|none|3D Medical image with decomposed domains. Each sub domain (3D block) passed through the QHED algorithm (simulated) 3 times (x,y,z plane). Each block was mapped using RCMO, edge detected, and pieced back together.]]

== References ==
[1] Acampora, Giovanni, et al. “D-NISQ: A Reference Model for Distributed Noisy Intermediate-Scale Quantum Computers.” Information Fusion, vol. 89, 2023, pp. 16–28., https://doi.org/10.1016/j.inffus.2022.08.003.

[2] .-W. Yao, H. Wang, Z. Liao, M.-C. Chen, J. Pan, J. Li, K. Zhang, X. Lin, Z. Wang, Z. Luo,
et al., Quantum image processing and its application to edge detection: Theory and experiment,
Physical Review X 7 (3) (2017). doi:10.1103/physrevx.7.031041.

[3]I. F. Araujo, D. K. Park, F. Petruccione, A. J. da Silva, A divide-and-conquer algo-
rithm for quantum state preparation, Scientific Reports 11 (1) (2021). doi:10.1038/
s41598-021-85474-1.

[4] Team, T. Q. (2022, July 6). Quantum Edge Detection - qhed algorithm on small and large images. Quantum Edge Detection - QHED Algorithm on Small and Large Images. Retrieved October 28, 2022, from https://qiskit.org/textbook/ch-applications/quantum-edge-detection.html

[5] Anand, A., Lyu, M., Baweja, P. S., & Patil, V. (2022). Quantum Image Processing. https://doi.org/https://arxiv.org/pdf/2203.01831.pdf

[6] Ferris, K. J., Ramusson, A. J., Bronn, N. T., & Lanes, O. (2022). Quantum Simulation on Noisy Superconducting Quantum Computers. https://doi.org/https://doi.org/10.48550/arXiv.2209.02795

[7] LI, X. I. A. O. Y. U., YANG, G. U. O. W. U., TORRES, C. A. R. L. O. S. M. A. N. U. E. L., ZHENG, D. E. S. H. E. N. G., & WANG, K. A. N. G. L. (2013). A class of efficient quantum incrementer gates for quantum circuit synthesis. International Journal of Modern Physics B, 28(01), 1350191. https://doi.org/10.1142/s0217979213501919

[8] . Gidney, Constructing large increment gates. URL https://algassert.com/circuits/2015/06/12/Constructing-Large-Increment-Gates.html

Internal:Quantum Edge Detection

2023-05-15T20:37:48Z

Ebillias: /* Decrement */

= Quantum Hadamard Edge Detection (QHED) =

A recent quantum edge detection algorithm called Quantum Hadamard Edge Detection[2] (QHED) provides a promising means of quantum image processing and experimentation. This is done by providing full boundary gradient across a 1D mapping of a 2D image. Due to fidelity issues on NISQ era hardware, we are required to divide our images into sub images (domain decomposition) for proper edge detection[1]. When doing this, we find a boundary error issue with the algorithm. In addition, we utilize a series of optimization techniques found in Ref. [6] to overcome the resultant hardware noise. The hardware limitations and the few issues with the QHED algorithm itself are reduced in order to produce simulated NISQ hardware results on large images.

The overall goal of this project is to produce high quality results via the QHED circuit on large medical images via REAL NISQ era hardware. Classically, we can use space filling curves or pixel buffers to improve results upon the decomposed image. As far as real hardware is concerned, areas of interest to achieve quality results are by implementing major improvements upon the decrement gate which seems to be the failure point. We can tackle this by a combination of efficient mathematics[7], NISQ error mitigation techniques[6], and VQC techniques. The combination of all of these applied to the three major sections of the circuit (ignoring the measurement phase) could very well result in accurate edge detection results on real quantum hardware. Without access to larger number of qubits (>7 qubits) we need to use the topology taken from noisy simulated hardware. The principles of CX error, single gate error, fidelity, and coherence normally found in real hardware are applicable to noisy simulations. Thus, this remains as a quality means of data analysis prior to execution on real hardware.

== Code ==
Download the Decrement and image encoding notebooks here [https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fquantum%5Fedge%5Fdetection%2Fnotebooks&view=0]

== Paper ==
Find the current version of paper here[https://www.overleaf.com/project/64341df873168e42fe8c2624]

== Quantum Fidelity ==

For most of this research project we have been using a fidelity metric from Ref. [https://arxiv.org/pdf/2209.02795.pdf]. This metric is a simple function dependent on the number of single qubit gates, CNOT gates, and their respective average error rates for some particular circuit on a pre specified backend. This is, in my opinion, analogous to a performance metric from the standpoint of an engineer (say miles per gallon on a car). The calculation itself yields a somewhat confusing unit of measurement (MPG is a cross sectional unit of area!). The metric of MPG still gives you insight into efficiency and performance. However, the results of MPG will depend entirely on the driver and the conditions that the vehicle is subject to. I believe that IBM did do a good job with this as it gives (seemingly) a predictable insight into the efficiency and performance of a circuit on some given hardware. If we want the real observed fidelity through sampling the circuit we are required to "drive" and test our circuit.

Fidelity in itself is not a strict metric. Rather, it is an abstract computation which can be used to predict the probability that one quantum state can pass as another [https://en.wikipedia.org/wiki/Fidelity_of_quantum_states]. Allegedly, Jozsa points out in the publication found here [https://www.tandfonline.com/doi/epdf/10.1080/09500349414552171?needAccess=true] that an overlap of pure quantum states on the geometry of hilbert space can easily be defined as:

|<ψ|χ>|

Which will be 1 where |χ> = |ψ> and 0 if they are perfectly orthogonal. This can be visualized as a simple overlap of two quantum states and the result is exactly how much they overlap. Since the QHED circuit produces pure quantum states we consider this as a fidelity option to calculate. Noisy circuits will yield (at the time of each individual measurement) a pure quantum state. However, the sum of those pure states will produce a density matrix which is most probably not pure. With that being said, Jozsa had produced a fidelity metric for one pure state (ideal) and one mixed state (noisy). Given two density operators where one is pure and the other mixed:

F(ρ,σ) = (tr √ (√ρ σ √ρ))²

There are other definitions for fidelity in the case of mixed states developed by Jozsa, Nielsen[https://arxiv.org/pdf/quant-ph/0205035.pdf], and several others [http://www.physik.uni-leipzig.de/~uhlmann/PDF/Uh76a.pdf]. A more robust technique is called Quantum Tomography [https://en.wikipedia.org/wiki/Quantum_tomography]. This, I believe, falls out of the scope of QHED. QHED relies only on the output state of the circuit in the computational (Z) basis, therefore I believe that Josza's trace definition should suffice.

In short, the Qiskit definition of fidelity in their paper is not wrong, but rather incomplete in my opinion. There is no strict definition for fidelity. Rather, fidelity is used to give insight to the closeness between states in quantum information theory. The IBM paper predicts the "overlap" while Josza's metric requires sampling to determine fidelity through experimentation. I think that redefining this metric for ourselves within the scope of Jozsa's definition allows for a more robust representation of what we have actually accomplished with these optimizations since we are comparing the ideal output directly to the actual result.

== QHED Circuit ==

[[File:Qhed circuit.png|500px|thumb|none|Figure 1 Generalized qHED Circuit with input vector f and output vector g.]]

=== State Prep ===
[[File:Rcmo.png|500px|thumb|none|Figure 2 Row (left) and Column (right) major ordered mapping.]]

The image is first mapped as a 2D array to a 1D vector. Ref. [2] uses methodology known as row and column major ordering (RCMO). Each pixel is then normalized such that the sum of their squares is equal to 1, a necessary quality of quantum states. Using a module presented by Ref. [3] (or through Qiskit's StatePreparation), we can calculate a quantum circuit which achieves what is known as amplitude encoding. The normalized pixel values of the input vector will be returned as the probability amplitudes of computational basis states. Those computational basis states act as the indexing of the original vector. I.e. if we had a length 64 vector, the 7th element is represented as c_7|000111>. The resultant normalized image state can be written as:

[[File:Img state.png|200px]]

The Hadamard gate in the state prep acts on the Least Significant Bit (LSB) initialized to state |0> which outputs the |+> state. Application of the H-Gate on the LSB has the following tensor product on the input image state:

[[File:State prep.png|400px]]

=== Decrement ===

The decrement portion of the quantum algorithm can be represented by the matrix unitary:

[[File:Decrement unitary.png|400px]]

With application of that unitary gate to the state prepared vector yields the decrement state:

[[File:Decrement state.png|500px]]

To the best of our abilities, we find that references to the QHED method provide very little (if any) detail as to the architecture of the decrement gate. Refs. [4] and presumably [5] use a qiskit unitary class function to convert a numpy matrix into a circuit. Although quite useful for simulations, this type of construction fails on real hardware. We can find a far more reasonable design of the gate in Ref. [7] which is shown below.

[[File:decrement_gate.png|500px|thumb|none|Multi controlled NOT gates perform the decrement operation. q_0 being the least significant qubit.]]

Although it is known that multi qubit gates are highly error prone, we achieve reasonable results when we compare the two methodologies. We begin with a 4 qubit circuit initialized to the state |0000> = (1...0) which is to be decremented to state |1111> = (0...1). Shown below are the results of the more careful multi controlled qubit construction and the unitary class function executed on the real quantum device, ibmq_lima. Based on the results, we know that we must design our own decrement gates and cannot rely on any arbitrary unitary transformation algorithim.

[[File:Lima tl 3.png|500px|thumb|none| Although the results are far from perfect, we can clearly see the state 1111> has been formed from the state 0000>.]]

[[File:Lima np.png|500px|thumb|none| The results of our gate are lost in the noise of the output using the unitary class function.]]

We can improve upon the Decrement gate by using 2n total qubits by altering the increment gates in Ref. [8]. More simply, using open controls (bit flip in the case of the qubit being in the state |0>) alters the increment permutation to a decrement.

[[File:DecrementOp.png|500px]]

Looking at the CX counts and fidelity estimates for QHED circuits show promising results. The upcoming section "Methods of Optimization" will describe the optimizations themselves as they are labeled in the charts below.

[[File:Qhed cx.png|500px]]
[[File:Qhed fidelity.png|500px]]

=== Permutation ===
This is the portion of the circuit where the actual edge detection occurs. It can be thought of as a series of identity gates tensored together with an H-Gate in the LSB tensored last. The resultant unitary matrix can be written as:

[[File:Permutation unitary.png|500px]]

With application of the resultant decrement vector as:

[[File:Permutation state.png|500px]]

This is the final output state. Note that if the LSB is in the state |1> we retrieve all of the odd indexed states i.e. |...001> (1), |...011> (3), |...111> (5), ect. These states provide the boundary gradient across the 1D input image. An overview of the QHED algorithm can be visualized as having the following effect on the input of an image state:

[[File:QHED output.png|300px]]

== Methods of Optimization ==

The improved decrement gate was already discussed in the previous section so we will leave it there.

We then utilize Qiskit's transpiler. The optimal SWAP mapping is an NP-Hard problem which yields ambiguous results. "The choice of initial layout can mean the difference between getting a result, and getting nothing but noise." To compute the best low noise layout, we use an open source module called mapomatic. Mapomatic finds the best low noise sub-graph for some given hardware backend(s). The end result is that the module returns the best set of qubits and their appropriate ordering to execute your circuit with minimal noise. This qubit layout is sent to the transpiler. A heuristic fidelity estimate is taken from Ref. [6].

We now turn to a means of error reduction in the measurement output of the circuit. Researchers are able to perform a variety of experiments to measure a qubit's state preparation and measurement (SPAM) errors forming a relationship of noisy probabilities to ideal probabilities in the form of a matrix transformation. The correction matrix can be measured by using a variety of circuits with known outcomes and finding the noisy outcome of every possible bit-string for a particular piece of hardware. From this, it is possible to reconstruct our desired output.

There are obvious scaling issues when it comes to building 2^n x 2^n matricies. There are alternatives to this which do not require such scaling or computational overhead. We make use of such a module called mthree. An excellent demonstration of this can be found in the Qiskit Textbook.

In the case of large images, we must perform domain decomposition to preserve fidelity and reduce noise. However, we find that when applying the suggested RMO and CMO indexed 2D to 1D mapping on decomposed sub images there is a non negligible quality reduction to the output edge detected image. This is due to the fact that this use of mapping does not preserve locality. It can be seen from Fig. [2] how these methods of indexing will provide errors across the boundaries of the image/sub images. Consider the output state |g>. It can be seen how non adjacent pixels of the original image will be compared with each other e.g. c_{3} - c_{4} in the Fig. [2] RMO mapping or c_{12} - c_{1} in the CMO mapping. This may lead to detected edges where there are none. To avoid these discrepancies we apply buffer cells to our decomposed images. We choose to do a row by row decomposition for the horizontal scan as shown below. This leaves 2 redundant pixels per sub image, no matter the decomposition size.

[[File:Boundary buffer.png|500px|thumb|none|Buffer pixels of value 0 are applied to the boundary of the overall image.]]

[[File:Buffer cells.png|500px|thumb|none|Further decomposition is then possible by adding neighboring pixels to be used as a buffer due to QHED error. The red cells are ultimately disposed in the final output.]]

With the decrement gate optimization, the more NISQ-era friendly QHED circuit takes the form shown below.

[[File:Qhed op.png|500px|thumb|none|QHED circuit with expanded, noise mitigated, decrement gate]]

== Domain Decomposition ==

Consider a 1024x1024 medical image. This comes out to 1,048,576 pixels requiring 20 (2^20) qubits plus 1 ancillary qubit for the QHED algorithm. Additionally, the amplitude encoding process expands exponentially with regards to qubit number. We can divide the image into separate sub images and solve either iteratively or in parallel (multithreading). Each sub image is now considered to be a sub input of the overall problem.

[[File:NaF-PROSTATE-01-0001_22.png|500px|thumb|none|Example of 1024x1024 Medical image decomposed into 256x256 sub images.]]

Errors begin to occur with the 2D to 1D mapping of subdomains. Consider the row major ordering in figure 1. Elements c_3 and c_4 will provide gradient detection for the output pixel at location 3. This is because the RCMO mappings do not preserve locality at the boarders of multi dimensional arrays. In a full image pass of the algorithm this would hardly be noticeable and leave little error on the output image. It becomes readily apparent in decomposed domains, however:

[[File:Rcmo example.png|1000px|thumb|none|RCMO 2D to 1D mapping applied prior to the output of QHED (simulated) shown above. RCMO mapping does not preserve locality and thus non neighboring pixels are calculated to have edges between them where no such edges exist.]]

=== Space Filling Curves ===

One way to solve this issue without the addition of extra qubits is to use space filling curves as a means of 2D to 1D mapping. Space filling curves preserve locality in that the final output of the algorithm will provide boundary detection across exclusively neighboring pixels (with the exception of one pixel per domain in certain cases).

[[File:QHED space filling curves.png|1200px|thumb|none|Example of 1024x1024 Medical image decomposed into 64x64 sub images. In the domain decomposed images (bottom row) a different space filling curve is used for mapping. A laplacian (far left column) edge detection stenciling is used as a classical analog for comparisons.]]

=== QHED in 3 Dimensions ===

We can apply the same principles to 3D. The main difference is that instead of performing a vertical and horizontal detection we need to add in a third in order to achieve a full boundary about each pixel. We consider a "scan" about the x, y, and z planes.

[[File:3d model.png|1200px|thumb|none|Example of 3D Medical image to be edge detected.]]
[[File:3d model rcmo.png|1200px|thumb|none|3D Medical image passed through the QHED algorithm (simulated) 3 times (x,y,z plane). The entire image was passed through each plane.]]
[[File:3d model rcmo dd.png|1200px|thumb|none|3D Medical image with decomposed domains. Each sub domain (3D block) passed through the QHED algorithm (simulated) 3 times (x,y,z plane). Each block was mapped using RCMO, edge detected, and pieced back together.]]

== References ==
[1] Acampora, Giovanni, et al. “D-NISQ: A Reference Model for Distributed Noisy Intermediate-Scale Quantum Computers.” Information Fusion, vol. 89, 2023, pp. 16–28., https://doi.org/10.1016/j.inffus.2022.08.003.

[2] .-W. Yao, H. Wang, Z. Liao, M.-C. Chen, J. Pan, J. Li, K. Zhang, X. Lin, Z. Wang, Z. Luo,
et al., Quantum image processing and its application to edge detection: Theory and experiment,
Physical Review X 7 (3) (2017). doi:10.1103/physrevx.7.031041.

[3]I. F. Araujo, D. K. Park, F. Petruccione, A. J. da Silva, A divide-and-conquer algo-
rithm for quantum state preparation, Scientific Reports 11 (1) (2021). doi:10.1038/
s41598-021-85474-1.

[4] Team, T. Q. (2022, July 6). Quantum Edge Detection - qhed algorithm on small and large images. Quantum Edge Detection - QHED Algorithm on Small and Large Images. Retrieved October 28, 2022, from https://qiskit.org/textbook/ch-applications/quantum-edge-detection.html

[5] Anand, A., Lyu, M., Baweja, P. S., & Patil, V. (2022). Quantum Image Processing. https://doi.org/https://arxiv.org/pdf/2203.01831.pdf

[6] Ferris, K. J., Ramusson, A. J., Bronn, N. T., & Lanes, O. (2022). Quantum Simulation on Noisy Superconducting Quantum Computers. https://doi.org/https://doi.org/10.48550/arXiv.2209.02795

[7] LI, X. I. A. O. Y. U., YANG, G. U. O. W. U., TORRES, C. A. R. L. O. S. M. A. N. U. E. L., ZHENG, D. E. S. H. E. N. G., & WANG, K. A. N. G. L. (2013). A class of efficient quantum incrementer gates for quantum circuit synthesis. International Journal of Modern Physics B, 28(01), 1350191. https://doi.org/10.1142/s0217979213501919

[8] . Gidney, Constructing large increment gates. URL https://algassert.com/circuits/2015/06/12/Constructing-Large-Increment-Gates.html

File:DecrementOp.png

2023-05-15T20:37:22Z

Ebillias:

File:Decrement op.png

2023-05-15T20:35:16Z

Ebillias: Ebillias uploaded a new version of File:Decrement op.png

File:Decrement op.png

2023-05-15T20:33:51Z

Ebillias: Ebillias uploaded a new version of File:Decrement op.png

Internal:Quantum Machine Learning

2023-05-09T17:09:07Z

Ebillias: /* [9] Precise Image Generation on Current Noisy Quantum Devices */

= Progress =

== March 21, 2023 ==

Many of these models require a hybrid approach. Brookhaven, for example, uses a distributed series of VQC's which then feed data to a classical NN to attain results. Others use a method more in line with Cirq where the input parameters are fed into a classical NN which then produces the parameters required for the VQC. This seems almost redundant UNLESS the input data is so large that classification via classical CNN is so computationally expensive that a regular NN plus VQC is somehow "cheaper". I am not sure if our 4,032 pixel data constitutes. I am required to accomplish two distinct goals with this project:

1. Distinguish myself by using a Quantum particle data classifier which has not been seen before.

2. The product of 1. must have some utility

In regards to the Qiskit QCNN method of attaining results on the particle data we find two main problems:

* The 36x112 feature particle data is too large to use any pauli mapping so we are reliant on a 12 qubit amplitude encoding circuit. This circuit trains extremely slow even with the use of GPU's. Optimizations need to be discovered in order to make progress with this area. With that being said, for small sample sizes we achieve good results (+90%).

* The 6 feature data encoded with the same Pauli methods attain very poor results as shown below.

There exists a few solutions to the 36x112 feature problem number:

* We can interpolate the data to smaller amplitude encoded circuits such as 8 qubits. Doing so achieves respectable results (+80% accuracy) for smaller datasets (under 1000 samples). For larger datasets training time is drastically increased and progress towards a minimum is slowed and we are back to the first problem again.

* We find ways of optimizing the circuits for training. Qiskit allegedly has several "fast" sampling methods. Learning the modules and applying a few test runs should determine if the full 12 qubits can be encoded correctly.

I propose a series of problems to solve where, if solved, any one of them will be both distinguishable and possess utility:

* We can optimize training the Qiskit circuits. There are other ways to produce the required results.
** Seen here[https://qiskit.org/documentation/tutorials/simulators/7_matrix_product_state_method.html] a 50 qubit EPR state is sampled in 0.1 seconds. There are fast sampling methods built in. If these can be sent to the optimizer as a Quantum_Instance (in the same way we use the GPU) then I can simulate a wide variety of large circuits very quickly. This will allow for a more "pure" QCNN than those seen in other papers as well as having the utility of being run on real hardware (in the near future maybe!).

* The dissertation written by Jonas Landman from University of Paris proposes intersting QNN architectures such as the NISQ algorithm for Orthogonal Neural Networks. This uses a connected series of quantum VQC's which replicate a classical neural network. Using this architecture could very well provide real results on the 6 feature data (or interpolated 36x112 feature).

* Much like a combination of Jonas Landman and the Brookhaven paper, I could construct my own series of Quantum circuits which act as a distributed Neural network. A layer of circuits produce an output which are then fed into the next layer of circuits. In this case, the circuits act as both the Nodes and carry the weights in a classical sense. This gives far more parameters to work with using "less" qubits per circuit. This means, with a sufficient distribution, every datapoint will be encoded into it's own qubit even for the 36x112 feature data. +4,000 qubits won't be an issue if they're broken up into sufficiently small circuits with distributed calculations.

== March 27, 2023 ==

From last week, two major problems are solved:

1. The 6 feature data will not produce reasonable results (possibly due to the loss of locality?). However, the 4032 feature data can be resized using:

cv2.resize(samples, dsize=(n, len(samples)), interpolation=cv2.INTER_AREA)

See [https://medium.com/@wenrudong/what-is-opencvs-inter-area-actually-doing-282a626a09b3] for INTER_AREA

This allows for resizing of the image to fit some n number of pixels without loosing any of the data points to full degredation (all 0 pixel values). This resizing will allow for the training of networks using pauli feature mapping (because cv2.INTER_AREA preserves some of the locality?). This, in turn, not only greatly decreasing training times and quickens convergence, but also increases the accuracy of result.

2. The GPU implementation only requires a few lines of code to be optimized:

try:
simulator_gpu = Aer.get_backend('aer_simulator')
simulator_gpu.set_options(device='GPU', precision='single')
except AerError as e:
print('GPU Err:\n',e)

Take note that for certain feature mapping and ansatz implementations the GPU may be slower than a CPU if an insufficient number of qubits is used.

Using the following we are able to produce a very rudimentary VQC with two parts; a feature mapping and ansatz. Using everything we learned we can achieve an accuracy of +98% for previously unseen testing data in 30 iterations, training time under 2 minutes, 0.01% of the data used for training. This is done with n number of qubits/features to be 6 or 8.

So far, there is no need for a complex distributed network, hybridization, or complex QCNN classification models. The following goal is to either discover or create a more "complete" ansatz which can cover as much of the hilbert space as possible. Doing so should bump us up to +99% with a mere few minutes of training time

== March 31, 2023 ==

Heavily influenced by REfs. [1, 2, 3] as well as Jonas Landman, we can create a distributed Quantum Neural Network for particle classification. The image below, from Ref. [1], can be thought of a two layer QNN.

[[File:Scalable_qnn.png|600px]]

=== Encoding ===
The first layer is encoded directly using the data sample. That encoding will be done with either the Qiskit Pauli feature mappings or the ones used in Ref. [3] (arctan mapping). In the subsequent layers, the inputs will be the Pauli Z expectation from the previous layers individual circuit. Example, Feature extractor 1 from the image above will yield some value [-1, 1]. That value will be input into the first qubit of the "Predictor" in the second layer. Likewise, the value yielded from feature extractor 4 will be input into the last qubit of the predictor. So we know that our predictor will be 4 qubits wide. The expectation value calculations come directly from Ref. [2] and are easily implemented in qiskit.

=== VQC's ===
Every VQC in each layer, U(θ), will be an independent ansatz with parameters p[0], p[1]... p[n]. Note, a back propagation algorithm could be relatively simple to implement since each layer of the network can be represented by a parameterized weight matrix. For layer 1 in the image we have:

p_1[0] p_1[1]... p_1[n]

p_2[0] p_2[1]... p_2[n]

p_3[0] p_3[1]... p_3[n]

p_4[0] p_4[1]... p_4[n]

And for the predictor layer we will have only one row of parameters since there is only one circuit:

p_pre[0] p_pre[1]... p_pre[n]

Note the reduction in dimensionality between the two layers. Also note that this is NOT a fully connected QCNN. Moving to that model should not be too difficult depending on the results gained from this experiment. This could be implemented by the techniques described in Landman's dissertation.

=== Classical Device ===

Upon measurement of the predictor we have our classification again as a value of [-1, 1]. From here, we implement a loss function and back propagation algorithm on our parameter matrices.

== April 9, 2023 ==

[[File:FCQNN_diagram.png|1500px]]

A Fully Connected Quantum Neural Network can be seen above. The closes approximation to this that I can find in the current literature is found here [https://link.springer.com/article/10.1007/s42484-021-00046-w] (see Ref. 8). They use amplitude encoded circuits for the MNIST dataset where the ansatz used look like circularly entangled pauli two design gates. The main mechanics of a forward pass are shown in the diagram. The encoding portions of the circuits, F(X), act as the analogous neurons while the VQC's, U(θ), act as the weight matrices. It can be thought of more as a connected series of smaller classical Neural networks.

Things to consider/progress to be made:

1. As far as quantum classifiers for nuclear physics goes I have not found this network architecture applied yet.
2. Outside of a few "toy" example datasets (MNIST) and those used for dissipative quantum neural networks, these networks seem to be rare.
3. Nobody has utilized this architecture in a distributive manner.
4. I will continue using qiskit for now but I must consider c++ or cuda based applications for a quicker expectation measurements.
5. I am dedicating approximately 30 minutes to 1 hour of literature review every day to ensure that 1-3 are true.

If this works out then my goals stated here[https://crtc.cs.odu.edu/Internal:Quantum_Machine_Learning#March_21.2C_2023] will be achieved.

1. Creating a scalable quantum classification network for high energy particle physics which has not been seen before.
2. The network has real utility in the future.

= Code : =

Download the notebooks here[https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2FQML%20Course%2Fqml%5Fnotebooks&view=0]

= Literature : Quantum Classifiers =
== [1] Scalable Quantum Neural Networks for Classification ==
Jindi Wu, Zeyi Tao, Qun Li
https://arxiv.org/abs/2208.07719

Relies on a hybrid classical-quantum architecture. Each subdomain has the following:

1. Encoding Unit
* Authors utilize angle encoding (N qubits for N features) because it can support gradient calculations
* Amplitude encoding not used due to error rate and difficulty in computing gradients

2. VQC
* They follow the VQC introduced in https://www.tensorflow.org/quantum/tutorials/mnist#21_build_the_model_circuit

3. Measurement
* Calculation of the expectation value, seemingly Pauli-Z operator giving [-1, 1]

4. The measurement of the sub domain is then encoded into a qubit in the next layer.

Seemingly, this process combines both convolutional and pooling layers in the same way that Iris Cong et al. performs calculations. Advantageous over the qiskit implementation in that the "pooling layers" are not parameterized since the pooling is the measurement itself. Additionally, we can run circuits in parallel.

== [2] Quantum convolutional neural networks ==
Iris Cong et al., Nature Physics
https://doi.org/10.1038/s41567-019-0648-8

N qubit input requires O(log(N)) variational parameters. "This corresponds to a double exponential reduction compared with a generic quantum circuit-based classifier..." hopefully leading to faster training times?

== [3] Quantum convolutional neural networks for high energy physics data analysis ==
Chen et al., Brookhaven National Labs
https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.013231

The (SIMULATED) QCNN follows the following protocol:

1. Feature mapped (Amplitude encoded?) particle images of size 30x30 are implemented in the encoding layer.

2. A VQC acts as a convolutional layer. Convolutional outputs are calculated via the expectation value of the Pauli-Z operator acting on the first qubit.

3. Pooling is done classically with nonlinear activation functions in between convolutional layers (look deeper into this).

4. Categorical Cross Entropy Loss Function is applied to the final output.

5. Back Prop to adjust the parameters in the VQC's (convolutional layers).

We can implement this "by hand" in qiskit using their approximate expectation function on a Wahab GPU node using simulator.set_options(device='GPU'). This is considerable because it may be a faster process (also for larger circuits) than available public access QML methods.

== [4] Quantum machine learning for particle physics using a variational quantum classifier ==
Andrew Blancea and Michael Spannowsky
https://link.springer.com/article/10.1007/JHEP02(2021)212

This method follows the same methodology as many others.

1. Angle Encoding the data
2. Generic VQC using universal single qubit gates and CNOTs producing layers of two entangled qubits
3. Measurement is performed by experimental repetitions to determine the expectation value of the Pauli-Z operator, not calculated deterministically

Rudimentary introduction to QNN classification.

== [5] Challenges and opportunities in quantum machine learning for high-energy physics ==
Sau Lan Wu and Shinjae Yoo2
https://www.nature.com/articles/s42254-022-00425-7

"Overall, the greatest challenge in using quantum computer hardware for machine learning at present... is the size of the event samples and the effective use of large num- bers of qubits... analyses will need to manage large event sample size and large data dimensionality...

... advanced quantum computers with large numbers of qubits, reduced noise and improved running time may outperform classical machine learn- ing in both classification power and in speed. QML may well be a new computational paradigm for big data analyses in HEP. For this reason, the HEP community should stay aware of what is happening in quantum technologies — improvements in the hardware, software ecosystem and algorithms — to bring a quantum advan- tage to the HEP data challenge. Conversely, the develop- ment of solutions for unique HEP data challenges could also lead to contributions to the development of quantum technologies."

== [6] Quantum machine learning in high energy physics ==
Guan et al.
https://iopscience.iop.org/article/10.1088/2632-2153/abc17d/pdf

Uses adiabatic quantum annealing as an optimizer. This methodology also uses angle encoding for particle track data, a general VQC, with different optimizers such as ADAM and COBYLA.

== [7] Hybrid Quantum-Classical Neural Network for Calculating Ground State Energies of Molecules ==
Xia, R.; Kais, S. Hybrid Quantum-Classical Neural Network for Calculating Ground State Energies of Molecules. Entropy 2020, 22, 828. https://arxiv.org/pdf/1912.06184.pdf

Although the problem set is not what we are looking for (to find a hamiltonian for potential energy curves) the architecture of this type of QNN can be used to create a fully connected QNN. We cans say that for the image in Ref. [1], each qubit from each circuit in the first layer is measured (the expectation value calculated) independently, we now have a value to pass to the next layer of circuits. I.E. if we have a two qubit circuit, that circuit will yield two expectation values meaning we can pass two different values to two different circuit in the next layer. The first circuit layer has some x number of qubits per circuit, we will have x number of circuits in the next layer.

== [8] QDNN: deep neural networks with quantum layers ==
Zhao, C., Gao, XS. QDNN: deep neural networks with quantum layers. Quantum Mach. Intell. 3, 15 (2021). https://doi.org/10.1007/s42484-021-00046-w

What distinguishes this model from others is that it utilizes non-linear activation functions within the quantum network. Just as well, it uses a very simple and effective gradient descent method to adjust the parameters of the network.

== [9] Precise Image Generation on Current Noisy Quantum Devices ==

At first glance from the abstract it seems to reproduce angle encoding VQC results for HEP data. We already have practical use cases from prior experience with this so no need to further sell me on the idea. HOWEVER, it seems to be a comprehensive study on the topic of angle encoding specifically for HEP data on real NISQ hardware. The extra information can be invaluable to our future work.

Stored in the OneDrive here[https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fqml%5Fpapers%2F604198%2Epdf&parent=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fqml%5Fpapers].

== [10] Application of quantum computing techniques in particle tracking at LHC ==

Slides found here[https://indico.jlab.org/event/459/contributions/11836/attachments/9331/13532/20230509_CHEP_v2.pdf].

The main difference between this model and those which were previously studied seems to be the use of a quantum annealer as opposed to a quantum computer. To my understanding, annealers work by initializing a quantum superposition with equal weights. From there, it evolves via the time-dependent Schrodinger equation slowly allowing itself to exist in the ground state of some transverse field ising model. Effectively, this is the ground state hamiltonian for the system. That hamiltonian represents the global minimum of some objective function. I need to read much further into this at some point to ensure this is all correct.

To summarize, this conference presentation utilizes a form of quantum computation which is specific to a particular system of quantum superpositions. The methodology of quantum computing we have been working with is more akin to a "general" quantum computer. This presentation does not directly apply to our past VQC work but opens doors to many more possibilities.

== [11] First Measurements With A Quantum Vision Transformer: A Naive Approach ==

Cannot find a publication for this one. It seems that this [https://indico.jlab.org/event/459/contributions/11832/] will be the first introduction to this research.

Awaiting the presentation...

== [12] The Role of Data in Projected Quantum Kernels: the Higgs Boson Discrimination ==

Full publication found here[http://kth.diva-portal.org/smash/get/diva2:1718318/FULLTEXT02.pdf].

This seems to be a more robust classification model in that it explicitly describes quantum advantage over classical in terms of ML. The full pub is over 90 pages so it will take some time to parse through. But if what they say in the abstract is true then their expressions of HEP data in hilbert space will be extremely important. QML advantage over classical ML seems to be relatively rare...

== [13] Hybrid actor-critic algorithm for quantum reinforcement learning at CERN beam lines ==

Full publication is found here[https://www.researchgate.net/publication/363765523_Hybrid_actor-critic_algorithm_for_quantum_reinforcement_learning_at_CERN_beam_lines]. This ML model utilizes annealing and something called a Quantum Boltzman Machine [https://arxiv.org/pdf/1601.02036.pdf]. I have little to no experience with both of these so I will update this once I complete my readings and formulate a better image of these methods.

== [14] Improving Noisy Hybrid Quantum Graph Neural Networks for Particle Decay Tree Reconstruction ==

Slides found here[https://indico.jlab.org/event/459/contributions/11837/attachments/9417/13658/chep23.pdf].

As a hybrid model this is something I am trying to avoid for my own project. However, for the convenience of working around unavoidable noise on NISQ hardware the optimizations used for the VQC portion of the network will be of great interest. Awaiting the actual presentation/publication...

== [15] Symmetry Invariant Quantum Machine Learning models for classification problems in Particle Physics ==

No publication or slides as of yet[https://indico.jlab.org/event/459/contributions/11831/].

Opening sentence of the abstract summarizes my plight the past semester to perfection:

"In the search for advantage in Quantum Machine Learning, appropriate encoding of the underlying classical data into a quantum state is a critical step."

There are self admitted scaling issues for their encoding methodology. However, I am always finding new ways to avoid this with respectable results on some occasions (see March 27, 2023 update above).

Internal:Quantum Machine Learning

2023-05-08T20:04:29Z

Ebillias: /* [15] Symmetry Invariant Quantum Machine Learning models for classification problems in Particle Physics */

= Progress =

== March 21, 2023 ==

Many of these models require a hybrid approach. Brookhaven, for example, uses a distributed series of VQC's which then feed data to a classical NN to attain results. Others use a method more in line with Cirq where the input parameters are fed into a classical NN which then produces the parameters required for the VQC. This seems almost redundant UNLESS the input data is so large that classification via classical CNN is so computationally expensive that a regular NN plus VQC is somehow "cheaper". I am not sure if our 4,032 pixel data constitutes. I am required to accomplish two distinct goals with this project:

1. Distinguish myself by using a Quantum particle data classifier which has not been seen before.

2. The product of 1. must have some utility

In regards to the Qiskit QCNN method of attaining results on the particle data we find two main problems:

* The 36x112 feature particle data is too large to use any pauli mapping so we are reliant on a 12 qubit amplitude encoding circuit. This circuit trains extremely slow even with the use of GPU's. Optimizations need to be discovered in order to make progress with this area. With that being said, for small sample sizes we achieve good results (+90%).

* The 6 feature data encoded with the same Pauli methods attain very poor results as shown below.

There exists a few solutions to the 36x112 feature problem number:

* We can interpolate the data to smaller amplitude encoded circuits such as 8 qubits. Doing so achieves respectable results (+80% accuracy) for smaller datasets (under 1000 samples). For larger datasets training time is drastically increased and progress towards a minimum is slowed and we are back to the first problem again.

* We find ways of optimizing the circuits for training. Qiskit allegedly has several "fast" sampling methods. Learning the modules and applying a few test runs should determine if the full 12 qubits can be encoded correctly.

I propose a series of problems to solve where, if solved, any one of them will be both distinguishable and possess utility:

* We can optimize training the Qiskit circuits. There are other ways to produce the required results.
** Seen here[https://qiskit.org/documentation/tutorials/simulators/7_matrix_product_state_method.html] a 50 qubit EPR state is sampled in 0.1 seconds. There are fast sampling methods built in. If these can be sent to the optimizer as a Quantum_Instance (in the same way we use the GPU) then I can simulate a wide variety of large circuits very quickly. This will allow for a more "pure" QCNN than those seen in other papers as well as having the utility of being run on real hardware (in the near future maybe!).

* The dissertation written by Jonas Landman from University of Paris proposes intersting QNN architectures such as the NISQ algorithm for Orthogonal Neural Networks. This uses a connected series of quantum VQC's which replicate a classical neural network. Using this architecture could very well provide real results on the 6 feature data (or interpolated 36x112 feature).

* Much like a combination of Jonas Landman and the Brookhaven paper, I could construct my own series of Quantum circuits which act as a distributed Neural network. A layer of circuits produce an output which are then fed into the next layer of circuits. In this case, the circuits act as both the Nodes and carry the weights in a classical sense. This gives far more parameters to work with using "less" qubits per circuit. This means, with a sufficient distribution, every datapoint will be encoded into it's own qubit even for the 36x112 feature data. +4,000 qubits won't be an issue if they're broken up into sufficiently small circuits with distributed calculations.

== March 27, 2023 ==

From last week, two major problems are solved:

1. The 6 feature data will not produce reasonable results (possibly due to the loss of locality?). However, the 4032 feature data can be resized using:

cv2.resize(samples, dsize=(n, len(samples)), interpolation=cv2.INTER_AREA)

See [https://medium.com/@wenrudong/what-is-opencvs-inter-area-actually-doing-282a626a09b3] for INTER_AREA

This allows for resizing of the image to fit some n number of pixels without loosing any of the data points to full degredation (all 0 pixel values). This resizing will allow for the training of networks using pauli feature mapping (because cv2.INTER_AREA preserves some of the locality?). This, in turn, not only greatly decreasing training times and quickens convergence, but also increases the accuracy of result.

2. The GPU implementation only requires a few lines of code to be optimized:

try:
simulator_gpu = Aer.get_backend('aer_simulator')
simulator_gpu.set_options(device='GPU', precision='single')
except AerError as e:
print('GPU Err:\n',e)

Take note that for certain feature mapping and ansatz implementations the GPU may be slower than a CPU if an insufficient number of qubits is used.

Using the following we are able to produce a very rudimentary VQC with two parts; a feature mapping and ansatz. Using everything we learned we can achieve an accuracy of +98% for previously unseen testing data in 30 iterations, training time under 2 minutes, 0.01% of the data used for training. This is done with n number of qubits/features to be 6 or 8.

So far, there is no need for a complex distributed network, hybridization, or complex QCNN classification models. The following goal is to either discover or create a more "complete" ansatz which can cover as much of the hilbert space as possible. Doing so should bump us up to +99% with a mere few minutes of training time

== March 31, 2023 ==

Heavily influenced by REfs. [1, 2, 3] as well as Jonas Landman, we can create a distributed Quantum Neural Network for particle classification. The image below, from Ref. [1], can be thought of a two layer QNN.

[[File:Scalable_qnn.png|600px]]

=== Encoding ===
The first layer is encoded directly using the data sample. That encoding will be done with either the Qiskit Pauli feature mappings or the ones used in Ref. [3] (arctan mapping). In the subsequent layers, the inputs will be the Pauli Z expectation from the previous layers individual circuit. Example, Feature extractor 1 from the image above will yield some value [-1, 1]. That value will be input into the first qubit of the "Predictor" in the second layer. Likewise, the value yielded from feature extractor 4 will be input into the last qubit of the predictor. So we know that our predictor will be 4 qubits wide. The expectation value calculations come directly from Ref. [2] and are easily implemented in qiskit.

=== VQC's ===
Every VQC in each layer, U(θ), will be an independent ansatz with parameters p[0], p[1]... p[n]. Note, a back propagation algorithm could be relatively simple to implement since each layer of the network can be represented by a parameterized weight matrix. For layer 1 in the image we have:

p_1[0] p_1[1]... p_1[n]

p_2[0] p_2[1]... p_2[n]

p_3[0] p_3[1]... p_3[n]

p_4[0] p_4[1]... p_4[n]

And for the predictor layer we will have only one row of parameters since there is only one circuit:

p_pre[0] p_pre[1]... p_pre[n]

Note the reduction in dimensionality between the two layers. Also note that this is NOT a fully connected QCNN. Moving to that model should not be too difficult depending on the results gained from this experiment. This could be implemented by the techniques described in Landman's dissertation.

=== Classical Device ===

Upon measurement of the predictor we have our classification again as a value of [-1, 1]. From here, we implement a loss function and back propagation algorithm on our parameter matrices.

== April 9, 2023 ==

[[File:FCQNN_diagram.png|1500px]]

A Fully Connected Quantum Neural Network can be seen above. The closes approximation to this that I can find in the current literature is found here [https://link.springer.com/article/10.1007/s42484-021-00046-w] (see Ref. 8). They use amplitude encoded circuits for the MNIST dataset where the ansatz used look like circularly entangled pauli two design gates. The main mechanics of a forward pass are shown in the diagram. The encoding portions of the circuits, F(X), act as the analogous neurons while the VQC's, U(θ), act as the weight matrices. It can be thought of more as a connected series of smaller classical Neural networks.

Things to consider/progress to be made:

1. As far as quantum classifiers for nuclear physics goes I have not found this network architecture applied yet.
2. Outside of a few "toy" example datasets (MNIST) and those used for dissipative quantum neural networks, these networks seem to be rare.
3. Nobody has utilized this architecture in a distributive manner.
4. I will continue using qiskit for now but I must consider c++ or cuda based applications for a quicker expectation measurements.
5. I am dedicating approximately 30 minutes to 1 hour of literature review every day to ensure that 1-3 are true.

If this works out then my goals stated here[https://crtc.cs.odu.edu/Internal:Quantum_Machine_Learning#March_21.2C_2023] will be achieved.

1. Creating a scalable quantum classification network for high energy particle physics which has not been seen before.
2. The network has real utility in the future.

= Code : =

Download the notebooks here[https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2FQML%20Course%2Fqml%5Fnotebooks&view=0]

= Literature : Quantum Classifiers =
== [1] Scalable Quantum Neural Networks for Classification ==
Jindi Wu, Zeyi Tao, Qun Li
https://arxiv.org/abs/2208.07719

Relies on a hybrid classical-quantum architecture. Each subdomain has the following:

1. Encoding Unit
* Authors utilize angle encoding (N qubits for N features) because it can support gradient calculations
* Amplitude encoding not used due to error rate and difficulty in computing gradients

2. VQC
* They follow the VQC introduced in https://www.tensorflow.org/quantum/tutorials/mnist#21_build_the_model_circuit

3. Measurement
* Calculation of the expectation value, seemingly Pauli-Z operator giving [-1, 1]

4. The measurement of the sub domain is then encoded into a qubit in the next layer.

Seemingly, this process combines both convolutional and pooling layers in the same way that Iris Cong et al. performs calculations. Advantageous over the qiskit implementation in that the "pooling layers" are not parameterized since the pooling is the measurement itself. Additionally, we can run circuits in parallel.

== [2] Quantum convolutional neural networks ==
Iris Cong et al., Nature Physics
https://doi.org/10.1038/s41567-019-0648-8

N qubit input requires O(log(N)) variational parameters. "This corresponds to a double exponential reduction compared with a generic quantum circuit-based classifier..." hopefully leading to faster training times?

== [3] Quantum convolutional neural networks for high energy physics data analysis ==
Chen et al., Brookhaven National Labs
https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.013231

The (SIMULATED) QCNN follows the following protocol:

1. Feature mapped (Amplitude encoded?) particle images of size 30x30 are implemented in the encoding layer.

2. A VQC acts as a convolutional layer. Convolutional outputs are calculated via the expectation value of the Pauli-Z operator acting on the first qubit.

3. Pooling is done classically with nonlinear activation functions in between convolutional layers (look deeper into this).

4. Categorical Cross Entropy Loss Function is applied to the final output.

5. Back Prop to adjust the parameters in the VQC's (convolutional layers).

We can implement this "by hand" in qiskit using their approximate expectation function on a Wahab GPU node using simulator.set_options(device='GPU'). This is considerable because it may be a faster process (also for larger circuits) than available public access QML methods.

== [4] Quantum machine learning for particle physics using a variational quantum classifier ==
Andrew Blancea and Michael Spannowsky
https://link.springer.com/article/10.1007/JHEP02(2021)212

This method follows the same methodology as many others.

1. Angle Encoding the data
2. Generic VQC using universal single qubit gates and CNOTs producing layers of two entangled qubits
3. Measurement is performed by experimental repetitions to determine the expectation value of the Pauli-Z operator, not calculated deterministically

Rudimentary introduction to QNN classification.

== [5] Challenges and opportunities in quantum machine learning for high-energy physics ==
Sau Lan Wu and Shinjae Yoo2
https://www.nature.com/articles/s42254-022-00425-7

"Overall, the greatest challenge in using quantum computer hardware for machine learning at present... is the size of the event samples and the effective use of large num- bers of qubits... analyses will need to manage large event sample size and large data dimensionality...

... advanced quantum computers with large numbers of qubits, reduced noise and improved running time may outperform classical machine learn- ing in both classification power and in speed. QML may well be a new computational paradigm for big data analyses in HEP. For this reason, the HEP community should stay aware of what is happening in quantum technologies — improvements in the hardware, software ecosystem and algorithms — to bring a quantum advan- tage to the HEP data challenge. Conversely, the develop- ment of solutions for unique HEP data challenges could also lead to contributions to the development of quantum technologies."

== [6] Quantum machine learning in high energy physics ==
Guan et al.
https://iopscience.iop.org/article/10.1088/2632-2153/abc17d/pdf

Uses adiabatic quantum annealing as an optimizer. This methodology also uses angle encoding for particle track data, a general VQC, with different optimizers such as ADAM and COBYLA.

== [7] Hybrid Quantum-Classical Neural Network for Calculating Ground State Energies of Molecules ==
Xia, R.; Kais, S. Hybrid Quantum-Classical Neural Network for Calculating Ground State Energies of Molecules. Entropy 2020, 22, 828. https://arxiv.org/pdf/1912.06184.pdf

Although the problem set is not what we are looking for (to find a hamiltonian for potential energy curves) the architecture of this type of QNN can be used to create a fully connected QNN. We cans say that for the image in Ref. [1], each qubit from each circuit in the first layer is measured (the expectation value calculated) independently, we now have a value to pass to the next layer of circuits. I.E. if we have a two qubit circuit, that circuit will yield two expectation values meaning we can pass two different values to two different circuit in the next layer. The first circuit layer has some x number of qubits per circuit, we will have x number of circuits in the next layer.

== [8] QDNN: deep neural networks with quantum layers ==
Zhao, C., Gao, XS. QDNN: deep neural networks with quantum layers. Quantum Mach. Intell. 3, 15 (2021). https://doi.org/10.1007/s42484-021-00046-w

What distinguishes this model from others is that it utilizes non-linear activation functions within the quantum network. Just as well, it uses a very simple and effective gradient descent method to adjust the parameters of the network.

== [9] Precise Image Generation on Current Noisy Quantum Devices ==

At first glance from the abstract it seems to reproduce angle encoding VQC results for HEP data. We already have practical use cases from prior experience with this so no need to further sell me on the idea. HOWEVER, it seems to be a comprehensive study on the topic of angle encoding specifically for HEP data on real NISQ hardware. The extra information can be invaluable to our future work.

Found here[https://ieeexplore.ieee.org/document/9996924], requested through ODU InterLibrary Loan.

== [10] Application of quantum computing techniques in particle tracking at LHC ==

Slides found here[https://indico.jlab.org/event/459/contributions/11836/attachments/9331/13532/20230509_CHEP_v2.pdf].

The main difference between this model and those which were previously studied seems to be the use of a quantum annealer as opposed to a quantum computer. To my understanding, annealers work by initializing a quantum superposition with equal weights. From there, it evolves via the time-dependent Schrodinger equation slowly allowing itself to exist in the ground state of some transverse field ising model. Effectively, this is the ground state hamiltonian for the system. That hamiltonian represents the global minimum of some objective function. I need to read much further into this at some point to ensure this is all correct.

To summarize, this conference presentation utilizes a form of quantum computation which is specific to a particular system of quantum superpositions. The methodology of quantum computing we have been working with is more akin to a "general" quantum computer. This presentation does not directly apply to our past VQC work but opens doors to many more possibilities.

== [11] First Measurements With A Quantum Vision Transformer: A Naive Approach ==

Cannot find a publication for this one. It seems that this [https://indico.jlab.org/event/459/contributions/11832/] will be the first introduction to this research.

Awaiting the presentation...

== [12] The Role of Data in Projected Quantum Kernels: the Higgs Boson Discrimination ==

Full publication found here[http://kth.diva-portal.org/smash/get/diva2:1718318/FULLTEXT02.pdf].

This seems to be a more robust classification model in that it explicitly describes quantum advantage over classical in terms of ML. The full pub is over 90 pages so it will take some time to parse through. But if what they say in the abstract is true then their expressions of HEP data in hilbert space will be extremely important. QML advantage over classical ML seems to be relatively rare...

== [13] Hybrid actor-critic algorithm for quantum reinforcement learning at CERN beam lines ==

Full publication is found here[https://www.researchgate.net/publication/363765523_Hybrid_actor-critic_algorithm_for_quantum_reinforcement_learning_at_CERN_beam_lines]. This ML model utilizes annealing and something called a Quantum Boltzman Machine [https://arxiv.org/pdf/1601.02036.pdf]. I have little to no experience with both of these so I will update this once I complete my readings and formulate a better image of these methods.

== [14] Improving Noisy Hybrid Quantum Graph Neural Networks for Particle Decay Tree Reconstruction ==

Slides found here[https://indico.jlab.org/event/459/contributions/11837/attachments/9417/13658/chep23.pdf].

As a hybrid model this is something I am trying to avoid for my own project. However, for the convenience of working around unavoidable noise on NISQ hardware the optimizations used for the VQC portion of the network will be of great interest. Awaiting the actual presentation/publication...

== [15] Symmetry Invariant Quantum Machine Learning models for classification problems in Particle Physics ==

No publication or slides as of yet[https://indico.jlab.org/event/459/contributions/11831/].

Opening sentence of the abstract summarizes my plight the past semester to perfection:

"In the search for advantage in Quantum Machine Learning, appropriate encoding of the underlying classical data into a quantum state is a critical step."

There are self admitted scaling issues for their encoding methodology. However, I am always finding new ways to avoid this with respectable results on some occasions (see March 27, 2023 update above).

Internal:Quantum Machine Learning

2023-05-08T20:03:36Z

Ebillias: /* Literature : Quantum Classifiers */

= Progress =

== March 21, 2023 ==

Many of these models require a hybrid approach. Brookhaven, for example, uses a distributed series of VQC's which then feed data to a classical NN to attain results. Others use a method more in line with Cirq where the input parameters are fed into a classical NN which then produces the parameters required for the VQC. This seems almost redundant UNLESS the input data is so large that classification via classical CNN is so computationally expensive that a regular NN plus VQC is somehow "cheaper". I am not sure if our 4,032 pixel data constitutes. I am required to accomplish two distinct goals with this project:

1. Distinguish myself by using a Quantum particle data classifier which has not been seen before.

2. The product of 1. must have some utility

In regards to the Qiskit QCNN method of attaining results on the particle data we find two main problems:

* The 36x112 feature particle data is too large to use any pauli mapping so we are reliant on a 12 qubit amplitude encoding circuit. This circuit trains extremely slow even with the use of GPU's. Optimizations need to be discovered in order to make progress with this area. With that being said, for small sample sizes we achieve good results (+90%).

* The 6 feature data encoded with the same Pauli methods attain very poor results as shown below.

There exists a few solutions to the 36x112 feature problem number:

* We can interpolate the data to smaller amplitude encoded circuits such as 8 qubits. Doing so achieves respectable results (+80% accuracy) for smaller datasets (under 1000 samples). For larger datasets training time is drastically increased and progress towards a minimum is slowed and we are back to the first problem again.

* We find ways of optimizing the circuits for training. Qiskit allegedly has several "fast" sampling methods. Learning the modules and applying a few test runs should determine if the full 12 qubits can be encoded correctly.

I propose a series of problems to solve where, if solved, any one of them will be both distinguishable and possess utility:

* We can optimize training the Qiskit circuits. There are other ways to produce the required results.
** Seen here[https://qiskit.org/documentation/tutorials/simulators/7_matrix_product_state_method.html] a 50 qubit EPR state is sampled in 0.1 seconds. There are fast sampling methods built in. If these can be sent to the optimizer as a Quantum_Instance (in the same way we use the GPU) then I can simulate a wide variety of large circuits very quickly. This will allow for a more "pure" QCNN than those seen in other papers as well as having the utility of being run on real hardware (in the near future maybe!).

* The dissertation written by Jonas Landman from University of Paris proposes intersting QNN architectures such as the NISQ algorithm for Orthogonal Neural Networks. This uses a connected series of quantum VQC's which replicate a classical neural network. Using this architecture could very well provide real results on the 6 feature data (or interpolated 36x112 feature).

* Much like a combination of Jonas Landman and the Brookhaven paper, I could construct my own series of Quantum circuits which act as a distributed Neural network. A layer of circuits produce an output which are then fed into the next layer of circuits. In this case, the circuits act as both the Nodes and carry the weights in a classical sense. This gives far more parameters to work with using "less" qubits per circuit. This means, with a sufficient distribution, every datapoint will be encoded into it's own qubit even for the 36x112 feature data. +4,000 qubits won't be an issue if they're broken up into sufficiently small circuits with distributed calculations.

== March 27, 2023 ==

From last week, two major problems are solved:

1. The 6 feature data will not produce reasonable results (possibly due to the loss of locality?). However, the 4032 feature data can be resized using:

cv2.resize(samples, dsize=(n, len(samples)), interpolation=cv2.INTER_AREA)

See [https://medium.com/@wenrudong/what-is-opencvs-inter-area-actually-doing-282a626a09b3] for INTER_AREA

This allows for resizing of the image to fit some n number of pixels without loosing any of the data points to full degredation (all 0 pixel values). This resizing will allow for the training of networks using pauli feature mapping (because cv2.INTER_AREA preserves some of the locality?). This, in turn, not only greatly decreasing training times and quickens convergence, but also increases the accuracy of result.

2. The GPU implementation only requires a few lines of code to be optimized:

try:
simulator_gpu = Aer.get_backend('aer_simulator')
simulator_gpu.set_options(device='GPU', precision='single')
except AerError as e:
print('GPU Err:\n',e)

Take note that for certain feature mapping and ansatz implementations the GPU may be slower than a CPU if an insufficient number of qubits is used.

Using the following we are able to produce a very rudimentary VQC with two parts; a feature mapping and ansatz. Using everything we learned we can achieve an accuracy of +98% for previously unseen testing data in 30 iterations, training time under 2 minutes, 0.01% of the data used for training. This is done with n number of qubits/features to be 6 or 8.

So far, there is no need for a complex distributed network, hybridization, or complex QCNN classification models. The following goal is to either discover or create a more "complete" ansatz which can cover as much of the hilbert space as possible. Doing so should bump us up to +99% with a mere few minutes of training time

== March 31, 2023 ==

Heavily influenced by REfs. [1, 2, 3] as well as Jonas Landman, we can create a distributed Quantum Neural Network for particle classification. The image below, from Ref. [1], can be thought of a two layer QNN.

[[File:Scalable_qnn.png|600px]]

=== Encoding ===
The first layer is encoded directly using the data sample. That encoding will be done with either the Qiskit Pauli feature mappings or the ones used in Ref. [3] (arctan mapping). In the subsequent layers, the inputs will be the Pauli Z expectation from the previous layers individual circuit. Example, Feature extractor 1 from the image above will yield some value [-1, 1]. That value will be input into the first qubit of the "Predictor" in the second layer. Likewise, the value yielded from feature extractor 4 will be input into the last qubit of the predictor. So we know that our predictor will be 4 qubits wide. The expectation value calculations come directly from Ref. [2] and are easily implemented in qiskit.

=== VQC's ===
Every VQC in each layer, U(θ), will be an independent ansatz with parameters p[0], p[1]... p[n]. Note, a back propagation algorithm could be relatively simple to implement since each layer of the network can be represented by a parameterized weight matrix. For layer 1 in the image we have:

p_1[0] p_1[1]... p_1[n]

p_2[0] p_2[1]... p_2[n]

p_3[0] p_3[1]... p_3[n]

p_4[0] p_4[1]... p_4[n]

And for the predictor layer we will have only one row of parameters since there is only one circuit:

p_pre[0] p_pre[1]... p_pre[n]

Note the reduction in dimensionality between the two layers. Also note that this is NOT a fully connected QCNN. Moving to that model should not be too difficult depending on the results gained from this experiment. This could be implemented by the techniques described in Landman's dissertation.

=== Classical Device ===

Upon measurement of the predictor we have our classification again as a value of [-1, 1]. From here, we implement a loss function and back propagation algorithm on our parameter matrices.

== April 9, 2023 ==

[[File:FCQNN_diagram.png|1500px]]

A Fully Connected Quantum Neural Network can be seen above. The closes approximation to this that I can find in the current literature is found here [https://link.springer.com/article/10.1007/s42484-021-00046-w] (see Ref. 8). They use amplitude encoded circuits for the MNIST dataset where the ansatz used look like circularly entangled pauli two design gates. The main mechanics of a forward pass are shown in the diagram. The encoding portions of the circuits, F(X), act as the analogous neurons while the VQC's, U(θ), act as the weight matrices. It can be thought of more as a connected series of smaller classical Neural networks.

Things to consider/progress to be made:

1. As far as quantum classifiers for nuclear physics goes I have not found this network architecture applied yet.
2. Outside of a few "toy" example datasets (MNIST) and those used for dissipative quantum neural networks, these networks seem to be rare.
3. Nobody has utilized this architecture in a distributive manner.
4. I will continue using qiskit for now but I must consider c++ or cuda based applications for a quicker expectation measurements.
5. I am dedicating approximately 30 minutes to 1 hour of literature review every day to ensure that 1-3 are true.

If this works out then my goals stated here[https://crtc.cs.odu.edu/Internal:Quantum_Machine_Learning#March_21.2C_2023] will be achieved.

1. Creating a scalable quantum classification network for high energy particle physics which has not been seen before.
2. The network has real utility in the future.

= Code : =

Download the notebooks here[https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2FQML%20Course%2Fqml%5Fnotebooks&view=0]

= Literature : Quantum Classifiers =
== [1] Scalable Quantum Neural Networks for Classification ==
Jindi Wu, Zeyi Tao, Qun Li
https://arxiv.org/abs/2208.07719

Relies on a hybrid classical-quantum architecture. Each subdomain has the following:

1. Encoding Unit
* Authors utilize angle encoding (N qubits for N features) because it can support gradient calculations
* Amplitude encoding not used due to error rate and difficulty in computing gradients

2. VQC
* They follow the VQC introduced in https://www.tensorflow.org/quantum/tutorials/mnist#21_build_the_model_circuit

3. Measurement
* Calculation of the expectation value, seemingly Pauli-Z operator giving [-1, 1]

4. The measurement of the sub domain is then encoded into a qubit in the next layer.

Seemingly, this process combines both convolutional and pooling layers in the same way that Iris Cong et al. performs calculations. Advantageous over the qiskit implementation in that the "pooling layers" are not parameterized since the pooling is the measurement itself. Additionally, we can run circuits in parallel.

== [2] Quantum convolutional neural networks ==
Iris Cong et al., Nature Physics
https://doi.org/10.1038/s41567-019-0648-8

N qubit input requires O(log(N)) variational parameters. "This corresponds to a double exponential reduction compared with a generic quantum circuit-based classifier..." hopefully leading to faster training times?

== [3] Quantum convolutional neural networks for high energy physics data analysis ==
Chen et al., Brookhaven National Labs
https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.013231

The (SIMULATED) QCNN follows the following protocol:

1. Feature mapped (Amplitude encoded?) particle images of size 30x30 are implemented in the encoding layer.

2. A VQC acts as a convolutional layer. Convolutional outputs are calculated via the expectation value of the Pauli-Z operator acting on the first qubit.

3. Pooling is done classically with nonlinear activation functions in between convolutional layers (look deeper into this).

4. Categorical Cross Entropy Loss Function is applied to the final output.

5. Back Prop to adjust the parameters in the VQC's (convolutional layers).

We can implement this "by hand" in qiskit using their approximate expectation function on a Wahab GPU node using simulator.set_options(device='GPU'). This is considerable because it may be a faster process (also for larger circuits) than available public access QML methods.

== [4] Quantum machine learning for particle physics using a variational quantum classifier ==
Andrew Blancea and Michael Spannowsky
https://link.springer.com/article/10.1007/JHEP02(2021)212

This method follows the same methodology as many others.

1. Angle Encoding the data
2. Generic VQC using universal single qubit gates and CNOTs producing layers of two entangled qubits
3. Measurement is performed by experimental repetitions to determine the expectation value of the Pauli-Z operator, not calculated deterministically

Rudimentary introduction to QNN classification.

== [5] Challenges and opportunities in quantum machine learning for high-energy physics ==
Sau Lan Wu and Shinjae Yoo2
https://www.nature.com/articles/s42254-022-00425-7

"Overall, the greatest challenge in using quantum computer hardware for machine learning at present... is the size of the event samples and the effective use of large num- bers of qubits... analyses will need to manage large event sample size and large data dimensionality...

... advanced quantum computers with large numbers of qubits, reduced noise and improved running time may outperform classical machine learn- ing in both classification power and in speed. QML may well be a new computational paradigm for big data analyses in HEP. For this reason, the HEP community should stay aware of what is happening in quantum technologies — improvements in the hardware, software ecosystem and algorithms — to bring a quantum advan- tage to the HEP data challenge. Conversely, the develop- ment of solutions for unique HEP data challenges could also lead to contributions to the development of quantum technologies."

== [6] Quantum machine learning in high energy physics ==
Guan et al.
https://iopscience.iop.org/article/10.1088/2632-2153/abc17d/pdf

Uses adiabatic quantum annealing as an optimizer. This methodology also uses angle encoding for particle track data, a general VQC, with different optimizers such as ADAM and COBYLA.

== [7] Hybrid Quantum-Classical Neural Network for Calculating Ground State Energies of Molecules ==
Xia, R.; Kais, S. Hybrid Quantum-Classical Neural Network for Calculating Ground State Energies of Molecules. Entropy 2020, 22, 828. https://arxiv.org/pdf/1912.06184.pdf

Although the problem set is not what we are looking for (to find a hamiltonian for potential energy curves) the architecture of this type of QNN can be used to create a fully connected QNN. We cans say that for the image in Ref. [1], each qubit from each circuit in the first layer is measured (the expectation value calculated) independently, we now have a value to pass to the next layer of circuits. I.E. if we have a two qubit circuit, that circuit will yield two expectation values meaning we can pass two different values to two different circuit in the next layer. The first circuit layer has some x number of qubits per circuit, we will have x number of circuits in the next layer.

== [8] QDNN: deep neural networks with quantum layers ==
Zhao, C., Gao, XS. QDNN: deep neural networks with quantum layers. Quantum Mach. Intell. 3, 15 (2021). https://doi.org/10.1007/s42484-021-00046-w

What distinguishes this model from others is that it utilizes non-linear activation functions within the quantum network. Just as well, it uses a very simple and effective gradient descent method to adjust the parameters of the network.

== [9] Precise Image Generation on Current Noisy Quantum Devices ==

At first glance from the abstract it seems to reproduce angle encoding VQC results for HEP data. We already have practical use cases from prior experience with this so no need to further sell me on the idea. HOWEVER, it seems to be a comprehensive study on the topic of angle encoding specifically for HEP data on real NISQ hardware. The extra information can be invaluable to our future work.

Found here[https://ieeexplore.ieee.org/document/9996924], requested through ODU InterLibrary Loan.

== [10] Application of quantum computing techniques in particle tracking at LHC ==

Slides found here[https://indico.jlab.org/event/459/contributions/11836/attachments/9331/13532/20230509_CHEP_v2.pdf].

The main difference between this model and those which were previously studied seems to be the use of a quantum annealer as opposed to a quantum computer. To my understanding, annealers work by initializing a quantum superposition with equal weights. From there, it evolves via the time-dependent Schrodinger equation slowly allowing itself to exist in the ground state of some transverse field ising model. Effectively, this is the ground state hamiltonian for the system. That hamiltonian represents the global minimum of some objective function. I need to read much further into this at some point to ensure this is all correct.

To summarize, this conference presentation utilizes a form of quantum computation which is specific to a particular system of quantum superpositions. The methodology of quantum computing we have been working with is more akin to a "general" quantum computer. This presentation does not directly apply to our past VQC work but opens doors to many more possibilities.

== [11] First Measurements With A Quantum Vision Transformer: A Naive Approach ==

Cannot find a publication for this one. It seems that this [https://indico.jlab.org/event/459/contributions/11832/] will be the first introduction to this research.

Awaiting the presentation...

== [12] The Role of Data in Projected Quantum Kernels: the Higgs Boson Discrimination ==

Full publication found here[http://kth.diva-portal.org/smash/get/diva2:1718318/FULLTEXT02.pdf].

This seems to be a more robust classification model in that it explicitly describes quantum advantage over classical in terms of ML. The full pub is over 90 pages so it will take some time to parse through. But if what they say in the abstract is true then their expressions of HEP data in hilbert space will be extremely important. QML advantage over classical ML seems to be relatively rare...

== [13] Hybrid actor-critic algorithm for quantum reinforcement learning at CERN beam lines ==

Full publication is found here[https://www.researchgate.net/publication/363765523_Hybrid_actor-critic_algorithm_for_quantum_reinforcement_learning_at_CERN_beam_lines]. This ML model utilizes annealing and something called a Quantum Boltzman Machine [https://arxiv.org/pdf/1601.02036.pdf]. I have little to no experience with both of these so I will update this once I complete my readings and formulate a better image of these methods.

== [14] Improving Noisy Hybrid Quantum Graph Neural Networks for Particle Decay Tree Reconstruction ==

Slides found here[https://indico.jlab.org/event/459/contributions/11837/attachments/9417/13658/chep23.pdf].

As a hybrid model this is something I am trying to avoid for my own project. However, for the convenience of working around unavoidable noise on NISQ hardware the optimizations used for the VQC portion of the network will be of great interest. Awaiting the actual presentation/publication...

== [15] Symmetry Invariant Quantum Machine Learning models for classification problems in Particle Physics ==

No publication or slides as of yet[https://indico.jlab.org/event/459/contributions/11831/].

Opening sentence of the abstract summarizes my plight the past semester to perfection:

"In the search for advantage in Quantum Machine Learning, appropriate encoding of the underlying classical data into a quantum state is a critical step."

There are self admitted scaling issues for their encoding methodology. However, I am always finding new ways to avoid this with respectable results on some occasions!

Internal:Quantum Information Science (QIS General)

2023-05-03T19:00:55Z

Ebillias: /* Inset Plot */

Internal:Quantum Information Science (QIS General)

2023-05-03T19:00:11Z

Ebillias: /* Inset Plot */

Internal:Quantum Information Science (QIS General)

2023-05-02T20:46:40Z

Ebillias: /* Code */

File:Inset2.png

2023-05-02T20:46:24Z

Ebillias:

File:Inset1.png

2023-05-02T20:40:44Z

Ebillias:

Internal:Quantum Information Science (QIS General)

2023-05-02T19:03:52Z

Ebillias: /* Qiskit */

Internal:Quantum Information Science (QIS General)

2023-05-02T18:54:30Z

Ebillias:

Internal:Quantum Information Science (QIS General)

2023-04-28T18:57:27Z

Ebillias: /* QIS General */

Internal:Quantum Edge Detection

2023-04-27T22:25:33Z

Ebillias: /* Quantum Fidelity */

= Quantum Hadamard Edge Detection (QHED) =

A recent quantum edge detection algorithm called Quantum Hadamard Edge Detection[2] (QHED) provides a promising means of quantum image processing and experimentation. This is done by providing full boundary gradient across a 1D mapping of a 2D image. Due to fidelity issues on NISQ era hardware, we are required to divide our images into sub images (domain decomposition) for proper edge detection[1]. When doing this, we find a boundary error issue with the algorithm. In addition, we utilize a series of optimization techniques found in Ref. [6] to overcome the resultant hardware noise. The hardware limitations and the few issues with the QHED algorithm itself are reduced in order to produce simulated NISQ hardware results on large images.

The overall goal of this project is to produce high quality results via the QHED circuit on large medical images via REAL NISQ era hardware. Classically, we can use space filling curves or pixel buffers to improve results upon the decomposed image. As far as real hardware is concerned, areas of interest to achieve quality results are by implementing major improvements upon the decrement gate which seems to be the failure point. We can tackle this by a combination of efficient mathematics[7], NISQ error mitigation techniques[6], and VQC techniques. The combination of all of these applied to the three major sections of the circuit (ignoring the measurement phase) could very well result in accurate edge detection results on real quantum hardware. Without access to larger number of qubits (>7 qubits) we need to use the topology taken from noisy simulated hardware. The principles of CX error, single gate error, fidelity, and coherence normally found in real hardware are applicable to noisy simulations. Thus, this remains as a quality means of data analysis prior to execution on real hardware.

== Code ==
Download the Decrement and image encoding notebooks here [https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fquantum%5Fedge%5Fdetection%2Fnotebooks&view=0]

== Paper ==
Find the current version of paper here[https://www.overleaf.com/project/64341df873168e42fe8c2624]

== Quantum Fidelity ==

For most of this research project we have been using a fidelity metric from Ref. [https://arxiv.org/pdf/2209.02795.pdf]. This metric is a simple function dependent on the number of single qubit gates, CNOT gates, and their respective average error rates for some particular circuit on a pre specified backend. This is, in my opinion, analogous to a performance metric from the standpoint of an engineer (say miles per gallon on a car). The calculation itself yields a somewhat confusing unit of measurement (MPG is a cross sectional unit of area!). The metric of MPG still gives you insight into efficiency and performance. However, the results of MPG will depend entirely on the driver and the conditions that the vehicle is subject to. I believe that IBM did do a good job with this as it gives (seemingly) a predictable insight into the efficiency and performance of a circuit on some given hardware. If we want the real observed fidelity through sampling the circuit we are required to "drive" and test our circuit.

Fidelity in itself is not a strict metric. Rather, it is an abstract computation which can be used to predict the probability that one quantum state can pass as another [https://en.wikipedia.org/wiki/Fidelity_of_quantum_states]. Allegedly, Jozsa points out in the publication found here [https://www.tandfonline.com/doi/epdf/10.1080/09500349414552171?needAccess=true] that an overlap of pure quantum states on the geometry of hilbert space can easily be defined as:

|<ψ|χ>|

Which will be 1 where |χ> = |ψ> and 0 if they are perfectly orthogonal. This can be visualized as a simple overlap of two quantum states and the result is exactly how much they overlap. Since the QHED circuit produces pure quantum states we consider this as a fidelity option to calculate. Noisy circuits will yield (at the time of each individual measurement) a pure quantum state. However, the sum of those pure states will produce a density matrix which is most probably not pure. With that being said, Jozsa had produced a fidelity metric for one pure state (ideal) and one mixed state (noisy). Given two density operators where one is pure and the other mixed:

F(ρ,σ) = (tr √ (√ρ σ √ρ))²

There are other definitions for fidelity in the case of mixed states developed by Jozsa, Nielsen[https://arxiv.org/pdf/quant-ph/0205035.pdf], and several others [http://www.physik.uni-leipzig.de/~uhlmann/PDF/Uh76a.pdf]. A more robust technique is called Quantum Tomography [https://en.wikipedia.org/wiki/Quantum_tomography]. This, I believe, falls out of the scope of QHED. QHED relies only on the output state of the circuit in the computational (Z) basis, therefore I believe that Josza's trace definition should suffice.

In short, the Qiskit definition of fidelity in their paper is not wrong, but rather incomplete in my opinion. There is no strict definition for fidelity. Rather, fidelity is used to give insight to the closeness between states in quantum information theory. The IBM paper predicts the "overlap" while Josza's metric requires sampling to determine fidelity through experimentation. I think that redefining this metric for ourselves within the scope of Jozsa's definition allows for a more robust representation of what we have actually accomplished with these optimizations since we are comparing the ideal output directly to the actual result.

== QHED Circuit ==

[[File:Qhed circuit.png|500px|thumb|none|Figure 1 Generalized qHED Circuit with input vector f and output vector g.]]

=== State Prep ===
[[File:Rcmo.png|500px|thumb|none|Figure 2 Row (left) and Column (right) major ordered mapping.]]

The image is first mapped as a 2D array to a 1D vector. Ref. [2] uses methodology known as row and column major ordering (RCMO). Each pixel is then normalized such that the sum of their squares is equal to 1, a necessary quality of quantum states. Using a module presented by Ref. [3] (or through Qiskit's StatePreparation), we can calculate a quantum circuit which achieves what is known as amplitude encoding. The normalized pixel values of the input vector will be returned as the probability amplitudes of computational basis states. Those computational basis states act as the indexing of the original vector. I.e. if we had a length 64 vector, the 7th element is represented as c_7|000111>. The resultant normalized image state can be written as:

[[File:Img state.png|200px]]

The Hadamard gate in the state prep acts on the Least Significant Bit (LSB) initialized to state |0> which outputs the |+> state. Application of the H-Gate on the LSB has the following tensor product on the input image state:

[[File:State prep.png|400px]]

=== Decrement ===

The decrement portion of the quantum algorithm can be represented by the matrix unitary:

[[File:Decrement unitary.png|400px]]

With application of that unitary gate to the state prepared vector yields the decrement state:

[[File:Decrement state.png|500px]]

To the best of our abilities, we find that references to the QHED method provide very little (if any) detail as to the architecture of the decrement gate. Refs. [4] and presumably [5] use a qiskit unitary class function to convert a numpy matrix into a circuit. Although quite useful for simulations, this type of construction fails on real hardware. We can find a far more reasonable design of the gate in Ref. [7] which is shown below.

[[File:decrement_gate.png|500px|thumb|none|Multi controlled NOT gates perform the decrement operation. q_0 being the least significant qubit.]]

Although it is known that multi qubit gates are highly error prone, we achieve reasonable results when we compare the two methodologies. We begin with a 4 qubit circuit initialized to the state |0000> = (1...0) which is to be decremented to state |1111> = (0...1). Shown below are the results of the more careful multi controlled qubit construction and the unitary class function executed on the real quantum device, ibmq_lima. Based on the results, we know that we must design our own decrement gates and cannot rely on any arbitrary unitary transformation algorithim.

[[File:Lima tl 3.png|500px|thumb|none| Although the results are far from perfect, we can clearly see the state 1111> has been formed from the state 0000>.]]

[[File:Lima np.png|500px|thumb|none| The results of our gate are lost in the noise of the output using the unitary class function.]]

We can improve upon the Decrement gate by using 2n total qubits by altering the increment gates in Ref. [8]. More simply, using open controls (bit flip in the case of the qubit being in the state |0>) alters the increment permutation to a decrement.

[[File:Decrement op.png|500px]]

Looking at the CX counts and fidelity estimates for QHED circuits show promising results. The upcoming section "Methods of Optimization" will describe the optimizations themselves as they are labeled in the charts below.

[[File:Qhed cx.png|500px]]
[[File:Qhed fidelity.png|500px]]

=== Permutation ===
This is the portion of the circuit where the actual edge detection occurs. It can be thought of as a series of identity gates tensored together with an H-Gate in the LSB tensored last. The resultant unitary matrix can be written as:

[[File:Permutation unitary.png|500px]]

With application of the resultant decrement vector as:

[[File:Permutation state.png|500px]]

This is the final output state. Note that if the LSB is in the state |1> we retrieve all of the odd indexed states i.e. |...001> (1), |...011> (3), |...111> (5), ect. These states provide the boundary gradient across the 1D input image. An overview of the QHED algorithm can be visualized as having the following effect on the input of an image state:

[[File:QHED output.png|300px]]

== Methods of Optimization ==

The improved decrement gate was already discussed in the previous section so we will leave it there.

We then utilize Qiskit's transpiler. The optimal SWAP mapping is an NP-Hard problem which yields ambiguous results. "The choice of initial layout can mean the difference between getting a result, and getting nothing but noise." To compute the best low noise layout, we use an open source module called mapomatic. Mapomatic finds the best low noise sub-graph for some given hardware backend(s). The end result is that the module returns the best set of qubits and their appropriate ordering to execute your circuit with minimal noise. This qubit layout is sent to the transpiler. A heuristic fidelity estimate is taken from Ref. [6].

We now turn to a means of error reduction in the measurement output of the circuit. Researchers are able to perform a variety of experiments to measure a qubit's state preparation and measurement (SPAM) errors forming a relationship of noisy probabilities to ideal probabilities in the form of a matrix transformation. The correction matrix can be measured by using a variety of circuits with known outcomes and finding the noisy outcome of every possible bit-string for a particular piece of hardware. From this, it is possible to reconstruct our desired output.

There are obvious scaling issues when it comes to building 2^n x 2^n matricies. There are alternatives to this which do not require such scaling or computational overhead. We make use of such a module called mthree. An excellent demonstration of this can be found in the Qiskit Textbook.

In the case of large images, we must perform domain decomposition to preserve fidelity and reduce noise. However, we find that when applying the suggested RMO and CMO indexed 2D to 1D mapping on decomposed sub images there is a non negligible quality reduction to the output edge detected image. This is due to the fact that this use of mapping does not preserve locality. It can be seen from Fig. [2] how these methods of indexing will provide errors across the boundaries of the image/sub images. Consider the output state |g>. It can be seen how non adjacent pixels of the original image will be compared with each other e.g. c_{3} - c_{4} in the Fig. [2] RMO mapping or c_{12} - c_{1} in the CMO mapping. This may lead to detected edges where there are none. To avoid these discrepancies we apply buffer cells to our decomposed images. We choose to do a row by row decomposition for the horizontal scan as shown below. This leaves 2 redundant pixels per sub image, no matter the decomposition size.

[[File:Boundary buffer.png|500px|thumb|none|Buffer pixels of value 0 are applied to the boundary of the overall image.]]

[[File:Buffer cells.png|500px|thumb|none|Further decomposition is then possible by adding neighboring pixels to be used as a buffer due to QHED error. The red cells are ultimately disposed in the final output.]]

With the decrement gate optimization, the more NISQ-era friendly QHED circuit takes the form shown below.

[[File:Qhed op.png|500px|thumb|none|QHED circuit with expanded, noise mitigated, decrement gate]]

== Domain Decomposition ==

Consider a 1024x1024 medical image. This comes out to 1,048,576 pixels requiring 20 (2^20) qubits plus 1 ancillary qubit for the QHED algorithm. Additionally, the amplitude encoding process expands exponentially with regards to qubit number. We can divide the image into separate sub images and solve either iteratively or in parallel (multithreading). Each sub image is now considered to be a sub input of the overall problem.

[[File:NaF-PROSTATE-01-0001_22.png|500px|thumb|none|Example of 1024x1024 Medical image decomposed into 256x256 sub images.]]

Errors begin to occur with the 2D to 1D mapping of subdomains. Consider the row major ordering in figure 1. Elements c_3 and c_4 will provide gradient detection for the output pixel at location 3. This is because the RCMO mappings do not preserve locality at the boarders of multi dimensional arrays. In a full image pass of the algorithm this would hardly be noticeable and leave little error on the output image. It becomes readily apparent in decomposed domains, however:

[[File:Rcmo example.png|1000px|thumb|none|RCMO 2D to 1D mapping applied prior to the output of QHED (simulated) shown above. RCMO mapping does not preserve locality and thus non neighboring pixels are calculated to have edges between them where no such edges exist.]]

=== Space Filling Curves ===

One way to solve this issue without the addition of extra qubits is to use space filling curves as a means of 2D to 1D mapping. Space filling curves preserve locality in that the final output of the algorithm will provide boundary detection across exclusively neighboring pixels (with the exception of one pixel per domain in certain cases).

[[File:QHED space filling curves.png|1200px|thumb|none|Example of 1024x1024 Medical image decomposed into 64x64 sub images. In the domain decomposed images (bottom row) a different space filling curve is used for mapping. A laplacian (far left column) edge detection stenciling is used as a classical analog for comparisons.]]

=== QHED in 3 Dimensions ===

We can apply the same principles to 3D. The main difference is that instead of performing a vertical and horizontal detection we need to add in a third in order to achieve a full boundary about each pixel. We consider a "scan" about the x, y, and z planes.

[[File:3d model.png|1200px|thumb|none|Example of 3D Medical image to be edge detected.]]
[[File:3d model rcmo.png|1200px|thumb|none|3D Medical image passed through the QHED algorithm (simulated) 3 times (x,y,z plane). The entire image was passed through each plane.]]
[[File:3d model rcmo dd.png|1200px|thumb|none|3D Medical image with decomposed domains. Each sub domain (3D block) passed through the QHED algorithm (simulated) 3 times (x,y,z plane). Each block was mapped using RCMO, edge detected, and pieced back together.]]

== References ==
[1] Acampora, Giovanni, et al. “D-NISQ: A Reference Model for Distributed Noisy Intermediate-Scale Quantum Computers.” Information Fusion, vol. 89, 2023, pp. 16–28., https://doi.org/10.1016/j.inffus.2022.08.003.

[2] .-W. Yao, H. Wang, Z. Liao, M.-C. Chen, J. Pan, J. Li, K. Zhang, X. Lin, Z. Wang, Z. Luo,
et al., Quantum image processing and its application to edge detection: Theory and experiment,
Physical Review X 7 (3) (2017). doi:10.1103/physrevx.7.031041.

[3]I. F. Araujo, D. K. Park, F. Petruccione, A. J. da Silva, A divide-and-conquer algo-
rithm for quantum state preparation, Scientific Reports 11 (1) (2021). doi:10.1038/
s41598-021-85474-1.

[4] Team, T. Q. (2022, July 6). Quantum Edge Detection - qhed algorithm on small and large images. Quantum Edge Detection - QHED Algorithm on Small and Large Images. Retrieved October 28, 2022, from https://qiskit.org/textbook/ch-applications/quantum-edge-detection.html

[5] Anand, A., Lyu, M., Baweja, P. S., & Patil, V. (2022). Quantum Image Processing. https://doi.org/https://arxiv.org/pdf/2203.01831.pdf

[6] Ferris, K. J., Ramusson, A. J., Bronn, N. T., & Lanes, O. (2022). Quantum Simulation on Noisy Superconducting Quantum Computers. https://doi.org/https://doi.org/10.48550/arXiv.2209.02795

[7] LI, X. I. A. O. Y. U., YANG, G. U. O. W. U., TORRES, C. A. R. L. O. S. M. A. N. U. E. L., ZHENG, D. E. S. H. E. N. G., & WANG, K. A. N. G. L. (2013). A class of efficient quantum incrementer gates for quantum circuit synthesis. International Journal of Modern Physics B, 28(01), 1350191. https://doi.org/10.1142/s0217979213501919

[8] . Gidney, Constructing large increment gates. URL https://algassert.com/circuits/2015/06/12/Constructing-Large-Increment-Gates.html

Internal:Quantum Edge Detection

2023-04-27T22:19:57Z

Ebillias: /* Quantum Fidelity */

= Quantum Hadamard Edge Detection (QHED) =

A recent quantum edge detection algorithm called Quantum Hadamard Edge Detection[2] (QHED) provides a promising means of quantum image processing and experimentation. This is done by providing full boundary gradient across a 1D mapping of a 2D image. Due to fidelity issues on NISQ era hardware, we are required to divide our images into sub images (domain decomposition) for proper edge detection[1]. When doing this, we find a boundary error issue with the algorithm. In addition, we utilize a series of optimization techniques found in Ref. [6] to overcome the resultant hardware noise. The hardware limitations and the few issues with the QHED algorithm itself are reduced in order to produce simulated NISQ hardware results on large images.

The overall goal of this project is to produce high quality results via the QHED circuit on large medical images via REAL NISQ era hardware. Classically, we can use space filling curves or pixel buffers to improve results upon the decomposed image. As far as real hardware is concerned, areas of interest to achieve quality results are by implementing major improvements upon the decrement gate which seems to be the failure point. We can tackle this by a combination of efficient mathematics[7], NISQ error mitigation techniques[6], and VQC techniques. The combination of all of these applied to the three major sections of the circuit (ignoring the measurement phase) could very well result in accurate edge detection results on real quantum hardware. Without access to larger number of qubits (>7 qubits) we need to use the topology taken from noisy simulated hardware. The principles of CX error, single gate error, fidelity, and coherence normally found in real hardware are applicable to noisy simulations. Thus, this remains as a quality means of data analysis prior to execution on real hardware.

== Code ==
Download the Decrement and image encoding notebooks here [https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fquantum%5Fedge%5Fdetection%2Fnotebooks&view=0]

== Paper ==
Find the current version of paper here[https://www.overleaf.com/project/64341df873168e42fe8c2624]

== Quantum Fidelity ==

For most of this research project we have been using a fidelity metric from Ref. [https://arxiv.org/pdf/2209.02795.pdf]. This metric is a simple function dependent on the number of single qubit gates, CNOT gates, and their respective average error rates for some particular circuit on a pre specified backend. This is, in my opinion, analogous to a performance metric from the standpoint of an engineer (say miles per gallon on a car). The calculation itself yields a somewhat confusing unit of measurement (MPG is a cross sectional unit of area!). At the same time, the results of MPG will depend entirely on the driver and the conditions that the vehicle is subject to. However, the result gives you insight into efficiency and performance. I believe that IBM did do a good job with this as it gives (seemingly) a predictable insight into the efficiency and performance of a circuit on some given hardware. If we want the real observed fidelity through sampling the circuit we are required to put in some extra work.

Fidelity in itself is not a strict metric. Rather, it is an abstract computation which can be used to predict the probability that one quantum state can pass as another [https://en.wikipedia.org/wiki/Fidelity_of_quantum_states]. Allegedly, Jozsa points out in the publication found here [https://www.tandfonline.com/doi/epdf/10.1080/09500349414552171?needAccess=true] that an overlap of pure quantum states on the geometry of hilbert space can easily be defined as:

|<ψ|χ>|

Which will be 1 where |χ> = |ψ> and 0 if they are perfectly orthogonal. This can be visualized as a simple overlap of two quantum states and the result is exactly how much they overlap. Since the QHED circuit produces pure quantum states we consider this as a fidelity option to calculate. Noisy circuits will yield (at the time of each individual measurement) a pure quantum state. However, the sum of those pure states will produce a density matrix which is most probably not pure. With that being said, Jozsa had produced a fidelity metric for one pure state (ideal) and one mixed state (noisy). Given two density operators where one is pure and the other mixed:

F(ρ,σ) = (tr √ (√ρ σ √ρ))²

There are other definitions for fidelity in the case of mixed states developed by Jozsa, Nielsen[https://arxiv.org/pdf/quant-ph/0205035.pdf], and several others [http://www.physik.uni-leipzig.de/~uhlmann/PDF/Uh76a.pdf]. A more robust technique is called Quantum Tomography [https://en.wikipedia.org/wiki/Quantum_tomography]. This, I believe, falls out of the scope of QHED. QHED relies only on the output state of the circuit in the computational (Z) basis, therefore I believe that Josza's trace definition should suffice.

In short, the Qiskit definition of fidelity in their paper is not wrong, but rather incomplete in my opinion. There is no strict definition for fidelity. Rather, fidelity is used to give insight to the closeness between states in quantum information theory. The IBM paper predicts the "overlap" while Josza's metric requires sampling to determine fidelity through experimentation. I think that redefining this metric for ourselves within the scope of Jozsa's definition allows for a more robust representation of what we have actually accomplished with these optimizations since we are comparing the ideal output directly to the actual result.

== QHED Circuit ==

[[File:Qhed circuit.png|500px|thumb|none|Figure 1 Generalized qHED Circuit with input vector f and output vector g.]]

=== State Prep ===
[[File:Rcmo.png|500px|thumb|none|Figure 2 Row (left) and Column (right) major ordered mapping.]]

The image is first mapped as a 2D array to a 1D vector. Ref. [2] uses methodology known as row and column major ordering (RCMO). Each pixel is then normalized such that the sum of their squares is equal to 1, a necessary quality of quantum states. Using a module presented by Ref. [3] (or through Qiskit's StatePreparation), we can calculate a quantum circuit which achieves what is known as amplitude encoding. The normalized pixel values of the input vector will be returned as the probability amplitudes of computational basis states. Those computational basis states act as the indexing of the original vector. I.e. if we had a length 64 vector, the 7th element is represented as c_7|000111>. The resultant normalized image state can be written as:

[[File:Img state.png|200px]]

The Hadamard gate in the state prep acts on the Least Significant Bit (LSB) initialized to state |0> which outputs the |+> state. Application of the H-Gate on the LSB has the following tensor product on the input image state:

[[File:State prep.png|400px]]

=== Decrement ===

The decrement portion of the quantum algorithm can be represented by the matrix unitary:

[[File:Decrement unitary.png|400px]]

With application of that unitary gate to the state prepared vector yields the decrement state:

[[File:Decrement state.png|500px]]

To the best of our abilities, we find that references to the QHED method provide very little (if any) detail as to the architecture of the decrement gate. Refs. [4] and presumably [5] use a qiskit unitary class function to convert a numpy matrix into a circuit. Although quite useful for simulations, this type of construction fails on real hardware. We can find a far more reasonable design of the gate in Ref. [7] which is shown below.

[[File:decrement_gate.png|500px|thumb|none|Multi controlled NOT gates perform the decrement operation. q_0 being the least significant qubit.]]

Although it is known that multi qubit gates are highly error prone, we achieve reasonable results when we compare the two methodologies. We begin with a 4 qubit circuit initialized to the state |0000> = (1...0) which is to be decremented to state |1111> = (0...1). Shown below are the results of the more careful multi controlled qubit construction and the unitary class function executed on the real quantum device, ibmq_lima. Based on the results, we know that we must design our own decrement gates and cannot rely on any arbitrary unitary transformation algorithim.

[[File:Lima tl 3.png|500px|thumb|none| Although the results are far from perfect, we can clearly see the state 1111> has been formed from the state 0000>.]]

[[File:Lima np.png|500px|thumb|none| The results of our gate are lost in the noise of the output using the unitary class function.]]

We can improve upon the Decrement gate by using 2n total qubits by altering the increment gates in Ref. [8]. More simply, using open controls (bit flip in the case of the qubit being in the state |0>) alters the increment permutation to a decrement.

[[File:Decrement op.png|500px]]

Looking at the CX counts and fidelity estimates for QHED circuits show promising results. The upcoming section "Methods of Optimization" will describe the optimizations themselves as they are labeled in the charts below.

[[File:Qhed cx.png|500px]]
[[File:Qhed fidelity.png|500px]]

=== Permutation ===
This is the portion of the circuit where the actual edge detection occurs. It can be thought of as a series of identity gates tensored together with an H-Gate in the LSB tensored last. The resultant unitary matrix can be written as:

[[File:Permutation unitary.png|500px]]

With application of the resultant decrement vector as:

[[File:Permutation state.png|500px]]

This is the final output state. Note that if the LSB is in the state |1> we retrieve all of the odd indexed states i.e. |...001> (1), |...011> (3), |...111> (5), ect. These states provide the boundary gradient across the 1D input image. An overview of the QHED algorithm can be visualized as having the following effect on the input of an image state:

[[File:QHED output.png|300px]]

== Methods of Optimization ==

The improved decrement gate was already discussed in the previous section so we will leave it there.

We then utilize Qiskit's transpiler. The optimal SWAP mapping is an NP-Hard problem which yields ambiguous results. "The choice of initial layout can mean the difference between getting a result, and getting nothing but noise." To compute the best low noise layout, we use an open source module called mapomatic. Mapomatic finds the best low noise sub-graph for some given hardware backend(s). The end result is that the module returns the best set of qubits and their appropriate ordering to execute your circuit with minimal noise. This qubit layout is sent to the transpiler. A heuristic fidelity estimate is taken from Ref. [6].

We now turn to a means of error reduction in the measurement output of the circuit. Researchers are able to perform a variety of experiments to measure a qubit's state preparation and measurement (SPAM) errors forming a relationship of noisy probabilities to ideal probabilities in the form of a matrix transformation. The correction matrix can be measured by using a variety of circuits with known outcomes and finding the noisy outcome of every possible bit-string for a particular piece of hardware. From this, it is possible to reconstruct our desired output.

There are obvious scaling issues when it comes to building 2^n x 2^n matricies. There are alternatives to this which do not require such scaling or computational overhead. We make use of such a module called mthree. An excellent demonstration of this can be found in the Qiskit Textbook.

In the case of large images, we must perform domain decomposition to preserve fidelity and reduce noise. However, we find that when applying the suggested RMO and CMO indexed 2D to 1D mapping on decomposed sub images there is a non negligible quality reduction to the output edge detected image. This is due to the fact that this use of mapping does not preserve locality. It can be seen from Fig. [2] how these methods of indexing will provide errors across the boundaries of the image/sub images. Consider the output state |g>. It can be seen how non adjacent pixels of the original image will be compared with each other e.g. c_{3} - c_{4} in the Fig. [2] RMO mapping or c_{12} - c_{1} in the CMO mapping. This may lead to detected edges where there are none. To avoid these discrepancies we apply buffer cells to our decomposed images. We choose to do a row by row decomposition for the horizontal scan as shown below. This leaves 2 redundant pixels per sub image, no matter the decomposition size.

[[File:Boundary buffer.png|500px|thumb|none|Buffer pixels of value 0 are applied to the boundary of the overall image.]]

[[File:Buffer cells.png|500px|thumb|none|Further decomposition is then possible by adding neighboring pixels to be used as a buffer due to QHED error. The red cells are ultimately disposed in the final output.]]

With the decrement gate optimization, the more NISQ-era friendly QHED circuit takes the form shown below.

[[File:Qhed op.png|500px|thumb|none|QHED circuit with expanded, noise mitigated, decrement gate]]

== Domain Decomposition ==

Consider a 1024x1024 medical image. This comes out to 1,048,576 pixels requiring 20 (2^20) qubits plus 1 ancillary qubit for the QHED algorithm. Additionally, the amplitude encoding process expands exponentially with regards to qubit number. We can divide the image into separate sub images and solve either iteratively or in parallel (multithreading). Each sub image is now considered to be a sub input of the overall problem.

[[File:NaF-PROSTATE-01-0001_22.png|500px|thumb|none|Example of 1024x1024 Medical image decomposed into 256x256 sub images.]]

Errors begin to occur with the 2D to 1D mapping of subdomains. Consider the row major ordering in figure 1. Elements c_3 and c_4 will provide gradient detection for the output pixel at location 3. This is because the RCMO mappings do not preserve locality at the boarders of multi dimensional arrays. In a full image pass of the algorithm this would hardly be noticeable and leave little error on the output image. It becomes readily apparent in decomposed domains, however:

[[File:Rcmo example.png|1000px|thumb|none|RCMO 2D to 1D mapping applied prior to the output of QHED (simulated) shown above. RCMO mapping does not preserve locality and thus non neighboring pixels are calculated to have edges between them where no such edges exist.]]

=== Space Filling Curves ===

One way to solve this issue without the addition of extra qubits is to use space filling curves as a means of 2D to 1D mapping. Space filling curves preserve locality in that the final output of the algorithm will provide boundary detection across exclusively neighboring pixels (with the exception of one pixel per domain in certain cases).

[[File:QHED space filling curves.png|1200px|thumb|none|Example of 1024x1024 Medical image decomposed into 64x64 sub images. In the domain decomposed images (bottom row) a different space filling curve is used for mapping. A laplacian (far left column) edge detection stenciling is used as a classical analog for comparisons.]]

=== QHED in 3 Dimensions ===

We can apply the same principles to 3D. The main difference is that instead of performing a vertical and horizontal detection we need to add in a third in order to achieve a full boundary about each pixel. We consider a "scan" about the x, y, and z planes.

[[File:3d model.png|1200px|thumb|none|Example of 3D Medical image to be edge detected.]]
[[File:3d model rcmo.png|1200px|thumb|none|3D Medical image passed through the QHED algorithm (simulated) 3 times (x,y,z plane). The entire image was passed through each plane.]]
[[File:3d model rcmo dd.png|1200px|thumb|none|3D Medical image with decomposed domains. Each sub domain (3D block) passed through the QHED algorithm (simulated) 3 times (x,y,z plane). Each block was mapped using RCMO, edge detected, and pieced back together.]]

== References ==
[1] Acampora, Giovanni, et al. “D-NISQ: A Reference Model for Distributed Noisy Intermediate-Scale Quantum Computers.” Information Fusion, vol. 89, 2023, pp. 16–28., https://doi.org/10.1016/j.inffus.2022.08.003.

[2] .-W. Yao, H. Wang, Z. Liao, M.-C. Chen, J. Pan, J. Li, K. Zhang, X. Lin, Z. Wang, Z. Luo,
et al., Quantum image processing and its application to edge detection: Theory and experiment,
Physical Review X 7 (3) (2017). doi:10.1103/physrevx.7.031041.

[3]I. F. Araujo, D. K. Park, F. Petruccione, A. J. da Silva, A divide-and-conquer algo-
rithm for quantum state preparation, Scientific Reports 11 (1) (2021). doi:10.1038/
s41598-021-85474-1.

[4] Team, T. Q. (2022, July 6). Quantum Edge Detection - qhed algorithm on small and large images. Quantum Edge Detection - QHED Algorithm on Small and Large Images. Retrieved October 28, 2022, from https://qiskit.org/textbook/ch-applications/quantum-edge-detection.html

[5] Anand, A., Lyu, M., Baweja, P. S., & Patil, V. (2022). Quantum Image Processing. https://doi.org/https://arxiv.org/pdf/2203.01831.pdf

[6] Ferris, K. J., Ramusson, A. J., Bronn, N. T., & Lanes, O. (2022). Quantum Simulation on Noisy Superconducting Quantum Computers. https://doi.org/https://doi.org/10.48550/arXiv.2209.02795

[7] LI, X. I. A. O. Y. U., YANG, G. U. O. W. U., TORRES, C. A. R. L. O. S. M. A. N. U. E. L., ZHENG, D. E. S. H. E. N. G., & WANG, K. A. N. G. L. (2013). A class of efficient quantum incrementer gates for quantum circuit synthesis. International Journal of Modern Physics B, 28(01), 1350191. https://doi.org/10.1142/s0217979213501919

[8] . Gidney, Constructing large increment gates. URL https://algassert.com/circuits/2015/06/12/Constructing-Large-Increment-Gates.html

Internal:Quantum Information Science (QIS General)

2023-04-21T13:43:44Z

Ebillias: Created page with "= QIS General = I will use this page to keep a general progression and categorization about QIS ranging from theory to useful code. == Notebooks == === QIS General === Custo..."

= QIS General =

I will use this page to keep a general progression and categorization about QIS ranging from theory to useful code.

== Notebooks ==
=== QIS General ===
Custom build QIS notebooks (some modeled after Nielsen's lectures) can be found here[https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2FBasics%5FQC%2Fnotebooks%2Fgeneral&view=0].

Internal:Student Reports

2023-04-21T13:39:28Z

Ebillias: /* Emmanuel */

== Current Students ==

=== Polykarpos ===
[[PREMA Shared Memory]]

[[Internal:IMR_2018_Runtime_Systems | IMR 2018 Runtime Systems]]

[[Intel Xeon Phi and High Bandwidth Memory]]

[[CNF:Machine_Learning | CNF Machine Learning Project]]

[[CNF:ML_Data_Denoise | Track denoising with ML]]

[https://docs.google.com/presentation/d/1rF3rElnBCsKR_Z_66nTCmMqSZa3b51mEzswiLz_3d3Q/edit?usp=sharing CNF HPC Workshop Slides]

[[PREMA SW4| SW4 Benchmark with PREMA]]

[[PDR.PODM Distributed Memory| PDR.PODM.PREMA]]

[https://www.overleaf.com/read/vgwrypshrkqp PREMA-Argobots Paper]

[https://olddominion-my.sharepoint.com/:b:/g/personal/pthom001_odu_edu/EYiL4h5xKThJgjyvbsFbZe4BH_4pr3rR-9x-gvErpDaq3A?e=hdy7ii Heterogeneousarchitecturesforcomputationalintensiveapplications:Acost-effectivenessanalysis]

[[Internal:TAPAS]]

=== Kevin ===
[[Internal:PDR_AFLR |PDR.AFLR Stability and Scalability]]

[[Internal:PDR_AFLR_Progress_Report |PDR.AFLR Progress Report]]

[[AFLR_Point_Spacing/Distribution_Function_Parameters | AFLR Point Spacing/Distribution Function Parameters]]

[[Internal:PDR_AFLR_Performance_Testing |PDR.AFLR Performance Testing]]

[[Internal:PDR_AFLR_Performance_AIAA |AIAA PDR.AFLR Performance Data]]

[[Internal:Report_Status |Report Status]]

[[Internal:PsC_AFLR_Performance |PsC.AFLR Performance Data]]

[[Internal:Next_Generation_Boundary_Layer |Next Generation Boundary Layer]]

[[Internal:CDT3D_GPU_Smoothing | CDT3D GPU Smoothing]]

[[Internal:Distributed_CDT3D_Notes | Distributed CDT3D Notes]]

=== Emmanuel ===
[[Internal:Quantum Information Science (QIS General) |Quantum Information Science (QIS General)]]

[[Internal:Quantum_Edge_Detection |Quantum Edge Detection]]

[[Internal:Hybrid Computing |Hybrid Computing]]

[[Internal:Quantum Machine Learning |Quantum Machine Learning]]

=== Chris ===
[[Internal:DQHED |Distributed Hadamard Quantum Edge Detection (DQHED)]]

[[Internal:QCED |Quantum Canny Edge Detection (QCED)]]

[[Internal:Quantum_PDEs |Quantum PDEs]]

[[Internal:weekly_report_rector |Weekly Report]]

=== Devon ===
[[Internal:Quantum_Clustering |Quantum Clustering]]

== Former Students ==

=== Angelos ===

[[Internal:GPCD | GPCD]]

[[Internal:APBNRRExecutionStatus | APBNRR Execution Status]]

[[Internal:PAPBNRRComparison | Pristine vs New PAPBNRR]]

[[Internal:APBNRRMachineLearning | APBNRR Machine Learning]]

[[Internal: SlicerExtensions | Slicer Extensions]]

=== Christos ===
'''[https://olddominion-my.sharepoint.com/:f:/r/personal/nchrisoc_odu_edu/Documents/From_Box/CRTC_Students/ChristosT/papers All papers]'''

'''[https://olddominion-my.sharepoint.com/:f:/r/personal/nchrisoc_odu_edu/Documents/From_Box/CRTC_Students/ChristosT/presentations All presentations]'''

<hr>

[https://olddominion-my.sharepoint.com/:b:/r/personal/nchrisoc_odu_edu/Documents/From_Box/CRTC_Students/ChristosT/dissertation/christos_dissertation.pdf Dissertation .pdf]

[https://www.overleaf.com/6438559258mdmsnbpffztx speculative meshing operations using tasks paper - overleaf]

[https://www.overleaf.com/3459466599cnnfkhzmkczs Adaptive CDT3D paper - overleaf]

[https://www.overleaf.com/8242192311zntgrtsphkvv Parallel Grid Adaptation Paper (UGAWG) - overleaf ]

[[Internal:Adaptive_Meshing_For_APBNRR]]

[https://docs.google.com/presentation/d/1Fjt5PoDPXa715nOAjn0F4IJpdhscIGnlaQvweqFnB0U Adaptivity PPoSS slides]

[https://docs.google.com/presentation/d/1RDtQufImuo5J1pKioIYDuTWCeX1UtjKyx7kQ2i24Tmo/edit?usp=sharing CNF HPC slides]

[https://git-community.cs.odu.edu/nikos/SciTech_2019/blob/draft/main.pdf Scitech Journal paper latest draft]

[https://olddominion-my.sharepoint.com/:b:/r/personal/nchrisoc_odu_edu/Documents/From_Box/CRTC_Students/ChristosT/candidacy_exam/cand_exam.pdf Candidacy exam (document)]
[https://olddominion-my.sharepoint.com/:p:/r/personal/nchrisoc_odu_edu/Documents/From_Box/CRTC_Students/ChristosT/candidacy_exam/PhD_Candidacy_presentation.pptx (presentation .pptx)]
[https://olddominion-my.sharepoint.com/:b:/r/personal/nchrisoc_odu_edu/Documents/From_Box/CRTC_Students/ChristosT/candidacy_exam/PhD_Candidacy%20_presentation.pdf (presentation pdf)]

[[Internal:Adaptive_CDT3D_Results | Metric Adaptive CDT3D results]]

[[Internal:Argobots_and_CDT3D | Argobots and CDT3D]]

[[Internal:4D_Predicates_Benchmark | 4D predicates benchmark]]

[[CNF:Mesh Sizing for CNF data]]

[[Internal:ACDT3D | Metric Adaptive CDT3D Notes ]]

[https://olddominion-my.sharepoint.com/:b:/r/personal/nchrisoc_odu_edu/Documents/frombox/CRTC_Students/ChristosT/candidacy_exam/paper.pdf Parallel Mesh Generation review paper]

[https://lbpw.larc.nasa.gov/ AIAA Sonic Boom Prediction Workshop (next in 2020)]

[[Internal:CDT3D_SU2 | SU2 and grid requirements ]]

[[Internal:Boundary_Layer_References | Boundary Layer References ]]

[[External:Mesh_Generation_Articles_In_Journals | Some Mesh Generation Journal papers]]

[https://docs.google.com/document/d/1txyCu6ibheH19hi3nZ10LgHm-WzglUrT5y0AaO__VYk/edit?usp=sharing PhD Tentative Shedule]

[https://odu.box.com/s/sfkd5l3d9r5865qbsovx0eo6gwlaiask Poster IMR]

[https://odu.box.com/s/1sok1edideblq4nctbufg79vud0oiu8f NIA presentation (September 2018) ]

[[Internal:IMR_2018_Short_Course | IMR 2018 Short Course notes]]

[[Internal:ACDT3D_Scitech2018 | SciTech 2018]]

[[Internal:Machine_Learning_CDT3D | Machine Learning and CDT3D]]

[[Internal:AIAA_2018_CDT3D | CDT3D AIAA Aviation Paper ]]

[[Internal:PODM4D_predicates | PODM4D fine grain concurrency benchmark ]]

[[Internal:AIAA_Geometry_and_Mesh_Generation_Workshop | Geometry and Mesh Generation Workshop ]]

[[Internal:CDT3D_RoadMap |CDT3D RoadMap]]

[[Internal:Computational_Resources | High capacity Computational Resources ]]

[[NDAM:Main | PODM 4D and Anisotropy ]]

[https://docs.google.com/document/d/1jzTiohDA51VHXc65tfIFkmjrKM_8yQn7YYj2txEyhyU MPI PDR.PODM 16,000 cores data and other]

=== Spiros ===
'''Image-To-Mesh Conversion Projects'''

[[Internal:Tessellate_2D | Tessellate 2D]]

[[Internal:PODM_3D | PODM 3D]]

[[Internal:PODM_4D | PODM 4D]]

'''BioInformatics Projects'''

[[Internal:GPCD | GPCD]]

'''Contrained Mesh Refinement Projects'''

[[Internal:CDT3D_GPU_Smoothing | CDT3D GPU Smoothing]]

'''CNF Related Projects'''

[[CNF:CNF_Data_Generation | CNF Data Generation]]

[[CNF:Monte_Carlo_Event_Generator_using_a_Tessellation | Monte Carlo Event Generator using a Tessellation]]

[[CNF:Smart_LookUp_Table_Utilities | Smart LookUp Table Utilities]]

[[CNF:PartonsToNRRD | PartonsToNRRD]]

[[CNF:Weighted_Mesh_To_Image | Weighted Mesh To Image]]

[[Internal:TetGen_CNF | TetGen CNF]]

'''Utilities Projects'''

[[Internal:Synthetical_Image_Data_Generator | Synthetical Image Data Generator]]

[[Internal:MeshIO | MeshIO]]

'''Other Projects'''

[[Internal:PDM_ND | PDM ND]]

[[Internal:GPU_Usage | GPU Usage]]

=== Medical Imaging SubGroup (Eleni, Thomas , Angelos) ===
[[Internal:ReportCloud | Cloud Report]]

[[Internal:Preprocess_Medical_Images | Preprocessing of Medical Images]]

[[Internal:Execution_And_Evaluation_Medical_Images | Execution and Evaluation of Medical Imaging data]]

=== Joi ===
[[Tasks | Tasks ]]

[[I2M_Conversion_Tool | Image-to-Mesh (I2M) Conversion Tool]]

[[3D_Slicer_CBC3D_Extension | 3D Slicer CBC3D Extension ]]

'''Reports'''

[[CNF:CNF_Adaptivity | CNF Adaptivity]]

== General ==

===Conference Slides ===
[https://odu.box.com/s/vev5nqudpd5yq143xfq99y7b8uyf0j4e AI in Nuclear Physics 2020]

=== Proposal Resources ===
[[Internal:NSF_PPOSS_Funded_Proposals]]

===Notes ===
[[Internal:CNF_Workshop]]

[[Internal:CNF_HPC_Workshop_2019]]

[[Internal:Kokkos_Tutorial_2020_02_19]]

[[Internal:Intel_OneAPI_Tutorial_2020_02_20]]

=== Papers ===
[http://www.cs.odu.edu/crtc/internal/papers/O'Connell_et_al._-_2018_-_Application_of_the_Dependency_Inversion_Principle_.pdf T-infinity: The Dependency Inversion Principle for Rapid and Sustainable Multidisciplinary Software Development]

[https://hal.inria.fr/hal-01927559 Meshless Voronoi on the GPU, Nicolas Ray,Dmitry Sokolov,Sylvain Lefebvre,Bruno Lévy]

[http://pages.saclay.inria.fr/frederic.alauzet/TetrahedronVI/Slides_Tetrahedron_VI/Thursday/Mike_Park_ugawg-tet-talk.pdf Democratizing Mesh Adaptation forComputational Fluid Dynamics Michael Park]

[[Internal:Hashing_Meshes]]

=== Videos ===
[https://www.youtube.com/watch?v=pn7IqhOEGpY Using Graphs for Unstructured Data (Keshav Pingali)]

[https://www.youtube.com/watch?v=RZ09uZs1ynA Big Data Brain Maps at Argonne National Laboratory (Bobby Kasthuri), ATPESC 2017]

=== Other ===
http://livingreview.in.tum.de/welcome/

=== CRTC lab Virtual meetings ===
* 2020.01.18 - Christos
:* Unified Approach for Speculative Operations, [https://docs.google.com/presentation/d/1haL6NVwZzRVG0W71KoWmqLKgxkf6to2sUsdTH5Xn4kw (presentation)], [https://olddominion-my.sharepoint.com/:f:/r/personal/ctsol001_odu_edu/Documents/Parallel_Operations?csf=1&web=1&e=hQ8rPg (shared directory)]

* 2021.02.03 - Kevin & Spiros
:* Introduction to GPU Parallelism, [https://drive.google.com/file/d/1vW3VJXi04JB2N7XpVoNnXXSNv4i1Pnet/view?usp=sharing (presentation)]

* 2021.02.10 - Kevin & Spiros
:* GPU Architecture, [https://drive.google.com/file/d/1LfDwsbdscSpTk3eBT74lfIlSyD-W_Zwh/view?usp=sharing (presentation)]

Internal:Quantum Edge Detection

2023-04-18T16:51:56Z

Ebillias:

= Quantum Hadamard Edge Detection (QHED) =

A recent quantum edge detection algorithm called Quantum Hadamard Edge Detection[2] (QHED) provides a promising means of quantum image processing and experimentation. This is done by providing full boundary gradient across a 1D mapping of a 2D image. Due to fidelity issues on NISQ era hardware, we are required to divide our images into sub images (domain decomposition) for proper edge detection[1]. When doing this, we find a boundary error issue with the algorithm. In addition, we utilize a series of optimization techniques found in Ref. [6] to overcome the resultant hardware noise. The hardware limitations and the few issues with the QHED algorithm itself are reduced in order to produce simulated NISQ hardware results on large images.

The overall goal of this project is to produce high quality results via the QHED circuit on large medical images via REAL NISQ era hardware. Classically, we can use space filling curves or pixel buffers to improve results upon the decomposed image. As far as real hardware is concerned, areas of interest to achieve quality results are by implementing major improvements upon the decrement gate which seems to be the failure point. We can tackle this by a combination of efficient mathematics[7], NISQ error mitigation techniques[6], and VQC techniques. The combination of all of these applied to the three major sections of the circuit (ignoring the measurement phase) could very well result in accurate edge detection results on real quantum hardware. Without access to larger number of qubits (>7 qubits) we need to use the topology taken from noisy simulated hardware. The principles of CX error, single gate error, fidelity, and coherence normally found in real hardware are applicable to noisy simulations. Thus, this remains as a quality means of data analysis prior to execution on real hardware.

== Code ==
Download the Decrement and image encoding notebooks here [https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fquantum%5Fedge%5Fdetection%2Fnotebooks&view=0]

== Paper ==
Find the current version of paper here[https://www.overleaf.com/project/64341df873168e42fe8c2624]

== Quantum Fidelity ==

A quick note on fidelity. For most of this research project we have been using a fidelity metric from Ref. [https://arxiv.org/pdf/2209.02795.pdf]. This metric is a simple calculation of the number of single qubit gates and their error rates along with the respective metrics from CNOT gates for some particular circuit.

Fidelity in itself is not a strict metric. Rather, it is an abstract computation which can be used to predict the probability that one quantum state can pass as another [https://en.wikipedia.org/wiki/Fidelity_of_quantum_states]. Allegedly, Jozsa points out in the publication found here [https://www.tandfonline.com/doi/epdf/10.1080/09500349414552171?needAccess=true] that an overlap of pure quantum states on the geometry of hilbert space can easily be defined as:

|<ψ|χ>|

Which will be 1 where |χ> = |ψ> and 0 if they are perfectly orthogonal. This can be visualized as a simple overlap of two quantum states and the result is exactly how much they overlap. Since the QHED circuit produces pure quantum states we consider this as a fidelity option to calculate. However, I am not entirely convinced that our noisy circuits produce pure quantum states. I need to run metrics on density matrix purity to determine this. With that being said, Jozsa had produced a fidelity metric for one pure state and one mixed state. Given two density operators where one is pure and the other mixed:

F(ρ,σ) = (tr √ (√ρ σ √ρ))²

There are other definitions for fidelity in the case of mixed states developed by Jozsa, Nielsen[https://arxiv.org/pdf/quant-ph/0205035.pdf], and several others [http://www.physik.uni-leipzig.de/~uhlmann/PDF/Uh76a.pdf]. A more robust technique is called Quantum Tomography [https://en.wikipedia.org/wiki/Quantum_tomography]. This, I believe, falls out of the scope of QHED. QHED relies only on the output state of the circuit, therefore I believe that Josza's trace definition should suffice.

In short, the Qiskit definition of fidelity in their paper is not wrong, but rather incomplete in my opinion. There is no strict definition for fidelity. Rather, fidelity is used to give insight to the closeness between states in quantum information theory. I think that redefining this metric for ourselves within the scope of Jozsa's definition allows for a more robust representation of what we have actually accomplished with these optimizations since we are comparing the ideal output directly to the actual result.

== QHED Circuit ==

[[File:Qhed circuit.png|500px|thumb|none|Figure 1 Generalized qHED Circuit with input vector f and output vector g.]]

=== State Prep ===
[[File:Rcmo.png|500px|thumb|none|Figure 2 Row (left) and Column (right) major ordered mapping.]]

The image is first mapped as a 2D array to a 1D vector. Ref. [2] uses methodology known as row and column major ordering (RCMO). Each pixel is then normalized such that the sum of their squares is equal to 1, a necessary quality of quantum states. Using a module presented by Ref. [3] (or through Qiskit's StatePreparation), we can calculate a quantum circuit which achieves what is known as amplitude encoding. The normalized pixel values of the input vector will be returned as the probability amplitudes of computational basis states. Those computational basis states act as the indexing of the original vector. I.e. if we had a length 64 vector, the 7th element is represented as c_7|000111>. The resultant normalized image state can be written as:

[[File:Img state.png|200px]]

The Hadamard gate in the state prep acts on the Least Significant Bit (LSB) initialized to state |0> which outputs the |+> state. Application of the H-Gate on the LSB has the following tensor product on the input image state:

[[File:State prep.png|400px]]

=== Decrement ===

The decrement portion of the quantum algorithm can be represented by the matrix unitary:

[[File:Decrement unitary.png|400px]]

With application of that unitary gate to the state prepared vector yields the decrement state:

[[File:Decrement state.png|500px]]

To the best of our abilities, we find that references to the QHED method provide very little (if any) detail as to the architecture of the decrement gate. Refs. [4] and presumably [5] use a qiskit unitary class function to convert a numpy matrix into a circuit. Although quite useful for simulations, this type of construction fails on real hardware. We can find a far more reasonable design of the gate in Ref. [7] which is shown below.

[[File:decrement_gate.png|500px|thumb|none|Multi controlled NOT gates perform the decrement operation. q_0 being the least significant qubit.]]

Although it is known that multi qubit gates are highly error prone, we achieve reasonable results when we compare the two methodologies. We begin with a 4 qubit circuit initialized to the state |0000> = (1...0) which is to be decremented to state |1111> = (0...1). Shown below are the results of the more careful multi controlled qubit construction and the unitary class function executed on the real quantum device, ibmq_lima. Based on the results, we know that we must design our own decrement gates and cannot rely on any arbitrary unitary transformation algorithim.

[[File:Lima tl 3.png|500px|thumb|none| Although the results are far from perfect, we can clearly see the state 1111> has been formed from the state 0000>.]]

[[File:Lima np.png|500px|thumb|none| The results of our gate are lost in the noise of the output using the unitary class function.]]

We can improve upon the Decrement gate by using 2n total qubits by altering the increment gates in Ref. [8]. More simply, using open controls (bit flip in the case of the qubit being in the state |0>) alters the increment permutation to a decrement.

[[File:Decrement op.png|500px]]

Looking at the CX counts and fidelity estimates for QHED circuits show promising results. The upcoming section "Methods of Optimization" will describe the optimizations themselves as they are labeled in the charts below.

[[File:Qhed cx.png|500px]]
[[File:Qhed fidelity.png|500px]]

=== Permutation ===
This is the portion of the circuit where the actual edge detection occurs. It can be thought of as a series of identity gates tensored together with an H-Gate in the LSB tensored last. The resultant unitary matrix can be written as:

[[File:Permutation unitary.png|500px]]

With application of the resultant decrement vector as:

[[File:Permutation state.png|500px]]

This is the final output state. Note that if the LSB is in the state |1> we retrieve all of the odd indexed states i.e. |...001> (1), |...011> (3), |...111> (5), ect. These states provide the boundary gradient across the 1D input image. An overview of the QHED algorithm can be visualized as having the following effect on the input of an image state:

[[File:QHED output.png|300px]]

== Methods of Optimization ==

The improved decrement gate was already discussed in the previous section so we will leave it there.

We then utilize Qiskit's transpiler. The optimal SWAP mapping is an NP-Hard problem which yields ambiguous results. "The choice of initial layout can mean the difference between getting a result, and getting nothing but noise." To compute the best low noise layout, we use an open source module called mapomatic. Mapomatic finds the best low noise sub-graph for some given hardware backend(s). The end result is that the module returns the best set of qubits and their appropriate ordering to execute your circuit with minimal noise. This qubit layout is sent to the transpiler. A heuristic fidelity estimate is taken from Ref. [6].

We now turn to a means of error reduction in the measurement output of the circuit. Researchers are able to perform a variety of experiments to measure a qubit's state preparation and measurement (SPAM) errors forming a relationship of noisy probabilities to ideal probabilities in the form of a matrix transformation. The correction matrix can be measured by using a variety of circuits with known outcomes and finding the noisy outcome of every possible bit-string for a particular piece of hardware. From this, it is possible to reconstruct our desired output.

There are obvious scaling issues when it comes to building 2^n x 2^n matricies. There are alternatives to this which do not require such scaling or computational overhead. We make use of such a module called mthree. An excellent demonstration of this can be found in the Qiskit Textbook.

In the case of large images, we must perform domain decomposition to preserve fidelity and reduce noise. However, we find that when applying the suggested RMO and CMO indexed 2D to 1D mapping on decomposed sub images there is a non negligible quality reduction to the output edge detected image. This is due to the fact that this use of mapping does not preserve locality. It can be seen from Fig. [2] how these methods of indexing will provide errors across the boundaries of the image/sub images. Consider the output state |g>. It can be seen how non adjacent pixels of the original image will be compared with each other e.g. c_{3} - c_{4} in the Fig. [2] RMO mapping or c_{12} - c_{1} in the CMO mapping. This may lead to detected edges where there are none. To avoid these discrepancies we apply buffer cells to our decomposed images. We choose to do a row by row decomposition for the horizontal scan as shown below. This leaves 2 redundant pixels per sub image, no matter the decomposition size.

[[File:Boundary buffer.png|500px|thumb|none|Buffer pixels of value 0 are applied to the boundary of the overall image.]]

[[File:Buffer cells.png|500px|thumb|none|Further decomposition is then possible by adding neighboring pixels to be used as a buffer due to QHED error. The red cells are ultimately disposed in the final output.]]

With the decrement gate optimization, the more NISQ-era friendly QHED circuit takes the form shown below.

[[File:Qhed op.png|500px|thumb|none|QHED circuit with expanded, noise mitigated, decrement gate]]

== Domain Decomposition ==

Consider a 1024x1024 medical image. This comes out to 1,048,576 pixels requiring 20 (2^20) qubits plus 1 ancillary qubit for the QHED algorithm. Additionally, the amplitude encoding process expands exponentially with regards to qubit number. We can divide the image into separate sub images and solve either iteratively or in parallel (multithreading). Each sub image is now considered to be a sub input of the overall problem.

[[File:NaF-PROSTATE-01-0001_22.png|500px|thumb|none|Example of 1024x1024 Medical image decomposed into 256x256 sub images.]]

Errors begin to occur with the 2D to 1D mapping of subdomains. Consider the row major ordering in figure 1. Elements c_3 and c_4 will provide gradient detection for the output pixel at location 3. This is because the RCMO mappings do not preserve locality at the boarders of multi dimensional arrays. In a full image pass of the algorithm this would hardly be noticeable and leave little error on the output image. It becomes readily apparent in decomposed domains, however:

[[File:Rcmo example.png|1000px|thumb|none|RCMO 2D to 1D mapping applied prior to the output of QHED (simulated) shown above. RCMO mapping does not preserve locality and thus non neighboring pixels are calculated to have edges between them where no such edges exist.]]

=== Space Filling Curves ===

One way to solve this issue without the addition of extra qubits is to use space filling curves as a means of 2D to 1D mapping. Space filling curves preserve locality in that the final output of the algorithm will provide boundary detection across exclusively neighboring pixels (with the exception of one pixel per domain in certain cases).

[[File:QHED space filling curves.png|1200px|thumb|none|Example of 1024x1024 Medical image decomposed into 64x64 sub images. In the domain decomposed images (bottom row) a different space filling curve is used for mapping. A laplacian (far left column) edge detection stenciling is used as a classical analog for comparisons.]]

=== QHED in 3 Dimensions ===

We can apply the same principles to 3D. The main difference is that instead of performing a vertical and horizontal detection we need to add in a third in order to achieve a full boundary about each pixel. We consider a "scan" about the x, y, and z planes.

[[File:3d model.png|1200px|thumb|none|Example of 3D Medical image to be edge detected.]]
[[File:3d model rcmo.png|1200px|thumb|none|3D Medical image passed through the QHED algorithm (simulated) 3 times (x,y,z plane). The entire image was passed through each plane.]]
[[File:3d model rcmo dd.png|1200px|thumb|none|3D Medical image with decomposed domains. Each sub domain (3D block) passed through the QHED algorithm (simulated) 3 times (x,y,z plane). Each block was mapped using RCMO, edge detected, and pieced back together.]]

== References ==
[1] Acampora, Giovanni, et al. “D-NISQ: A Reference Model for Distributed Noisy Intermediate-Scale Quantum Computers.” Information Fusion, vol. 89, 2023, pp. 16–28., https://doi.org/10.1016/j.inffus.2022.08.003.

[2] .-W. Yao, H. Wang, Z. Liao, M.-C. Chen, J. Pan, J. Li, K. Zhang, X. Lin, Z. Wang, Z. Luo,
et al., Quantum image processing and its application to edge detection: Theory and experiment,
Physical Review X 7 (3) (2017). doi:10.1103/physrevx.7.031041.

[3]I. F. Araujo, D. K. Park, F. Petruccione, A. J. da Silva, A divide-and-conquer algo-
rithm for quantum state preparation, Scientific Reports 11 (1) (2021). doi:10.1038/
s41598-021-85474-1.

[4] Team, T. Q. (2022, July 6). Quantum Edge Detection - qhed algorithm on small and large images. Quantum Edge Detection - QHED Algorithm on Small and Large Images. Retrieved October 28, 2022, from https://qiskit.org/textbook/ch-applications/quantum-edge-detection.html

[5] Anand, A., Lyu, M., Baweja, P. S., & Patil, V. (2022). Quantum Image Processing. https://doi.org/https://arxiv.org/pdf/2203.01831.pdf

[6] Ferris, K. J., Ramusson, A. J., Bronn, N. T., & Lanes, O. (2022). Quantum Simulation on Noisy Superconducting Quantum Computers. https://doi.org/https://doi.org/10.48550/arXiv.2209.02795

[7] LI, X. I. A. O. Y. U., YANG, G. U. O. W. U., TORRES, C. A. R. L. O. S. M. A. N. U. E. L., ZHENG, D. E. S. H. E. N. G., & WANG, K. A. N. G. L. (2013). A class of efficient quantum incrementer gates for quantum circuit synthesis. International Journal of Modern Physics B, 28(01), 1350191. https://doi.org/10.1142/s0217979213501919

[8] . Gidney, Constructing large increment gates. URL https://algassert.com/circuits/2015/06/12/Constructing-Large-Increment-Gates.html

Internal:Quantum Edge Detection

2023-04-18T16:11:00Z

Ebillias:

= Quantum Hadamard Edge Detection (QHED) =

A recent quantum edge detection algorithm called Quantum Hadamard Edge Detection[2] (QHED) provides a promising means of quantum image processing and experimentation. This is done by providing full boundary gradient across a 1D mapping of a 2D image. Due to fidelity issues on NISQ era hardware, we are required to divide our images into sub images (domain decomposition) for proper edge detection[1]. When doing this, we find a boundary error issue with the algorithm. In addition, we utilize a series of optimization techniques found in Ref. [6] to overcome the resultant hardware noise. The hardware limitations and the few issues with the QHED algorithm itself are reduced in order to produce simulated NISQ hardware results on large images.

The overall goal of this project is to produce high quality results via the QHED circuit on large medical images via REAL NISQ era hardware. Classically, we can use space filling curves or pixel buffers to improve results upon the decomposed image. As far as real hardware is concerned, areas of interest to achieve quality results are by implementing major improvements upon the decrement gate which seems to be the failure point. We can tackle this by a combination of efficient mathematics[7], NISQ error mitigation techniques[6], and VQC techniques. The combination of all of these applied to the three major sections of the circuit (ignoring the measurement phase) could very well result in accurate edge detection results on real quantum hardware. Without access to larger number of qubits (>7 qubits) we need to use the topology taken from noisy simulated hardware. The principles of CX error, single gate error, fidelity, and coherence normally found in real hardware are applicable to noisy simulations. Thus, this remains as a quality means of data analysis prior to execution on real hardware.

== Code ==
Download the Decrement and image encoding notebooks here [https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fquantum%5Fedge%5Fdetection%2Fnotebooks&view=0]

== Paper ==
Find the current version of paper here[https://www.overleaf.com/project/64341df873168e42fe8c2624]

== Quantum Fidelity ==

A quick note on fidelity. For most of this research project

== QHED Circuit ==

[[File:Qhed circuit.png|500px|thumb|none|Figure 1 Generalized qHED Circuit with input vector f and output vector g.]]

=== State Prep ===
[[File:Rcmo.png|500px|thumb|none|Figure 2 Row (left) and Column (right) major ordered mapping.]]

The image is first mapped as a 2D array to a 1D vector. Ref. [2] uses methodology known as row and column major ordering (RCMO). Each pixel is then normalized such that the sum of their squares is equal to 1, a necessary quality of quantum states. Using a module presented by Ref. [3] (or through Qiskit's StatePreparation), we can calculate a quantum circuit which achieves what is known as amplitude encoding. The normalized pixel values of the input vector will be returned as the probability amplitudes of computational basis states. Those computational basis states act as the indexing of the original vector. I.e. if we had a length 64 vector, the 7th element is represented as c_7|000111>. The resultant normalized image state can be written as:

[[File:Img state.png|200px]]

The Hadamard gate in the state prep acts on the Least Significant Bit (LSB) initialized to state |0> which outputs the |+> state. Application of the H-Gate on the LSB has the following tensor product on the input image state:

[[File:State prep.png|400px]]

=== Decrement ===

The decrement portion of the quantum algorithm can be represented by the matrix unitary:

[[File:Decrement unitary.png|400px]]

With application of that unitary gate to the state prepared vector yields the decrement state:

[[File:Decrement state.png|500px]]

To the best of our abilities, we find that references to the QHED method provide very little (if any) detail as to the architecture of the decrement gate. Refs. [4] and presumably [5] use a qiskit unitary class function to convert a numpy matrix into a circuit. Although quite useful for simulations, this type of construction fails on real hardware. We can find a far more reasonable design of the gate in Ref. [7] which is shown below.

[[File:decrement_gate.png|500px|thumb|none|Multi controlled NOT gates perform the decrement operation. q_0 being the least significant qubit.]]

Although it is known that multi qubit gates are highly error prone, we achieve reasonable results when we compare the two methodologies. We begin with a 4 qubit circuit initialized to the state |0000> = (1...0) which is to be decremented to state |1111> = (0...1). Shown below are the results of the more careful multi controlled qubit construction and the unitary class function executed on the real quantum device, ibmq_lima. Based on the results, we know that we must design our own decrement gates and cannot rely on any arbitrary unitary transformation algorithim.

[[File:Lima tl 3.png|500px|thumb|none| Although the results are far from perfect, we can clearly see the state 1111> has been formed from the state 0000>.]]

[[File:Lima np.png|500px|thumb|none| The results of our gate are lost in the noise of the output using the unitary class function.]]

We can improve upon the Decrement gate by using 2n total qubits by altering the increment gates in Ref. [8]. More simply, using open controls (bit flip in the case of the qubit being in the state |0>) alters the increment permutation to a decrement.

[[File:Decrement op.png|500px]]

Looking at the CX counts and fidelity estimates for QHED circuits show promising results. The upcoming section "Methods of Optimization" will describe the optimizations themselves as they are labeled in the charts below.

[[File:Qhed cx.png|500px]]
[[File:Qhed fidelity.png|500px]]

=== Permutation ===
This is the portion of the circuit where the actual edge detection occurs. It can be thought of as a series of identity gates tensored together with an H-Gate in the LSB tensored last. The resultant unitary matrix can be written as:

[[File:Permutation unitary.png|500px]]

With application of the resultant decrement vector as:

[[File:Permutation state.png|500px]]

This is the final output state. Note that if the LSB is in the state |1> we retrieve all of the odd indexed states i.e. |...001> (1), |...011> (3), |...111> (5), ect. These states provide the boundary gradient across the 1D input image. An overview of the QHED algorithm can be visualized as having the following effect on the input of an image state:

[[File:QHED output.png|300px]]

== Methods of Optimization ==

The improved decrement gate was already discussed in the previous section so we will leave it there.

We then utilize Qiskit's transpiler. The optimal SWAP mapping is an NP-Hard problem which yields ambiguous results. "The choice of initial layout can mean the difference between getting a result, and getting nothing but noise." To compute the best low noise layout, we use an open source module called mapomatic. Mapomatic finds the best low noise sub-graph for some given hardware backend(s). The end result is that the module returns the best set of qubits and their appropriate ordering to execute your circuit with minimal noise. This qubit layout is sent to the transpiler. A heuristic fidelity estimate is taken from Ref. [6].

We now turn to a means of error reduction in the measurement output of the circuit. Researchers are able to perform a variety of experiments to measure a qubit's state preparation and measurement (SPAM) errors forming a relationship of noisy probabilities to ideal probabilities in the form of a matrix transformation. The correction matrix can be measured by using a variety of circuits with known outcomes and finding the noisy outcome of every possible bit-string for a particular piece of hardware. From this, it is possible to reconstruct our desired output.

There are obvious scaling issues when it comes to building 2^n x 2^n matricies. There are alternatives to this which do not require such scaling or computational overhead. We make use of such a module called mthree. An excellent demonstration of this can be found in the Qiskit Textbook.

In the case of large images, we must perform domain decomposition to preserve fidelity and reduce noise. However, we find that when applying the suggested RMO and CMO indexed 2D to 1D mapping on decomposed sub images there is a non negligible quality reduction to the output edge detected image. This is due to the fact that this use of mapping does not preserve locality. It can be seen from Fig. [2] how these methods of indexing will provide errors across the boundaries of the image/sub images. Consider the output state |g>. It can be seen how non adjacent pixels of the original image will be compared with each other e.g. c_{3} - c_{4} in the Fig. [2] RMO mapping or c_{12} - c_{1} in the CMO mapping. This may lead to detected edges where there are none. To avoid these discrepancies we apply buffer cells to our decomposed images. We choose to do a row by row decomposition for the horizontal scan as shown below. This leaves 2 redundant pixels per sub image, no matter the decomposition size.

[[File:Boundary buffer.png|500px|thumb|none|Buffer pixels of value 0 are applied to the boundary of the overall image.]]

[[File:Buffer cells.png|500px|thumb|none|Further decomposition is then possible by adding neighboring pixels to be used as a buffer due to QHED error. The red cells are ultimately disposed in the final output.]]

With the decrement gate optimization, the more NISQ-era friendly QHED circuit takes the form shown below.

[[File:Qhed op.png|500px|thumb|none|QHED circuit with expanded, noise mitigated, decrement gate]]

== Domain Decomposition ==

Consider a 1024x1024 medical image. This comes out to 1,048,576 pixels requiring 20 (2^20) qubits plus 1 ancillary qubit for the QHED algorithm. Additionally, the amplitude encoding process expands exponentially with regards to qubit number. We can divide the image into separate sub images and solve either iteratively or in parallel (multithreading). Each sub image is now considered to be a sub input of the overall problem.

[[File:NaF-PROSTATE-01-0001_22.png|500px|thumb|none|Example of 1024x1024 Medical image decomposed into 256x256 sub images.]]

Errors begin to occur with the 2D to 1D mapping of subdomains. Consider the row major ordering in figure 1. Elements c_3 and c_4 will provide gradient detection for the output pixel at location 3. This is because the RCMO mappings do not preserve locality at the boarders of multi dimensional arrays. In a full image pass of the algorithm this would hardly be noticeable and leave little error on the output image. It becomes readily apparent in decomposed domains, however:

[[File:Rcmo example.png|1000px|thumb|none|RCMO 2D to 1D mapping applied prior to the output of QHED (simulated) shown above. RCMO mapping does not preserve locality and thus non neighboring pixels are calculated to have edges between them where no such edges exist.]]

=== Space Filling Curves ===

One way to solve this issue without the addition of extra qubits is to use space filling curves as a means of 2D to 1D mapping. Space filling curves preserve locality in that the final output of the algorithm will provide boundary detection across exclusively neighboring pixels (with the exception of one pixel per domain in certain cases).

[[File:QHED space filling curves.png|1200px|thumb|none|Example of 1024x1024 Medical image decomposed into 64x64 sub images. In the domain decomposed images (bottom row) a different space filling curve is used for mapping. A laplacian (far left column) edge detection stenciling is used as a classical analog for comparisons.]]

=== QHED in 3 Dimensions ===

We can apply the same principles to 3D. The main difference is that instead of performing a vertical and horizontal detection we need to add in a third in order to achieve a full boundary about each pixel. We consider a "scan" about the x, y, and z planes.

[[File:3d model.png|1200px|thumb|none|Example of 3D Medical image to be edge detected.]]
[[File:3d model rcmo.png|1200px|thumb|none|3D Medical image passed through the QHED algorithm (simulated) 3 times (x,y,z plane). The entire image was passed through each plane.]]
[[File:3d model rcmo dd.png|1200px|thumb|none|3D Medical image with decomposed domains. Each sub domain (3D block) passed through the QHED algorithm (simulated) 3 times (x,y,z plane). Each block was mapped using RCMO, edge detected, and pieced back together.]]

== References ==
[1] Acampora, Giovanni, et al. “D-NISQ: A Reference Model for Distributed Noisy Intermediate-Scale Quantum Computers.” Information Fusion, vol. 89, 2023, pp. 16–28., https://doi.org/10.1016/j.inffus.2022.08.003.

[2] .-W. Yao, H. Wang, Z. Liao, M.-C. Chen, J. Pan, J. Li, K. Zhang, X. Lin, Z. Wang, Z. Luo,
et al., Quantum image processing and its application to edge detection: Theory and experiment,
Physical Review X 7 (3) (2017). doi:10.1103/physrevx.7.031041.

[3]I. F. Araujo, D. K. Park, F. Petruccione, A. J. da Silva, A divide-and-conquer algo-
rithm for quantum state preparation, Scientific Reports 11 (1) (2021). doi:10.1038/
s41598-021-85474-1.

[4] Team, T. Q. (2022, July 6). Quantum Edge Detection - qhed algorithm on small and large images. Quantum Edge Detection - QHED Algorithm on Small and Large Images. Retrieved October 28, 2022, from https://qiskit.org/textbook/ch-applications/quantum-edge-detection.html

[5] Anand, A., Lyu, M., Baweja, P. S., & Patil, V. (2022). Quantum Image Processing. https://doi.org/https://arxiv.org/pdf/2203.01831.pdf

[6] Ferris, K. J., Ramusson, A. J., Bronn, N. T., & Lanes, O. (2022). Quantum Simulation on Noisy Superconducting Quantum Computers. https://doi.org/https://doi.org/10.48550/arXiv.2209.02795

[7] LI, X. I. A. O. Y. U., YANG, G. U. O. W. U., TORRES, C. A. R. L. O. S. M. A. N. U. E. L., ZHENG, D. E. S. H. E. N. G., & WANG, K. A. N. G. L. (2013). A class of efficient quantum incrementer gates for quantum circuit synthesis. International Journal of Modern Physics B, 28(01), 1350191. https://doi.org/10.1142/s0217979213501919

[8] . Gidney, Constructing large increment gates. URL https://algassert.com/circuits/2015/06/12/Constructing-Large-Increment-Gates.html

Internal:Quantum Edge Detection

2023-04-10T14:36:51Z

Ebillias: /* Paper */

= Quantum Hadamard Edge Detection (QHED) =

A recent quantum edge detection algorithm called Quantum Hadamard Edge Detection[2] (QHED) provides a promising means of quantum image processing and experimentation. This is done by providing full boundary gradient across a 1D mapping of a 2D image. Due to fidelity issues on NISQ era hardware, we are required to divide our images into sub images (domain decomposition) for proper edge detection[1]. When doing this, we find a boundary error issue with the algorithm. In addition, we utilize a series of optimization techniques found in Ref. [6] to overcome the resultant hardware noise. The hardware limitations and the few issues with the QHED algorithm itself are reduced in order to produce simulated NISQ hardware results on large images.

The overall goal of this project is to produce high quality results via the QHED circuit on large medical images via REAL NISQ era hardware. Classically, we can use space filling curves or pixel buffers to improve results upon the decomposed image. As far as real hardware is concerned, areas of interest to achieve quality results are by implementing major improvements upon the decrement gate which seems to be the failure point. We can tackle this by a combination of efficient mathematics[7], NISQ error mitigation techniques[6], and VQC techniques. The combination of all of these applied to the three major sections of the circuit (ignoring the measurement phase) could very well result in accurate edge detection results on real quantum hardware. Without access to larger number of qubits (>7 qubits) we need to use the topology taken from noisy simulated hardware. The principles of CX error, single gate error, fidelity, and coherence normally found in real hardware are applicable to noisy simulations. Thus, this remains as a quality means of data analysis prior to execution on real hardware.

== Code ==
Download the Decrement and image encoding notebooks here [https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fquantum%5Fedge%5Fdetection%2Fnotebooks&view=0]

== Paper ==
Find the current version of paper here[https://www.overleaf.com/project/64341df873168e42fe8c2624]

== QHED Circuit ==

[[File:Qhed circuit.png|500px|thumb|none|Figure 1 Generalized qHED Circuit with input vector f and output vector g.]]

=== State Prep ===
[[File:Rcmo.png|500px|thumb|none|Figure 2 Row (left) and Column (right) major ordered mapping.]]

The image is first mapped as a 2D array to a 1D vector. Ref. [2] uses methodology known as row and column major ordering (RCMO). Each pixel is then normalized such that the sum of their squares is equal to 1, a necessary quality of quantum states. Using a module presented by Ref. [3] (or through Qiskit's StatePreparation), we can calculate a quantum circuit which achieves what is known as amplitude encoding. The normalized pixel values of the input vector will be returned as the probability amplitudes of computational basis states. Those computational basis states act as the indexing of the original vector. I.e. if we had a length 64 vector, the 7th element is represented as c_7|000111>. The resultant normalized image state can be written as:

[[File:Img state.png|200px]]

The Hadamard gate in the state prep acts on the Least Significant Bit (LSB) initialized to state |0> which outputs the |+> state. Application of the H-Gate on the LSB has the following tensor product on the input image state:

[[File:State prep.png|400px]]

=== Decrement ===

The decrement portion of the quantum algorithm can be represented by the matrix unitary:

[[File:Decrement unitary.png|400px]]

With application of that unitary gate to the state prepared vector yields the decrement state:

[[File:Decrement state.png|500px]]

To the best of our abilities, we find that references to the QHED method provide very little (if any) detail as to the architecture of the decrement gate. Refs. [4] and presumably [5] use a qiskit unitary class function to convert a numpy matrix into a circuit. Although quite useful for simulations, this type of construction fails on real hardware. We can find a far more reasonable design of the gate in Ref. [7] which is shown below.

[[File:decrement_gate.png|500px|thumb|none|Multi controlled NOT gates perform the decrement operation. q_0 being the least significant qubit.]]

Although it is known that multi qubit gates are highly error prone, we achieve reasonable results when we compare the two methodologies. We begin with a 4 qubit circuit initialized to the state |0000> = (1...0) which is to be decremented to state |1111> = (0...1). Shown below are the results of the more careful multi controlled qubit construction and the unitary class function executed on the real quantum device, ibmq_lima. Based on the results, we know that we must design our own decrement gates and cannot rely on any arbitrary unitary transformation algorithim.

[[File:Lima tl 3.png|500px|thumb|none| Although the results are far from perfect, we can clearly see the state 1111> has been formed from the state 0000>.]]

[[File:Lima np.png|500px|thumb|none| The results of our gate are lost in the noise of the output using the unitary class function.]]

We can improve upon the Decrement gate by using 2n total qubits by altering the increment gates in Ref. [8]. More simply, using open controls (bit flip in the case of the qubit being in the state |0>) alters the increment permutation to a decrement.

[[File:Decrement op.png|500px]]

Looking at the CX counts and fidelity estimates for QHED circuits show promising results. The upcoming section "Methods of Optimization" will describe the optimizations themselves as they are labeled in the charts below.

[[File:Qhed cx.png|500px]]
[[File:Qhed fidelity.png|500px]]

=== Permutation ===
This is the portion of the circuit where the actual edge detection occurs. It can be thought of as a series of identity gates tensored together with an H-Gate in the LSB tensored last. The resultant unitary matrix can be written as:

[[File:Permutation unitary.png|500px]]

With application of the resultant decrement vector as:

[[File:Permutation state.png|500px]]

This is the final output state. Note that if the LSB is in the state |1> we retrieve all of the odd indexed states i.e. |...001> (1), |...011> (3), |...111> (5), ect. These states provide the boundary gradient across the 1D input image. An overview of the QHED algorithm can be visualized as having the following effect on the input of an image state:

[[File:QHED output.png|300px]]

== Methods of Optimization ==

The improved decrement gate was already discussed in the previous section so we will leave it there.

We then utilize Qiskit's transpiler. The optimal SWAP mapping is an NP-Hard problem which yields ambiguous results. "The choice of initial layout can mean the difference between getting a result, and getting nothing but noise." To compute the best low noise layout, we use an open source module called mapomatic. Mapomatic finds the best low noise sub-graph for some given hardware backend(s). The end result is that the module returns the best set of qubits and their appropriate ordering to execute your circuit with minimal noise. This qubit layout is sent to the transpiler. A heuristic fidelity estimate is taken from Ref. [6].

We now turn to a means of error reduction in the measurement output of the circuit. Researchers are able to perform a variety of experiments to measure a qubit's state preparation and measurement (SPAM) errors forming a relationship of noisy probabilities to ideal probabilities in the form of a matrix transformation. The correction matrix can be measured by using a variety of circuits with known outcomes and finding the noisy outcome of every possible bit-string for a particular piece of hardware. From this, it is possible to reconstruct our desired output.

There are obvious scaling issues when it comes to building 2^n x 2^n matricies. There are alternatives to this which do not require such scaling or computational overhead. We make use of such a module called mthree. An excellent demonstration of this can be found in the Qiskit Textbook.

In the case of large images, we must perform domain decomposition to preserve fidelity and reduce noise. However, we find that when applying the suggested RMO and CMO indexed 2D to 1D mapping on decomposed sub images there is a non negligible quality reduction to the output edge detected image. This is due to the fact that this use of mapping does not preserve locality. It can be seen from Fig. [2] how these methods of indexing will provide errors across the boundaries of the image/sub images. Consider the output state |g>. It can be seen how non adjacent pixels of the original image will be compared with each other e.g. c_{3} - c_{4} in the Fig. [2] RMO mapping or c_{12} - c_{1} in the CMO mapping. This may lead to detected edges where there are none. To avoid these discrepancies we apply buffer cells to our decomposed images. We choose to do a row by row decomposition for the horizontal scan as shown below. This leaves 2 redundant pixels per sub image, no matter the decomposition size.

[[File:Boundary buffer.png|500px|thumb|none|Buffer pixels of value 0 are applied to the boundary of the overall image.]]

[[File:Buffer cells.png|500px|thumb|none|Further decomposition is then possible by adding neighboring pixels to be used as a buffer due to QHED error. The red cells are ultimately disposed in the final output.]]

With the decrement gate optimization, the more NISQ-era friendly QHED circuit takes the form shown below.

[[File:Qhed op.png|500px|thumb|none|QHED circuit with expanded, noise mitigated, decrement gate]]

== Domain Decomposition ==

Consider a 1024x1024 medical image. This comes out to 1,048,576 pixels requiring 20 (2^20) qubits plus 1 ancillary qubit for the QHED algorithm. Additionally, the amplitude encoding process expands exponentially with regards to qubit number. We can divide the image into separate sub images and solve either iteratively or in parallel (multithreading). Each sub image is now considered to be a sub input of the overall problem.

[[File:NaF-PROSTATE-01-0001_22.png|500px|thumb|none|Example of 1024x1024 Medical image decomposed into 256x256 sub images.]]

Errors begin to occur with the 2D to 1D mapping of subdomains. Consider the row major ordering in figure 1. Elements c_3 and c_4 will provide gradient detection for the output pixel at location 3. This is because the RCMO mappings do not preserve locality at the boarders of multi dimensional arrays. In a full image pass of the algorithm this would hardly be noticeable and leave little error on the output image. It becomes readily apparent in decomposed domains, however:

[[File:Rcmo example.png|1000px|thumb|none|RCMO 2D to 1D mapping applied prior to the output of QHED (simulated) shown above. RCMO mapping does not preserve locality and thus non neighboring pixels are calculated to have edges between them where no such edges exist.]]

=== Space Filling Curves ===

One way to solve this issue without the addition of extra qubits is to use space filling curves as a means of 2D to 1D mapping. Space filling curves preserve locality in that the final output of the algorithm will provide boundary detection across exclusively neighboring pixels (with the exception of one pixel per domain in certain cases).

[[File:QHED space filling curves.png|1200px|thumb|none|Example of 1024x1024 Medical image decomposed into 64x64 sub images. In the domain decomposed images (bottom row) a different space filling curve is used for mapping. A laplacian (far left column) edge detection stenciling is used as a classical analog for comparisons.]]

=== QHED in 3 Dimensions ===

We can apply the same principles to 3D. The main difference is that instead of performing a vertical and horizontal detection we need to add in a third in order to achieve a full boundary about each pixel. We consider a "scan" about the x, y, and z planes.

[[File:3d model.png|1200px|thumb|none|Example of 3D Medical image to be edge detected.]]
[[File:3d model rcmo.png|1200px|thumb|none|3D Medical image passed through the QHED algorithm (simulated) 3 times (x,y,z plane). The entire image was passed through each plane.]]
[[File:3d model rcmo dd.png|1200px|thumb|none|3D Medical image with decomposed domains. Each sub domain (3D block) passed through the QHED algorithm (simulated) 3 times (x,y,z plane). Each block was mapped using RCMO, edge detected, and pieced back together.]]

== References ==
[1] Acampora, Giovanni, et al. “D-NISQ: A Reference Model for Distributed Noisy Intermediate-Scale Quantum Computers.” Information Fusion, vol. 89, 2023, pp. 16–28., https://doi.org/10.1016/j.inffus.2022.08.003.

[2] .-W. Yao, H. Wang, Z. Liao, M.-C. Chen, J. Pan, J. Li, K. Zhang, X. Lin, Z. Wang, Z. Luo,
et al., Quantum image processing and its application to edge detection: Theory and experiment,
Physical Review X 7 (3) (2017). doi:10.1103/physrevx.7.031041.

[3]I. F. Araujo, D. K. Park, F. Petruccione, A. J. da Silva, A divide-and-conquer algo-
rithm for quantum state preparation, Scientific Reports 11 (1) (2021). doi:10.1038/
s41598-021-85474-1.

[4] Team, T. Q. (2022, July 6). Quantum Edge Detection - qhed algorithm on small and large images. Quantum Edge Detection - QHED Algorithm on Small and Large Images. Retrieved October 28, 2022, from https://qiskit.org/textbook/ch-applications/quantum-edge-detection.html

[5] Anand, A., Lyu, M., Baweja, P. S., & Patil, V. (2022). Quantum Image Processing. https://doi.org/https://arxiv.org/pdf/2203.01831.pdf

[6] Ferris, K. J., Ramusson, A. J., Bronn, N. T., & Lanes, O. (2022). Quantum Simulation on Noisy Superconducting Quantum Computers. https://doi.org/https://doi.org/10.48550/arXiv.2209.02795

[7] LI, X. I. A. O. Y. U., YANG, G. U. O. W. U., TORRES, C. A. R. L. O. S. M. A. N. U. E. L., ZHENG, D. E. S. H. E. N. G., & WANG, K. A. N. G. L. (2013). A class of efficient quantum incrementer gates for quantum circuit synthesis. International Journal of Modern Physics B, 28(01), 1350191. https://doi.org/10.1142/s0217979213501919

[8] . Gidney, Constructing large increment gates. URL https://algassert.com/circuits/2015/06/12/Constructing-Large-Increment-Gates.html

Internal:Quantum Machine Learning

2023-04-09T17:59:00Z

Ebillias: /* April 9, 2023 */

= Progress =

== March 21, 2023 ==

Many of these models require a hybrid approach. Brookhaven, for example, uses a distributed series of VQC's which then feed data to a classical NN to attain results. Others use a method more in line with Cirq where the input parameters are fed into a classical NN which then produces the parameters required for the VQC. This seems almost redundant UNLESS the input data is so large that classification via classical CNN is so computationally expensive that a regular NN plus VQC is somehow "cheaper". I am not sure if our 4,032 pixel data constitutes. I am required to accomplish two distinct goals with this project:

1. Distinguish myself by using a Quantum particle data classifier which has not been seen before.

2. The product of 1. must have some utility

In regards to the Qiskit QCNN method of attaining results on the particle data we find two main problems:

* The 36x112 feature particle data is too large to use any pauli mapping so we are reliant on a 12 qubit amplitude encoding circuit. This circuit trains extremely slow even with the use of GPU's. Optimizations need to be discovered in order to make progress with this area. With that being said, for small sample sizes we achieve good results (+90%).

* The 6 feature data encoded with the same Pauli methods attain very poor results as shown below.

There exists a few solutions to the 36x112 feature problem number:

* We can interpolate the data to smaller amplitude encoded circuits such as 8 qubits. Doing so achieves respectable results (+80% accuracy) for smaller datasets (under 1000 samples). For larger datasets training time is drastically increased and progress towards a minimum is slowed and we are back to the first problem again.

* We find ways of optimizing the circuits for training. Qiskit allegedly has several "fast" sampling methods. Learning the modules and applying a few test runs should determine if the full 12 qubits can be encoded correctly.

I propose a series of problems to solve where, if solved, any one of them will be both distinguishable and possess utility:

* We can optimize training the Qiskit circuits. There are other ways to produce the required results.
** Seen here[https://qiskit.org/documentation/tutorials/simulators/7_matrix_product_state_method.html] a 50 qubit EPR state is sampled in 0.1 seconds. There are fast sampling methods built in. If these can be sent to the optimizer as a Quantum_Instance (in the same way we use the GPU) then I can simulate a wide variety of large circuits very quickly. This will allow for a more "pure" QCNN than those seen in other papers as well as having the utility of being run on real hardware (in the near future maybe!).

* The dissertation written by Jonas Landman from University of Paris proposes intersting QNN architectures such as the NISQ algorithm for Orthogonal Neural Networks. This uses a connected series of quantum VQC's which replicate a classical neural network. Using this architecture could very well provide real results on the 6 feature data (or interpolated 36x112 feature).

* Much like a combination of Jonas Landman and the Brookhaven paper, I could construct my own series of Quantum circuits which act as a distributed Neural network. A layer of circuits produce an output which are then fed into the next layer of circuits. In this case, the circuits act as both the Nodes and carry the weights in a classical sense. This gives far more parameters to work with using "less" qubits per circuit. This means, with a sufficient distribution, every datapoint will be encoded into it's own qubit even for the 36x112 feature data. +4,000 qubits won't be an issue if they're broken up into sufficiently small circuits with distributed calculations.

== March 27, 2023 ==

From last week, two major problems are solved:

1. The 6 feature data will not produce reasonable results (possibly due to the loss of locality?). However, the 4032 feature data can be resized using:

cv2.resize(samples, dsize=(n, len(samples)), interpolation=cv2.INTER_AREA)

See [https://medium.com/@wenrudong/what-is-opencvs-inter-area-actually-doing-282a626a09b3] for INTER_AREA

This allows for resizing of the image to fit some n number of pixels without loosing any of the data points to full degredation (all 0 pixel values). This resizing will allow for the training of networks using pauli feature mapping (because cv2.INTER_AREA preserves some of the locality?). This, in turn, not only greatly decreasing training times and quickens convergence, but also increases the accuracy of result.

2. The GPU implementation only requires a few lines of code to be optimized:

try:
simulator_gpu = Aer.get_backend('aer_simulator')
simulator_gpu.set_options(device='GPU', precision='single')
except AerError as e:
print('GPU Err:\n',e)

Take note that for certain feature mapping and ansatz implementations the GPU may be slower than a CPU if an insufficient number of qubits is used.

Using the following we are able to produce a very rudimentary VQC with two parts; a feature mapping and ansatz. Using everything we learned we can achieve an accuracy of +98% for previously unseen testing data in 30 iterations, training time under 2 minutes, 0.01% of the data used for training. This is done with n number of qubits/features to be 6 or 8.

So far, there is no need for a complex distributed network, hybridization, or complex QCNN classification models. The following goal is to either discover or create a more "complete" ansatz which can cover as much of the hilbert space as possible. Doing so should bump us up to +99% with a mere few minutes of training time

== March 31, 2023 ==

Heavily influenced by REfs. [1, 2, 3] as well as Jonas Landman, we can create a distributed Quantum Neural Network for particle classification. The image below, from Ref. [1], can be thought of a two layer QNN.

[[File:Scalable_qnn.png|600px]]

=== Encoding ===
The first layer is encoded directly using the data sample. That encoding will be done with either the Qiskit Pauli feature mappings or the ones used in Ref. [3] (arctan mapping). In the subsequent layers, the inputs will be the Pauli Z expectation from the previous layers individual circuit. Example, Feature extractor 1 from the image above will yield some value [-1, 1]. That value will be input into the first qubit of the "Predictor" in the second layer. Likewise, the value yielded from feature extractor 4 will be input into the last qubit of the predictor. So we know that our predictor will be 4 qubits wide. The expectation value calculations come directly from Ref. [2] and are easily implemented in qiskit.

=== VQC's ===
Every VQC in each layer, U(θ), will be an independent ansatz with parameters p[0], p[1]... p[n]. Note, a back propagation algorithm could be relatively simple to implement since each layer of the network can be represented by a parameterized weight matrix. For layer 1 in the image we have:

p_1[0] p_1[1]... p_1[n]

p_2[0] p_2[1]... p_2[n]

p_3[0] p_3[1]... p_3[n]

p_4[0] p_4[1]... p_4[n]

And for the predictor layer we will have only one row of parameters since there is only one circuit:

p_pre[0] p_pre[1]... p_pre[n]

Note the reduction in dimensionality between the two layers. Also note that this is NOT a fully connected QCNN. Moving to that model should not be too difficult depending on the results gained from this experiment. This could be implemented by the techniques described in Landman's dissertation.

=== Classical Device ===

Upon measurement of the predictor we have our classification again as a value of [-1, 1]. From here, we implement a loss function and back propagation algorithm on our parameter matrices.

== April 9, 2023 ==

[[File:FCQNN_diagram.png|1500px]]

A Fully Connected Quantum Neural Network can be seen above. The closes approximation to this that I can find in the current literature is found here [https://link.springer.com/article/10.1007/s42484-021-00046-w] (see Ref. 8). They use amplitude encoded circuits for the MNIST dataset where the ansatz used look like circularly entangled pauli two design gates. The main mechanics of a forward pass are shown in the diagram. The encoding portions of the circuits, F(X), act as the analogous neurons while the VQC's, U(θ), act as the weight matrices. It can be thought of more as a connected series of smaller classical Neural networks.

Things to consider/progress to be made:

1. As far as quantum classifiers for nuclear physics goes I have not found this network architecture applied yet.
2. Outside of a few "toy" example datasets (MNIST) and those used for dissipative quantum neural networks, these networks seem to be rare.
3. Nobody has utilized this architecture in a distributive manner.
4. I will continue using qiskit for now but I must consider c++ or cuda based applications for a quicker expectation measurements.
5. I am dedicating approximately 30 minutes to 1 hour of literature review every day to ensure that 1-3 are true.

If this works out then my goals stated here[https://crtc.cs.odu.edu/Internal:Quantum_Machine_Learning#March_21.2C_2023] will be achieved.

1. Creating a scalable quantum classification network for high energy particle physics which has not been seen before.
2. The network has real utility in the future.

= Code : =

Download the notebooks here[https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2FQML%20Course%2Fqml%5Fnotebooks&view=0]

= Literature : Quantum Classifiers =
== [1] Scalable Quantum Neural Networks for Classification ==
Jindi Wu, Zeyi Tao, Qun Li
https://arxiv.org/abs/2208.07719

Relies on a hybrid classical-quantum architecture. Each subdomain has the following:

1. Encoding Unit
* Authors utilize angle encoding (N qubits for N features) because it can support gradient calculations
* Amplitude encoding not used due to error rate and difficulty in computing gradients

2. VQC
* They follow the VQC introduced in https://www.tensorflow.org/quantum/tutorials/mnist#21_build_the_model_circuit

3. Measurement
* Calculation of the expectation value, seemingly Pauli-Z operator giving [-1, 1]

4. The measurement of the sub domain is then encoded into a qubit in the next layer.

Seemingly, this process combines both convolutional and pooling layers in the same way that Iris Cong et al. performs calculations. Advantageous over the qiskit implementation in that the "pooling layers" are not parameterized since the pooling is the measurement itself. Additionally, we can run circuits in parallel.

== [2] Quantum convolutional neural networks ==
Iris Cong et al., Nature Physics
https://doi.org/10.1038/s41567-019-0648-8

N qubit input requires O(log(N)) variational parameters. "This corresponds to a double exponential reduction compared with a generic quantum circuit-based classifier..." hopefully leading to faster training times?

== [3] Quantum convolutional neural networks for high energy physics data analysis ==
Chen et al., Brookhaven National Labs
https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.013231

The (SIMULATED) QCNN follows the following protocol:

1. Feature mapped (Amplitude encoded?) particle images of size 30x30 are implemented in the encoding layer.

2. A VQC acts as a convolutional layer. Convolutional outputs are calculated via the expectation value of the Pauli-Z operator acting on the first qubit.

3. Pooling is done classically with nonlinear activation functions in between convolutional layers (look deeper into this).

4. Categorical Cross Entropy Loss Function is applied to the final output.

5. Back Prop to adjust the parameters in the VQC's (convolutional layers).

We can implement this "by hand" in qiskit using their approximate expectation function on a Wahab GPU node using simulator.set_options(device='GPU'). This is considerable because it may be a faster process (also for larger circuits) than available public access QML methods.

== [4] Quantum machine learning for particle physics using a variational quantum classifier ==
Andrew Blancea and Michael Spannowsky
https://link.springer.com/article/10.1007/JHEP02(2021)212

This method follows the same methodology as many others.

1. Angle Encoding the data
2. Generic VQC using universal single qubit gates and CNOTs producing layers of two entangled qubits
3. Measurement is performed by experimental repetitions to determine the expectation value of the Pauli-Z operator, not calculated deterministically

Rudimentary introduction to QNN classification.

== [5] Challenges and opportunities in quantum machine learning for high-energy physics ==
Sau Lan Wu and Shinjae Yoo2
https://www.nature.com/articles/s42254-022-00425-7

"Overall, the greatest challenge in using quantum computer hardware for machine learning at present... is the size of the event samples and the effective use of large num- bers of qubits... analyses will need to manage large event sample size and large data dimensionality...

... advanced quantum computers with large numbers of qubits, reduced noise and improved running time may outperform classical machine learn- ing in both classification power and in speed. QML may well be a new computational paradigm for big data analyses in HEP. For this reason, the HEP community should stay aware of what is happening in quantum technologies — improvements in the hardware, software ecosystem and algorithms — to bring a quantum advan- tage to the HEP data challenge. Conversely, the develop- ment of solutions for unique HEP data challenges could also lead to contributions to the development of quantum technologies."

== [6] Quantum machine learning in high energy physics ==
Guan et al.
https://iopscience.iop.org/article/10.1088/2632-2153/abc17d/pdf

Uses adiabatic quantum annealing as an optimizer. This methodology also uses angle encoding for particle track data, a general VQC, with different optimizers such as ADAM and COBYLA.

== [7] Hybrid Quantum-Classical Neural Network for Calculating Ground State Energies of Molecules ==
Xia, R.; Kais, S. Hybrid Quantum-Classical Neural Network for Calculating Ground State Energies of Molecules. Entropy 2020, 22, 828. https://arxiv.org/pdf/1912.06184.pdf

Although the problem set is not what we are looking for (to find a hamiltonian for potential energy curves) the architecture of this type of QNN can be used to create a fully connected QNN. We cans say that for the image in Ref. [1], each qubit from each circuit in the first layer is measured (the expectation value calculated) independently, we now have a value to pass to the next layer of circuits. I.E. if we have a two qubit circuit, that circuit will yield two expectation values meaning we can pass two different values to two different circuit in the next layer. The first circuit layer has some x number of qubits per circuit, we will have x number of circuits in the next layer.

== [8] QDNN: deep neural networks with quantum layers ==
Zhao, C., Gao, XS. QDNN: deep neural networks with quantum layers. Quantum Mach. Intell. 3, 15 (2021). https://doi.org/10.1007/s42484-021-00046-w

What distinguishes this model from others is that it utilizes non-linear activation functions within the quantum network. Just as well, it uses a very simple and effective gradient descent method to adjust the parameters of the network.

Internal:Quantum Machine Learning

2023-04-09T17:58:45Z

Ebillias: /* Literature : Quantum Classifiers */

= Progress =

== March 21, 2023 ==

Many of these models require a hybrid approach. Brookhaven, for example, uses a distributed series of VQC's which then feed data to a classical NN to attain results. Others use a method more in line with Cirq where the input parameters are fed into a classical NN which then produces the parameters required for the VQC. This seems almost redundant UNLESS the input data is so large that classification via classical CNN is so computationally expensive that a regular NN plus VQC is somehow "cheaper". I am not sure if our 4,032 pixel data constitutes. I am required to accomplish two distinct goals with this project:

1. Distinguish myself by using a Quantum particle data classifier which has not been seen before.

2. The product of 1. must have some utility

In regards to the Qiskit QCNN method of attaining results on the particle data we find two main problems:

* The 36x112 feature particle data is too large to use any pauli mapping so we are reliant on a 12 qubit amplitude encoding circuit. This circuit trains extremely slow even with the use of GPU's. Optimizations need to be discovered in order to make progress with this area. With that being said, for small sample sizes we achieve good results (+90%).

* The 6 feature data encoded with the same Pauli methods attain very poor results as shown below.

There exists a few solutions to the 36x112 feature problem number:

* We can interpolate the data to smaller amplitude encoded circuits such as 8 qubits. Doing so achieves respectable results (+80% accuracy) for smaller datasets (under 1000 samples). For larger datasets training time is drastically increased and progress towards a minimum is slowed and we are back to the first problem again.

* We find ways of optimizing the circuits for training. Qiskit allegedly has several "fast" sampling methods. Learning the modules and applying a few test runs should determine if the full 12 qubits can be encoded correctly.

I propose a series of problems to solve where, if solved, any one of them will be both distinguishable and possess utility:

* We can optimize training the Qiskit circuits. There are other ways to produce the required results.
** Seen here[https://qiskit.org/documentation/tutorials/simulators/7_matrix_product_state_method.html] a 50 qubit EPR state is sampled in 0.1 seconds. There are fast sampling methods built in. If these can be sent to the optimizer as a Quantum_Instance (in the same way we use the GPU) then I can simulate a wide variety of large circuits very quickly. This will allow for a more "pure" QCNN than those seen in other papers as well as having the utility of being run on real hardware (in the near future maybe!).

* The dissertation written by Jonas Landman from University of Paris proposes intersting QNN architectures such as the NISQ algorithm for Orthogonal Neural Networks. This uses a connected series of quantum VQC's which replicate a classical neural network. Using this architecture could very well provide real results on the 6 feature data (or interpolated 36x112 feature).

* Much like a combination of Jonas Landman and the Brookhaven paper, I could construct my own series of Quantum circuits which act as a distributed Neural network. A layer of circuits produce an output which are then fed into the next layer of circuits. In this case, the circuits act as both the Nodes and carry the weights in a classical sense. This gives far more parameters to work with using "less" qubits per circuit. This means, with a sufficient distribution, every datapoint will be encoded into it's own qubit even for the 36x112 feature data. +4,000 qubits won't be an issue if they're broken up into sufficiently small circuits with distributed calculations.

== March 27, 2023 ==

From last week, two major problems are solved:

1. The 6 feature data will not produce reasonable results (possibly due to the loss of locality?). However, the 4032 feature data can be resized using:

cv2.resize(samples, dsize=(n, len(samples)), interpolation=cv2.INTER_AREA)

See [https://medium.com/@wenrudong/what-is-opencvs-inter-area-actually-doing-282a626a09b3] for INTER_AREA

This allows for resizing of the image to fit some n number of pixels without loosing any of the data points to full degredation (all 0 pixel values). This resizing will allow for the training of networks using pauli feature mapping (because cv2.INTER_AREA preserves some of the locality?). This, in turn, not only greatly decreasing training times and quickens convergence, but also increases the accuracy of result.

2. The GPU implementation only requires a few lines of code to be optimized:

try:
simulator_gpu = Aer.get_backend('aer_simulator')
simulator_gpu.set_options(device='GPU', precision='single')
except AerError as e:
print('GPU Err:\n',e)

Take note that for certain feature mapping and ansatz implementations the GPU may be slower than a CPU if an insufficient number of qubits is used.

Using the following we are able to produce a very rudimentary VQC with two parts; a feature mapping and ansatz. Using everything we learned we can achieve an accuracy of +98% for previously unseen testing data in 30 iterations, training time under 2 minutes, 0.01% of the data used for training. This is done with n number of qubits/features to be 6 or 8.

So far, there is no need for a complex distributed network, hybridization, or complex QCNN classification models. The following goal is to either discover or create a more "complete" ansatz which can cover as much of the hilbert space as possible. Doing so should bump us up to +99% with a mere few minutes of training time

== March 31, 2023 ==

Heavily influenced by REfs. [1, 2, 3] as well as Jonas Landman, we can create a distributed Quantum Neural Network for particle classification. The image below, from Ref. [1], can be thought of a two layer QNN.

[[File:Scalable_qnn.png|600px]]

=== Encoding ===
The first layer is encoded directly using the data sample. That encoding will be done with either the Qiskit Pauli feature mappings or the ones used in Ref. [3] (arctan mapping). In the subsequent layers, the inputs will be the Pauli Z expectation from the previous layers individual circuit. Example, Feature extractor 1 from the image above will yield some value [-1, 1]. That value will be input into the first qubit of the "Predictor" in the second layer. Likewise, the value yielded from feature extractor 4 will be input into the last qubit of the predictor. So we know that our predictor will be 4 qubits wide. The expectation value calculations come directly from Ref. [2] and are easily implemented in qiskit.

=== VQC's ===
Every VQC in each layer, U(θ), will be an independent ansatz with parameters p[0], p[1]... p[n]. Note, a back propagation algorithm could be relatively simple to implement since each layer of the network can be represented by a parameterized weight matrix. For layer 1 in the image we have:

p_1[0] p_1[1]... p_1[n]

p_2[0] p_2[1]... p_2[n]

p_3[0] p_3[1]... p_3[n]

p_4[0] p_4[1]... p_4[n]

And for the predictor layer we will have only one row of parameters since there is only one circuit:

p_pre[0] p_pre[1]... p_pre[n]

Note the reduction in dimensionality between the two layers. Also note that this is NOT a fully connected QCNN. Moving to that model should not be too difficult depending on the results gained from this experiment. This could be implemented by the techniques described in Landman's dissertation.

=== Classical Device ===

Upon measurement of the predictor we have our classification again as a value of [-1, 1]. From here, we implement a loss function and back propagation algorithm on our parameter matrices.

== April 9, 2023 ==

[[File:FCQNN_diagram.png|1500px]]

A Fully Connected Quantum Neural Network can be seen above. The closes approximation to this that I can find in the current literature is found here [https://link.springer.com/article/10.1007/s42484-021-00046-w]. They use amplitude encoded circuits for the MNIST dataset where the ansatz used look like circularly entangled pauli two design gates. The main mechanics of a forward pass are shown in the diagram. The encoding portions of the circuits, F(X), act as the analogous neurons while the VQC's, U(θ), act as the weight matrices. It can be thought of more as a connected series of smaller classical Neural networks.

Things to consider/progress to be made:

1. As far as quantum classifiers for nuclear physics goes I have not found this network architecture applied yet.
2. Outside of a few "toy" example datasets (MNIST) and those used for dissipative quantum neural networks, these networks seem to be rare.
3. Nobody has utilized this architecture in a distributive manner.
4. I will continue using qiskit for now but I must consider c++ or cuda based applications for a quicker expectation measurements.
5. I am dedicating approximately 30 minutes to 1 hour of literature review every day to ensure that 1-3 are true.

If this works out then my goals stated here[https://crtc.cs.odu.edu/Internal:Quantum_Machine_Learning#March_21.2C_2023] will be achieved.

1. Creating a scalable quantum classification network for high energy particle physics which has not been seen before.
2. The network has real utility in the future.

= Code : =

Download the notebooks here[https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2FQML%20Course%2Fqml%5Fnotebooks&view=0]

= Literature : Quantum Classifiers =
== [1] Scalable Quantum Neural Networks for Classification ==
Jindi Wu, Zeyi Tao, Qun Li
https://arxiv.org/abs/2208.07719

Relies on a hybrid classical-quantum architecture. Each subdomain has the following:

1. Encoding Unit
* Authors utilize angle encoding (N qubits for N features) because it can support gradient calculations
* Amplitude encoding not used due to error rate and difficulty in computing gradients

2. VQC
* They follow the VQC introduced in https://www.tensorflow.org/quantum/tutorials/mnist#21_build_the_model_circuit

3. Measurement
* Calculation of the expectation value, seemingly Pauli-Z operator giving [-1, 1]

4. The measurement of the sub domain is then encoded into a qubit in the next layer.

Seemingly, this process combines both convolutional and pooling layers in the same way that Iris Cong et al. performs calculations. Advantageous over the qiskit implementation in that the "pooling layers" are not parameterized since the pooling is the measurement itself. Additionally, we can run circuits in parallel.

== [2] Quantum convolutional neural networks ==
Iris Cong et al., Nature Physics
https://doi.org/10.1038/s41567-019-0648-8

N qubit input requires O(log(N)) variational parameters. "This corresponds to a double exponential reduction compared with a generic quantum circuit-based classifier..." hopefully leading to faster training times?

== [3] Quantum convolutional neural networks for high energy physics data analysis ==
Chen et al., Brookhaven National Labs
https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.013231

The (SIMULATED) QCNN follows the following protocol:

1. Feature mapped (Amplitude encoded?) particle images of size 30x30 are implemented in the encoding layer.

2. A VQC acts as a convolutional layer. Convolutional outputs are calculated via the expectation value of the Pauli-Z operator acting on the first qubit.

3. Pooling is done classically with nonlinear activation functions in between convolutional layers (look deeper into this).

4. Categorical Cross Entropy Loss Function is applied to the final output.

5. Back Prop to adjust the parameters in the VQC's (convolutional layers).

We can implement this "by hand" in qiskit using their approximate expectation function on a Wahab GPU node using simulator.set_options(device='GPU'). This is considerable because it may be a faster process (also for larger circuits) than available public access QML methods.

== [4] Quantum machine learning for particle physics using a variational quantum classifier ==
Andrew Blancea and Michael Spannowsky
https://link.springer.com/article/10.1007/JHEP02(2021)212

This method follows the same methodology as many others.

1. Angle Encoding the data
2. Generic VQC using universal single qubit gates and CNOTs producing layers of two entangled qubits
3. Measurement is performed by experimental repetitions to determine the expectation value of the Pauli-Z operator, not calculated deterministically

Rudimentary introduction to QNN classification.

== [5] Challenges and opportunities in quantum machine learning for high-energy physics ==
Sau Lan Wu and Shinjae Yoo2
https://www.nature.com/articles/s42254-022-00425-7

"Overall, the greatest challenge in using quantum computer hardware for machine learning at present... is the size of the event samples and the effective use of large num- bers of qubits... analyses will need to manage large event sample size and large data dimensionality...

... advanced quantum computers with large numbers of qubits, reduced noise and improved running time may outperform classical machine learn- ing in both classification power and in speed. QML may well be a new computational paradigm for big data analyses in HEP. For this reason, the HEP community should stay aware of what is happening in quantum technologies — improvements in the hardware, software ecosystem and algorithms — to bring a quantum advan- tage to the HEP data challenge. Conversely, the develop- ment of solutions for unique HEP data challenges could also lead to contributions to the development of quantum technologies."

== [6] Quantum machine learning in high energy physics ==
Guan et al.
https://iopscience.iop.org/article/10.1088/2632-2153/abc17d/pdf

Uses adiabatic quantum annealing as an optimizer. This methodology also uses angle encoding for particle track data, a general VQC, with different optimizers such as ADAM and COBYLA.

== [7] Hybrid Quantum-Classical Neural Network for Calculating Ground State Energies of Molecules ==
Xia, R.; Kais, S. Hybrid Quantum-Classical Neural Network for Calculating Ground State Energies of Molecules. Entropy 2020, 22, 828. https://arxiv.org/pdf/1912.06184.pdf

Although the problem set is not what we are looking for (to find a hamiltonian for potential energy curves) the architecture of this type of QNN can be used to create a fully connected QNN. We cans say that for the image in Ref. [1], each qubit from each circuit in the first layer is measured (the expectation value calculated) independently, we now have a value to pass to the next layer of circuits. I.E. if we have a two qubit circuit, that circuit will yield two expectation values meaning we can pass two different values to two different circuit in the next layer. The first circuit layer has some x number of qubits per circuit, we will have x number of circuits in the next layer.

== [8] QDNN: deep neural networks with quantum layers ==
Zhao, C., Gao, XS. QDNN: deep neural networks with quantum layers. Quantum Mach. Intell. 3, 15 (2021). https://doi.org/10.1007/s42484-021-00046-w

What distinguishes this model from others is that it utilizes non-linear activation functions within the quantum network. Just as well, it uses a very simple and effective gradient descent method to adjust the parameters of the network.

Internal:Quantum Machine Learning

2023-04-09T17:43:29Z

Ebillias: /* April 9, 2023 */

= Progress =

== March 21, 2023 ==

Many of these models require a hybrid approach. Brookhaven, for example, uses a distributed series of VQC's which then feed data to a classical NN to attain results. Others use a method more in line with Cirq where the input parameters are fed into a classical NN which then produces the parameters required for the VQC. This seems almost redundant UNLESS the input data is so large that classification via classical CNN is so computationally expensive that a regular NN plus VQC is somehow "cheaper". I am not sure if our 4,032 pixel data constitutes. I am required to accomplish two distinct goals with this project:

1. Distinguish myself by using a Quantum particle data classifier which has not been seen before.

2. The product of 1. must have some utility

In regards to the Qiskit QCNN method of attaining results on the particle data we find two main problems:

* The 36x112 feature particle data is too large to use any pauli mapping so we are reliant on a 12 qubit amplitude encoding circuit. This circuit trains extremely slow even with the use of GPU's. Optimizations need to be discovered in order to make progress with this area. With that being said, for small sample sizes we achieve good results (+90%).

* The 6 feature data encoded with the same Pauli methods attain very poor results as shown below.

There exists a few solutions to the 36x112 feature problem number:

* We can interpolate the data to smaller amplitude encoded circuits such as 8 qubits. Doing so achieves respectable results (+80% accuracy) for smaller datasets (under 1000 samples). For larger datasets training time is drastically increased and progress towards a minimum is slowed and we are back to the first problem again.

* We find ways of optimizing the circuits for training. Qiskit allegedly has several "fast" sampling methods. Learning the modules and applying a few test runs should determine if the full 12 qubits can be encoded correctly.

I propose a series of problems to solve where, if solved, any one of them will be both distinguishable and possess utility:

* We can optimize training the Qiskit circuits. There are other ways to produce the required results.
** Seen here[https://qiskit.org/documentation/tutorials/simulators/7_matrix_product_state_method.html] a 50 qubit EPR state is sampled in 0.1 seconds. There are fast sampling methods built in. If these can be sent to the optimizer as a Quantum_Instance (in the same way we use the GPU) then I can simulate a wide variety of large circuits very quickly. This will allow for a more "pure" QCNN than those seen in other papers as well as having the utility of being run on real hardware (in the near future maybe!).

* The dissertation written by Jonas Landman from University of Paris proposes intersting QNN architectures such as the NISQ algorithm for Orthogonal Neural Networks. This uses a connected series of quantum VQC's which replicate a classical neural network. Using this architecture could very well provide real results on the 6 feature data (or interpolated 36x112 feature).

* Much like a combination of Jonas Landman and the Brookhaven paper, I could construct my own series of Quantum circuits which act as a distributed Neural network. A layer of circuits produce an output which are then fed into the next layer of circuits. In this case, the circuits act as both the Nodes and carry the weights in a classical sense. This gives far more parameters to work with using "less" qubits per circuit. This means, with a sufficient distribution, every datapoint will be encoded into it's own qubit even for the 36x112 feature data. +4,000 qubits won't be an issue if they're broken up into sufficiently small circuits with distributed calculations.

== March 27, 2023 ==

From last week, two major problems are solved:

1. The 6 feature data will not produce reasonable results (possibly due to the loss of locality?). However, the 4032 feature data can be resized using:

cv2.resize(samples, dsize=(n, len(samples)), interpolation=cv2.INTER_AREA)

See [https://medium.com/@wenrudong/what-is-opencvs-inter-area-actually-doing-282a626a09b3] for INTER_AREA

This allows for resizing of the image to fit some n number of pixels without loosing any of the data points to full degredation (all 0 pixel values). This resizing will allow for the training of networks using pauli feature mapping (because cv2.INTER_AREA preserves some of the locality?). This, in turn, not only greatly decreasing training times and quickens convergence, but also increases the accuracy of result.

2. The GPU implementation only requires a few lines of code to be optimized:

try:
simulator_gpu = Aer.get_backend('aer_simulator')
simulator_gpu.set_options(device='GPU', precision='single')
except AerError as e:
print('GPU Err:\n',e)

Take note that for certain feature mapping and ansatz implementations the GPU may be slower than a CPU if an insufficient number of qubits is used.

Using the following we are able to produce a very rudimentary VQC with two parts; a feature mapping and ansatz. Using everything we learned we can achieve an accuracy of +98% for previously unseen testing data in 30 iterations, training time under 2 minutes, 0.01% of the data used for training. This is done with n number of qubits/features to be 6 or 8.

So far, there is no need for a complex distributed network, hybridization, or complex QCNN classification models. The following goal is to either discover or create a more "complete" ansatz which can cover as much of the hilbert space as possible. Doing so should bump us up to +99% with a mere few minutes of training time

== March 31, 2023 ==

Heavily influenced by REfs. [1, 2, 3] as well as Jonas Landman, we can create a distributed Quantum Neural Network for particle classification. The image below, from Ref. [1], can be thought of a two layer QNN.

[[File:Scalable_qnn.png|600px]]

=== Encoding ===
The first layer is encoded directly using the data sample. That encoding will be done with either the Qiskit Pauli feature mappings or the ones used in Ref. [3] (arctan mapping). In the subsequent layers, the inputs will be the Pauli Z expectation from the previous layers individual circuit. Example, Feature extractor 1 from the image above will yield some value [-1, 1]. That value will be input into the first qubit of the "Predictor" in the second layer. Likewise, the value yielded from feature extractor 4 will be input into the last qubit of the predictor. So we know that our predictor will be 4 qubits wide. The expectation value calculations come directly from Ref. [2] and are easily implemented in qiskit.

=== VQC's ===
Every VQC in each layer, U(θ), will be an independent ansatz with parameters p[0], p[1]... p[n]. Note, a back propagation algorithm could be relatively simple to implement since each layer of the network can be represented by a parameterized weight matrix. For layer 1 in the image we have:

p_1[0] p_1[1]... p_1[n]

p_2[0] p_2[1]... p_2[n]

p_3[0] p_3[1]... p_3[n]

p_4[0] p_4[1]... p_4[n]

And for the predictor layer we will have only one row of parameters since there is only one circuit:

p_pre[0] p_pre[1]... p_pre[n]

Note the reduction in dimensionality between the two layers. Also note that this is NOT a fully connected QCNN. Moving to that model should not be too difficult depending on the results gained from this experiment. This could be implemented by the techniques described in Landman's dissertation.

=== Classical Device ===

Upon measurement of the predictor we have our classification again as a value of [-1, 1]. From here, we implement a loss function and back propagation algorithm on our parameter matrices.

== April 9, 2023 ==

[[File:FCQNN_diagram.png|1500px]]

A Fully Connected Quantum Neural Network can be seen above. The closes approximation to this that I can find in the current literature is found here [https://link.springer.com/article/10.1007/s42484-021-00046-w]. They use amplitude encoded circuits for the MNIST dataset where the ansatz used look like circularly entangled pauli two design gates. The main mechanics of a forward pass are shown in the diagram. The encoding portions of the circuits, F(X), act as the analogous neurons while the VQC's, U(θ), act as the weight matrices. It can be thought of more as a connected series of smaller classical Neural networks.

Things to consider/progress to be made:

1. As far as quantum classifiers for nuclear physics goes I have not found this network architecture applied yet.
2. Outside of a few "toy" example datasets (MNIST) and those used for dissipative quantum neural networks, these networks seem to be rare.
3. Nobody has utilized this architecture in a distributive manner.
4. I will continue using qiskit for now but I must consider c++ or cuda based applications for a quicker expectation measurements.
5. I am dedicating approximately 30 minutes to 1 hour of literature review every day to ensure that 1-3 are true.

If this works out then my goals stated here[https://crtc.cs.odu.edu/Internal:Quantum_Machine_Learning#March_21.2C_2023] will be achieved.

1. Creating a scalable quantum classification network for high energy particle physics which has not been seen before.
2. The network has real utility in the future.

= Code : =

Download the notebooks here[https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2FQML%20Course%2Fqml%5Fnotebooks&view=0]

= Literature : Quantum Classifiers =
== [1] Scalable Quantum Neural Networks for Classification ==
Jindi Wu, Zeyi Tao, Qun Li
https://arxiv.org/abs/2208.07719

Relies on a hybrid classical-quantum architecture. Each subdomain has the following:

1. Encoding Unit
* Authors utilize angle encoding (N qubits for N features) because it can support gradient calculations
* Amplitude encoding not used due to error rate and difficulty in computing gradients

2. VQC
* They follow the VQC introduced in https://www.tensorflow.org/quantum/tutorials/mnist#21_build_the_model_circuit

3. Measurement
* Calculation of the expectation value, seemingly Pauli-Z operator giving [-1, 1]

4. The measurement of the sub domain is then encoded into a qubit in the next layer.

Seemingly, this process combines both convolutional and pooling layers in the same way that Iris Cong et al. performs calculations. Advantageous over the qiskit implementation in that the "pooling layers" are not parameterized since the pooling is the measurement itself. Additionally, we can run circuits in parallel.

== [2] Quantum convolutional neural networks ==
Iris Cong et al., Nature Physics
https://doi.org/10.1038/s41567-019-0648-8

N qubit input requires O(log(N)) variational parameters. "This corresponds to a double exponential reduction compared with a generic quantum circuit-based classifier..." hopefully leading to faster training times?

== [3] Quantum convolutional neural networks for high energy physics data analysis ==
Chen et al., Brookhaven National Labs
https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.013231

The (SIMULATED) QCNN follows the following protocol:

1. Feature mapped (Amplitude encoded?) particle images of size 30x30 are implemented in the encoding layer.

2. A VQC acts as a convolutional layer. Convolutional outputs are calculated via the expectation value of the Pauli-Z operator acting on the first qubit.

3. Pooling is done classically with nonlinear activation functions in between convolutional layers (look deeper into this).

4. Categorical Cross Entropy Loss Function is applied to the final output.

5. Back Prop to adjust the parameters in the VQC's (convolutional layers).

We can implement this "by hand" in qiskit using their approximate expectation function on a Wahab GPU node using simulator.set_options(device='GPU'). This is considerable because it may be a faster process (also for larger circuits) than available public access QML methods.

== [4] Quantum machine learning for particle physics using a variational quantum classifier ==
Andrew Blancea and Michael Spannowsky
https://link.springer.com/article/10.1007/JHEP02(2021)212

This method follows the same methodology as many others.

1. Angle Encoding the data
2. Generic VQC using universal single qubit gates and CNOTs producing layers of two entangled qubits
3. Measurement is performed by experimental repetitions to determine the expectation value of the Pauli-Z operator, not calculated deterministically

Rudimentary introduction to QNN classification.

== [5] Challenges and opportunities in quantum machine learning for high-energy physics ==
Sau Lan Wu and Shinjae Yoo2
https://www.nature.com/articles/s42254-022-00425-7

"Overall, the greatest challenge in using quantum computer hardware for machine learning at present... is the size of the event samples and the effective use of large num- bers of qubits... analyses will need to manage large event sample size and large data dimensionality...

... advanced quantum computers with large numbers of qubits, reduced noise and improved running time may outperform classical machine learn- ing in both classification power and in speed. QML may well be a new computational paradigm for big data analyses in HEP. For this reason, the HEP community should stay aware of what is happening in quantum technologies — improvements in the hardware, software ecosystem and algorithms — to bring a quantum advan- tage to the HEP data challenge. Conversely, the develop- ment of solutions for unique HEP data challenges could also lead to contributions to the development of quantum technologies."

== [6] Quantum machine learning in high energy physics ==
Guan et al.
https://iopscience.iop.org/article/10.1088/2632-2153/abc17d/pdf

Uses adiabatic quantum annealing as an optimizer. This methodology also uses angle encoding for particle track data, a general VQC, with different optimizers such as ADAM and COBYLA.

== [7] Hybrid Quantum-Classical Neural Network for Calculating Ground State Energies of Molecules ==
Xia, R.; Kais, S. Hybrid Quantum-Classical Neural Network for Calculating Ground State Energies of Molecules. Entropy 2020, 22, 828. https://arxiv.org/pdf/1912.06184.pdf

Although the problem set is not what we are looking for (to find a hamiltonian for potential energy curves) the architecture of this type of QNN can be used to create a fully connected QNN. We cans say that for the image in Ref. [1], each qubit from each circuit in the first layer is measured (the expectation value calculated) independently, we now have a value to pass to the next layer of circuits. I.E. if we have a two qubit circuit, that circuit will yield two expectation values meaning we can pass two different values to two different circuit in the next layer. The first circuit layer has some x number of qubits per circuit, we will have x number of circuits in the next layer.

Internal:Quantum Machine Learning

2023-04-09T17:06:10Z

Ebillias: /* Progress */

File:FCQNN diagram.png

2023-04-09T16:57:46Z

Ebillias:

Internal:Quantum Edge Detection

2023-04-07T15:10:19Z

Ebillias:

= Quantum Hadamard Edge Detection (QHED) =

A recent quantum edge detection algorithm called Quantum Hadamard Edge Detection[2] (QHED) provides a promising means of quantum image processing and experimentation. This is done by providing full boundary gradient across a 1D mapping of a 2D image. Due to fidelity issues on NISQ era hardware, we are required to divide our images into sub images (domain decomposition) for proper edge detection[1]. When doing this, we find a boundary error issue with the algorithm. In addition, we utilize a series of optimization techniques found in Ref. [6] to overcome the resultant hardware noise. The hardware limitations and the few issues with the QHED algorithm itself are reduced in order to produce simulated NISQ hardware results on large images.

The overall goal of this project is to produce high quality results via the QHED circuit on large medical images via REAL NISQ era hardware. Classically, we can use space filling curves or pixel buffers to improve results upon the decomposed image. As far as real hardware is concerned, areas of interest to achieve quality results are by implementing major improvements upon the decrement gate which seems to be the failure point. We can tackle this by a combination of efficient mathematics[7], NISQ error mitigation techniques[6], and VQC techniques. The combination of all of these applied to the three major sections of the circuit (ignoring the measurement phase) could very well result in accurate edge detection results on real quantum hardware. Without access to larger number of qubits (>7 qubits) we need to use the topology taken from noisy simulated hardware. The principles of CX error, single gate error, fidelity, and coherence normally found in real hardware are applicable to noisy simulations. Thus, this remains as a quality means of data analysis prior to execution on real hardware.

== Code ==
Download the Decrement and image encoding notebooks here [https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fquantum%5Fedge%5Fdetection%2Fnotebooks&view=0]

== Paper ==
Find the current version of paper here[https://www.overleaf.com/project/63924b684bfa06b39df1bdfc]

== QHED Circuit ==

[[File:Qhed circuit.png|500px|thumb|none|Figure 1 Generalized qHED Circuit with input vector f and output vector g.]]

=== State Prep ===
[[File:Rcmo.png|500px|thumb|none|Figure 2 Row (left) and Column (right) major ordered mapping.]]

The image is first mapped as a 2D array to a 1D vector. Ref. [2] uses methodology known as row and column major ordering (RCMO). Each pixel is then normalized such that the sum of their squares is equal to 1, a necessary quality of quantum states. Using a module presented by Ref. [3] (or through Qiskit's StatePreparation), we can calculate a quantum circuit which achieves what is known as amplitude encoding. The normalized pixel values of the input vector will be returned as the probability amplitudes of computational basis states. Those computational basis states act as the indexing of the original vector. I.e. if we had a length 64 vector, the 7th element is represented as c_7|000111>. The resultant normalized image state can be written as:

[[File:Img state.png|200px]]

The Hadamard gate in the state prep acts on the Least Significant Bit (LSB) initialized to state |0> which outputs the |+> state. Application of the H-Gate on the LSB has the following tensor product on the input image state:

[[File:State prep.png|400px]]

=== Decrement ===

The decrement portion of the quantum algorithm can be represented by the matrix unitary:

[[File:Decrement unitary.png|400px]]

With application of that unitary gate to the state prepared vector yields the decrement state:

[[File:Decrement state.png|500px]]

To the best of our abilities, we find that references to the QHED method provide very little (if any) detail as to the architecture of the decrement gate. Refs. [4] and presumably [5] use a qiskit unitary class function to convert a numpy matrix into a circuit. Although quite useful for simulations, this type of construction fails on real hardware. We can find a far more reasonable design of the gate in Ref. [7] which is shown below.

[[File:decrement_gate.png|500px|thumb|none|Multi controlled NOT gates perform the decrement operation. q_0 being the least significant qubit.]]

Although it is known that multi qubit gates are highly error prone, we achieve reasonable results when we compare the two methodologies. We begin with a 4 qubit circuit initialized to the state |0000> = (1...0) which is to be decremented to state |1111> = (0...1). Shown below are the results of the more careful multi controlled qubit construction and the unitary class function executed on the real quantum device, ibmq_lima. Based on the results, we know that we must design our own decrement gates and cannot rely on any arbitrary unitary transformation algorithim.

[[File:Lima tl 3.png|500px|thumb|none| Although the results are far from perfect, we can clearly see the state 1111> has been formed from the state 0000>.]]

[[File:Lima np.png|500px|thumb|none| The results of our gate are lost in the noise of the output using the unitary class function.]]

We can improve upon the Decrement gate by using 2n total qubits by altering the increment gates in Ref. [8]. More simply, using open controls (bit flip in the case of the qubit being in the state |0>) alters the increment permutation to a decrement.

[[File:Decrement op.png|500px]]

Looking at the CX counts and fidelity estimates for QHED circuits show promising results. The upcoming section "Methods of Optimization" will describe the optimizations themselves as they are labeled in the charts below.

[[File:Qhed cx.png|500px]]
[[File:Qhed fidelity.png|500px]]

=== Permutation ===
This is the portion of the circuit where the actual edge detection occurs. It can be thought of as a series of identity gates tensored together with an H-Gate in the LSB tensored last. The resultant unitary matrix can be written as:

[[File:Permutation unitary.png|500px]]

With application of the resultant decrement vector as:

[[File:Permutation state.png|500px]]

This is the final output state. Note that if the LSB is in the state |1> we retrieve all of the odd indexed states i.e. |...001> (1), |...011> (3), |...111> (5), ect. These states provide the boundary gradient across the 1D input image. An overview of the QHED algorithm can be visualized as having the following effect on the input of an image state:

[[File:QHED output.png|300px]]

== Methods of Optimization ==

The improved decrement gate was already discussed in the previous section so we will leave it there.

We then utilize Qiskit's transpiler. The optimal SWAP mapping is an NP-Hard problem which yields ambiguous results. "The choice of initial layout can mean the difference between getting a result, and getting nothing but noise." To compute the best low noise layout, we use an open source module called mapomatic. Mapomatic finds the best low noise sub-graph for some given hardware backend(s). The end result is that the module returns the best set of qubits and their appropriate ordering to execute your circuit with minimal noise. This qubit layout is sent to the transpiler. A heuristic fidelity estimate is taken from Ref. [6].

We now turn to a means of error reduction in the measurement output of the circuit. Researchers are able to perform a variety of experiments to measure a qubit's state preparation and measurement (SPAM) errors forming a relationship of noisy probabilities to ideal probabilities in the form of a matrix transformation. The correction matrix can be measured by using a variety of circuits with known outcomes and finding the noisy outcome of every possible bit-string for a particular piece of hardware. From this, it is possible to reconstruct our desired output.

There are obvious scaling issues when it comes to building 2^n x 2^n matricies. There are alternatives to this which do not require such scaling or computational overhead. We make use of such a module called mthree. An excellent demonstration of this can be found in the Qiskit Textbook.

In the case of large images, we must perform domain decomposition to preserve fidelity and reduce noise. However, we find that when applying the suggested RMO and CMO indexed 2D to 1D mapping on decomposed sub images there is a non negligible quality reduction to the output edge detected image. This is due to the fact that this use of mapping does not preserve locality. It can be seen from Fig. [2] how these methods of indexing will provide errors across the boundaries of the image/sub images. Consider the output state |g>. It can be seen how non adjacent pixels of the original image will be compared with each other e.g. c_{3} - c_{4} in the Fig. [2] RMO mapping or c_{12} - c_{1} in the CMO mapping. This may lead to detected edges where there are none. To avoid these discrepancies we apply buffer cells to our decomposed images. We choose to do a row by row decomposition for the horizontal scan as shown below. This leaves 2 redundant pixels per sub image, no matter the decomposition size.

[[File:Boundary buffer.png|500px|thumb|none|Buffer pixels of value 0 are applied to the boundary of the overall image.]]

[[File:Buffer cells.png|500px|thumb|none|Further decomposition is then possible by adding neighboring pixels to be used as a buffer due to QHED error. The red cells are ultimately disposed in the final output.]]

With the decrement gate optimization, the more NISQ-era friendly QHED circuit takes the form shown below.

[[File:Qhed op.png|500px|thumb|none|QHED circuit with expanded, noise mitigated, decrement gate]]

== Domain Decomposition ==

Consider a 1024x1024 medical image. This comes out to 1,048,576 pixels requiring 20 (2^20) qubits plus 1 ancillary qubit for the QHED algorithm. Additionally, the amplitude encoding process expands exponentially with regards to qubit number. We can divide the image into separate sub images and solve either iteratively or in parallel (multithreading). Each sub image is now considered to be a sub input of the overall problem.

[[File:NaF-PROSTATE-01-0001_22.png|500px|thumb|none|Example of 1024x1024 Medical image decomposed into 256x256 sub images.]]

Errors begin to occur with the 2D to 1D mapping of subdomains. Consider the row major ordering in figure 1. Elements c_3 and c_4 will provide gradient detection for the output pixel at location 3. This is because the RCMO mappings do not preserve locality at the boarders of multi dimensional arrays. In a full image pass of the algorithm this would hardly be noticeable and leave little error on the output image. It becomes readily apparent in decomposed domains, however:

[[File:Rcmo example.png|1000px|thumb|none|RCMO 2D to 1D mapping applied prior to the output of QHED (simulated) shown above. RCMO mapping does not preserve locality and thus non neighboring pixels are calculated to have edges between them where no such edges exist.]]

=== Space Filling Curves ===

One way to solve this issue without the addition of extra qubits is to use space filling curves as a means of 2D to 1D mapping. Space filling curves preserve locality in that the final output of the algorithm will provide boundary detection across exclusively neighboring pixels (with the exception of one pixel per domain in certain cases).

[[File:QHED space filling curves.png|1200px|thumb|none|Example of 1024x1024 Medical image decomposed into 64x64 sub images. In the domain decomposed images (bottom row) a different space filling curve is used for mapping. A laplacian (far left column) edge detection stenciling is used as a classical analog for comparisons.]]

=== QHED in 3 Dimensions ===

We can apply the same principles to 3D. The main difference is that instead of performing a vertical and horizontal detection we need to add in a third in order to achieve a full boundary about each pixel. We consider a "scan" about the x, y, and z planes.

[[File:3d model.png|1200px|thumb|none|Example of 3D Medical image to be edge detected.]]
[[File:3d model rcmo.png|1200px|thumb|none|3D Medical image passed through the QHED algorithm (simulated) 3 times (x,y,z plane). The entire image was passed through each plane.]]
[[File:3d model rcmo dd.png|1200px|thumb|none|3D Medical image with decomposed domains. Each sub domain (3D block) passed through the QHED algorithm (simulated) 3 times (x,y,z plane). Each block was mapped using RCMO, edge detected, and pieced back together.]]

== References ==
[1] Acampora, Giovanni, et al. “D-NISQ: A Reference Model for Distributed Noisy Intermediate-Scale Quantum Computers.” Information Fusion, vol. 89, 2023, pp. 16–28., https://doi.org/10.1016/j.inffus.2022.08.003.

[2] .-W. Yao, H. Wang, Z. Liao, M.-C. Chen, J. Pan, J. Li, K. Zhang, X. Lin, Z. Wang, Z. Luo,
et al., Quantum image processing and its application to edge detection: Theory and experiment,
Physical Review X 7 (3) (2017). doi:10.1103/physrevx.7.031041.

[3]I. F. Araujo, D. K. Park, F. Petruccione, A. J. da Silva, A divide-and-conquer algo-
rithm for quantum state preparation, Scientific Reports 11 (1) (2021). doi:10.1038/
s41598-021-85474-1.

[4] Team, T. Q. (2022, July 6). Quantum Edge Detection - qhed algorithm on small and large images. Quantum Edge Detection - QHED Algorithm on Small and Large Images. Retrieved October 28, 2022, from https://qiskit.org/textbook/ch-applications/quantum-edge-detection.html

[5] Anand, A., Lyu, M., Baweja, P. S., & Patil, V. (2022). Quantum Image Processing. https://doi.org/https://arxiv.org/pdf/2203.01831.pdf

[6] Ferris, K. J., Ramusson, A. J., Bronn, N. T., & Lanes, O. (2022). Quantum Simulation on Noisy Superconducting Quantum Computers. https://doi.org/https://doi.org/10.48550/arXiv.2209.02795

[7] LI, X. I. A. O. Y. U., YANG, G. U. O. W. U., TORRES, C. A. R. L. O. S. M. A. N. U. E. L., ZHENG, D. E. S. H. E. N. G., & WANG, K. A. N. G. L. (2013). A class of efficient quantum incrementer gates for quantum circuit synthesis. International Journal of Modern Physics B, 28(01), 1350191. https://doi.org/10.1142/s0217979213501919

[8] . Gidney, Constructing large increment gates. URL https://algassert.com/circuits/2015/06/12/Constructing-Large-Increment-Gates.html

Internal:Quantum Edge Detection

2023-04-07T15:08:38Z

Ebillias:

= Quantum Hadamard Edge Detection (QHED) =

A recent quantum edge detection algorithm called Quantum Hadamard Edge Detection[2] (QHED) provides a promising means of quantum image processing and experimentation. This is done by providing full boundary gradient across a 1D mapping of a 2D image. Due to fidelity issues on NISQ era hardware, we are required to divide our images into sub images (domain decomposition) for proper edge detection[1]. When doing this, we find a boundary error issue with the algorithm. In addition, we utilize a series of optimization techniques found in Ref. [6] to overcome the resultant hardware noise. The hardware limitations and the few issues with the QHED algorithm itself are reduced in order to produce simulated NISQ hardware results on large images.

The overall goal of this project is to produce high quality results via the QHED circuit on large medical images via REAL NISQ era hardware. Classically, we can use space filling curves or pixel buffers to improve results upon the decomposed image. As far as real hardware is concerned, areas of interest to achieve quality results are by implementing major improvements upon the decrement gate which seems to be the failure point. We can tackle this by a combination of efficient mathematics[7], NISQ error mitigation techniques[6], and VQC techniques. The combination of all of these applied to the three major sections of the circuit (ignoring the measurement phase) could very well result in accurate edge detection results on real quantum hardware. Without access to larger number of qubits (>7 qubits) we need to use the topology taken from noisy simulated hardware. The principles of CX error, single gate error, fidelity, and coherence normally found in real hardware are applicable to noisy simulations. Thus, this remains as a quality means of data analysis prior to execution on real hardware.

== Code ==
Download the Decrement and image encoding notebooks here [https://olddominion-my.sharepoint.com/personal/nchrisoc_odu_edu/_layouts/15/onedrive.aspx?ga=1&id=%2Fpersonal%2Fnchrisoc%5Fodu%5Fedu%2FDocuments%2FSpring%5F23%2Fquantum%5Fedge%5Fdetection%2Fnotebooks&view=0]

== QHED Circuit ==

[[File:Qhed circuit.png|500px|thumb|none|Figure 1 Generalized qHED Circuit with input vector f and output vector g.]]

=== State Prep ===
[[File:Rcmo.png|500px|thumb|none|Figure 2 Row (left) and Column (right) major ordered mapping.]]

The image is first mapped as a 2D array to a 1D vector. Ref. [2] uses methodology known as row and column major ordering (RCMO). Each pixel is then normalized such that the sum of their squares is equal to 1, a necessary quality of quantum states. Using a module presented by Ref. [3] (or through Qiskit's StatePreparation), we can calculate a quantum circuit which achieves what is known as amplitude encoding. The normalized pixel values of the input vector will be returned as the probability amplitudes of computational basis states. Those computational basis states act as the indexing of the original vector. I.e. if we had a length 64 vector, the 7th element is represented as c_7|000111>. The resultant normalized image state can be written as:

[[File:Img state.png|200px]]

The Hadamard gate in the state prep acts on the Least Significant Bit (LSB) initialized to state |0> which outputs the |+> state. Application of the H-Gate on the LSB has the following tensor product on the input image state:

[[File:State prep.png|400px]]

=== Decrement ===

The decrement portion of the quantum algorithm can be represented by the matrix unitary:

[[File:Decrement unitary.png|400px]]

With application of that unitary gate to the state prepared vector yields the decrement state:

[[File:Decrement state.png|500px]]

To the best of our abilities, we find that references to the QHED method provide very little (if any) detail as to the architecture of the decrement gate. Refs. [4] and presumably [5] use a qiskit unitary class function to convert a numpy matrix into a circuit. Although quite useful for simulations, this type of construction fails on real hardware. We can find a far more reasonable design of the gate in Ref. [7] which is shown below.

[[File:decrement_gate.png|500px|thumb|none|Multi controlled NOT gates perform the decrement operation. q_0 being the least significant qubit.]]

Although it is known that multi qubit gates are highly error prone, we achieve reasonable results when we compare the two methodologies. We begin with a 4 qubit circuit initialized to the state |0000> = (1...0) which is to be decremented to state |1111> = (0...1). Shown below are the results of the more careful multi controlled qubit construction and the unitary class function executed on the real quantum device, ibmq_lima. Based on the results, we know that we must design our own decrement gates and cannot rely on any arbitrary unitary transformation algorithim.

[[File:Lima tl 3.png|500px|thumb|none| Although the results are far from perfect, we can clearly see the state 1111> has been formed from the state 0000>.]]

[[File:Lima np.png|500px|thumb|none| The results of our gate are lost in the noise of the output using the unitary class function.]]

We can improve upon the Decrement gate by using 2n total qubits by altering the increment gates in Ref. [8]. More simply, using open controls (bit flip in the case of the qubit being in the state |0>) alters the increment permutation to a decrement.

[[File:Decrement op.png|500px]]

Looking at the CX counts and fidelity estimates for QHED circuits show promising results. The upcoming section "Methods of Optimization" will describe the optimizations themselves as they are labeled in the charts below.

[[File:Qhed cx.png|500px]]
[[File:Qhed fidelity.png|500px]]

=== Permutation ===
This is the portion of the circuit where the actual edge detection occurs. It can be thought of as a series of identity gates tensored together with an H-Gate in the LSB tensored last. The resultant unitary matrix can be written as:

[[File:Permutation unitary.png|500px]]

With application of the resultant decrement vector as:

[[File:Permutation state.png|500px]]

This is the final output state. Note that if the LSB is in the state |1> we retrieve all of the odd indexed states i.e. |...001> (1), |...011> (3), |...111> (5), ect. These states provide the boundary gradient across the 1D input image. An overview of the QHED algorithm can be visualized as having the following effect on the input of an image state:

[[File:QHED output.png|300px]]

== Methods of Optimization ==

The improved decrement gate was already discussed in the previous section so we will leave it there.

We then utilize Qiskit's transpiler. The optimal SWAP mapping is an NP-Hard problem which yields ambiguous results. "The choice of initial layout can mean the difference between getting a result, and getting nothing but noise." To compute the best low noise layout, we use an open source module called mapomatic. Mapomatic finds the best low noise sub-graph for some given hardware backend(s). The end result is that the module returns the best set of qubits and their appropriate ordering to execute your circuit with minimal noise. This qubit layout is sent to the transpiler. A heuristic fidelity estimate is taken from Ref. [6].

We now turn to a means of error reduction in the measurement output of the circuit. Researchers are able to perform a variety of experiments to measure a qubit's state preparation and measurement (SPAM) errors forming a relationship of noisy probabilities to ideal probabilities in the form of a matrix transformation. The correction matrix can be measured by using a variety of circuits with known outcomes and finding the noisy outcome of every possible bit-string for a particular piece of hardware. From this, it is possible to reconstruct our desired output.

There are obvious scaling issues when it comes to building 2^n x 2^n matricies. There are alternatives to this which do not require such scaling or computational overhead. We make use of such a module called mthree. An excellent demonstration of this can be found in the Qiskit Textbook.

In the case of large images, we must perform domain decomposition to preserve fidelity and reduce noise. However, we find that when applying the suggested RMO and CMO indexed 2D to 1D mapping on decomposed sub images there is a non negligible quality reduction to the output edge detected image. This is due to the fact that this use of mapping does not preserve locality. It can be seen from Fig. [2] how these methods of indexing will provide errors across the boundaries of the image/sub images. Consider the output state |g>. It can be seen how non adjacent pixels of the original image will be compared with each other e.g. c_{3} - c_{4} in the Fig. [2] RMO mapping or c_{12} - c_{1} in the CMO mapping. This may lead to detected edges where there are none. To avoid these discrepancies we apply buffer cells to our decomposed images. We choose to do a row by row decomposition for the horizontal scan as shown below. This leaves 2 redundant pixels per sub image, no matter the decomposition size.

[[File:Boundary buffer.png|500px|thumb|none|Buffer pixels of value 0 are applied to the boundary of the overall image.]]

[[File:Buffer cells.png|500px|thumb|none|Further decomposition is then possible by adding neighboring pixels to be used as a buffer due to QHED error. The red cells are ultimately disposed in the final output.]]

With the decrement gate optimization, the more NISQ-era friendly QHED circuit takes the form shown below.

[[File:Qhed op.png|500px|thumb|none|QHED circuit with expanded, noise mitigated, decrement gate]]

== Domain Decomposition ==

Consider a 1024x1024 medical image. This comes out to 1,048,576 pixels requiring 20 (2^20) qubits plus 1 ancillary qubit for the QHED algorithm. Additionally, the amplitude encoding process expands exponentially with regards to qubit number. We can divide the image into separate sub images and solve either iteratively or in parallel (multithreading). Each sub image is now considered to be a sub input of the overall problem.

[[File:NaF-PROSTATE-01-0001_22.png|500px|thumb|none|Example of 1024x1024 Medical image decomposed into 256x256 sub images.]]

Errors begin to occur with the 2D to 1D mapping of subdomains. Consider the row major ordering in figure 1. Elements c_3 and c_4 will provide gradient detection for the output pixel at location 3. This is because the RCMO mappings do not preserve locality at the boarders of multi dimensional arrays. In a full image pass of the algorithm this would hardly be noticeable and leave little error on the output image. It becomes readily apparent in decomposed domains, however:

[[File:Rcmo example.png|1000px|thumb|none|RCMO 2D to 1D mapping applied prior to the output of QHED (simulated) shown above. RCMO mapping does not preserve locality and thus non neighboring pixels are calculated to have edges between them where no such edges exist.]]

=== Space Filling Curves ===

One way to solve this issue without the addition of extra qubits is to use space filling curves as a means of 2D to 1D mapping. Space filling curves preserve locality in that the final output of the algorithm will provide boundary detection across exclusively neighboring pixels (with the exception of one pixel per domain in certain cases).

[[File:QHED space filling curves.png|1200px|thumb|none|Example of 1024x1024 Medical image decomposed into 64x64 sub images. In the domain decomposed images (bottom row) a different space filling curve is used for mapping. A laplacian (far left column) edge detection stenciling is used as a classical analog for comparisons.]]

=== QHED in 3 Dimensions ===

We can apply the same principles to 3D. The main difference is that instead of performing a vertical and horizontal detection we need to add in a third in order to achieve a full boundary about each pixel. We consider a "scan" about the x, y, and z planes.

[[File:3d model.png|1200px|thumb|none|Example of 3D Medical image to be edge detected.]]
[[File:3d model rcmo.png|1200px|thumb|none|3D Medical image passed through the QHED algorithm (simulated) 3 times (x,y,z plane). The entire image was passed through each plane.]]
[[File:3d model rcmo dd.png|1200px|thumb|none|3D Medical image with decomposed domains. Each sub domain (3D block) passed through the QHED algorithm (simulated) 3 times (x,y,z plane). Each block was mapped using RCMO, edge detected, and pieced back together.]]

== References ==
[1] Acampora, Giovanni, et al. “D-NISQ: A Reference Model for Distributed Noisy Intermediate-Scale Quantum Computers.” Information Fusion, vol. 89, 2023, pp. 16–28., https://doi.org/10.1016/j.inffus.2022.08.003.

[2] .-W. Yao, H. Wang, Z. Liao, M.-C. Chen, J. Pan, J. Li, K. Zhang, X. Lin, Z. Wang, Z. Luo,
et al., Quantum image processing and its application to edge detection: Theory and experiment,
Physical Review X 7 (3) (2017). doi:10.1103/physrevx.7.031041.

[3]I. F. Araujo, D. K. Park, F. Petruccione, A. J. da Silva, A divide-and-conquer algo-
rithm for quantum state preparation, Scientific Reports 11 (1) (2021). doi:10.1038/
s41598-021-85474-1.

[4] Team, T. Q. (2022, July 6). Quantum Edge Detection - qhed algorithm on small and large images. Quantum Edge Detection - QHED Algorithm on Small and Large Images. Retrieved October 28, 2022, from https://qiskit.org/textbook/ch-applications/quantum-edge-detection.html

[5] Anand, A., Lyu, M., Baweja, P. S., & Patil, V. (2022). Quantum Image Processing. https://doi.org/https://arxiv.org/pdf/2203.01831.pdf

[6] Ferris, K. J., Ramusson, A. J., Bronn, N. T., & Lanes, O. (2022). Quantum Simulation on Noisy Superconducting Quantum Computers. https://doi.org/https://doi.org/10.48550/arXiv.2209.02795

[7] LI, X. I. A. O. Y. U., YANG, G. U. O. W. U., TORRES, C. A. R. L. O. S. M. A. N. U. E. L., ZHENG, D. E. S. H. E. N. G., & WANG, K. A. N. G. L. (2013). A class of efficient quantum incrementer gates for quantum circuit synthesis. International Journal of Modern Physics B, 28(01), 1350191. https://doi.org/10.1142/s0217979213501919

[8] . Gidney, Constructing large increment gates. URL https://algassert.com/circuits/2015/06/12/Constructing-Large-Increment-Gates.html

Internal:Quantum Machine Learning

2023-04-07T15:03:52Z

Ebillias: /* Code : */

Internal:Quantum Machine Learning

2023-04-04T23:22:39Z

Ebillias: /* [7] Hybrid Quantum-Classical Neural Network for Calculating Ground State Energies of Molecules */

Internal:Quantum Machine Learning

2023-04-04T23:21:56Z

Ebillias: /* [6] Hybrid Quantum-Classical Neural Network for Calculating Ground State Energies of Molecules */

Internal:Quantum Machine Learning

2023-04-04T22:50:51Z

Ebillias: /* Quantum Classifiers */

Internal:Quantum Machine Learning

2023-03-31T19:53:16Z

Ebillias: /* Progress */

File:Scalable qnn.png

2023-03-31T19:26:01Z

Ebillias:

Internal:Quantum Machine Learning

2023-03-31T19:21:41Z

Ebillias: /* Quantum Classifiers */

Internal:Quantum Machine Learning

2023-03-29T20:53:10Z

Ebillias: /* March 27, 2023 */

Internal:Quantum Machine Learning

2023-03-27T19:58:46Z

Ebillias: /* Quantum Classifiers */

Internal:Quantum Machine Learning

2023-03-27T19:58:05Z

Ebillias: