[4_ary]_pretrain_6x2_squeeze_MNIST.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "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 torch.optim import lr_scheduler\n",
    "from torchvision import datasets, transforms\n",
    "from tqdm import tqdm\n",
    "import pickle\n",
    "# Pennylane\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": 2,
   "metadata": {
    "id": "VNDrzJlUTbv1"
   },
   "outputs": [],
   "source": [
    "random_model = torch.load(\"./MNIST/random_mnist.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 164
    },
    "id": "fok2C-ecl4pV",
    "outputId": "cd22c63d-7c73-4e83-e1cd-a85250c4cab5"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Linear(in_features=784, out_features=128, bias=True)\n",
       "  (1): SpikingActivation(\n",
       "    (activation): ReLU()\n",
       "  )\n",
       "  (2): TemporalAvgPool()\n",
       "  (3): Linear(in_features=128, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(random_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "THJBENVKRYSJ"
   },
   "outputs": [],
   "source": [
    "n_qubits = 6                # Number of qubits\n",
    "nqubits=n_qubits\n",
    "q_depth = 2                 # Depth of the quantum circuit (number of variational layers)\n",
    "q_delta = 0.01              # Initial spread of random quantum weights\n",
    "tensor_length = n_qubits*(n_qubits-1)*q_depth+n_qubits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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",
    "            # vqc_params.append(param)\n",
    "            qml.RZ(param, wires=i)\n",
    "            p+=1\n",
    "            param = next(weights_)\n",
    "            # vqc_params.append(param)\n",
    "            qml.RX(param, wires=i)\n",
    "            p+=1\n",
    "            qml.CNOT(wires=[j,i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "AoUoGHoFV8rI"
   },
   "outputs": [],
   "source": [
    "dev = qml.device(\"default.qubit\", wires=n_qubits)\n",
    "@qml.qnode(dev, interface=\"torch\")\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",
    "    # Expectation values in the Z basis\n",
    "    exp_vals = [qml.expval(qml.PauliZ(position)) for position in range(n_qubits)]\n",
    "\n",
    "    return tuple(exp_vals)\n",
    "    \n",
    "class DressedQuantumNet(nn.Module):\n",
    "    def __init__(self):\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",
    "        pre_out = self.pre_net(input_features)\n",
    "        q_in = torch.tanh(pre_out) * np.pi / 2.0\n",
    "\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)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "Oe15V30yVwln"
   },
   "outputs": [],
   "source": [
    "model_hybrid = copy.deepcopy(torch.nn.Sequential(*(list(random_model.children())[:-1])))\n",
    "for param in model_hybrid.parameters():\n",
    "    param.requires_grad = False\n",
    "    \n",
    "model_hybrid.fc = DressedQuantumNet()\n",
    "\n",
    "model_hybrid = model_hybrid.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 219
    },
    "id": "4GrawGKtVFBV",
    "outputId": "5c8e00e5-4af6-494d-919b-bc65153291b9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Linear(in_features=784, out_features=128, bias=True)\n",
       "  (1): SpikingActivation(\n",
       "    (activation): ReLU()\n",
       "  )\n",
       "  (2): TemporalAvgPool()\n",
       "  (fc): DressedQuantumNet(\n",
       "    (pre_net): Linear(in_features=128, out_features=6, bias=True)\n",
       "    (post_net): Linear(in_features=6, out_features=5, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(model_hybrid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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",
    "arr = idx2numpy.convert_from_file(file1)\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": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "k8WsgkKno38A",
    "outputId": "0d26035c-535f-4407-d22e-30401ce1fc36"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23983"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(arr4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "9XrbmsLB_sbt"
   },
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "NTmQ0jC-10dq",
    "outputId": "31e079bc-d486-4907-956d-3dbf74301501"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 0, 1, ..., 2, 0, 2])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_labels -= 6\n",
    "display(train_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 785
    },
    "id": "5iOn-WphsNw8",
    "outputId": "ed68c026-5d0d-4d9a-d27b-778d664ec173"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x720 with 25 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "f-WhMWC7pHOf",
    "outputId": "9f46dcec-4c0c-4520-d650-dc0780ce575e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16788 7195\n",
      "16788 7195\n",
      "7195 7195 5000 5000\n"
     ]
    }
   ],
   "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": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "metric = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "QfTPVzsst41s"
   },
   "outputs": [],
   "source": [
    "def train(input_model, train_x, test_x):\n",
    "    minibatch_size = 32\n",
    "    optimizer = torch.optim.Adam(input_model.parameters())\n",
    " \n",
    "    input_model.train()\n",
    "    for j in range(100):\n",
    "        train_acc = 0\n",
    "        loss_acc = 0\n",
    "        for i in tqdm(range(train_x.shape[0] // minibatch_size)):\n",
    "            input_model.zero_grad()\n",
    " \n",
    "            batch_in = train_x[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "            # flatten images\n",
    "            batch_in = batch_in.reshape((-1,) + train_x.shape[1:-2] + (784,))\n",
    "            batch_label = train_labels[i * minibatch_size : (i + 1) * minibatch_size]\n",
    "            output = input_model(torch.tensor(batch_in))\n",
    " \n",
    "            # compute sparse categorical cross entropy loss\n",
    "            logp = torch.nn.functional.log_softmax(output, dim=-1)\n",
    "            logpy = torch.gather(logp, 1, torch.tensor(batch_label).view(-1, 1))\n",
    "            loss = -logpy.mean()\n",
    "            loss_acc += loss \n",
    " \n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    " \n",
    "            train_acc += torch.mean(\n",
    "                torch.eq(torch.argmax(output, dim=1), torch.tensor(batch_label)).float()\n",
    "            )\n",
    "        train_acc /= i + 1  \n",
    "        print(\"Train accuracy (%d): \" % j, train_acc.numpy())\n",
    "        #metric_train=train_acc.numpy()\n",
    "\n",
    "        loss_acc /=i + 1\n",
    "        print(\"Loss (%d): \" % j, loss_acc.detach().numpy())\n",
    "        torch.save(model_hybrid,f=\"./model_saves/4_class_MNIST/6x2_zz_{0}_{1}_{2}.h5\".format(j,train_acc.numpy(),loss_acc.detach().numpy()))\n",
    " \n",
    "    # compute test accuracy\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 = test_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())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "huwxaiS52-NG"
   },
   "outputs": [],
   "source": [
    "def test(input_model, test_x):\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 = test_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())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "id": "TwU0pUFe0JAg"
   },
   "outputs": [],
   "source": [
    "model_hybrid=torch.load(\"./model_saves/4_class_MNIST/6x2_zz_0_0.5458734035491943_1.3720676898956299.h5\")"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "[5-ary] pretrain 4x1 squeeze.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
}