--- a
+++ b/Code/All Qiskit, PennyLane QML Nov 23/10a5 Eff. Dimension .98Local 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_997/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.08),\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.90364938 0.90980573 0.91262332 0.9278936  0.93160656 0.93584534\n",
+      " 0.93889356 0.94090242 0.94655892 0.95020267]\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.96313668 0.9651986  0.96619113 0.9718596  0.97328164 0.97491658\n",
+      " 0.97609801 0.97687862 0.97908289 0.98050616]\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:35:11 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": {
+     "1b2ec079d8c447f889f45dd44f8ee416": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_e4bbec0b6208400bb29eeecdc9d2b19c",
+       "style": "IPY_MODEL_7b2ea2b539c44179acd1bb1f72205eb2",
+       "value": "<h5>Job ID</h5>"
+      }
+     },
+     "1fc09824d26a495b864d790b13063a6c": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_ed6111497ed8429bb90b415b498f5e13",
+       "style": "IPY_MODEL_50241d04ad694be59d260a78dfaff032",
+       "value": "<p style='font-family: IBM Plex Sans, Arial, Helvetica, sans-serif; font-size: 20px; font-weight: medium;'>Circuit Properties</p>"
+      }
+     },
+     "283188115c8949dfa8484b948fb416a6": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_1b2ec079d8c447f889f45dd44f8ee416",
+        "IPY_MODEL_80bc9efc07f5427387ddcc5fad700728",
+        "IPY_MODEL_fea1837f3c0d4fd9ad07b8f11f28fdc1",
+        "IPY_MODEL_f571729c8d0f486c92debe93b4eba1cf",
+        "IPY_MODEL_7245e76b221947aea4ebbc5f94f9dc52"
+       ],
+       "layout": "IPY_MODEL_8d67f7dc186140c89a98d2a43ed603f0"
+      }
+     },
+     "3a84ec8ff5e64a26be49b455b1f78b6c": {
+      "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
+      }
+     },
+     "40541eae52094679b68270356c4c9e47": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "4c4c0a13b6aa4f8e93a5d7c4500be112": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "70px"
+      }
+     },
+     "50241d04ad694be59d260a78dfaff032": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "60b2c3a3ad8d4cf18a616ece09fd6b75": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "95px"
+      }
+     },
+     "6eebe6a687bc4107888b8cccde4c6fa1": {
+      "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"
+      }
+     },
+     "7245e76b221947aea4ebbc5f94f9dc52": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_86784ff3b09b434a9116c1f1c2668da7",
+       "style": "IPY_MODEL_ed20a2d5c84c46e0895d935421006af4",
+       "value": "<h5>Message</h5>"
+      }
+     },
+     "7b2ea2b539c44179acd1bb1f72205eb2": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "8025ac4df5124f0c96607b079fc2723d": {
+      "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%"
+      }
+     },
+     "80bc9efc07f5427387ddcc5fad700728": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_9e83574698c0480dbd231909dbfdafd7",
+       "style": "IPY_MODEL_40541eae52094679b68270356c4c9e47",
+       "value": "<h5>Backend</h5>"
+      }
+     },
+     "86784ff3b09b434a9116c1f1c2668da7": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "8d67f7dc186140c89a98d2a43ed603f0": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "margin": "0px 0px 0px 37px",
+       "width": "600px"
+      }
+     },
+     "9e83574698c0480dbd231909dbfdafd7": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "145px"
+      }
+     },
+     "a0284394e3924931920fc44d29bf5c2b": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "ButtonModel",
+      "state": {
+       "button_style": "primary",
+       "description": "Clear",
+       "layout": "IPY_MODEL_6eebe6a687bc4107888b8cccde4c6fa1",
+       "style": "IPY_MODEL_3a84ec8ff5e64a26be49b455b1f78b6c",
+       "tooltip": null
+      }
+     },
+     "ab8a44298e574b66947e3048c1515844": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "d144408efff048f39342490ae700b9b0": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "d42496dd4db14a2d962e8dc57e20e7a6": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "GridBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_a0284394e3924931920fc44d29bf5c2b"
+       ],
+       "layout": "IPY_MODEL_8025ac4df5124f0c96607b079fc2723d"
+      }
+     },
+     "e4bbec0b6208400bb29eeecdc9d2b19c": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "190px"
+      }
+     },
+     "ed20a2d5c84c46e0895d935421006af4": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "ed6111497ed8429bb90b415b498f5e13": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "margin": "0px 0px 10px 0px"
+      }
+     },
+     "f571729c8d0f486c92debe93b4eba1cf": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_4c4c0a13b6aa4f8e93a5d7c4500be112",
+       "style": "IPY_MODEL_ab8a44298e574b66947e3048c1515844",
+       "value": "<h5>Queue</h5>"
+      }
+     },
+     "fea1837f3c0d4fd9ad07b8f11f28fdc1": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_60b2c3a3ad8d4cf18a616ece09fd6b75",
+       "style": "IPY_MODEL_d144408efff048f39342490ae700b9b0",
+       "value": "<h5>Status</h5>"
+      }
+     }
+    },
+    "version_major": 2,
+    "version_minor": 0
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}