Merge pull request #313 from sQUlearn/develop

Release 0.8.1

Author: MoritzWillmann

README.md

@@ -4,10 +4,10 @@
 
 sQUlearn is a user-friendly, NISQ-ready Python library for quantum machine learning (QML), designed for seamless integration with classical machine learning tools like scikit-learn. The library's dual-layer architecture serves both QML researchers and practitioners, enabling efficient prototyping, experimentation, and pipelining. sQUlearn provides a comprehensive tool set that includes both quantum kernel methods and quantum neural networks, along with features like customizable data encoding strategies, automated execution handling, and specialized kernel regularization techniques. By focusing on NISQ-compatibility and end-to-end automation, sQUlearn aims to bridge the gap between current quantum computing capabilities and practical machine learning applications.
 
-sQUlearn offers scikit-learn compatible high-level interfaces for various kernel methods and QNNs. They build on top of the low-level interfaces of the QNN engine and the quantum kernel engine. The executor is used to run experiments on simulated and real backends of the Qiskit or PennyLane frameworks.
+sQUlearn offers scikit-learn compatible high-level interfaces for various kernel methods, QNNs and quantum reservoir computing. They build on top of the low-level interfaces of the QNN engine and the quantum kernel engine. The executor is used to run experiments on simulated and real backends of the Qiskit or PennyLane frameworks.
 
 <p align="center">
-  <img width=500px alt="sQUlearn schematic" src="https://raw.githubusercontent.com/sQUlearn/squlearn/main/docs/_static/schematic.png" />
+  <img width=600px alt="sQUlearn schematic" src="https://raw.githubusercontent.com/sQUlearn/squlearn/main/docs/_static/schematic.png" />
 </p>
 
 ---

docs/_static/qkm/QKM_scheme_pic.jpg

@@ -0,0 +1,6 @@
+{
+    "path": "../../examples/tutorials/qnn_ode_solver.ipynb",
+    "extra-media": [
+        "../../examples/tutorials/images"
+    ]
+}

docs/_static/qrc/QRC_user_guide.png

@@ -10,4 +10,5 @@ Examples
     example_kernel_digit_classification
     example_kernel_grid_search
     example_quantum_bayesian_optimization
-    example_qnn_backend_mitigation
+    example_qnn_backend_mitigation
+    example_qnn_ode_solver

docs/_static/qrc/qrc_classification_transparent.png

@@ -50,6 +50,21 @@ state [1]. In the quantum computational practice, the Hilbert-Schmidt inner prod
 measurements. Consequently, in quantum computing, access to the Hilbert space of quantum states is
 given by measurements.
 
+.. _figure 1:
+.. figure:: ../_static/qkm/QKM_scheme_pic.jpg
+    :alt: Quantum Kernel Methods
+    :width: 500
+    :align: center
+
+    **Figure 1** Schematic illustration of the function principle of quantum kernel methods, which can be formally embedded in the rich
+    mathematical framework of conventional kernel theory. Data points  :math:`\symbf{x}` are mapped to the quantum Hilbert space by
+    encoding them into a quantum state  :math:`\ket{\symbf{\psi}(\symbf{x})}`. Access to the quantum Hilbert space is granted by
+    measurements. :math:`\symbf{Left:}` In quantum mechanics measurements are expressed through Hilbert-Schmidt inner products. 
+    Quantum kernels, which are defined using this fidelity-type metric are thus referred to as fidelity quantum kernels (FQKs).
+    More on FQKs in sQUlearn will be discussed below. :math:`\symbf{Right:}` When projecting the quantum states to an approximate
+    classical representation using, e.g., reduced physical observables this gives rise to a family of projected quantum kernels (PQKs).
+    These will be also subject to discussion in the sQUlearn context below.
+
 
 .. currentmodule:: squlearn.kernel.ml
 

docs/_static/qrc/qrc_regression_transparent.png

@@ -15,13 +15,13 @@ minimized by a classical optimizer. The resultant QNN can then be employed to pr
 for new input data.
 
 In many cases, QNNs adhere to a layered design, akin to classical neural networks, as illustrated
-in `figure 1`_. However, it is essential to note that they do not adhere to the concept of
+in `figure_qnn 1`_. However, it is essential to note that they do not adhere to the concept of
 neurons as seen in classical neural networks. Therefore, the term "Quantum Neural Network" may
 be somewhat misleading, as QNNs do not conform to the traditional neural network paradigm.
 Nevertheless, their application domain closely resembles that of classical neural networks,
 which explains the established nomenclature.
 
-.. _figure 1:
+.. _figure_qnn 1:
 .. figure:: ../_static/qnn/qnn.svg
     :alt: Quantum Neural Network (QNN)
     :width: 600
@@ -57,7 +57,7 @@ It's worth noting that both the embedding layers :math:`U_i({x})` and the observ
 
 To train Quantum Neural Networks (QNNs), a hybrid quantum-classical approach is employed.
 The training process consists of two phases: quantum circuit evaluation and classical optimization
-(as illustrated in `figure 1`_).
+(as illustrated in `figure_qnn 1`_).
 
 In the quantum circuit evaluation phase, the QNN and its gradient with respect to the parameters
 are assessed using a quantum computer or simulator. The gradient can be obtained using the
@@ -292,13 +292,13 @@ The noise level of the model thus depends on its variance, which can be calculat
     \sigma_f^2 = \langle\Psi\lvert\hat{C}^2\rvert\Psi\rangle -
     \langle\Psi\lvert\hat{C}\rvert\Psi\rangle^2 \text{.}
 
-`Figure 2`_ shows the output of a :class:`QNNRegressor` fit to a logarithm
+`Figure_qnn 3`_ shows the output of a :class:`QNNRegressor` fit to a logarithm
 with :class:`SquaredLoss <squlearn.qnn.loss.SquaredLoss>` evaluated on Qiskit's
 :class:`QasmSimulator <qiskit_aer.QasmSimulator>`.
 The model has been trained with a noise-free simulator, but evaluating it on a noisy simulator
 yields a high variance in the model output.
 
-.. _figure 2:
+.. _figure_qnn 2:
 .. plot::
     :caption: **Figure 2** Logarithm and output of :class:`QNNRegressor` :math:`f(\theta, x)` evaluated on Qiskit's
               :class:`QasmSimulator <qiskit_aer.QasmSimulator>`. The QNN output has a high variance.
@@ -359,9 +359,9 @@ takes the keyword argument ``iteration`` to dynamically adjust the factor. Value
 :math:`10^{-2}` and :math:`10^{-4}` have shown to yield satisfying results. `[1]`_
 
 Evaluation on Qiskit's :class:`QasmSimulator <qiskit_aer.QasmSimulator>` now yields less variance
-in the model, as depicted in `figure 3`_.
+in the model, as depicted in `figure_qnn 3`_.
 
-.. _figure 3:
+.. _figure_qnn 3:
 .. plot::
     :caption: **Figure 3** Logarithm and output of :class:`QNNRegressor` :math:`f(\theta, x)`, trained with variance
               regularization, evaluated on Qiskit's :class:`QasmSimulator <qiskit_aer.QasmSimulator>`.