qaoa_ansatz-nbranch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install git+https://github.com/XanaduAI/pennylane.git@prob_fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pennylane as qml\n",
    "from variational_notebooks.entangler import get_entangler_map\n",
    "from pennylane import numpy as np\n",
    "from pennylane.optimize import GradientDescentOptimizer,NesterovMomentumOptimizer\n",
    "from pennylane.beta import prob\n",
    "\n",
    "\n",
    "from data_loader import *\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "idx_array = []\n",
    "X = []\n",
    "Y = []\n",
    "labels = []\n",
    "crops = []\n",
    "sources = []\n",
    "        \n",
    "for idx, ((i, j), train, target, label, source, (cropX, cropY)) in enumerate(train_fashion_loader):\n",
    "    \n",
    "    idx_array.append((i, j))\n",
    "    X.append(train.tolist())\n",
    "    Y.append(target.item())\n",
    "    labels.append(label.item())\n",
    "    crops.append((cropX, cropY))\n",
    "    \n",
    "    sources.append(source)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "shirts_inds = [i for i in range(len(labels)) if labels[i]==6]\n",
    "train_inds = shirts_inds[:500]\n",
    "tests_inds = shirts_inds[500:600]\n",
    "\n",
    "X_train = [X[i] for i in train_inds]\n",
    "Y_train = [Y[i] for i in train_inds]\n",
    "\n",
    "X_test = [X[i] for i in tests_inds]\n",
    "Y_test = [Y[i] for i in tests_inds]\n",
    "\n",
    "crops_test = [crops[i] for i in tests_inds]\n",
    "sources_test = [sources[i] for i in tests_inds]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(500, 100)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(Y_train),len(Y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_wires = 9\n",
    "n_qubits_readout = 8\n",
    "dev = qml.device(\"default.qubit\", wires=n_wires)\n",
    "\n",
    "graph = get_entangler_map()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_layer_application = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bitstring integer value\n",
    "bitstring_values = list(range(2**n_qubits_readout))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qml.qnode(dev)\n",
    "def quantum_completer(weights, x=None):\n",
    "    \n",
    "    for i in range(nb_layer_application):\n",
    "    \n",
    "        encoding(x)\n",
    "        variational_circuit(weights[2*i],weights[2*i+1])\n",
    "\n",
    "    return prob(wires=list(range(n_qubits_readout))) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# feature map \n",
    "# parameters should be of the form params = np.random.uniform(size=(num_layers, num_qubits, 3))\n",
    "\n",
    "def encoding(x):\n",
    "    for wire in range(n_wires // 3):\n",
    "        qml.Rot(*x[3*wire: 3*(wire+1)], wires=[wire])     #Encode three features in each qubit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# QAOA ansatz definition\n",
    "# unitary operator U_B with parameter beta\n",
    "def U_B(beta):\n",
    "    for wire in range(n_wires):\n",
    "        qml.RX(2 * beta, wires=wire)\n",
    "\n",
    "# unitary operator U_C with parameter gamma\n",
    "def U_C(gamma):\n",
    "    for wire_pair in graph:\n",
    "        qml.CNOT(wires=[wire_pair[0], wire_pair[1]])\n",
    "        qml.RZ(2*gamma, wires=wire_pair[1])\n",
    "        qml.CNOT(wires=[wire_pair[0], wire_pair[1]])\n",
    "        \n",
    "def variational_circuit(gamma,beta):\n",
    "\n",
    "    U_C(gamma)\n",
    "    U_B(beta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss(labels, predictions):\n",
    "    return sum([(label - prediction)**2 for label, prediction in zip(labels, predictions)]) / float(len(labels))\n",
    "\n",
    "def cost(weights, X, Y):\n",
    "    predictions = [np.sum(quantum_completer(weights, x=x) * bitstring_values) / 255. for x in X]\n",
    "    return loss(Y, predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(X,weights):\n",
    "    return [np.sum(quantum_completer(weights, x=x) * bitstring_values) / 255. for x in X]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter:     1 | Cost: 0.0994237 | Test: 0.1067182\n",
      "Iter:     2 | Cost: 0.0808549 | Test: 0.0871652\n",
      "Iter:     3 | Cost: 0.0772386 | Test: 0.0861058\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Define optimizer. \n",
    "opt = NesterovMomentumOptimizer(stepsize=0.1)\n",
    "batch_size = 10\n",
    "\n",
    "# Setup initial weights and number of optimization steps.\n",
    "weights = np.random.random(2*nb_layer_application) \n",
    "steps = 50\n",
    "\n",
    "# Optimizing the loss-function.\n",
    "for it in range(steps):\n",
    "    # Update the weights by one optimizer step\n",
    "    batch_index = np.random.randint(0, len(X_train), (batch_size,))\n",
    "    X_batch = [X_train[i] for i in batch_index]\n",
    "    Y_batch = [Y_train[i] for i in batch_index]\n",
    "    weights = opt.step(lambda v: cost(v, X_batch, Y_batch), weights)\n",
    "    \n",
    "    loss_test = loss(Y_test,predict(X_test,weights))\n",
    "    print(\"Iter: {:5d} | Cost: {:0.7f} | Test: {:0.7f}\".format(it + 1, cost(weights, X_train, Y_train),loss_test))\n",
    "    if loss_test < .01:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "white_shirt = np.array(sources_test[1].tolist())\n",
    "white_shirt_before = white_shirt.copy()\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "rect = patches.Rectangle((10-1, 10-1),4,4,linewidth=1,edgecolor='r',facecolor='none')\n",
    "ax.add_patch(rect)\n",
    "ax.imshow(np.array(white_shirt_before), cmap=plt.cm.gray, vmin=0, vmax=1)\n",
    "\n",
    "cropX, cropY = crops_test[0]\n",
    "# Creating boxes\n",
    "windows = []\n",
    "correct_labels = []\n",
    "for x in range (3):\n",
    "    for y in range(3):\n",
    "        # Saving correct label and putting pixel to 0.\n",
    "        correct_labels.append(white_shirt[10+x, 10+y])\n",
    "        white_shirt[10+x, 10+y] = 0\n",
    "        white_shirt_before[10+x, 10+y] = 1\n",
    "        # Collecting crops/windows\n",
    "        window = np.array(white_shirt[10+x-1:10+x+2,10+y-1:10+y+2]).reshape(9)\n",
    "        #print(np.array(white_shirt[10+x-1:10+x+2,10+y-1:10+y+2]).reshape(9))\n",
    "        # Predicting new pixel value and inserting prediction.\n",
    "        predicted_label = predict([window],weights)\n",
    "        white_shirt[10+x, 10+y] = predicted_label[0]\n",
    "        print(predicted_label[0])\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "rect = patches.Rectangle((10-1, 10-1),4,4,linewidth=1,edgecolor='r',facecolor='none')\n",
    "ax.add_patch(rect)\n",
    "ax.imshow(white_shirt, cmap=plt.cm.gray, vmin=0, vmax=1)\n",
    "#fig.savefig(f'./images/full_{idx}.png')\n",
    "#source_test_example[cropY:cropY+3, cropX:cropX+3] = new_window_values\n",
    "#fig = plt.figure()\n",
    "#ax = fig.add_subplot(111)\n",
    "#rect = patches.Rectangle((10-1, 10-1),4,4,linewidth=1,edgecolor='r',facecolor='none')\n",
    "#ax.add_patch(rect)\n",
    "#ax.imshow(white_shirt_before, cmap=plt.cm.plasma, vmin=0, vmax=1)\n",
    "#fig.savefig(f'./images/full_{idx}_crop.png')\n",
    "\n",
    "#fig.savefig(f'./images/full_{idx}_crop.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ind_example = 0\n",
    "\n",
    "# X_test_example = X_test[ind_example]\n",
    "# source_test_example = np.array(sources_test[ind_example].tolist())\n",
    "# cropX, cropY = crops_test[ind_example]\n",
    "\n",
    "# new_window_values = np.array(X_test_example).reshape(3, 3)\n",
    "# # source_test_example[cropY:cropY+3, cropX:cropX+3] = new_window_values\n",
    "\n",
    "# fig = plt.figure()\n",
    "# ax = fig.add_subplot(111)\n",
    "# rect = patches.Rectangle((cropX-1, cropY-1),4,4,linewidth=1,edgecolor='r',facecolor='none')\n",
    "# ax.add_patch(rect)\n",
    "# ax.imshow(source_test_example, cmap=plt.cm.gray, vmin=0, vmax=1)\n",
    "# fig.savefig(f'./images/full_{idx}.png')\n",
    "\n",
    "# source_test_example[cropY:cropY+3, cropX:cropX+3] = new_window_values\n",
    "\n",
    "# fig = plt.figure()\n",
    "# ax = fig.add_subplot(111)\n",
    "# rect = patches.Rectangle((cropX-1, cropY-1),4,4,linewidth=1,edgecolor='r',facecolor='none')\n",
    "# ax.add_patch(rect)\n",
    "# ax.imshow(source_test_example, cmap=plt.cm.gray, vmin=0, vmax=1)\n",
    "# fig.savefig(f'./images/full_{idx}_crop.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:pennylane]",
   "language": "python",
   "name": "conda-env-pennylane-py"
  },
  "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}