Noise_[4_ary]_zz_template.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "oaYVuKnhWLB9"
   },
   "outputs": [],
   "source": [
    "device = \"cpu\"\n",
    "# device = \"cuda\"\n",
    "import time,os,copy,torch,torchvision\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets, transforms\n",
    "from tqdm import tqdm\n",
    "import pickle\n",
    "import pennylane as qml\n",
    "from pennylane import numpy as np\n",
    "\n",
    "torch.manual_seed(42)\n",
    "np.random.seed(42)\n",
    "\n",
    "# Plotting\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# OpenMP: number of parallel threads.\n",
    "os.environ[\"OMP_NUM_THREADS\"] = \"16\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "THJBENVKRYSJ",
    "outputId": "f9a08146-cda9-4b88-ca1a-347c61ea92fb"
   },
   "outputs": [],
   "source": [
    "n_qubits = 6                # Number of qubits\n",
    "nqubits = n_qubits          \n",
    "batch_size = 4              # Number of samples for each training step\n",
    "q_depth = 1                 # Depth of the quantum circuit (number of variational layers)\n",
    "q_delta = 0.01              # Initial spread of random quantum weights\n",
    "\n",
    "tensor_length = n_qubits*(n_qubits-1)*q_depth+n_qubits*(q_depth-1)\n",
    "print(tensor_length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XYFDgRZ3YNcv"
   },
   "outputs": [],
   "source": [
    "def H_layer(nqubits):\n",
    "    for idx in range(nqubits):\n",
    "        qml.Hadamard(wires=idx)\n",
    "\n",
    "def RZ_layer(w):\n",
    "    for idx, element in enumerate(w):\n",
    "        qml.RZ(element, wires=idx)\n",
    "\n",
    "def entangling_layer(nqubits,weights):\n",
    "    p = nqubits\n",
    "    weights_ = (weight for weight in weights)\n",
    "    for i in range(1,nqubits):\n",
    "        for j in range(i):\n",
    "            qml.CNOT(wires=[j,i])\n",
    "            param = next(weights_)\n",
    "            qml.RZ(param, wires=i)\n",
    "            p+=1\n",
    "            param = next(weights_)\n",
    "            qml.RX(param, wires=i)\n",
    "            p+=1\n",
    "            qml.CNOT(wires=[j,i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AoUoGHoFV8rI"
   },
   "outputs": [],
   "source": [
    "dev = qml.device(\"default.qubit\", wires=n_qubits)\n",
    "@qml.qnode(dev, interface=\"torch\")\n",
    "\n",
    "def quantum_net(q_input_features, q_weights_flat):\n",
    "    q_weights = q_weights_flat\n",
    "    H_layer(n_qubits)\n",
    "    RZ_layer(q_input_features)\n",
    "    entangling_layer(nqubits,q_weights)\n",
    "    exp_vals = [qml.expval(qml.PauliZ(position)) for position in range(n_qubits)]\n",
    "    return tuple(exp_vals)\n",
    "    \n",
    "class DressedQuantumNet(nn.Module):\n",
    "\n",
    "    def __init__(self):\n",
    "\n",
    "        super().__init__()\n",
    "        self.pre_net = nn.Linear(128, n_qubits)\n",
    "        self.q_params = nn.Parameter(q_delta * torch.randn(tensor_length))\n",
    "        self.post_net = nn.Linear(n_qubits, 5)\n",
    "\n",
    "    def forward(self, input_features):\n",
    "\n",
    "        pre_out = self.pre_net(input_features)\n",
    "        q_in = torch.tanh(pre_out) * np.pi / 2.0\n",
    "\n",
    "        q_out = torch.Tensor(0, n_qubits)\n",
    "        q_out = q_out.to(device)\n",
    "        for elem in q_in:\n",
    "            q_out_elem = quantum_net(elem, self.q_params).float().unsqueeze(0)\n",
    "            q_out = torch.cat((q_out, q_out_elem))\n",
    "\n",
    "        return self.post_net(q_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DressedClassicalNet(nn.Module):\n",
    "\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.pre_net = nn.Linear(128, 6)\n",
    "        self.mid_net = nn.Linear(6,6)\n",
    "        self.post_net = nn.Linear(6, 5)\n",
    "\n",
    "    def forward(self, input_features):\n",
    "\n",
    "        pre_out = self.pre_net(input_features)\n",
    "        q_in = torch.tanh(pre_out) * np.pi / 2.0\n",
    "        mid_out = self.mid_net(q_in)\n",
    "        return self.post_net(mid_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Oe15V30yVwln"
   },
   "outputs": [],
   "source": [
    "# model_hybrid = copy.deepcopy(torch.nn.Sequential(*(list(spikeaware_model.children())[:-1])))\n",
    "# for param in model_hybrid.parameters():\n",
    "#     param.requires_grad = False\n",
    "# # Notice that model_hybrid.fc is the last layer of ResNet18\n",
    "# model_hybrid.fc = DressedQuantumNet()\n",
    "\n",
    "# # Use CUDA or CPU according to the \"device\" object.\n",
    "# model_hybrid = model_hybrid.to(device)\n",
    "# display(model_hybrid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "BBqhpzaiuuWC"
   },
   "outputs": [],
   "source": [
    "class_names = [\n",
    "    \"6\",\n",
    "    \"7\",\n",
    "    \"8\",\n",
    "    \"9\",\n",
    "]\n",
    "num_classes = len(class_names)\n",
    "\n",
    "import idx2numpy \n",
    "import numpy as np \n",
    "arr3 = []\n",
    "arr4 = []\n",
    "file1 = './MNIST/TorchvisionDatasetWrapper/raw/train-images-idx3-ubyte' \n",
    "# file1 = './HybridQSNN/EMNIST/raw/gzip/emnist-digits-train-images-idx3-ubyte'\n",
    "arr = idx2numpy.convert_from_file(file1)\n",
    "# file2 = './HybridQSNN/EMNIST/raw/gzip/emnist-digits-train-labels-idx1-ubyte' \n",
    "file2 = './MNIST/TorchvisionDatasetWrapper/raw/train-labels-idx1-ubyte' \n",
    "arr2 = idx2numpy.convert_from_file(file2)\n",
    "for i in range(len(arr)):\n",
    "    if arr2[i] in [6,7,8,9]:\n",
    "        arr3.append(arr[i])\n",
    "        arr4.append(arr2[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "9XrbmsLB_sbt",
    "outputId": "0f98cf2f-4bfe-4e51-969c-2a88d4906f98"
   },
   "outputs": [],
   "source": [
    "n_steps = 10\n",
    "train_images = np.asarray(arr3,dtype=np.float32) / 255.0\n",
    "train_labels = np.asarray(arr4,dtype=np.int64)\n",
    "train_labels -= 6\n",
    "display(train_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rTWUCvCTifg7"
   },
   "source": [
    "These are the 4 classes that we perform the classification on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 785
    },
    "id": "5iOn-WphsNw8",
    "outputId": "9277593a-828b-4576-fb53-809abaa041a5"
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10, 10))\n",
    "for i in range(25):\n",
    "    plt.subplot(5, 5, i + 1)\n",
    "    plt.imshow(train_images[i], cmap=plt.cm.binary)\n",
    "    plt.axis(\"off\")\n",
    "    plt.title(class_names[train_labels[i]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "f-WhMWC7pHOf",
    "outputId": "a057c498-a7ba-49a0-fdb0-f6950fee0826"
   },
   "outputs": [],
   "source": [
    "# test_sequences = train_sequences[:int(len(train_sequences)*0.3)]\n",
    "# test_labels = train_labels[:int(len(train_labels)*0.3)]\n",
    "# train_sequences = train_sequences[int(len(train_sequences)*0.7):]\n",
    "# train_labels = train_labels[int(len(train_labels)*0.7):]\n",
    "split = np.array_split(train_images,[int(len(train_images)*0.7)])\n",
    "train_sequences = split[0]\n",
    "test_sequences = split[1]\n",
    "print(len(split[0]),len(split[1]))\n",
    "split = np.array_split(train_labels,[int(len(train_labels)*0.7)])\n",
    "train_labels = split[0]\n",
    "test_labels = split[1]\n",
    "print(len(split[0]),len(split[1]))\n",
    "datalength = 5000\n",
    "\n",
    "train_sequences = np.tile(train_sequences[:, None], (1, n_steps, 1, 1))[:datalength]\n",
    "test_sequences = np.tile(test_sequences[:, None], (1, n_steps, 1, 1))\n",
    "train_labels = train_labels[:datalength]\n",
    "test_labels = test_labels\n",
    "\n",
    "print(len(test_labels),len(test_sequences),len(train_labels),len(train_sequences))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_hybrid=torch.load(\"./model_saves/4_class_KMNIST/6x2_zz_24_0.9641426205635071_0.1356203258037567.h5\")\n",
    "display(model_hybrid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZhhDI8qczWjQ"
   },
   "source": [
    "Here we try to add salt & pepper noise to the test_sequences and then we test our model on them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qQIEkKCi1t9C"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "def salt_pepper(test_sequences,test_labels,prob,salt=0,pepper=1):\n",
    "  sampled_images = copy.deepcopy(test_sequences)\n",
    "  sampled_labels = copy.deepcopy(test_labels)\n",
    "  for j in range(len(test_labels)):\n",
    "    for i in range(np.shape(sampled_images[j])[0]):\n",
    "      for y in range(28):\n",
    "        for x in range(28):\n",
    "          r = random.random() \n",
    "          if r < prob:\n",
    "            sampled_images[j][i][y][x] = salt\n",
    "          elif r > 1-prob:\n",
    "            sampled_images[j][i][y][x] = pepper\n",
    "  return sampled_images,sampled_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tRYGLE_fEouB"
   },
   "outputs": [],
   "source": [
    "def test_noise(input_model,prob,salt=0,pepper=1):\n",
    "    test_x , tst_labels = salt_pepper(test_sequences,test_labels,prob=prob,salt=0,pepper=1)\n",
    "    minibatch_size = 32\n",
    "    optimizer = torch.optim.Adam(input_model.parameters())\n",
    "\n",
    "    input_model.eval()\n",
    "    test_acc = 0\n",
    "    for i in range(test_x.shape[0] // minibatch_size):\n",
    "        batch_in = test_x[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        batch_in = batch_in.reshape((-1,) + test_x.shape[1:-2] + (784,))\n",
    "        batch_label = tst_labels[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        output = input_model(torch.tensor(batch_in))\n",
    "\n",
    "        test_acc += torch.mean(\n",
    "            torch.eq(torch.argmax(output, dim=1), torch.tensor(batch_label)).float()\n",
    "        )\n",
    "\n",
    "    test_acc /= i + 1\n",
    "\n",
    "    print(\"Test accuracy:\", test_acc.numpy())\n",
    "    print('here is a random image from the generated noisy data:')\n",
    "    r=random.randint(0,9000)\n",
    "    plt.title(str(class_names[tst_labels[r]]))\n",
    "    plt.imshow(test_x[r][0],cmap=plt.cm.binary)\n",
    "\n",
    "    # return test_x,tst_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "3LPfcJEahdF2",
    "outputId": "4c14808c-b1f7-4c40-b58d-058fc3e5a880"
   },
   "outputs": [],
   "source": [
    "test_noise(model_hybrid,prob=0.01,salt=0,pepper=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "bUbY6op_hhoR",
    "outputId": "0cb5f2c5-da12-4e2c-9ee0-6e60b291e6ee"
   },
   "outputs": [],
   "source": [
    "test_noise(model_hybrid,prob=0.02,salt=0,pepper=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "bdjHGf4Ghqv2",
    "outputId": "913dac1e-e2ca-4c11-dc86-b597a2557df1"
   },
   "outputs": [],
   "source": [
    "test_noise(model_hybrid,prob=0.03,salt=0,pepper=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "n9KHOI7dhrW-",
    "outputId": "1c5ba849-69b6-4a12-a550-09f144b57dd3"
   },
   "outputs": [],
   "source": [
    "test_noise(model_hybrid,prob=0.04,salt=0,pepper=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "-oLQQB9zhr7L",
    "outputId": "0f24a201-bece-4a9f-b6bb-8df3870edde8"
   },
   "outputs": [],
   "source": [
    "test_noise(model_hybrid,prob=0.05,salt=0,pepper=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "zm7UVxhehsnu",
    "outputId": "837caf15-7ca0-4bcf-a488-9f943dc1234f"
   },
   "outputs": [],
   "source": [
    "test_noise(model_hybrid,prob=0.06,salt=0,pepper=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "2BprJspriArZ",
    "outputId": "d6555c1f-4604-408c-a593-c4d76a39ebf5"
   },
   "outputs": [],
   "source": [
    "test_noise(model_hybrid,prob=0.07,salt=0,pepper=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "zOOnk41biBUd",
    "outputId": "d1e24a7e-8ba2-46e2-c85b-23e83c5e8321"
   },
   "outputs": [],
   "source": [
    "test_noise(model_hybrid,prob=0.08,salt=0,pepper=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "h3PjhMpyiI6M",
    "outputId": "e872ef41-5124-4cdc-a3b2-37796fca38bf"
   },
   "outputs": [],
   "source": [
    "test_noise(model_hybrid,prob=0.09,salt=0,pepper=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "LEFXOYZRdD8A",
    "outputId": "9f0dbe7f-9281-4d68-fd94-6625bb92b344"
   },
   "outputs": [],
   "source": [
    "test_noise(model_hybrid,prob=0.1,salt=0,pepper=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "j5s1j236lMib",
    "outputId": "81ef7007-f9ee-4e62-dcd0-d687a65858b1"
   },
   "outputs": [],
   "source": [
    "test_noise(model_hybrid,prob=0.2,salt=0,pepper=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "wjq5Zw_2EeMD",
    "outputId": "7b8e32b4-be9f-4244-ef72-bb634d863448"
   },
   "outputs": [],
   "source": [
    "test_noise(model_hybrid,prob=0.3,salt=0,pepper=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "FQVJkHB4IL_j",
    "outputId": "e6777322-36ec-4e39-d7f8-d74c4ca8ab4c"
   },
   "outputs": [],
   "source": [
    "test_noise(model_hybrid,prob=0.3,salt=0,pepper=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "TbsWYSROJC3V",
    "outputId": "9efff25e-8a42-4568-9f76-dc9265abd4e7"
   },
   "outputs": [],
   "source": [
    "test_noise(model_hybrid,prob=0.4,salt=0,pepper=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "OmZsTg9zJYTj",
    "outputId": "9221ed78-6a3a-4ec3-8908-eab28aeafa8f"
   },
   "outputs": [],
   "source": [
    "test_noise(model_hybrid,prob=0.5,salt=0,pepper=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Kc7C0YWF-VBG"
   },
   "source": [
    "--------x-------------x------------x------------x-------------x-------------x--------------------x--------------x--------x-------------x------------x------------x-------------x-------------x--------------------x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cniWJU2QkIm-"
   },
   "source": [
    "In the next section we add gaussian noise to the images:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "5O4D0I4Tv_2l",
    "outputId": "e370c3c8-7c9d-4d21-e439-cdd090706755"
   },
   "outputs": [],
   "source": [
    "sampled_images = copy.deepcopy(test_sequences)\n",
    "sampled_labels = copy.deepcopy(test_labels)\n",
    "sigma = 0.2**0.5\n",
    "mean = 0\n",
    "for j in range(len(test_labels)):\n",
    "  for _ in range(len(sampled_images[j])):\n",
    "    im = sampled_images[j][_] \n",
    "    row,col = sampled_images[j][_].shape\n",
    "    # gauss = np.array(np.random.normal(mean,sigma,size=(28,28))).reshape(row,col)\n",
    "    gauss = np.array(np.random.randn(row*col)) #* var ** 0.5 + mean\n",
    "    gauss = gauss*sigma + mean\n",
    "    gauss = gauss.reshape(row,col)\n",
    "    sampled_images[j][_] = sampled_images[j][_] + gauss\n",
    "r=np.random.randint(0,9000)\n",
    "def test_noise(input_model):\n",
    "    # test_x , tst_labels = gaussian_noise(test_sequences,test_labels,mean =mean,var = var)\n",
    "    test_x , tst_labels =sampled_images,test_labels\n",
    "    minibatch_size = 32\n",
    "    optimizer = torch.optim.Adam(input_model.parameters())\n",
    "\n",
    "    input_model.eval()\n",
    "    test_acc = 0\n",
    "    for i in range(test_x.shape[0] // minibatch_size):\n",
    "        batch_in = test_x[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        batch_in = batch_in.reshape((-1,) + test_x.shape[1:-2] + (784,))\n",
    "        batch_label = tst_labels[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        output = input_model(torch.tensor(batch_in))\n",
    "\n",
    "        test_acc += torch.mean(\n",
    "            torch.eq(torch.argmax(output, dim=1), torch.tensor(batch_label)).float()\n",
    "        )\n",
    "\n",
    "    test_acc /= i + 1\n",
    "\n",
    "    print(\"Test accuracy:\", test_acc.numpy())\n",
    "    print('here is a random image from the generated noisy data:')\n",
    "    r=np.random.randint(0,9000)\n",
    "\n",
    "test_noise(model_hybrid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "K5GdFGxTaJDW",
    "outputId": "a1ee64f8-7e97-42f4-db07-34be049de9b7"
   },
   "outputs": [],
   "source": [
    "sampled_images = copy.deepcopy(test_sequences)\n",
    "sampled_labels = copy.deepcopy(test_labels)\n",
    "sigma = 0.2**0.5\n",
    "mean = 0\n",
    "for j in range(len(test_labels)):\n",
    "  for _ in range(len(sampled_images[j])):\n",
    "    im = sampled_images[j][_] \n",
    "    row,col = sampled_images[j][_].shape\n",
    "    # gauss = np.array(np.random.normal(mean,sigma,size=(28,28))).reshape(row,col)\n",
    "    gauss = np.array(np.random.randn(row*col)) #* var ** 0.5 + mean\n",
    "    gauss = gauss*sigma + mean\n",
    "    gauss = gauss.reshape(row,col)\n",
    "    sampled_images[j][_] = sampled_images[j][_] + gauss\n",
    "r=np.random.randint(0,9000)\n",
    "plt.title(str(class_names[test_labels[r]]))\n",
    "plt.imshow(sampled_images[r][0],cmap=plt.cm.binary)\n",
    "def test_noise(input_model):\n",
    "    # test_x , tst_labels = gaussian_noise(test_sequences,test_labels,mean =mean,var = var)\n",
    "    test_x , tst_labels =sampled_images,test_labels\n",
    "    minibatch_size = 32\n",
    "    optimizer = torch.optim.Adam(input_model.parameters())\n",
    "\n",
    "    input_model.eval()\n",
    "    test_acc = 0\n",
    "    for i in range(test_x.shape[0] // minibatch_size):\n",
    "        batch_in = test_x[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        batch_in = batch_in.reshape((-1,) + test_x.shape[1:-2] + (784,))\n",
    "        batch_label = tst_labels[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        output = input_model(torch.tensor(batch_in))\n",
    "\n",
    "        test_acc += torch.mean(\n",
    "            torch.eq(torch.argmax(output, dim=1), torch.tensor(batch_label)).float()\n",
    "        )\n",
    "\n",
    "    test_acc /= i + 1\n",
    "\n",
    "    print(\"Test accuracy:\", test_acc.numpy())\n",
    "    print('here is a random image from the generated noisy data:')\n",
    "    r=np.random.randint(0,9000)\n",
    "    plt.title(str(class_names[tst_labels[r]]))\n",
    "    plt.imshow(test_x[r][0],cmap=plt.cm.binary)\n",
    "\n",
    "    # return test_x,tst_labels\n",
    "test_noise(model_hybrid)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "dSU56mNmaNNj",
    "outputId": "acac1747-9f84-47d7-9f3d-40716ff4eaf5"
   },
   "outputs": [],
   "source": [
    "sampled_images = copy.deepcopy(test_sequences)\n",
    "sampled_labels = copy.deepcopy(test_labels)\n",
    "sigma = 0.3**0.5\n",
    "mean = 0\n",
    "for j in range(len(test_labels)):\n",
    "  for _ in range(len(sampled_images[j])):\n",
    "    im = sampled_images[j][_] \n",
    "    row,col = sampled_images[j][_].shape\n",
    "    # gauss = np.array(np.random.normal(mean,sigma,size=(28,28))).reshape(row,col)\n",
    "    gauss = np.array(np.random.randn(row*col)) #* var ** 0.5 + mean\n",
    "    gauss = gauss*sigma + mean\n",
    "    gauss = gauss.reshape(row,col)\n",
    "    sampled_images[j][_] = sampled_images[j][_] + gauss\n",
    "r=np.random.randint(0,9000)\n",
    "plt.title(str(class_names[test_labels[r]]))\n",
    "plt.imshow(sampled_images[r][0],cmap=plt.cm.binary)\n",
    "def test_noise(input_model):\n",
    "    # test_x , tst_labels = gaussian_noise(test_sequences,test_labels,mean =mean,var = var)\n",
    "    test_x , tst_labels =sampled_images,test_labels\n",
    "    minibatch_size = 32\n",
    "    optimizer = torch.optim.Adam(input_model.parameters())\n",
    "\n",
    "    input_model.eval()\n",
    "    test_acc = 0\n",
    "    for i in range(test_x.shape[0] // minibatch_size):\n",
    "        batch_in = test_x[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        batch_in = batch_in.reshape((-1,) + test_x.shape[1:-2] + (784,))\n",
    "        batch_label = tst_labels[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        output = input_model(torch.tensor(batch_in))\n",
    "\n",
    "        test_acc += torch.mean(\n",
    "            torch.eq(torch.argmax(output, dim=1), torch.tensor(batch_label)).float()\n",
    "        )\n",
    "\n",
    "    test_acc /= i + 1\n",
    "\n",
    "    print(\"Test accuracy:\", test_acc.numpy())\n",
    "    print('here is a random image from the generated noisy data:')\n",
    "    r=np.random.randint(0,9000)\n",
    "    plt.title(str(class_names[tst_labels[r]]))\n",
    "    plt.imshow(test_x[r][0],cmap=plt.cm.binary)\n",
    "\n",
    "    # return test_x,tst_labels\n",
    "test_noise(model_hybrid)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "IuuCRntZaOxs",
    "outputId": "647e4334-d232-491b-b127-e4ef18ac318f"
   },
   "outputs": [],
   "source": [
    "sampled_images = copy.deepcopy(test_sequences)\n",
    "sampled_labels = copy.deepcopy(test_labels)\n",
    "sigma = 0.4**0.5\n",
    "mean = 0\n",
    "\n",
    "for j in range(len(test_labels)):\n",
    "  for _ in range(len(sampled_images[j])):\n",
    "    im = sampled_images[j][_] \n",
    "    row,col = sampled_images[j][_].shape\n",
    "    # gauss = np.array(np.random.normal(mean,sigma,size=(28,28))).reshape(row,col)\n",
    "    gauss = np.array(np.random.randn(row*col)) #* var ** 0.5 + mean\n",
    "    gauss = gauss*sigma + mean\n",
    "    gauss = gauss.reshape(row,col)\n",
    "    sampled_images[j][_] = sampled_images[j][_] + gauss\n",
    "r=np.random.randint(0,9000)\n",
    "plt.title(str(class_names[test_labels[r]]))\n",
    "plt.imshow(sampled_images[r][0],cmap=plt.cm.binary)\n",
    "\n",
    "def test_noise(input_model):\n",
    "    # test_x , tst_labels = gaussian_noise(test_sequences,test_labels,mean =mean,var = var)\n",
    "    test_x , tst_labels =sampled_images,test_labels\n",
    "    minibatch_size = 32\n",
    "    optimizer = torch.optim.Adam(input_model.parameters())\n",
    "\n",
    "    input_model.eval()\n",
    "    test_acc = 0\n",
    "    for i in range(test_x.shape[0] // minibatch_size):\n",
    "        batch_in = test_x[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        batch_in = batch_in.reshape((-1,) + test_x.shape[1:-2] + (784,))\n",
    "        batch_label = tst_labels[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        output = input_model(torch.tensor(batch_in))\n",
    "\n",
    "        test_acc += torch.mean(\n",
    "            torch.eq(torch.argmax(output, dim=1), torch.tensor(batch_label)).float()\n",
    "        )\n",
    "\n",
    "    test_acc /= i + 1\n",
    "\n",
    "    print(\"Test accuracy:\", test_acc.numpy())\n",
    "    print('here is a random image from the generated noisy data:')\n",
    "    r=np.random.randint(0,9000)\n",
    "    plt.title(str(class_names[tst_labels[r]]))\n",
    "    plt.imshow(test_x[r][0],cmap=plt.cm.binary)\n",
    "\n",
    "    # return test_x,tst_labels\n",
    "test_noise(model_hybrid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "Sb8-sQR-aQOJ",
    "outputId": "fdc5ea0a-0397-4e5a-a051-148260c92c03"
   },
   "outputs": [],
   "source": [
    "sampled_images = copy.deepcopy(test_sequences)\n",
    "sampled_labels = copy.deepcopy(test_labels)\n",
    "sigma = 0.5**0.5\n",
    "mean = 0\n",
    "for j in range(len(test_labels)):\n",
    "  for _ in range(len(sampled_images[j])):\n",
    "    im = sampled_images[j][_] \n",
    "    row,col = sampled_images[j][_].shape\n",
    "    # gauss = np.array(np.random.normal(mean,sigma,size=(28,28))).reshape(row,col)\n",
    "    gauss = np.array(np.random.randn(row*col)) #* var ** 0.5 + mean\n",
    "    gauss = gauss*sigma + mean\n",
    "    gauss = gauss.reshape(row,col)\n",
    "    sampled_images[j][_] = sampled_images[j][_] + gauss\n",
    "r=np.random.randint(0,9000)\n",
    "plt.title(str(class_names[test_labels[r]]))\n",
    "plt.imshow(sampled_images[r][0],cmap=plt.cm.binary)\n",
    "def test_noise(input_model):\n",
    "    # test_x , tst_labels = gaussian_noise(test_sequences,test_labels,mean =mean,var = var)\n",
    "    test_x , tst_labels =sampled_images,test_labels\n",
    "    minibatch_size = 32\n",
    "    optimizer = torch.optim.Adam(input_model.parameters())\n",
    "\n",
    "    input_model.eval()\n",
    "    test_acc = 0\n",
    "    for i in range(test_x.shape[0] // minibatch_size):\n",
    "        batch_in = test_x[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        batch_in = batch_in.reshape((-1,) + test_x.shape[1:-2] + (784,))\n",
    "        batch_label = tst_labels[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        output = input_model(torch.tensor(batch_in))\n",
    "\n",
    "        test_acc += torch.mean(\n",
    "            torch.eq(torch.argmax(output, dim=1), torch.tensor(batch_label)).float()\n",
    "        )\n",
    "\n",
    "    test_acc /= i + 1\n",
    "\n",
    "    print(\"Test accuracy:\", test_acc.numpy())\n",
    "    print('here is a random image from the generated noisy data:')\n",
    "    r=np.random.randint(0,9000)\n",
    "    plt.title(str(class_names[tst_labels[r]]))\n",
    "    plt.imshow(test_x[r][0],cmap=plt.cm.binary)\n",
    "\n",
    "    # return test_x,tst_labels\n",
    "test_noise(model_hybrid)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 409
    },
    "id": "s_o7FszHaTiW",
    "outputId": "f2d727f3-4d06-422c-83a6-5013c794a9c0"
   },
   "outputs": [],
   "source": [
    "sampled_images = copy.deepcopy(test_sequences)\n",
    "sampled_labels = copy.deepcopy(test_labels)\n",
    "sigma = 0.6**0.5\n",
    "mean = 0\n",
    "for j in range(len(test_labels)):\n",
    "  for _ in range(len(sampled_images[j])):\n",
    "    im = sampled_images[j][_] \n",
    "    row,col = sampled_images[j][_].shape\n",
    "    # gauss = np.array(np.random.normal(mean,sigma,size=(28,28))).reshape(row,col)\n",
    "    gauss = np.array(np.random.randn(row*col)) #* var ** 0.5 + mean\n",
    "    gauss = gauss*sigma + mean\n",
    "    gauss = gauss.reshape(row,col)\n",
    "    sampled_images[j][_] = sampled_images[j][_] + gauss\n",
    "r=np.random.randint(0,9000)\n",
    "plt.title(str(class_names[test_labels[r]]))\n",
    "plt.imshow(sampled_images[r][0],cmap=plt.cm.binary)\n",
    "def test_noise(input_model):\n",
    "    # test_x , tst_labels = gaussian_noise(test_sequences,test_labels,mean =mean,var = var)\n",
    "    test_x , tst_labels =sampled_images,test_labels\n",
    "    minibatch_size = 32\n",
    "    optimizer = torch.optim.Adam(input_model.parameters())\n",
    "\n",
    "    input_model.eval()\n",
    "    test_acc = 0\n",
    "    for i in range(test_x.shape[0] // minibatch_size):\n",
    "        batch_in = test_x[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        batch_in = batch_in.reshape((-1,) + test_x.shape[1:-2] + (784,))\n",
    "        batch_label = tst_labels[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        output = input_model(torch.tensor(batch_in))\n",
    "\n",
    "        test_acc += torch.mean(\n",
    "            torch.eq(torch.argmax(output, dim=1), torch.tensor(batch_label)).float()\n",
    "        )\n",
    "\n",
    "    test_acc /= i + 1\n",
    "\n",
    "    print(\"Test accuracy:\", test_acc.numpy())\n",
    "    print('here is a random image from the generated noisy data:')\n",
    "    r=np.random.randint(0,9000)\n",
    "    plt.title(str(class_names[tst_labels[r]]))\n",
    "    plt.imshow(test_x[r][0],cmap=plt.cm.binary)\n",
    "\n",
    "    # return test_x,tst_labels\n",
    "test_noise(model_hybrid)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Fsoilz4JG--v"
   },
   "outputs": [],
   "source": [
    "sampled_images = copy.deepcopy(test_sequences)\n",
    "sampled_labels = copy.deepcopy(test_labels)\n",
    "sigma = 0.7**0.5\n",
    "mean = 0\n",
    "for j in range(len(test_labels)):\n",
    "  for _ in range(len(sampled_images[j])):\n",
    "    im = sampled_images[j][_] \n",
    "    row,col = sampled_images[j][_].shape\n",
    "    # gauss = np.array(np.random.normal(mean,sigma,size=(28,28))).reshape(row,col)\n",
    "    gauss = np.array(np.random.randn(row*col)) #* var ** 0.5 + mean\n",
    "    gauss = gauss*sigma + mean\n",
    "    gauss = gauss.reshape(row,col)\n",
    "    sampled_images[j][_] = sampled_images[j][_] + gauss\n",
    "r=np.random.randint(0,9000)\n",
    "plt.title(str(class_names[test_labels[r]]))\n",
    "plt.imshow(sampled_images[r][0],cmap=plt.cm.binary)\n",
    "def test_noise(input_model):\n",
    "    # test_x , tst_labels = gaussian_noise(test_sequences,test_labels,mean =mean,var = var)\n",
    "    test_x , tst_labels =sampled_images,test_labels\n",
    "    minibatch_size = 32\n",
    "    optimizer = torch.optim.Adam(input_model.parameters())\n",
    "\n",
    "    input_model.eval()\n",
    "    test_acc = 0\n",
    "    for i in range(test_x.shape[0] // minibatch_size):\n",
    "        batch_in = test_x[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        batch_in = batch_in.reshape((-1,) + test_x.shape[1:-2] + (784,))\n",
    "        batch_label = tst_labels[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        output = input_model(torch.tensor(batch_in))\n",
    "\n",
    "        test_acc += torch.mean(\n",
    "            torch.eq(torch.argmax(output, dim=1), torch.tensor(batch_label)).float()\n",
    "        )\n",
    "\n",
    "    test_acc /= i + 1\n",
    "\n",
    "    print(\"Test accuracy:\", test_acc.numpy())\n",
    "    print('here is a random image from the generated noisy data:')\n",
    "    r=np.random.randint(0,9000)\n",
    "    plt.title(str(class_names[tst_labels[r]]))\n",
    "    plt.imshow(test_x[r][0],cmap=plt.cm.binary)\n",
    "\n",
    "    # return test_x,tst_labels\n",
    "test_noise(model_hybrid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "G2xhgBUMHHRi"
   },
   "outputs": [],
   "source": [
    "sampled_images = copy.deepcopy(test_sequences)\n",
    "sampled_labels = copy.deepcopy(test_labels)\n",
    "sigma = 0.8**0.5\n",
    "mean = 0\n",
    "for j in range(len(test_labels)):\n",
    "  for _ in range(len(sampled_images[j])):\n",
    "    im = sampled_images[j][_] \n",
    "    row,col = sampled_images[j][_].shape\n",
    "    # gauss = np.array(np.random.normal(mean,sigma,size=(28,28))).reshape(row,col)\n",
    "    gauss = np.array(np.random.randn(row*col)) #* var ** 0.5 + mean\n",
    "    gauss = gauss*sigma + mean\n",
    "    gauss = gauss.reshape(row,col)\n",
    "    sampled_images[j][_] = sampled_images[j][_] + gauss\n",
    "r=np.random.randint(0,9000)\n",
    "plt.title(str(class_names[test_labels[r]]))\n",
    "plt.imshow(sampled_images[r][0],cmap=plt.cm.binary)\n",
    "def test_noise(input_model):\n",
    "    # test_x , tst_labels = gaussian_noise(test_sequences,test_labels,mean =mean,var = var)\n",
    "    test_x , tst_labels =sampled_images,test_labels\n",
    "    minibatch_size = 32\n",
    "    optimizer = torch.optim.Adam(input_model.parameters())\n",
    "\n",
    "    input_model.eval()\n",
    "    test_acc = 0\n",
    "    for i in range(test_x.shape[0] // minibatch_size):\n",
    "        batch_in = test_x[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        batch_in = batch_in.reshape((-1,) + test_x.shape[1:-2] + (784,))\n",
    "        batch_label = tst_labels[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        output = input_model(torch.tensor(batch_in))\n",
    "\n",
    "        test_acc += torch.mean(\n",
    "            torch.eq(torch.argmax(output, dim=1), torch.tensor(batch_label)).float()\n",
    "        )\n",
    "\n",
    "    test_acc /= i + 1\n",
    "\n",
    "    print(\"Test accuracy:\", test_acc.numpy())\n",
    "    print('here is a random image from the generated noisy data:')\n",
    "    r=np.random.randint(0,9000)\n",
    "    plt.title(str(class_names[tst_labels[r]]))\n",
    "    plt.imshow(test_x[r][0],cmap=plt.cm.binary)\n",
    "\n",
    "    # return test_x,tst_labels\n",
    "test_noise(model_hybrid)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "692tzCt8HMeK"
   },
   "outputs": [],
   "source": [
    "sampled_images = copy.deepcopy(test_sequences)\n",
    "sampled_labels = copy.deepcopy(test_labels)\n",
    "sigma = 0.9**0.5\n",
    "mean = 0\n",
    "for j in range(len(test_labels)):\n",
    "  for _ in range(len(sampled_images[j])):\n",
    "    im = sampled_images[j][_] \n",
    "    row,col = sampled_images[j][_].shape\n",
    "    # gauss = np.array(np.random.normal(mean,sigma,size=(28,28))).reshape(row,col)\n",
    "    gauss = np.array(np.random.randn(row*col)) #* var ** 0.5 + mean\n",
    "    gauss = gauss*sigma + mean\n",
    "    gauss = gauss.reshape(row,col)\n",
    "    sampled_images[j][_] = sampled_images[j][_] + gauss\n",
    "r=np.random.randint(0,9000)\n",
    "plt.title(str(class_names[test_labels[r]]))\n",
    "plt.imshow(sampled_images[r][0],cmap=plt.cm.binary)\n",
    "def test_noise(input_model):\n",
    "    # test_x , tst_labels = gaussian_noise(test_sequences,test_labels,mean =mean,var = var)\n",
    "    test_x , tst_labels =sampled_images,test_labels\n",
    "    minibatch_size = 32\n",
    "    optimizer = torch.optim.Adam(input_model.parameters())\n",
    "\n",
    "    input_model.eval()\n",
    "    test_acc = 0\n",
    "    for i in range(test_x.shape[0] // minibatch_size):\n",
    "        batch_in = test_x[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        batch_in = batch_in.reshape((-1,) + test_x.shape[1:-2] + (784,))\n",
    "        batch_label = tst_labels[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        output = input_model(torch.tensor(batch_in))\n",
    "\n",
    "        test_acc += torch.mean(\n",
    "            torch.eq(torch.argmax(output, dim=1), torch.tensor(batch_label)).float()\n",
    "        )\n",
    "\n",
    "    test_acc /= i + 1\n",
    "\n",
    "    print(\"Test accuracy:\", test_acc.numpy())\n",
    "    print('here is a random image from the generated noisy data:')\n",
    "    r=np.random.randint(0,9000)\n",
    "    plt.title(str(class_names[tst_labels[r]]))\n",
    "    plt.imshow(test_x[r][0],cmap=plt.cm.binary)\n",
    "\n",
    "    # return test_x,tst_labels\n",
    "test_noise(model_hybrid)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZMWRgNh6HOUu"
   },
   "outputs": [],
   "source": [
    "sampled_images = copy.deepcopy(test_sequences)\n",
    "sampled_labels = copy.deepcopy(test_labels)\n",
    "sigma = 1.0**0.5\n",
    "mean = 0\n",
    "for j in range(len(test_labels)):\n",
    "  for _ in range(len(sampled_images[j])):\n",
    "    im = sampled_images[j][_] \n",
    "    row,col = sampled_images[j][_].shape\n",
    "    # gauss = np.array(np.random.normal(mean,sigma,size=(28,28))).reshape(row,col)\n",
    "    gauss = np.array(np.random.randn(row*col)) #* var ** 0.5 + mean\n",
    "    gauss = gauss*sigma + mean\n",
    "    gauss = gauss.reshape(row,col)\n",
    "    sampled_images[j][_] = sampled_images[j][_] + gauss\n",
    "r=np.random.randint(0,9000)\n",
    "plt.title(str(class_names[test_labels[r]]))\n",
    "plt.imshow(sampled_images[r][0],cmap=plt.cm.binary)\n",
    "def test_noise(input_model):\n",
    "    # test_x , tst_labels = gaussian_noise(test_sequences,test_labels,mean =mean,var = var)\n",
    "    test_x , tst_labels =sampled_images,test_labels\n",
    "    minibatch_size = 32\n",
    "    optimizer = torch.optim.Adam(input_model.parameters())\n",
    "\n",
    "    input_model.eval()\n",
    "    test_acc = 0\n",
    "    for i in range(test_x.shape[0] // minibatch_size):\n",
    "        batch_in = test_x[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        batch_in = batch_in.reshape((-1,) + test_x.shape[1:-2] + (784,))\n",
    "        batch_label = tst_labels[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "        output = input_model(torch.tensor(batch_in))\n",
    "\n",
    "        test_acc += torch.mean(\n",
    "            torch.eq(torch.argmax(output, dim=1), torch.tensor(batch_label)).float()\n",
    "        )\n",
    "\n",
    "    test_acc /= i + 1\n",
    "\n",
    "    print(\"Test accuracy:\", test_acc.numpy())\n",
    "    print('here is a random image from the generated noisy data:')\n",
    "    r=np.random.randint(0,9000)\n",
    "    plt.title(str(class_names[tst_labels[r]]))\n",
    "    plt.imshow(test_x[r][0],cmap=plt.cm.binary)\n",
    "\n",
    "    # return test_x,tst_labels\n",
    "test_noise(model_hybrid)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Noise [5-ary] zz template.ipynb",
   "provenance": []
  },
  "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}