--- a
+++ b/Code/All Qiskit, PennyLane QML Nov 23/10a3 Eff. Dimension .945Local kkawchak.ipynb
@@ -0,0 +1,1052 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Effective Dimension of Qiskit Neural Networks\n",
+    "In this tutorial, we will take advantage of the `EffectiveDimension` and `LocalEffectiveDimension` classes to evaluate the power of Quantum Neural Network models. These are metrics based on information geometry that connect to notions such as trainability, expressibility or ability to generalize.\n",
+    "\n",
+    "Before diving into the code example, we will briefly explain what is the difference between these two metrics, and why are they relevant to the study of Quantum Neural Networks. More information about global effective dimension can be found in [this paper](https://arxiv.org/pdf/2011.00027.pdf), while the local effective dimension was introduced in a [later work](https://arxiv.org/abs/2112.04807)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## 1. Global vs. Local Effective Dimension\n",
+    "Both classical and quantum machine learning models share a common goal: being good at **generalizing**, i.e. learning insights from data and applying them on unseen data.\n",
+    "\n",
+    "Finding a good metric to assess this ability is a non-trivial matter. In [The Power of Quantum Neural Networks](https://arxiv.org/pdf/2011.00027.pdf), the authors introduce the **global** effective dimension as a useful indicator of how well a particular model will be able to perform on new data. In [Effective Dimension of Machine Learning Models](https://arxiv.org/pdf/2112.04807.pdf), the **local** effective dimension is proposed as a new capacity measure that bounds the generalization error of machine learning models.\n",
+    "\n",
+    "The key difference between global (`EffectiveDimension` class) and **local** effective dimension (`LocalEffectiveDimension` class) is actually not in the way they are computed, but in the nature of the parameter space that is analyzed. The global effective dimension incorporates the **full parameter space** of the model, and is calculated from a **large number of parameter (weight) sets**. On the other hand, the local effective dimension focuses on how well the **trained** model can generalize to new data, and how **expressive** it can be. Therefore, the local effective dimension is calculated from **a single** set of weight samples (training result). This difference is small in terms of practical implementation, but quite relevant at a conceptual level."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. The Effective Dimension Algorithm\n",
+    "\n",
+    "Both the global and local effective dimension algorithms use the Fisher Information matrix to provide a measure of complexity. The details on how this matrix is calculated are provided in the [reference paper](https://arxiv.org/pdf/2011.00027.pdf), but in general terms, this matrix captures how sensitive a neural network's output is to changes in the network's parameter space.\n",
+    "\n",
+    "In particular, this algorithm follows 4 main steps:\n",
+    "\n",
+    "1. **Monte Carlo simulation:** the forward and backward passes (gradients) of the neural network are computed for each pair of input and weight samples.\n",
+    "2. **Fisher Matrix Computation:** these outputs and gradients are used to compute the Fisher Information Matrix.\n",
+    "3. **Fisher Matrix Normalization:** averaging over all input samples and dividing by the matrix trace\n",
+    "4. **Effective Dimension Calculation:** according to the formula from [*Abbas et al.*](https://arxiv.org/pdf/2011.00027.pdf)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## 3. Basic Example (SamplerQNN)\n",
+    "\n",
+    "This example shows how to set up a QNN model problem and run the global effective dimension algorithm. Both Qiskit `SamplerQNN` (shown in this example) and `EstimatorQNN` (shown in a later example) can be used with the `EffectiveDimension` class.\n",
+    "\n",
+    "We start off from the required imports and a fixed seed for the random number generator for reproducibility purposes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "skip"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_579/2968235742.py:6: DeprecationWarning: ``qiskit.algorithms`` has been migrated to an independent package: https://github.com/qiskit-community/qiskit-algorithms. The ``qiskit.algorithms`` import path is deprecated as of qiskit-terra 0.25.0 and will be removed no earlier than 3 months after the release date. Please run ``pip install qiskit_algorithms`` and use ``import qiskit_algorithms`` instead.\n",
+      "  from qiskit.algorithms.optimizers import COBYLA\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Necessary imports\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from IPython.display import clear_output\n",
+    "from qiskit import QuantumCircuit\n",
+    "from qiskit.algorithms.optimizers import COBYLA\n",
+    "from qiskit.circuit.library import ZFeatureMap, RealAmplitudes, ZZFeatureMap\n",
+    "from qiskit.utils import algorithm_globals\n",
+    "from sklearn.datasets import make_classification\n",
+    "from sklearn.preprocessing import MinMaxScaler\n",
+    "\n",
+    "from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier\n",
+    "from qiskit_machine_learning.neural_networks import EffectiveDimension, LocalEffectiveDimension\n",
+    "from qiskit_machine_learning.neural_networks import SamplerQNN, EstimatorQNN\n",
+    "\n",
+    "# set random seed\n",
+    "algorithm_globals.random_seed = 42"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    },
+    "slideshow": {
+     "slide_type": "skip"
+    }
+   },
+   "source": [
+    "### 3.1 Define QNN\n",
+    "\n",
+    "The first step to create a `SamplerQNN` is to define a parametrized feature map and ansatz. In this toy example, we will use 3 qubits, and we will define the circuit used in the `SamplerQNN` class."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "slideshow": {
+     "slide_type": "-"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 621.941x284.278 with 1 Axes>"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "num_qubits = 3\n",
+    "# create a feature map\n",
+    "feature_map = ZZFeatureMap(feature_dimension=num_qubits, reps=1)\n",
+    "# create a variational circuit\n",
+    "ansatz = RealAmplitudes(num_qubits, reps=1)\n",
+    "\n",
+    "# combine feature map and ansatz into a single circuit\n",
+    "qc = QuantumCircuit(num_qubits)\n",
+    "qc.append(feature_map, range(num_qubits))\n",
+    "qc.append(ansatz, range(num_qubits))\n",
+    "qc.decompose().draw(\"mpl\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The parametrized circuit can then be sent together with an optional interpret map (parity in this case) to the `SamplerQNN` constructor."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# parity maps bitstrings to 0 or 1\n",
+    "def parity(x):\n",
+    "    return \"{:b}\".format(x).count(\"1\") % 2\n",
+    "\n",
+    "\n",
+    "output_shape = 2  # corresponds to the number of classes, possible outcomes of the (parity) mapping."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# construct QNN\n",
+    "qnn = SamplerQNN(\n",
+    "    circuit=qc,\n",
+    "    input_params=feature_map.parameters,\n",
+    "    weight_params=ansatz.parameters,\n",
+    "    interpret=parity,\n",
+    "    output_shape=output_shape,\n",
+    "    sparse=False,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2 Set up Effective Dimension calculation\n",
+    "\n",
+    "In order to compute the effective dimension of our QNN using the `EffectiveDimension` class, we need a series of sets of input samples and weights, as well as the total number of data samples available in a dataset. The `input_samples` and `weight_samples` are set in the class constructor, while the number of data samples is given during the call to the effective dimension computation, to be able to test and compare how this measure changes with different dataset sizes."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can define the number of input samples and weight samples and the class will randomly sample a corresponding array from a normal (for `input_samples`) or a uniform (for `weight_samples`) distribution. Instead of passing a number of samples we can pass an array, sampled manually."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# we can set the total number of input samples and weight samples for random selection\n",
+    "num_input_samples = 10\n",
+    "num_weight_samples = 10\n",
+    "\n",
+    "global_ed = EffectiveDimension(\n",
+    "    qnn=qnn, weight_samples=num_weight_samples, input_samples=num_input_samples\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If we want to test a specific set of input samples and weight samples, we can provide it directly to the `EffectiveDimension` class as shown in the following snippet:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# we can also provide user-defined samples and parameters\n",
+    "input_samples = algorithm_globals.random.normal(0, 1, size=(10, qnn.num_inputs))\n",
+    "weight_samples = algorithm_globals.random.uniform(0, 1, size=(10, qnn.num_weights))\n",
+    "\n",
+    "global_ed = EffectiveDimension(qnn=qnn, weight_samples=weight_samples, input_samples=input_samples)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The effective dimension algorithm also requires a dataset size. In this example, we will define an array of sizes to later see how this input affects the result."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# finally, we will define ranges to test different numbers of data, n\n",
+    "n = [5000, 8000, 10000, 40000, 60000, 100000, 150000, 200000, 500000, 1000000]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.3 Compute Global Effective Dimension\n",
+    "Let's now calculate the effective dimension of our network for the previously defined set of input samples, weights, and a dataset size of 5000."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "global_eff_dim_0 = global_ed.get_effective_dimension(dataset_size=n[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The effective dimension values will range between 0 and `d`, where `d` represents the dimension of the model, and it's practically obtained from the number of weights of the QNN. By dividing the result by `d`, we can obtain the normalized effective dimension, which correlates directly with the capacity of the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Data size: 5000, global effective dimension: 5.2939\n",
+      "Number of weights: 6, normalized effective dimension: 0.8823\n"
+     ]
+    }
+   ],
+   "source": [
+    "d = qnn.num_weights\n",
+    "\n",
+    "print(\"Data size: {}, global effective dimension: {:.4f}\".format(n[0], global_eff_dim_0))\n",
+    "print(\n",
+    "    \"Number of weights: {}, normalized effective dimension: {:.4f}\".format(d, global_eff_dim_0 / d)\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "By calling the `EffectiveDimension` class with an array if input sizes `n`, we can monitor how the effective dimension changes with the dataset size."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "slideshow": {
+     "slide_type": "-"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "global_eff_dim_1 = global_ed.get_effective_dimension(dataset_size=n)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Effective dimension: [5.29390229 5.33597126 5.35545289 5.46354885 5.49042841 5.52135717\n",
+      " 5.54374079 5.55854944 5.60045031 5.62756494]\n",
+      "Number of weights: 6\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Effective dimension: {}\".format(global_eff_dim_1))\n",
+    "print(\"Number of weights: {}\".format(d))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot the normalized effective dimension for the model\n",
+    "plt.plot(n, np.array(global_eff_dim_1) / d)\n",
+    "plt.xlabel(\"Number of data\")\n",
+    "plt.ylabel(\"Normalized GLOBAL effective dimension\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## 4. Local Effective Dimension Example\n",
+    "As explained in the introduction, the local effective dimension algorithm only uses **one** set of weights, and it can be used to monitor how training affects the expressiveness of a neural network. The `LocalEffectiveDimension` class enforces this constraint to ensure that these calculations are conceptually separate, but the rest of the implementation is shared with `EffectiveDimension`.\n",
+    "\n",
+    "This example shows how to leverage the `LocalEffectiveDimension` class to analyze the effect of training on QNN expressiveness."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.1 Define Dataset and QNN\n",
+    "\n",
+    "We start by creating a 3D binary classification dataset using `make_classification` function from scikit-learn."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "num_inputs = 3\n",
+    "num_samples = 50\n",
+    "\n",
+    "X, y = make_classification(\n",
+    "    n_samples=num_samples,\n",
+    "    n_features=num_inputs,\n",
+    "    n_informative=3,\n",
+    "    n_redundant=0,\n",
+    "    n_clusters_per_class=1,\n",
+    "    class_sep=2.0,\n",
+    ")\n",
+    "X = MinMaxScaler().fit_transform(X)\n",
+    "y = 2 * y - 1  # labels in {-1, 1}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The next step is to create a QNN, an instance of `EstimatorQNN` in our case in the same fashion we created an instance of `SamplerQNN`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "estimator_qnn = EstimatorQNN(\n",
+    "    circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.2 Train QNN\n",
+    "\n",
+    "We can now proceed to train the QNN. The training step may take some time, be patient. You can pass a callback to the classifier to observe how the training process is going on. We fix `initial_point` for reproducibility purposes as usual."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# callback function that draws a live plot when the .fit() method is called\n",
+    "def callback_graph(weights, obj_func_eval):\n",
+    "    clear_output(wait=True)\n",
+    "    objective_func_vals.append(obj_func_eval)\n",
+    "    plt.title(\"Objective function value against iteration\")\n",
+    "    plt.xlabel(\"Iteration\")\n",
+    "    plt.ylabel(\"Objective function value\")\n",
+    "    plt.plot(range(len(objective_func_vals)), objective_func_vals)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# construct classifier\n",
+    "initial_point = algorithm_globals.random.random(estimator_qnn.num_weights)\n",
+    "\n",
+    "estimator_classifier = NeuralNetworkClassifier(\n",
+    "    neural_network=estimator_qnn,\n",
+    "    optimizer=COBYLA(maxiter=80, rhobeg=1.2),\n",
+    "    initial_point=initial_point,\n",
+    "    callback=callback_graph,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# create empty array for callback to store evaluations of the objective function (callback)\n",
+    "objective_func_vals = []\n",
+    "plt.rcParams[\"figure.figsize\"] = (12, 6)\n",
+    "\n",
+    "# fit classifier to data\n",
+    "estimator_classifier.fit(X, y)\n",
+    "\n",
+    "# return to default figsize\n",
+    "plt.rcParams[\"figure.figsize\"] = (6, 4)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The classifier can now differentiate between classes with an accuracy of:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.84"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# score classifier\n",
+    "estimator_classifier.score(X, y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.3 Compute Local Effective Dimension of trained QNN\n",
+    "\n",
+    "Now that we have trained our network, let's evaluate the local effective dimension based on the trained weights. To do that we access the trained weights directly from the classifier."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "normalized local effective dimensions for trained QNN:  [0.85451059 0.86386733 0.86813224 0.89118527 0.89678665 0.90318158\n",
+      " 0.9077807  0.91081181 0.91934737 0.9248461 ]\n"
+     ]
+    }
+   ],
+   "source": [
+    "trained_weights = estimator_classifier.weights\n",
+    "\n",
+    "# get Local Effective Dimension for set of trained weights\n",
+    "local_ed_trained = LocalEffectiveDimension(\n",
+    "    qnn=estimator_qnn, weight_samples=trained_weights, input_samples=X\n",
+    ")\n",
+    "\n",
+    "local_eff_dim_trained = local_ed_trained.get_effective_dimension(dataset_size=n)\n",
+    "\n",
+    "print(\n",
+    "    \"normalized local effective dimensions for trained QNN: \",\n",
+    "    local_eff_dim_trained / estimator_qnn.num_weights,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.4 Compute Local Effective Dimension of untrained QNN\n",
+    "\n",
+    "We can compare this result with the effective dimension of the untrained network, using the `initial_point` as our weight sample:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "normalized local effective dimensions for untrained QNN:  [0.91155343 0.91717311 0.91974992 0.93374636 0.9371546  0.9410469\n",
+      " 0.94384667 0.94569204 0.95088899 0.95423713]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# get Local Effective Dimension for set of untrained weights\n",
+    "local_ed_untrained = LocalEffectiveDimension(\n",
+    "    qnn=estimator_qnn, weight_samples=initial_point, input_samples=X\n",
+    ")\n",
+    "\n",
+    "local_eff_dim_untrained = local_ed_untrained.get_effective_dimension(dataset_size=n)\n",
+    "\n",
+    "print(\n",
+    "    \"normalized local effective dimensions for untrained QNN: \",\n",
+    "    local_eff_dim_untrained / estimator_qnn.num_weights,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "### 4.5 Plot and analyze results\n",
+    "\n",
+    "If we plot the effective dimension values before and after training, we can see the following result:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "tags": [
+     "nbsphinx-thumbnail"
+    ]
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 600x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot the normalized effective dimension for the model\n",
+    "plt.plot(n, np.array(local_eff_dim_trained) / estimator_qnn.num_weights, label=\"trained weights\")\n",
+    "plt.plot(\n",
+    "    n, np.array(local_eff_dim_untrained) / estimator_qnn.num_weights, label=\"untrained weights\"\n",
+    ")\n",
+    "\n",
+    "plt.xlabel(\"Number of data\")\n",
+    "plt.ylabel(\"Normalized LOCAL effective dimension\")\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In general, we should expect the value of the local effective dimension to decrease after training. This can be understood by looking back into the main goal of machine learning, which is to pick a model that is expressive enough to fit your data, but not too expressive that it overfits and performs badly on new data samples.  \n",
+    "\n",
+    "Certain optimizers help regularize the overfitting of a model by learning parameters, and this action of learning inherently reduces a model’s expressiveness, as measured by the local effective dimension. Following this logic, a randomly initialized parameter set will most likely produce a higher effective dimension that the final set of trained weights, because that model with that particular parameterization is “using more parameters” unnecessarily to fit the data. After training (with the implicit regularization), a trained model will not need to use so many parameters and thus have more “inactive parameters” and a lower effective dimension. \n",
+    "\n",
+    "We must keep in mind though that this is the general intuition, and there might be cases where a randomly selected set of weights happens to provide a lower effective dimension than the trained weights for a specific model. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<h3>Version Information</h3><table><tr><th>Software</th><th>Version</th></tr><tr><td><code>qiskit</code></td><td>0.44.1</td></tr><tr><td><code>qiskit-terra</code></td><td>0.25.1</td></tr><tr><td><code>qiskit_machine_learning</code></td><td>0.6.1</td></tr><tr><th colspan='2'>System information</th></tr><tr><td>Python version</td><td>3.10.8</td></tr><tr><td>Python compiler</td><td>GCC 10.4.0</td></tr><tr><td>Python build</td><td>main, Nov 22 2022 08:26:04</td></tr><tr><td>OS</td><td>Linux</td></tr><tr><td>CPUs</td><td>8</td></tr><tr><td>Memory (Gb)</td><td>31.142810821533203</td></tr><tr><td colspan='2'>Wed Nov 22 16:28:37 2023 UTC</td></tr></table>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>&copy; Copyright IBM 2017, 2023.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import qiskit.tools.jupyter\n",
+    "\n",
+    "%qiskit_version_table\n",
+    "%qiskit_copyright"
+   ]
+  }
+ ],
+ "metadata": {
+  "celltoolbar": "Tags",
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "state": {
+     "0025d1aeb2fe47198f5232800c0a3252": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "045c5b9039e94aa6a05fcda8c9871831": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_3b49ce2b1c9f40fa8c67614685c4180d",
+       "style": "IPY_MODEL_98fc2a80a2e245d7b7b59925cdc22677",
+       "value": "<h5>Message</h5>"
+      }
+     },
+     "1186288ee0bf4c00ada8ba50d9d80014": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_ddea4d4e06124ace8cedbb9886a2f23e",
+        "IPY_MODEL_e0a875ccf9554b9b92c7828713e1a290",
+        "IPY_MODEL_37e90ca36c6b408eb41419bc1defc51f",
+        "IPY_MODEL_f19cc6fe8fa440a2ad6b2e25f011ad98",
+        "IPY_MODEL_045c5b9039e94aa6a05fcda8c9871831"
+       ],
+       "layout": "IPY_MODEL_9584f154e376422d9e94683944225c21"
+      }
+     },
+     "20561f3ea26a46abaf6243d9cba85390": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "341128aaa0044f049891e14b3efd83bb": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "145px"
+      }
+     },
+     "37e90ca36c6b408eb41419bc1defc51f": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_f037f14996854014853bd5462f34a6f3",
+       "style": "IPY_MODEL_84bba6f17792483daeeacd6abf5cb53f",
+       "value": "<h5>Status</h5>"
+      }
+     },
+     "3b49ce2b1c9f40fa8c67614685c4180d": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "3cd3c9eb9a3640eb94082906375664aa": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "ButtonModel",
+      "state": {
+       "button_style": "primary",
+       "description": "Clear",
+       "layout": "IPY_MODEL_ad7159f10e214addbd409050cbdd2dee",
+       "style": "IPY_MODEL_6392916eaeba43ccbf354337d46c9131",
+       "tooltip": null
+      }
+     },
+     "4debe150268047b38963850b5ef31f3b": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "grid_template_areas": "\n                                       \". . . . right \"\n                                        ",
+       "grid_template_columns": "20% 20% 20% 20% 20%",
+       "width": "100%"
+      }
+     },
+     "6392916eaeba43ccbf354337d46c9131": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "ButtonStyleModel",
+      "state": {
+       "font_family": null,
+       "font_size": null,
+       "font_style": null,
+       "font_variant": null,
+       "font_weight": null,
+       "text_color": null,
+       "text_decoration": null
+      }
+     },
+     "7023a3256dad49a98aa9b7b854ef9e46": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "190px"
+      }
+     },
+     "787657936efd4b0d9ed6f4fa50ff5cee": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "84bba6f17792483daeeacd6abf5cb53f": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "9584f154e376422d9e94683944225c21": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "margin": "0px 0px 0px 37px",
+       "width": "600px"
+      }
+     },
+     "98fc2a80a2e245d7b7b59925cdc22677": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "999fd3987d8e44f7a4177ccb01012736": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_eece8c2e0b14419fa2e314f55392e659",
+       "style": "IPY_MODEL_787657936efd4b0d9ed6f4fa50ff5cee",
+       "value": "<p style='font-family: IBM Plex Sans, Arial, Helvetica, sans-serif; font-size: 20px; font-weight: medium;'>Circuit Properties</p>"
+      }
+     },
+     "a67874436aae47358841e68c4b2002f0": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "ad7159f10e214addbd409050cbdd2dee": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "grid_area": "right",
+       "padding": "0px 0px 0px 0px",
+       "width": "70px"
+      }
+     },
+     "d43181a30b6a4abbab9ad8ea70c709be": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "GridBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_3cd3c9eb9a3640eb94082906375664aa"
+       ],
+       "layout": "IPY_MODEL_4debe150268047b38963850b5ef31f3b"
+      }
+     },
+     "ddea4d4e06124ace8cedbb9886a2f23e": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_7023a3256dad49a98aa9b7b854ef9e46",
+       "style": "IPY_MODEL_0025d1aeb2fe47198f5232800c0a3252",
+       "value": "<h5>Job ID</h5>"
+      }
+     },
+     "e0a875ccf9554b9b92c7828713e1a290": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_341128aaa0044f049891e14b3efd83bb",
+       "style": "IPY_MODEL_a67874436aae47358841e68c4b2002f0",
+       "value": "<h5>Backend</h5>"
+      }
+     },
+     "eece8c2e0b14419fa2e314f55392e659": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "margin": "0px 0px 10px 0px"
+      }
+     },
+     "f037f14996854014853bd5462f34a6f3": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "95px"
+      }
+     },
+     "f19cc6fe8fa440a2ad6b2e25f011ad98": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_f7b9249330504c1597d6b93a45bc0b77",
+       "style": "IPY_MODEL_20561f3ea26a46abaf6243d9cba85390",
+       "value": "<h5>Queue</h5>"
+      }
+     },
+     "f7b9249330504c1597d6b93a45bc0b77": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "70px"
+      }
+     }
+    },
+    "version_major": 2,
+    "version_minor": 0
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}