From f32013565ba03cadc128230692142e9ba50a19c8 Mon Sep 17 00:00:00 2001
From: hamiltonke <88093459+hamiltonke@users.noreply.github.com>
Date: Thu, 21 Sep 2023 12:42:12 -0400
Subject: [PATCH] Add files via upload

updated the `rescale_features` function -- now includes an example for discretizing features (hard-wired for 2 features only)
---
 QNLP_tutorial_QNNs.ipynb | 1827 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 1827 insertions(+)
 create mode 100644 QNLP_tutorial_QNNs.ipynb

diff --git a/QNLP_tutorial_QNNs.ipynb b/QNLP_tutorial_QNNs.ipynb
new file mode 100644
index 0000000..e7d0ca9
--- /dev/null
+++ b/QNLP_tutorial_QNNs.ipynb
@@ -0,0 +1,1827 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b4f46ddb",
+   "metadata": {},
+   "source": [
+    "### QNLP Tutorial (IEEE Quantum Week 2023):  A QNN Introduction\n",
+    "\n",
+    "This notebook explores the design space of QNNs trained on synthetic data or on a NLP dataset.  The goal of this tutorial is to introduce several methods for feature embedding, ansatz construction, and label assignment.  \n",
+    "\n",
+    "In this tutorial we will use three datsets:  first, is a set of random feature vectors with random labels, constructed as in the  `TwoMoons` dataset.   The second dataset is derived from the `IMDB` (Internet Movie DataBase) dataset: the original data is a collection of 50K text reviews, labeled by sentiment (positive or negative).  Prior to this tutorial these features were embedded using length 3 feature vectors using `doc2vec`  embedding (introduced in the previous session).  Finally, we have an example of multiclass classification using random features with random labels."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b781a3c7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pennylane import numpy as np\n",
+    "import pennylane as qml\n",
+    "import copy\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pandas as pd\n",
+    "\n",
+    "from sklearn.metrics import confusion_matrix\n",
+    "import seaborn as sns\n",
+    "\n",
+    "from sklearn.datasets import make_moons,make_classification"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e91d547",
+   "metadata": {},
+   "source": [
+    "# Construct Unstructured Data (Synthetic)\n",
+    "\n",
+    "The `TwoMoons` dataset constructs a sythetic dataset of 2 dimensional features.  The two classes are half-cirles. \n",
+    "\n",
+    "$200$ samples are generated and $10\\%$ are held out as the test data. \n",
+    "\n",
+    "These functions are wrappers of existing functions in `scikit-learn`. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "708980c7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Make a dataset of two moons\n",
+    "def moons(samples, noise = 0.1, random_state=2023):\n",
+    "    \"\"\"\n",
+    "    Args:\n",
+    "        samples (int): number of samples to generate\n",
+    "        center (tuple): center of the circle\n",
+    "        radius (float: radius of the circle\n",
+    "\n",
+    "    Returns:\n",
+    "        Xvals (array[tuple]): coordinates of points\n",
+    "        yvals (array[int]): classification labels\n",
+    "    \"\"\"\n",
+    "    X, y = make_moons(n_samples=samples, noise=noise,random_state=random_state)\n",
+    "    return np.array(X, requires_grad=False), np.array(y, requires_grad=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "9ddd3233",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def partition_data(X,y,test_size=0.2):\n",
+    "    '''\n",
+    "    since the synthetic datasets used in this tutorial are already shuffled\n",
+    "    the partitioning is just separating the first 80% of samples for traning\n",
+    "    and the remaining 20% are held for testing'''\n",
+    "    n_train_samples = int(len(X)*(1.-test_size))\n",
+    "    trainX = X[:n_train_samples]\n",
+    "    trainY = y[:n_train_samples]\n",
+    "    \n",
+    "    testX = X[n_train_samples:]\n",
+    "    testY = y[n_train_samples:]\n",
+    "    return trainX,trainY,testX,testY"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "112bb0c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rescale_features(X,a=-np.pi,b=np.pi,normalize=False,discretize=False,bins=20):\n",
+    "    '''\n",
+    "    can use either simple shift/rescale of features into a range of values [a,b]\n",
+    "    or can use a discrete map of categorical features to rotations\n",
+    "    (c) unique values equally spaced in [a,b]'''\n",
+    "    \n",
+    "\n",
+    "\n",
+    "    if not discretize:\n",
+    "        Xvals = X.copy()\n",
+    "        Xmin = np.min(X, axis=0).numpy()\n",
+    "        Xmax = np.max(X, axis=0).numpy()\n",
+    "        Xvals = (b-a) * (Xvals - Xmin) / (Xmax - Xmin) + a\n",
+    "    elif discretize:\n",
+    "        if len(np.unique(X))==X.shape[0]*X.shape[1]:\n",
+    "            Xvals = []\n",
+    "            rot_angles = np.linspace(a,b,num=bins,endpoint=True)\n",
+    "            # pandas.cut(x, bins, right=True, labels=None, retbins=False,\n",
+    "            X0_labels,X0_bins = pd.cut(X[:,0],bins, labels=rot_angles,retbins=True)\n",
+    "            X1_labels,X1_bins = pd.cut(X[:,1],bins, labels=rot_angles,retbins=True)\n",
+    "            my_corpus = []\n",
+    "            for idx in range(len(X0_labels)):\n",
+    "                x0=X0_labels[idx]\n",
+    "                x1=X1_labels[idx]\n",
+    "                Xvals.append([x0,x1])\n",
+    "            Xvals=np.asarray(Xvals)\n",
+    "        else:\n",
+    "            rot_angles = np.linspace(a,b,num=len(np.unique(X)), endpoint=True)\n",
+    "            Xvals = np.asarray([[rot_angles[y].numpy() for y in x] for x in X])\n",
+    "    if normalize:\n",
+    "        row_norms = np.linalg.norm(Xvals,axis=1)\n",
+    "        Xvals = Xvals / row_norms[:, np.newaxis]\n",
+    "        Xvals[np.isnan(Xvals)] = 0\n",
+    "        mask = np.all(np.abs(Xvals) < 1e-10, axis=1)\n",
+    "        pos = np.where(~(mask))\n",
+    "        return Xvals[pos],pos\n",
+    "    else:\n",
+    "        return Xvals"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "02fd3ffb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def one_hot_encode_labels(y,L):\n",
+    "    '''\n",
+    "    replace class labels with one-hot encoded labels of length L\n",
+    "    example: if L = 2\n",
+    "    0 -> [1,0]\n",
+    "    1 -> [0,1]\n",
+    "    '''\n",
+    "    unique_classes = set(y)\n",
+    "    label_map = {}\n",
+    "    for idx,c in enumerate(unique_classes):\n",
+    "        label_vec = [0]*L\n",
+    "        label_vec[idx]=1\n",
+    "        label_map[c]=label_vec.copy()\n",
+    "    one_hot_y=[label_map[iy] for _,iy in enumerate(y)]\n",
+    "    return one_hot_y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "5d65bd7d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot2d_data(X,y,fig=None, ax=None):\n",
+    "    SMALL_SIZE = 12\n",
+    "    MEDIUM_SIZE = 20\n",
+    "    BIGGER_SIZE = 24\n",
+    "\n",
+    "    plt.rc('font', size=SMALL_SIZE)          # controls default text sizes\n",
+    "    plt.rc('axes', titlesize=SMALL_SIZE)     # fontsize of the axes title\n",
+    "    plt.rc('axes', labelsize=MEDIUM_SIZE)    # fontsize of the x and y labels\n",
+    "    plt.rc('xtick', labelsize=MEDIUM_SIZE)    # fontsize of the tick labels\n",
+    "    plt.rc('ytick', labelsize=MEDIUM_SIZE)    # fontsize of the tick labels\n",
+    "    plt.rc('legend', fontsize=SMALL_SIZE)    # legend fontsize\n",
+    "    plt.rc('figure', titlesize=BIGGER_SIZE)  # fontsize of the figure title\n",
+    "    color_map={0:'blue',1: 'orange',2:'cyan'}\n",
+    "    shape_map={0:'x',1:'o',2:'^'}\n",
+    "    if fig == None:\n",
+    "        fig, ax = plt.subplots(1, 1, figsize=(10, 10))\n",
+    "    blues = y == 0\n",
+    "    oranges = y == 1\n",
+    "    brights = y == 2\n",
+    "    ax.scatter(X[blues, 0], X[blues, 1], c=color_map[0], s=75,marker=shape_map[0], alpha=0.75)\n",
+    "    ax.scatter(X[oranges, 0], X[oranges, 1], c=color_map[1], s=75,marker=shape_map[1], alpha=0.75)\n",
+    "    ax.scatter(X[brights, 0], X[brights, 1], c=color_map[2], s=75,marker=shape_map[1], alpha=0.75)\n",
+    "    #ax.scatter(X[:,0],X[:,1], c=y, s=75, alpha=0.5,cmap='bwr')\n",
+    "    ax.set_xlabel(\"$x_1$\")\n",
+    "    ax.set_ylabel(\"$x_2$\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b14727fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot2d_boundary_data(X,y,xx,yy,z_height,fig=None, ax=None):\n",
+    "    SMALL_SIZE = 12\n",
+    "    MEDIUM_SIZE = 20\n",
+    "    BIGGER_SIZE = 24\n",
+    "\n",
+    "    plt.rc('font', size=SMALL_SIZE)          # controls default text sizes\n",
+    "    plt.rc('axes', titlesize=SMALL_SIZE)     # fontsize of the axes title\n",
+    "    plt.rc('axes', labelsize=MEDIUM_SIZE)    # fontsize of the x and y labels\n",
+    "    plt.rc('xtick', labelsize=MEDIUM_SIZE)    # fontsize of the tick labels\n",
+    "    plt.rc('ytick', labelsize=MEDIUM_SIZE)    # fontsize of the tick labels\n",
+    "    plt.rc('legend', fontsize=SMALL_SIZE)    # legend fontsize\n",
+    "    plt.rc('figure', titlesize=BIGGER_SIZE)  # fontsize of the figure title\n",
+    "    color_map={0:'blue',1: 'orange',2:'cyan'}\n",
+    "    shape_map={0:'x',1:'o',2:'^'}\n",
+    "    if fig == None:\n",
+    "        fig, ax = plt.subplots(1, 1, figsize=(10, 10))\n",
+    "    blues = y == 0\n",
+    "    oranges = y == 1\n",
+    "    brights = y == 2\n",
+    "    ax.scatter(X[blues, 0], X[blues, 1], c=color_map[0], s=75,marker=shape_map[0], alpha=0.75)\n",
+    "    ax.scatter(X[oranges, 0], X[oranges, 1], c=color_map[1], s=75,marker=shape_map[1], alpha=0.75)\n",
+    "    ax.scatter(X[brights, 0], X[brights, 1], c=color_map[2], s=75,marker=shape_map[1], alpha=0.75)\n",
+    "    ax.contourf(xx, yy, z_height, alpha=0.2,cmap='bwr')    \n",
+    "    ax.set_xlabel(\"$x_1$\",fontsize=18)\n",
+    "    ax.set_ylabel(\"$x_2$\",fontsize=18)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "81c185f5",
+   "metadata": {},
+   "source": [
+    "The individual features are not syntatically related -- each feature vector is a random point in a high-dimesional space.  We arbitrarily shift and rescale the generated vectors so that the values of the feature vectors are in the range $[0, 2\\pi]$.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "cb1ef163",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X, y = moons(200)\n",
+    "X_train,y_train,X_test,y_test = partition_data(X,y)\n",
+    "\n",
+    "X_train_discrete = rescale_features(X_train,discretize=True,bins=20)\n",
+    "X_test_discrete = rescale_features(X_test,discretize=True,bins=20)\n",
+    "\n",
+    "X_train = rescale_features(X_train)\n",
+    "X_test = rescale_features(X_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b43467c1",
+   "metadata": {},
+   "source": [
+    "Just making a quick side-by-side comparison, the features of `X_train` should be rescaled to $[-\\pi,\\pi]$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "2a722c82",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'discretized data')"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 2520x864 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "f, ax = plt.subplots(ncols=3,figsize=(35,12))\n",
+    "\n",
+    "plt.rc('text',usetex=False)\n",
+    "plt.rc('font',family='serif')\n",
+    "plt.rc('xtick',labelsize=18)\n",
+    "plt.rc('ytick',labelsize=18)\n",
+    "plt.rc('legend',**{'numpoints':1,'fontsize':18,'handlelength':2})\n",
+    "\n",
+    "# add a big axis, hide frame\n",
+    "f.add_subplot(111,frameon=False) \n",
+    "# hide tick and tick label of the big axis\n",
+    "plt.tick_params(labelcolor='none', which='both', top=False, bottom=False, left=False, right=False)\n",
+    "\n",
+    "\n",
+    "f.subplots_adjust( wspace=0.1,hspace=0.2 )\n",
+    "\n",
+    "plot2d_data(X,y, fig=f, ax=ax[0])\n",
+    "ax[0].set_title(\"original generated data\",fontsize=24)\n",
+    "plot2d_data(X_train,y_train,fig=f,ax=ax[1])\n",
+    "ax[1].set_title(\"rescaled data\",fontsize=24)\n",
+    "plot2d_data(X_train_discrete,y_train,fig=f,ax=ax[2])\n",
+    "ax[2].set_title(\"discretized data\",fontsize=24)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88496b7f",
+   "metadata": {},
+   "source": [
+    "## (Optional): A second synthetic dataset\n",
+    "\n",
+    "Instead of using hte `TwoMoons` (or another `scikit-learn` dataset), you can also generate a set of random features labeled with random binary labels"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "d89ae983",
+   "metadata": {},
+   "source": [
+    "noise_features = (2*np.pi)*np.random.random((150,2)) #generate uniform random samples on [0,2pi]\n",
+    "noise_labels = np.asarray([x.numpy() for x in np.random.binomial(1, 0.5,150)]) #generate random binary labels"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c7a17274",
+   "metadata": {},
+   "source": [
+    "# Define Layer Templates"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dd179e7c",
+   "metadata": {},
+   "source": [
+    "The first template is the data-encoding layer.  This takes as an input a feature vector (x) and encodes it into a single qubit using 3 gates (RY-RZ-RY).  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "a383a02b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def AngleEncodingLayer(x,dev_wires):\n",
+    "    '''\n",
+    "    Layer template that applies the rotation gate layer\n",
+    "    '''\n",
+    "    if len(x)<3*len(dev_wires):\n",
+    "        x_ = np.reshape(np.tile(x,3*len(dev_wires)),(-1,3))\n",
+    "    else:\n",
+    "        x_ = np.reshape(x,(-1,3))\n",
+    "    for idx in range(len(dev_wires)):\n",
+    "        qml.RY(x_[idx][0],wires=dev_wires[idx])\n",
+    "        qml.RZ(x_[idx][1],wires=dev_wires[idx])\n",
+    "        qml.RY(x_[idx][2],wires=dev_wires[idx])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "256c6120",
+   "metadata": {},
+   "source": [
+    "The second template is the trainable ansatz layer -- for this tutorial we will use a bilayer ansatz built from interlevaed layers of CNOTS followed by trainable rotation gates. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "f6227c44",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def EdgeListLayer(params,dev_wires,edge_list=[]):\n",
+    "    ''' Layer template that takes an edge list and builds\n",
+    "    entangling layer - rotation layer -  ansatz\n",
+    "\n",
+    "    params: list of floats (trainable parameters)\n",
+    "\n",
+    "    wires: list of int\n",
+    "    edge_list: list of lists for CNOT layouts\n",
+    "    '''\n",
+    "    # add entangling layer with CNOTs defined by edge_list\n",
+    "    if len(edge_list) > 0:\n",
+    "        for edx in edge_list:\n",
+    "            qml.CNOT(wires=[dev_wires[edx[0]],dev_wires[edx[1]]])\n",
+    "    for idx in dev_wires:\n",
+    "        qml.Rot(*params[idx], wires=dev_wires[idx])\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "543530ae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class binaryQNN(object):\n",
+    "    '''\n",
+    "    build a Quantum Neural Network where label extraction is done via bitstring probabilities\n",
+    "    '''\n",
+    "    def __init__(self, wires=1,layers=1,shots=None,edge_list=[],\\\n",
+    "                    max_iter=32,tol=1e-3,output_qubits=[0],\\\n",
+    "                        batch_size=16,learning_rate=0.05,coefs=None,**kwargs):\n",
+    "        self.n_wires = wires #QNN wires\n",
+    "        self.n_layers=layers #QNN layers\n",
+    "        self.edge_list=edge_list #Connectivity for the entangling layers\n",
+    "        self.dev_wires = [np.array(idx, requires_grad=True) for idx in range(self.n_wires)] #whole register\n",
+    "        self.n_shots=shots #samples to take to generate bitstring probabilities\n",
+    "        self.coefs_=coefs #stored model parameters\n",
+    "        self.output_qubits = output_qubits #which qubits to measure for output\n",
+    "        self.device = qml.device(\"default.qubit\", wires=self.dev_wires,shots=self.n_shots) #Pennylane qubit device\n",
+    "        self.learning_rate=learning_rate # learning rate for optimizer\n",
+    "        self.batch_size=batch_size #batch size for batched gradient descent\n",
+    "        self.max_iter = max_iter #maximum number of epochs\n",
+    "        self.tol=tol #tolerance to detect early stopping\n",
+    "        self.wait_time = 10 #number of epochs with no change that triggers early stopping\n",
+    "        \n",
+    "    def build_circuit(self,*args, **kwds):\n",
+    "        raise NotImplementedError\n",
+    "        \n",
+    "    def initialize_params(self):\n",
+    "        params = 2.*np.pi*np.random.random(3*self.n_wires*self.n_layers)\n",
+    "        self.coefs_=params.copy()\n",
+    "        \n",
+    "    def accuracy_score(self,y_true, y_pred):\n",
+    "        \"\"\"Accuracy score.\n",
+    "\n",
+    "        Args:\n",
+    "            y_true (array[float]): 1-d array of targets\n",
+    "            y_predicted (array[float]): 1-d array of predictions\n",
+    "        Returns:\n",
+    "            score (float): the fraction of correctly classified samples\n",
+    "        \"\"\"\n",
+    "        if (y_true.ndim==1) and (y_pred.ndim==1):\n",
+    "            score = y_true == y_pred\n",
+    "        elif (y_true.ndim>1) and (y_pred.ndim==1):\n",
+    "            score = np.argmax(y_true,axis=1) == y_pred\n",
+    "        else:\n",
+    "            score = np.argmax(y_true,axis=1) == np.argmax(y_pred,axis=1)\n",
+    "        return score.sum() / len(score)\n",
+    "\n",
+    "    def make_predictions(self,params,x):\n",
+    "        \"\"\"\n",
+    "        assign labels to some data features\n",
+    "        \"\"\"\n",
+    "        predicted = []\n",
+    "        qnode_ = qml.QNode(self.build_circuit, self.device)\n",
+    "        for i in range(len(x)):\n",
+    "            P = qnode_(params,x[i])\n",
+    "            decoded=np.argmax(P)\n",
+    "            predicted.append(decoded)\n",
+    "        return np.array(predicted)\n",
+    "\n",
+    "    def class_probabilities(self,params,x):\n",
+    "        predicted = []\n",
+    "        qnode_ = qml.QNode(self.build_circuit, self.device)\n",
+    "        for i in range(len(x)):\n",
+    "            P = qnode_(params,x[i])\n",
+    "            predicted.append(P)\n",
+    "        return np.array(predicted)\n",
+    "\n",
+    "    def loss_function(self,params,x, y):\n",
+    "        \"\"\"\n",
+    "        Cost function to be minimized.\n",
+    "\n",
+    "        Args:\n",
+    "          params (array[float]): array of parameters\n",
+    "          x (array[float]): 2-d array of input vectors\n",
+    "          y (array[float]): 1-d array of targets\n",
+    "\n",
+    "        Returns:\n",
+    "          float: loss value to be minimized\n",
+    "        \"\"\"\n",
+    "        # Compute prediction for each input in data batch\n",
+    "        loss = 0.0\n",
+    "        qnode_ = qml.QNode(self.build_circuit, self.device)\n",
+    "        for i in range(len(x)):\n",
+    "            qp = qnode_(params,x[i])\n",
+    "            yval=y[i]\n",
+    "            if yval==0:\n",
+    "                yp = np.array([1, 0])\n",
+    "                loss = loss -np.sum(yp * np.log(qp+10**-12))\n",
+    "            else:\n",
+    "                yp = np.array([0,1])\n",
+    "                loss = loss -np.sum(yp * np.log(qp+10**-12))\n",
+    "        return loss / len(x)\n",
+    "\n",
+    "    def iterate_minibatches(self,inputs, targets, batch_size):\n",
+    "        \"\"\"\n",
+    "        A generator for batches of the input data\n",
+    "\n",
+    "        Args:\n",
+    "            inputs (array[float]): input data\n",
+    "            targets (array[float]): targets\n",
+    "\n",
+    "        Returns:\n",
+    "            inputs (array[float]): one batch of input data of length `batch_size`\n",
+    "            targets (array[float]): one batch of targets of length `batch_size`\n",
+    "        \"\"\"\n",
+    "        for start_idx in range(0, inputs.shape[0] - batch_size + 1, batch_size):\n",
+    "            idxs = slice(start_idx, start_idx + batch_size)\n",
+    "            yield inputs[idxs], targets[idxs]\n",
+    "            \n",
+    "    def fit(self,X,y,Xtest=None,ytest=None):\n",
+    "        \"\"\"\n",
+    "        implement gradient based training\n",
+    "        \"\"\"\n",
+    "        if (Xtest is not None) and (ytest is not None):\n",
+    "            #if you provide the testing data that will allso be used during evaluating hte loss and accuracy curves\n",
+    "            self.loss_curve_test = []\n",
+    "            self.accuracy_curve_test = []\n",
+    "            \n",
+    "        opt = qml.optimize.AdamOptimizer(self.learning_rate, beta1=0.9, beta2=0.999)\n",
+    "\n",
+    "        if self.coefs_ is None:\n",
+    "            # initialize random weights\n",
+    "            self.initialize_params()\n",
+    "            params = self.coefs_.copy()\n",
+    "        else:\n",
+    "            params = self.coefs_\n",
+    "\n",
+    "        if len(X)<self.batch_size:\n",
+    "            self.batch_size = int(len(X))\n",
+    "            print('WARNING: number of samples is smaller'+\\\n",
+    "             'than current batch size \\n '+\\\n",
+    "             'Resetting batch size for all trainings to: '+str(self.batch_size))\n",
+    "        loss = self.loss_function(params,X, y)\n",
+    "        preds = self.make_predictions(params,X)\n",
+    "        accuracy = self.accuracy_score(y, preds)\n",
+    "        print('initial loss and accuracy (random model): ',loss,accuracy)\n",
+    "        best_loss=loss\n",
+    "        best_accuracy=accuracy\n",
+    "        iter_count=0\n",
+    "\n",
+    "        for it in range(self.max_iter):\n",
+    "            for Xbatch, ybatch in self.iterate_minibatches(X, y, batch_size=self.batch_size):\n",
+    "                params = opt.step(lambda v: self.loss_function(v, Xbatch, ybatch), params)\n",
+    "                self.coefs_ = params.copy()\n",
+    "            # check for early stopping\n",
+    "            loss = self.loss_function(params,X, y)\n",
+    "            preds = self.make_predictions(params,X)\n",
+    "            accuracy = self.accuracy_score(y, preds)\n",
+    "            self.loss_curve.append(loss.numpy())\n",
+    "            self.accuracy_curve.append(accuracy.numpy())\n",
+    "            if (Xtest is not None) and (ytest is not None):\n",
+    "                self.loss_curve_test.append(self.loss_function(params,Xtest, ytest).numpy())\n",
+    "                testPreds=self.make_predictions(params,Xtest)\n",
+    "                self.accuracy_curve_test.append(self.accuracy_score(ytest,testPreds).numpy())\n",
+    "            if np.abs(best_loss-loss)<self.tol:\n",
+    "                iter_count+=1\n",
+    "            elif best_loss-loss>self.tol:\n",
+    "                best_loss = loss\n",
+    "                iter_count=0\n",
+    "            if iter_count>self.wait_time:\n",
+    "                print('early stopping ')\n",
+    "                print(\n",
+    "                  \"Epoch: {:2d} | Loss: {:3f} | Train accuracy: {:3f}\".format(\n",
+    "                      it+1, loss, accuracy\n",
+    "                  )\n",
+    "                )\n",
+    "                break\n",
+    "            else:\n",
+    "                print(\n",
+    "                      \"Epoch: {:2d} | Loss: {:3f} | Train accuracy: {:3f}\".format(\n",
+    "                          it+1, loss, accuracy\n",
+    "                      )\n",
+    "                    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "a5de330f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class druQNN(binaryQNN):\n",
+    "    '''\n",
+    "    build a Quantum Neural Network where label extraction is done via bitstring probabilities\n",
+    "    using data re-uploading\n",
+    "    '''\n",
+    "    def __init__(self, **kwargs):\n",
+    "        super(druQNN,self).__init__(**kwargs)\n",
+    "        self.loss_curve=[]\n",
+    "        self.accuracy_curve=[]\n",
+    "        \n",
+    "    def _reset_(self):\n",
+    "        self.coefs_=None\n",
+    "        self.loss_curve=[]\n",
+    "        self.accuracy_curve=[]\n",
+    "        \n",
+    "    def build_circuit(self,params,x=None):\n",
+    "        shape = (-1,len(self.dev_wires),3)\n",
+    "        params = np.asarray(params).reshape(shape)\n",
+    "        #x = np.resize(x, params.shape[0]-1)\n",
+    "        \n",
+    "        for idx in range(params.shape[0]-1):\n",
+    "            qml.layer(AngleEncodingLayer,1,x=x,dev_wires=self.dev_wires)\n",
+    "            qml.layer(EdgeListLayer, 1,[params[idx]],\\\n",
+    "                            dev_wires=self.dev_wires,\\\n",
+    "                            edge_list=self.edge_list)\n",
+    "        return qml.probs(wires=[self.dev_wires[ix] for ix in self.output_qubits])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "6e2e28f4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class basicQNN(binaryQNN):\n",
+    "    '''\n",
+    "    build a Quantum Neural Network where label extraction is done via bitstring probabilities\n",
+    "    using data re-uploading\n",
+    "    '''\n",
+    "    def __init__(self,**kwargs):\n",
+    "        super(basicQNN,self).__init__(**kwargs)\n",
+    "        self.loss_curve=[]\n",
+    "        self.accuracy_curve=[]\n",
+    "    \n",
+    "    def _reset_(self):\n",
+    "        self.coefs_=None\n",
+    "        self.loss_curve=[]\n",
+    "        self.accuracy_curve=[]\n",
+    "        \n",
+    "    def build_circuit(self,params,x=None):\n",
+    "        shape = (-1,len(self.dev_wires),3)\n",
+    "        params = np.asarray(params).reshape(shape)\n",
+    "        #x = np.resize(x, params.shape[0]-1)\n",
+    "        qml.layer(AngleEncodingLayer,1,x=x,dev_wires=self.dev_wires)\n",
+    "        for idx in range(params.shape[0]-1):\n",
+    "            qml.layer(EdgeListLayer, 1,[params[idx]],\\\n",
+    "                            dev_wires=self.dev_wires,\\\n",
+    "                            edge_list=self.edge_list)\n",
+    "        return qml.probs(wires=[self.dev_wires[ix] for ix in self.output_qubits])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cd236299",
+   "metadata": {},
+   "source": [
+    "# Example 1:  train a quantum classifier for binary classification "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "c35777b1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_layers = 6 # number of ansatz layers\n",
+    "n_qubits = 3 # number of qubits\n",
+    "max_steps= 15 # maximum number of epochs \n",
+    "alpha = 0.05\n",
+    "edge_list = [0,1],[2,1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "35b89f41",
+   "metadata": {},
+   "source": [
+    "So for these trial runs the QNN is built with 3 qubits.  Overall each feature vector needs to have shape (3,3). In the definition of the endcoding layer, the first step is to tile the passed feature vector-- this can be used to redundantly encode a feature (x) in severeal qubits. \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d33142b4",
+   "metadata": {},
+   "source": [
+    "To ensure that the features are encoded uniformly we need to add a 3rd dimension.\n",
+    "\n",
+    "Let's add a 3rd feature that is uninformative noise"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "f3787a4f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.55728475, 0.16374129, 0.03862261])"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X_train_padNoise = np.asarray(np.hstack((X_train,0.1*np.random.random((len(X_train),1))-0.05)),requires_grad=False)\n",
+    "X_test_padNoise = np.asarray(np.hstack((X_test,0.1*np.random.random((len(X_test),1))-0.05)),requires_grad=False)\n",
+    "\n",
+    "X_train_padNoise[0].numpy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "743ddefd",
+   "metadata": {},
+   "source": [
+    "Alternatively this 3rd dimension could have been all zero -- this will reduce the third gate in the angle encoding layer (RY) to an indentity gate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "5446fcbd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.55728475, 0.16374129, 0.        ])"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X_train_padZero = np.asarray(np.hstack((X_train,np.zeros((len(X_train),1)))),requires_grad=False)\n",
+    "X_test_padZero = np.asarray(np.hstack((X_test,np.zeros((len(X_test),1)))),requires_grad=False)\n",
+    "\n",
+    "X_train_padZero[0].numpy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1fa285eb",
+   "metadata": {},
+   "source": [
+    "Another option would be to only encode a single feature in a single qubit, and replace all remaining gates with identities"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "e7c29027",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.55728475, 0.16374129, 0.        , 0.        , 0.        ,\n",
+       "       0.        , 0.        , 0.        , 0.        ])"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X_train_dilute = np.asarray(np.hstack((X_train,np.zeros((len(X_train),7)))),requires_grad=False)\n",
+    "X_test_dilute = np.asarray(np.hstack((X_test,np.zeros((len(X_test),7)))),requires_grad=False)\n",
+    "\n",
+    "X_train_dilute[0].numpy()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "2c122285",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.49604095, 0.16534698, 0.        , 0.        , 0.        ,\n",
+       "       0.        , 0.        , 0.        , 0.        ])"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X_train_discrete = np.asarray(np.hstack((X_train_discrete,np.zeros((len(X_train_discrete),7)))),requires_grad=False)\n",
+    "X_test_discrete = np.asarray(np.hstack((X_test_discrete,np.zeros((len(X_test_discrete),7)))),requires_grad=False)\n",
+    "\n",
+    "X_train_discrete[0].numpy()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "eb859a93",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "basic_classifier_ = basicQNN(wires=n_qubits,shots=None,\\\n",
+    "                                  max_iter=max_steps,edge_list=edge_list,\\\n",
+    "                            layers=n_layers,batch_size=32,\\\n",
+    "                                 learning_rate=alpha\n",
+    "                            )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "26968f44",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'n_wires': 3,\n",
+       " 'n_layers': 6,\n",
+       " 'edge_list': ([0, 1], [2, 1]),\n",
+       " 'dev_wires': [tensor(0, requires_grad=True),\n",
+       "  tensor(1, requires_grad=True),\n",
+       "  tensor(2, requires_grad=True)],\n",
+       " 'n_shots': None,\n",
+       " 'coefs_': None,\n",
+       " 'output_qubits': [0],\n",
+       " 'device': <DefaultQubit device (wires=3, shots=None) at 0x1311a2a90>,\n",
+       " 'learning_rate': 0.05,\n",
+       " 'batch_size': 32,\n",
+       " 'max_iter': 15,\n",
+       " 'tol': 0.001,\n",
+       " 'wait_time': 10,\n",
+       " 'loss_curve': [],\n",
+       " 'accuracy_curve': []}"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "basic_classifier_.__dict__"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "4550ff80",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "initial loss and accuracy (random model):  0.9951733035724024 0.3625\n",
+      "Epoch:  1 | Loss: 0.605363 | Train accuracy: 0.693750\n",
+      "Epoch:  2 | Loss: 0.569405 | Train accuracy: 0.612500\n",
+      "Epoch:  3 | Loss: 0.558104 | Train accuracy: 0.693750\n",
+      "Epoch:  4 | Loss: 0.539677 | Train accuracy: 0.718750\n",
+      "Epoch:  5 | Loss: 0.544186 | Train accuracy: 0.718750\n",
+      "Epoch:  6 | Loss: 0.530777 | Train accuracy: 0.656250\n",
+      "Epoch:  7 | Loss: 0.532916 | Train accuracy: 0.668750\n",
+      "Epoch:  8 | Loss: 0.530325 | Train accuracy: 0.687500\n",
+      "Epoch:  9 | Loss: 0.530421 | Train accuracy: 0.693750\n",
+      "Epoch: 10 | Loss: 0.529168 | Train accuracy: 0.668750\n",
+      "Epoch: 11 | Loss: 0.529022 | Train accuracy: 0.675000\n",
+      "Epoch: 12 | Loss: 0.529404 | Train accuracy: 0.681250\n",
+      "Epoch: 13 | Loss: 0.528718 | Train accuracy: 0.668750\n",
+      "Epoch: 14 | Loss: 0.528669 | Train accuracy: 0.668750\n",
+      "Epoch: 15 | Loss: 0.528834 | Train accuracy: 0.675000\n"
+     ]
+    }
+   ],
+   "source": [
+    "basic_classifier_.fit(X_train_dilute,y_train,X_test_dilute,y_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "6ad9a3a0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bc_dilute_model = copy.deepcopy(basic_classifier_.__dict__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "413e93cb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "initial loss and accuracy (random model):  0.8946561361186868 0.475\n",
+      "Epoch:  1 | Loss: 0.563786 | Train accuracy: 0.718750\n",
+      "Epoch:  2 | Loss: 0.530503 | Train accuracy: 0.662500\n",
+      "Epoch:  3 | Loss: 0.514228 | Train accuracy: 0.706250\n",
+      "Epoch:  4 | Loss: 0.503182 | Train accuracy: 0.731250\n",
+      "Epoch:  5 | Loss: 0.497404 | Train accuracy: 0.731250\n",
+      "Epoch:  6 | Loss: 0.492449 | Train accuracy: 0.706250\n",
+      "Epoch:  7 | Loss: 0.487364 | Train accuracy: 0.743750\n",
+      "Epoch:  8 | Loss: 0.486383 | Train accuracy: 0.737500\n",
+      "Epoch:  9 | Loss: 0.486425 | Train accuracy: 0.743750\n",
+      "Epoch: 10 | Loss: 0.485516 | Train accuracy: 0.750000\n",
+      "Epoch: 11 | Loss: 0.485106 | Train accuracy: 0.743750\n",
+      "Epoch: 12 | Loss: 0.484911 | Train accuracy: 0.750000\n",
+      "Epoch: 13 | Loss: 0.484814 | Train accuracy: 0.743750\n",
+      "Epoch: 14 | Loss: 0.484794 | Train accuracy: 0.750000\n",
+      "Epoch: 15 | Loss: 0.484732 | Train accuracy: 0.750000\n"
+     ]
+    }
+   ],
+   "source": [
+    "basic_classifier_._reset_()\n",
+    "basic_classifier_.fit(X_train_discrete,y_train,X_test_discrete,y_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "e4d95ab8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bc_discrete_model = copy.deepcopy(basic_classifier_.__dict__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "b3b23811",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.0, 1.0)"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1728x864 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "f, ax = plt.subplots(ncols=2,figsize=(24,12))\n",
+    "\n",
+    "plt.rc('text',usetex=False)\n",
+    "plt.rc('font',family='serif')\n",
+    "plt.rc('xtick',labelsize=18)\n",
+    "plt.rc('ytick',labelsize=18)\n",
+    "plt.rc('legend',**{'numpoints':1,'fontsize':18,'handlelength':2})\n",
+    "\n",
+    "ax[0].plot(bc_dilute_model['loss_curve'],'r+',ms=25,label='train')\n",
+    "ax[0].plot(bc_dilute_model['loss_curve_test'],'b.',ms=25,label='test')\n",
+    "ax[0].set_ylim(0,1)\n",
+    "\n",
+    "ax[1].plot(bc_discrete_model['loss_curve'],'r+',ms=25,label='train')\n",
+    "ax[1].plot(bc_discrete_model['loss_curve_test'],'b.',ms=25,label='test')\n",
+    "ax[1].set_ylim(0,1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "78b68022",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred = basic_classifier_.make_predictions(bc_discrete_model['coefs_'],X_train_discrete)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "82274d68",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "xx, yy = np.meshgrid(np.arange(-np.pi, np.pi+0.1, 0.1), np.arange(-np.pi, np.pi+0.1, 0.1))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "ae20a8a0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "BC_boundary = basic_classifier_.make_predictions(bc_discrete_model['coefs_'],np.c_[xx.ravel(), yy.ravel(),np.zeros((len(xx.ravel()),7))])\n",
+    "BC_boundary = BC_boundary.reshape(xx.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "1afb36ed",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1728x864 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "f, ax = plt.subplots(ncols=2,figsize=(24,12))\n",
+    "\n",
+    "plt.rc('text',usetex=False)\n",
+    "plt.rc('font',family='serif')\n",
+    "plt.rc('xtick',labelsize=18)\n",
+    "plt.rc('ytick',labelsize=18)\n",
+    "plt.rc('legend',**{'numpoints':1,'fontsize':18,'handlelength':2})\n",
+    "\n",
+    "# add a big axis, hide frame\n",
+    "f.add_subplot(111,frameon=False) \n",
+    "# hide tick and tick label of the big axis\n",
+    "plt.tick_params(labelcolor='none', which='both', top=False, bottom=False, left=False, right=False)\n",
+    "\n",
+    "\n",
+    "f.subplots_adjust( wspace=0.1,hspace=0.2 )\n",
+    "\n",
+    "plot2d_data(X_train_discrete,y_train, fig=f, ax=ax[0])\n",
+    "plot2d_boundary_data(X_train_discrete,y_pred,xx,yy,BC_boundary, fig=f, ax=ax[1])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "da73a2ec",
+   "metadata": {},
+   "source": [
+    "A word of caution -- with the `QNN` class, the final trained model (i.e. parameters) are stored in `.coefs_`.  Also the loss trace and accuracies tracked during training are stored in `.loss_curve` and `.accuracy_curve`.  These can be saved to a file for future use.\n",
+    "\n",
+    "If you was to train on a different set of data, the training will start with those stored values.  To re-initialize the model  make sure to set `.coefs_ = None`, `.loss_curve=[]`, and `.accuracy_curve=[]`. This can be done using the `.reset()` method.\n",
+    "\n",
+    "For example, if you want to re-train the same QNN using the features padded with random noise."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "2b99b0e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "basic_classifier_._reset_()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "dbcaf9ba",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "initial loss and accuracy (random model):  0.7879930232973773 0.55\n",
+      "Epoch:  1 | Loss: 0.529834 | Train accuracy: 0.756250\n",
+      "Epoch:  2 | Loss: 0.468426 | Train accuracy: 0.806250\n",
+      "Epoch:  3 | Loss: 0.465213 | Train accuracy: 0.800000\n",
+      "Epoch:  4 | Loss: 0.461767 | Train accuracy: 0.800000\n",
+      "Epoch:  5 | Loss: 0.456449 | Train accuracy: 0.775000\n",
+      "Epoch:  6 | Loss: 0.452417 | Train accuracy: 0.793750\n",
+      "Epoch:  7 | Loss: 0.450744 | Train accuracy: 0.781250\n",
+      "Epoch:  8 | Loss: 0.449373 | Train accuracy: 0.787500\n",
+      "Epoch:  9 | Loss: 0.448215 | Train accuracy: 0.806250\n",
+      "Epoch: 10 | Loss: 0.447213 | Train accuracy: 0.800000\n",
+      "Epoch: 11 | Loss: 0.446798 | Train accuracy: 0.793750\n",
+      "Epoch: 12 | Loss: 0.446379 | Train accuracy: 0.806250\n",
+      "Epoch: 13 | Loss: 0.445944 | Train accuracy: 0.806250\n",
+      "Epoch: 14 | Loss: 0.445673 | Train accuracy: 0.806250\n",
+      "Epoch: 15 | Loss: 0.445504 | Train accuracy: 0.800000\n"
+     ]
+    }
+   ],
+   "source": [
+    "basic_classifier_.fit(X_train_padZero,y_train,X_test_padZero,y_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "e5871ac6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bc_padNoise_model = copy.deepcopy(basic_classifier_.__dict__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "f325cf74",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "BC_padNoise_boundary = basic_classifier_.make_predictions(bc_padNoise_model['coefs_'],np.c_[xx.ravel(), yy.ravel(),0.1*np.random.random((len(xx.ravel()),1))-0.05])\n",
+    "BC_padNoise_boundary = BC_padNoise_boundary.reshape(xx.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "374b3261",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "7345ed11",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1728x864 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "f, ax = plt.subplots(ncols=2,figsize=(24,12))\n",
+    "\n",
+    "plt.rc('text',usetex=False)\n",
+    "plt.rc('font',family='serif')\n",
+    "plt.rc('xtick',labelsize=18)\n",
+    "plt.rc('ytick',labelsize=18)\n",
+    "plt.rc('legend',**{'numpoints':1,'fontsize':18,'handlelength':2})\n",
+    "\n",
+    "ax[0].plot(basic_classifier_.loss_curve,'r+',ms=25,label='train')\n",
+    "ax[0].plot(basic_classifier_.loss_curve_test,'b.',ms=25,label='test')\n",
+    "ax[0].set_ylim(0,1)\n",
+    "\n",
+    "plot2d_boundary_data(X_train_padNoise,y_train,xx,yy,BC_padNoise_boundary, fig=f, ax=ax[1])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d685b1e8",
+   "metadata": {},
+   "source": [
+    "## Using a Data Re Uploading QNN\n",
+    "\n",
+    "The examples above can also be executed using the data re-uploading QNN.  The same processed features can be used.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da6d2e3f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dru_classifier_ = druQNN(wires=n_qubits,shots=None,\\\n",
+    "                                  max_iter=max_steps,edge_list=edge_list,\\\n",
+    "                            layers=n_layers,batch_size=32,\\\n",
+    "                                 learning_rate=alpha\n",
+    "                            )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3d154b3c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dru_classifier_.__dict__"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "370bb692",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dru_classifier_.fit(X_train_padNoise,y_train,X_test_padNoise,y_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9e666ee1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "f, ax = plt.subplots(ncols=2,figsize=(24,12))\n",
+    "\n",
+    "plt.rc('text',usetex=False)\n",
+    "plt.rc('font',family='serif')\n",
+    "plt.rc('xtick',labelsize=18)\n",
+    "plt.rc('ytick',labelsize=18)\n",
+    "plt.rc('legend',**{'numpoints':1,'fontsize':18,'handlelength':2})\n",
+    "\n",
+    "ax[0].plot(dru_classifier_.loss_curve,'r+',ms=25,label='train')\n",
+    "ax[0].plot(dru_classifier_.loss_curve_test,'b.',ms=25,label='test')\n",
+    "ax[0].set_title(\"Loss Curves\",fontsize=24)\n",
+    "ax[0].legend()\n",
+    "ax[1].plot(dru_classifier_.accuracy_curve,'r+',ms=25,label='train')\n",
+    "ax[1].plot(dru_classifier_.accuracy_curve_test,'b.',ms=25,label='test')\n",
+    "ax[1].set_title(\"Accuracy Curves\",fontsize=24)\n",
+    "ax[1].legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d0a026ed",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b94fe52",
+   "metadata": {},
+   "source": [
+    "## Using a set of text features\n",
+    "\n",
+    "The previous two datasets (`TwoMoons` and `noise`). This next example uses features extracted from the IMDB dataset for a text classifiation (discerning positive versus negative reviews).  The features in the external file `imdb_data_subset.csv` have been procesed using `doc2vec` to generate features of length 2. \n",
+    "\n",
+    "The full IMDB dataset contains 50K labeled examples.  But due to time, and for demonstration purposes we do not train over the entire dataset.  Instead, we only extract a small fraction of the dataset for training and testing. There are 1000 samples in the file `imdb_data_subset.csv` and they are shuffled already, so we can use simple slciing of the data samples. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cce1fab3",
+   "metadata": {},
+   "source": [
+    "## Import IMDB features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08cea959",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "imdb_data = pd.read_csv('imdb_data_subset.csv')\n",
+    "imdb_data = imdb_data.replace({'sentiment': {'positive': 1, 'negative': 0}}) #map the class labels to binary values\n",
+    "\n",
+    "\n",
+    "imdb_training_data = imdb_data.head(150)\n",
+    "imdb_training_features = np.asarray([np.asarray(eval(x)) for x in imdb_training_data.doc2vec.values],requires_grad=False)\n",
+    "imdb_training_features = rescale_features(imdb_training_features)\n",
+    "\n",
+    "imdb_training_labels = np.asarray([int(x) for x in imdb_training_data.sentiment.values])\n",
+    "\n",
+    "imdb_testing_data = imdb_data.tail(50)\n",
+    "imdb_testing_features = np.asarray([np.asarray(eval(x)) for x in imdb_testing_data.doc2vec.values],requires_grad=False)\n",
+    "imdb_testing_features = rescale_features(imdb_testing_features)\n",
+    "imdb_testing_labels = np.asarray([int(x) for x in imdb_testing_data.sentiment.values])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "057e681f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dru_classifier_._reset_()\n",
+    "dru_classifier_.fit(imdb_training_features,imdb_training_labels,imdb_testing_features,imdb_testing_labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9c090bf7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "f, ax = plt.subplots(ncols=2,figsize=(24,12))\n",
+    "\n",
+    "plt.rc('text',usetex=False)\n",
+    "plt.rc('font',family='serif')\n",
+    "plt.rc('xtick',labelsize=18)\n",
+    "plt.rc('ytick',labelsize=18)\n",
+    "plt.rc('legend',**{'numpoints':1,'fontsize':18,'handlelength':2})\n",
+    "\n",
+    "ax[0].plot(dru_classifier_.loss_curve,'r+',ms=25,label='train')\n",
+    "ax[0].plot(dru_classifier_.loss_curve_test,'b.',ms=25,label='test')\n",
+    "ax[0].set_title(\"Loss Curves\",fontsize=24)\n",
+    "ax[0].legend()\n",
+    "ax[1].plot(dru_classifier_.accuracy_curve,'r+',ms=25,label='train')\n",
+    "ax[1].plot(dru_classifier_.accuracy_curve_test,'b.',ms=25,label='test')\n",
+    "ax[1].set_title(\"Accuracy Curves\",fontsize=24)\n",
+    "ax[1].legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dd793cb5",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0fa7ff74",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9c30f36c",
+   "metadata": {},
+   "source": [
+    "# Multiclass Classification\n",
+    "\n",
+    "We can also use QNNs for multiclass classification.  The modifications needed for our exisitng `binaryQNN` class are:\n",
+    "* use Categorical Cross Entropy instead of Binary Cross Entropy\n",
+    "* Define a way to extract more than 2 labels\n",
+    "\n",
+    "The label extraction method we are choosing to use is implemented with 3 steps: \n",
+    "1) measure 3 qubits and generate a distribution over bitstrings (more than just `0` and `1`) \n",
+    "\n",
+    "2) downselecting the low weight bitstrings (`001`, `010`, `100`) \n",
+    "\n",
+    "3) renormalizing these amplitudes using a sigmoid function.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "72a247b5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class multiclassQNN(object):\n",
+    "    '''\n",
+    "    build a Quantum Neural Network where label extraction is done via bitstring probabilities\n",
+    "    '''\n",
+    "    def __init__(self, wires=3,layers=1,shots=None,edge_list=[],\\\n",
+    "                    max_iter=32,tol=1e-3,output_qubits=[0,1,2],\\\n",
+    "                        batch_size=16,learning_rate=0.05,coefs=None,**kwargs):\n",
+    "        self.n_wires = wires #QNN wires\n",
+    "        self.n_layers=layers #QNN layers\n",
+    "        self.edge_list=edge_list #Connectivity for the entangling layers\n",
+    "        self.dev_wires = [np.array(idx, requires_grad=True) for idx in range(self.n_wires)] #whole register\n",
+    "        self.n_shots=shots #samples to take to generate bitstring probabilities\n",
+    "        self.coefs_=coefs #stored model parameters\n",
+    "        assert wires>=len(output_qubits), 'need to add more qubits to your circuit'\n",
+    "        self.output_qubits = output_qubits #which qubits to measure for output\n",
+    "        self.device = qml.device(\"default.qubit\", wires=self.dev_wires,shots=self.n_shots) #Pennylane qubit device\n",
+    "        self.learning_rate=learning_rate # learning rate for optimizer\n",
+    "        self.batch_size=batch_size #batch size for batched gradient descent\n",
+    "        self.max_iter = max_iter #maximum number of epochs\n",
+    "        self.tol=tol #tolerance to detect early stopping\n",
+    "        self.wait_time = 10 #number of epochs with no change that triggers early stopping\n",
+    "        \n",
+    "    def build_circuit(self,*args, **kwds):\n",
+    "        raise NotImplementedError\n",
+    "        \n",
+    "    def initialize_params(self):\n",
+    "        params = 2.*np.pi*np.random.random(3*self.n_wires*self.n_layers)\n",
+    "        self.coefs_=params.copy()\n",
+    "        \n",
+    "    def accuracy_score(self,y_true, y_pred):\n",
+    "        \"\"\"Accuracy score.\n",
+    "\n",
+    "        Args:\n",
+    "            y_true (array[float]): 1-d array of targets\n",
+    "            y_predicted (array[float]): 1-d array of predictions\n",
+    "        Returns:\n",
+    "            score (float): the fraction of correctly classified samples\n",
+    "        \"\"\"\n",
+    "        if (y_true.ndim==1) and (y_pred.ndim==1):\n",
+    "            score = y_true == y_pred\n",
+    "        elif (y_true.ndim>1) and (y_pred.ndim==1):\n",
+    "            score = np.argmax(y_true,axis=1) == y_pred\n",
+    "        else:\n",
+    "            score = np.argmax(y_true,axis=1) == np.argmax(y_pred,axis=1)\n",
+    "        return score.sum() / len(score)\n",
+    "\n",
+    "    def softmax(self,P):\n",
+    "        \"\"\"Compute softmax values for each sets of scores in x.\"\"\"\n",
+    "        P = np.asarray(P).astype(float)\n",
+    "        e_x = np.exp(P - np.max(P))\n",
+    "        return e_x / e_x.sum()\n",
+    "\n",
+    "    def make_predictions(self,params,x):\n",
+    "        \"\"\"\n",
+    "        assign labels to some data features\n",
+    "        \"\"\"\n",
+    "        predicted = []\n",
+    "        qnode_ = qml.QNode(self.build_circuit, self.device)\n",
+    "        for i in range(len(x)):\n",
+    "            decoded = np.zeros(len(self.output_qubits))\n",
+    "            P = qnode_(params,x[i])\n",
+    "            w_states = [P[idc] for idc in [1,2,4]]  # downselect on low weight states\n",
+    "            decoded[np.argmax(self.softmax(w_states))]=1\n",
+    "            predicted.append(decoded)\n",
+    "        return np.array(predicted)\n",
+    "\n",
+    "    def class_probabilities(self,params,x):\n",
+    "        predicted = []\n",
+    "        qnode_ = qml.QNode(self.build_circuit, self.device)\n",
+    "        for i in range(len(x)):\n",
+    "            P = qnode_(params,x[i])\n",
+    "            w_states = [P[idc] for idc in [1,2,4]]  # downselect on low weight states\n",
+    "            class_probs=self.softmax(w_states)\n",
+    "            predicted.append(class_probs)\n",
+    "        return np.array(predicted)\n",
+    "\n",
+    "    def loss_function(self,params,x, y):\n",
+    "        \"\"\"\n",
+    "        Cost function to be minimized.\n",
+    "\n",
+    "        Args:\n",
+    "          params (array[float]): array of parameters\n",
+    "          x (array[float]): 2-d array of input vectors\n",
+    "          y (array[float]): 1-d array of targets\n",
+    "\n",
+    "        Returns:\n",
+    "          float: loss value to be minimized\n",
+    "        \"\"\"\n",
+    "        # Compute prediction for each input in data batch\n",
+    "        loss = 0.0\n",
+    "        qnode_ = qml.QNode(self.build_circuit, self.device)\n",
+    "        for i in range(len(x)):\n",
+    "            P = qnode_(params,x[i])\n",
+    "            w_states = [P[idc] for idc in [1,2,4]] # downselect on low weight states\n",
+    "            qp = self.softmax(w_states)\n",
+    "            yp = y[i] # one hot encoded label\n",
+    "            loss = loss - np.sum(yp * np.log(qp+10**-12))\n",
+    "        return loss / len(x)\n",
+    "\n",
+    "    def iterate_minibatches(self,inputs, targets, batch_size):\n",
+    "        \"\"\"\n",
+    "        A generator for batches of the input data\n",
+    "\n",
+    "        Args:\n",
+    "            inputs (array[float]): input data\n",
+    "            targets (array[float]): targets\n",
+    "\n",
+    "        Returns:\n",
+    "            inputs (array[float]): one batch of input data of length `batch_size`\n",
+    "            targets (array[float]): one batch of targets of length `batch_size`\n",
+    "        \"\"\"\n",
+    "        for start_idx in range(0, inputs.shape[0] - batch_size + 1, batch_size):\n",
+    "            idxs = slice(start_idx, start_idx + batch_size)\n",
+    "            yield inputs[idxs], targets[idxs]\n",
+    "            \n",
+    "    def fit(self,X,y,Xtest=None,ytest=None):\n",
+    "        \"\"\"\n",
+    "        implement gradient based training\n",
+    "        \"\"\"\n",
+    "        if (Xtest is not None) and (ytest is not None):\n",
+    "            #if you provide the testing data that will allso be used during evaluating hte loss and accuracy curves\n",
+    "            self.loss_curve_test = []\n",
+    "            self.accuracy_curve_test = []\n",
+    "            \n",
+    "        opt = qml.optimize.AdamOptimizer(self.learning_rate, beta1=0.9, beta2=0.999)\n",
+    "\n",
+    "        if self.coefs_ is None:\n",
+    "            # initialize random weights\n",
+    "            self.initialize_params()\n",
+    "            params = self.coefs_.copy()\n",
+    "        else:\n",
+    "            params = self.coefs_\n",
+    "\n",
+    "        if len(X)<self.batch_size:\n",
+    "            self.batch_size = int(len(X))\n",
+    "            print('WARNING: number of samples is smaller'+\\\n",
+    "             'than current batch size \\n '+\\\n",
+    "             'Resetting batch size for all trainings to: '+str(self.batch_size))\n",
+    "        loss = self.loss_function(params,X, y)\n",
+    "        preds = self.make_predictions(params,X)\n",
+    "        accuracy = self.accuracy_score(y, preds)\n",
+    "        print('initial loss and accuracy (random model): ',loss,accuracy)\n",
+    "        best_loss=loss\n",
+    "        best_accuracy=accuracy\n",
+    "        iter_count=0\n",
+    "\n",
+    "        for it in range(self.max_iter):\n",
+    "            for Xbatch, ybatch in self.iterate_minibatches(X, y, batch_size=self.batch_size):\n",
+    "                params = opt.step(lambda v: self.loss_function(v, Xbatch, ybatch), params)\n",
+    "                self.coefs_ = params.copy()\n",
+    "            # check for early stopping\n",
+    "            loss = self.loss_function(params,X, y)\n",
+    "            preds = self.make_predictions(params,X)\n",
+    "            accuracy = self.accuracy_score(y, preds)\n",
+    "            self.loss_curve.append(loss.numpy())\n",
+    "            self.accuracy_curve.append(accuracy.numpy())\n",
+    "            if (Xtest is not None) and (ytest is not None):\n",
+    "                self.loss_curve_test.append(self.loss_function(params,Xtest, ytest).numpy())\n",
+    "                testPreds=self.make_predictions(params,Xtest)\n",
+    "                self.accuracy_curve_test.append(self.accuracy_score(ytest,testPreds).numpy())\n",
+    "            if np.abs(best_loss-loss)<self.tol:\n",
+    "                iter_count+=1\n",
+    "            elif best_loss-loss>self.tol:\n",
+    "                best_loss = loss\n",
+    "                iter_count=0\n",
+    "            if iter_count>self.wait_time:\n",
+    "                print('early stopping ')\n",
+    "                print(\n",
+    "                  \"Epoch: {:2d} | Loss: {:3f} | Train accuracy: {:3f}\".format(\n",
+    "                      it+1, loss, accuracy\n",
+    "                  )\n",
+    "                )\n",
+    "                break\n",
+    "            else:\n",
+    "                print(\n",
+    "                      \"Epoch: {:2d} | Loss: {:3f} | Train accuracy: {:3f}\".format(\n",
+    "                          it+1, loss, accuracy\n",
+    "                      )\n",
+    "                    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3e6ea8be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class MultiClassDruQNN(multiclassQNN):\n",
+    "    '''\n",
+    "    build a Quantum Neural Network where label extraction is done via bitstring probabilities\n",
+    "    using data re-uploading\n",
+    "    '''\n",
+    "    def __init__(self, **kwargs):\n",
+    "        super(MultiClassDruQNN,self).__init__(**kwargs)\n",
+    "        self.loss_curve=[]\n",
+    "        self.accuracy_curve=[]\n",
+    "        \n",
+    "    def _reset_(self):\n",
+    "        self.coefs_=None\n",
+    "        self.loss_curve=[]\n",
+    "        self.accuracy_curve=[]\n",
+    "        \n",
+    "    def build_circuit(self,params,x=None):\n",
+    "        shape = (-1,len(self.dev_wires),3)\n",
+    "        params = np.asarray(params).reshape(shape)\n",
+    "        #x = np.resize(x, params.shape[0]-1)\n",
+    "        \n",
+    "        for idx in range(params.shape[0]-1):\n",
+    "            qml.layer(AngleEncodingLayer,1,x=x,dev_wires=self.dev_wires)\n",
+    "            qml.layer(EdgeListLayer, 1,[params[idx]],\\\n",
+    "                            dev_wires=self.dev_wires,\\\n",
+    "                            edge_list=self.edge_list)\n",
+    "        return qml.probs(wires=[self.dev_wires[ix] for ix in self.output_qubits])\n",
+    "\n",
+    "class MultiClassBasicQNN(multiclassQNN):\n",
+    "    '''\n",
+    "    build a Quantum Neural Network where label extraction is done via bitstring probabilities\n",
+    "    using data re-uploading\n",
+    "    '''\n",
+    "    def __init__(self,**kwargs):\n",
+    "        super(MultiClassBasicQNN,self).__init__(**kwargs)\n",
+    "        self.loss_curve=[]\n",
+    "        self.accuracy_curve=[]\n",
+    "    \n",
+    "    def _reset_(self):\n",
+    "        self.coefs_=None\n",
+    "        self.loss_curve=[]\n",
+    "        self.accuracy_curve=[]\n",
+    "        \n",
+    "    def build_circuit(self,params,x=None):\n",
+    "        shape = (-1,len(self.dev_wires),3)\n",
+    "        params = np.asarray(params).reshape(shape)\n",
+    "        #x = np.resize(x, params.shape[0]-1)\n",
+    "        qml.layer(AngleEncodingLayer,1,x=x,dev_wires=self.dev_wires)\n",
+    "        for idx in range(params.shape[0]-1):\n",
+    "            qml.layer(EdgeListLayer, 1,[params[idx]],\\\n",
+    "                            dev_wires=self.dev_wires,\\\n",
+    "                            edge_list=self.edge_list)\n",
+    "        return qml.probs(wires=[self.dev_wires[ix] for ix in self.output_qubits])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ddf653b8",
+   "metadata": {},
+   "source": [
+    "## Generate the Data\n",
+    "\n",
+    "For this example, we're going to use the random features, random labels dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "39fea3dc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "noise_train_features = (2*np.pi)*np.random.random((150,9)) #generate uniform random samples on [0,2pi]\n",
+    "noise_test_features = (2*np.pi)*np.random.random((50,9)) #generate uniform random samples on [0,2pi]\n",
+    "\n",
+    "noise_train_labels = np.asarray(np.random.choice(3, size=150, replace=True),requires_grad=False) #generate 3 random categorical labels\n",
+    "noise_test_labels = np.asarray(np.random.choice(3, size=50, replace=True),requires_grad=False) #generate 3 random categorical labels\n",
+    "\n",
+    "noise_onehot_train_labels = np.asarray(one_hot_encode_labels(noise_train_labels,3),requires_grad=False)\n",
+    "noise_onehot_test_labels = np.asarray(one_hot_encode_labels(noise_test_labels,3),requires_grad=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1dd04987",
+   "metadata": {},
+   "source": [
+    "# Build a Multiclass Classifier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee9f2e05",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_layers = 6 # number of ansatz layers\n",
+    "n_qubits = 3 # number of qubits\n",
+    "max_steps= 15 # maximum number of epochs \n",
+    "alpha = 0.05\n",
+    "edge_list = [0,1],[2,1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "11514907",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "multiclass_classifier_ = MultiClassDruQNN(wires=n_qubits,shots=None,\\\n",
+    "                                  max_iter=max_steps,edge_list=edge_list,\\\n",
+    "                            layers=n_layers,batch_size=32,\\\n",
+    "                                 learning_rate=alpha,output_qubits=[0,1,2]\n",
+    "                            )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e4661641",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "multiclass_classifier_.__dict__"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fcf7e8fe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "multiclass_classifier_.fit(noise_train_features,noise_onehot_train_labels,noise_test_features,noise_onehot_test_labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "751be9c1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "f, ax = plt.subplots(ncols=2,figsize=(24,12))\n",
+    "\n",
+    "plt.rc('text',usetex=False)\n",
+    "plt.rc('font',family='serif')\n",
+    "plt.rc('xtick',labelsize=18)\n",
+    "plt.rc('ytick',labelsize=18)\n",
+    "plt.rc('legend',**{'numpoints':1,'fontsize':18,'handlelength':2})\n",
+    "\n",
+    "ax[0].plot(multiclass_classifier_.loss_curve,'r+',ms=25,label='train')\n",
+    "ax[0].plot(multiclass_classifier_.loss_curve_test,'b.',ms=25,label='test')\n",
+    "ax[0].set_title(\"Loss Curves\",fontsize=24)\n",
+    "ax[0].legend()\n",
+    "ax[1].plot(multiclass_classifier_.accuracy_curve,'r+',ms=25,label='train')\n",
+    "ax[1].plot(multiclass_classifier_.accuracy_curve_test,'b.',ms=25,label='test')\n",
+    "ax[1].set_title(\"Accuracy Curves\",fontsize=24)\n",
+    "ax[1].legend()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3dea5110",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "predicted_train_labels = multiclass_classifier_.make_predictions(multiclass_classifier_.coefs_,noise_train_features)\n",
+    "predicted_test_labels = multiclass_classifier_.make_predictions(multiclass_classifier_.coefs_,noise_test_features)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e30b1ed7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "predicted_train_categorical = np.argmax(predicted_train_labels,axis=1)\n",
+    "predicted_test_categorical = np.argmax(predicted_test_labels,axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "00dac179",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "temp_train = np.argmax(noise_onehot_train_labels,axis=1)\n",
+    "temp_test = np.argmax(noise_onehot_test_labels,axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3b585c94",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sns.heatmap(confusion_matrix(temp,temp,normalize='all'),annot=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36f01022",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sns.heatmap(confusion_matrix(temp_train,predicted_train_categorical,normalize='all'),annot=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8b09522d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sns.heatmap(confusion_matrix(temp_test,predicted_test_categorical,normalize='all'),annot=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e9c42b11",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "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.8.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}