tutorial/104_ttn_mps.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantum Machine Learning and TTN\n",
    "Let's look at the Tree Tensor Network as a model for quantum machine learning.\n",
    "\n",
    "## What you will learn\n",
    "1. TTN model\n",
    "2. Optimization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model we are going to build is called TTN. The quantum circuit is as follows.\n",
    "\n",
    "(no image now)\n",
    "\n",
    "It has a shape that takes on tree structure.  \n",
    "This circuit uses a one qubit arbitrary rotation gate (a combination of $Rx$, $Rz$ and $Ry$ gates) and a two qubit gate ($CX$ gate).  \n",
    "More details are as follows.\n",
    "\n",
    "```\n",
    "|0> -RX-RY-RZ--CX--\n",
    "               |\n",
    "|0> -RX-RY-RZ--CX--RX-RY-RZ--CX--\n",
    "                             |\n",
    "|0> -RX-RY-RZ--CX--          |\n",
    "               |             |\n",
    "|0> -RX-RY-RZ--CX--RX-RY-RZ--CX--M\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from blueqat import Circuit\n",
    "from blueqat.pauli import Z\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import time\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Configure hyperparameters and other settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(45)\n",
    "\n",
    "nsteps = 2000\n",
    "nparams = 18\n",
    "h = 0.01\n",
    "e = 0.01\n",
    "\n",
    "param_init = [np.random.rand()*np.pi*2 for i in range(nparams)]\n",
    "\n",
    "arr = []\n",
    "\n",
    "mode = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We create a model of the tree structure.  \n",
    "Set upthe input to the quantum circuit and the target label for it and start learning.  \n",
    "This time, the input data can be selected by arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def TTN_Z(a, ran, mode=1):\n",
    "    \n",
    "    # Input circuit\n",
    "    init = [Circuit(4).x[0,1], Circuit(4).x[2,3], Circuit(4).x[0], Circuit(4).x[1], Circuit(4).x[2], Circuit(4).x[0,2]]\n",
    "    # Target label\n",
    "    target = [1,1,-1,-1,-1,1]\n",
    "   \n",
    "    # Circuit construct}ion\n",
    "    u = init[ran]\n",
    "    u.rx(a[0])[0].ry(a[1])[0].rz(a[2])[0]\n",
    "    u.rx(a[3])[1].ry(a[4])[1].rz(a[5])[1]\n",
    "    u.rx(a[6])[2].ry(a[7])[2].rz(a[8])[2]\n",
    "    u.rx(a[9])[3].ry(a[10])[3].rz(a[11])[3]\n",
    "    u.cx[0,1].cx[2,3]\n",
    "    u.rx(a[12])[1].ry(a[13])[1].rz(a[14])[1]\n",
    "    u.rx(a[15])[3].ry(a[16])[3].rz(a[17])[3]\n",
    "    u.cx[1,3]\n",
    "    \n",
    "    # Calculate expectation value from state vector\n",
    "    expt = u.run(hamiltonian=1*Z[3])\n",
    "    \n",
    "    if(mode ==1):\n",
    "        # return error between label and prediction\n",
    "        return (expt - target[ran])**2\n",
    "    else:\n",
    "        return expt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stochastic gradient descent (SGD) is used to learning.\n",
    "At the start of each step, the input data is randomly selected from 6 ways (0 to 5), and the gradient is calculated and the parameters are updated.\n",
    "\n",
    "In each step, the gradient calculation and parameter update are performed on only one data, but by repeating the process while randomly selecting input data, the system eventually learns to minimize the loss function for all data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "557.4303178787231\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "\n",
    "param = param_init.copy()\n",
    "for i in range(nsteps):\n",
    "    it = np.random.randint(0,6)\n",
    "    \n",
    "    loss = TTN_Z(param, it, mode)\n",
    "    arr.append(loss)\n",
    "    param_new = [0 for i in range(nparams)]\n",
    "    \n",
    "    for j in range(nparams):\n",
    "        _param = param.copy()\n",
    "        _param[j] += h\n",
    "        param_new[j] = param[j] - e*(TTN_Z(_param, it, mode) - loss)/h\n",
    "\n",
    "    param = param_new\n",
    "\n",
    "plt.plot(arr)\n",
    "plt.show()\n",
    "print(time.time() - start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It converged well.  \n",
    "Let's check it out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prediction : 0.9890604670982991         Target : 1\n",
      "Prediction : 0.9873710399334666         Target : 1\n",
      "Prediction : -0.9890604670982991         Target : -1\n",
      "Prediction : -0.9870095481423591         Target : -1\n",
      "Prediction : -0.9873710399334665         Target : -1\n",
      "Prediction : 0.9894227100375274         Target : 1\n"
     ]
    }
   ],
   "source": [
    "target = [1,1,-1,-1,-1,1]\n",
    "preds = []\n",
    "for i in range(6):\n",
    "    pred = TTN_Z(param, i, mode=2)\n",
    "    preds.append(pred)\n",
    "    print(\"Prediction :\", pred, \"        Target :\", target[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the above, we were able to learn a quantum circuit using the TTN model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quantum Machine Learning and MPS\n",
    "Let's look at the Tree Tensor Network as a model for quantum machine learning.\n",
    "\n",
    "## What you will learn\n",
    "1. MPS model\n",
    "2. Optimization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model we are going to build is called MPS.This circuit uses a one qubit arbitrary rotation gate (a combination of $Rz$ and $Ry$ gates) and a two qubit gate ($CX$ gate).  \n",
    "More details are as follows.\n",
    "\n",
    "```\n",
    "|0> -RX-RY-RZ--CX--\n",
    "               |\n",
    "|0> -RX-RY-RZ--CX--RX-RY-RZ--CX--\n",
    "                             |\n",
    "|0> -RX-RY-RZ----------------CX--RX-RY-RZ--CX--\n",
    "                                           |\n",
    "|0> -RX-RY-RZ------------------------------CX--M\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Configure hyperparameters and other settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(45)\n",
    "\n",
    "# Number of steps of optimizetaion\n",
    "nsteps = 5000\n",
    "\n",
    "# Number of parameters of the quantum circuit to be optimized\n",
    "nparams = 18\n",
    "\n",
    "# Fineness of numerical differentiation\n",
    "h = 0.01\n",
    "\n",
    "# Learning rate\n",
    "e = 0.01\n",
    "\n",
    "# Initial parameter\n",
    "param_init = [np.random.rand() * np.pi * 2 for i in range(nparams)]\n",
    "\n",
    "# list for containing results\n",
    "arr = []\n",
    "\n",
    "# 1: train, 2: prediction\n",
    "mode = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mpsZ(a, ran, mode=1):\n",
    "    \n",
    "    # Input circuit\n",
    "    init = [Circuit(4).x[0,1], Circuit(4).x[2,3], Circuit(4).x[0], Circuit(4).x[1], Circuit(4).x[2], Circuit(4).x[0,2]]\n",
    "    # Target label\n",
    "    target = [1, 1, -1, -1, -1, 1]\n",
    "   \n",
    "    # Circuit construction\n",
    "    u = init[ran]\n",
    "    u.rx(a[0])[0].ry(a[1])[0].rz(a[2])[0]\n",
    "    u.rx(a[3])[1].ry(a[4])[1].rz(a[5])[1]    \n",
    "    u.rx(a[6])[2].ry(a[7])[2].rz(a[8])[2]\n",
    "    u.rx(a[9])[3].ry(a[10])[3].rz(a[11])[3]\n",
    "    u.cx[0,1]\n",
    "    u.rx(a[12])[1].ry(a[13])[1].rz(a[14])[1]\n",
    "    u.cx[1,2]\n",
    "    u.rx(a[15])[2].ry(a[16])[2].rz(a[17])[2]\n",
    "    u.cx[2,3]\n",
    "    \n",
    "    # Calculate expectation value from state vector\n",
    "    expt = u.run(hamiltonian=1*Z[3])\n",
    "    \n",
    "    if(mode ==1):\n",
    "        # return error between label and prediction\n",
    "        return (expt - target[ran]) ** 2\n",
    "    else:\n",
    "        return expt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stochastic gradient descent (SGD) is used to learning.\n",
    "At the start of each step, the input data is randomly selected from 6 ways (0 to 5), and the gradient is calculated and the parameters are updated.\n",
    "\n",
    "In each step, the gradient calculation and parameter update are performed on only one data, but by repeating the process while randomly selecting input data, the system eventually learns to minimize the loss function for all data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1416.9488594532013\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "\n",
    "param = param_init.copy()\n",
    "\n",
    "for i in range(nsteps):\n",
    "    it = np.random.randint(0,6)\n",
    "    \n",
    "    loss = mpsZ(param, it)\n",
    "    arr.append(loss)\n",
    "    param_new = [0 for i in range(nparams)]\n",
    "    \n",
    "    for j in range(nparams):\n",
    "        _param = param.copy()\n",
    "        _param[j] += h\n",
    "        param_new[j] = param[j] - e*(mpsZ(_param, it) - loss) / h\n",
    "\n",
    "    param = param_new\n",
    "\n",
    "plt.plot(arr)\n",
    "plt.show()\n",
    "print(time.time() - start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It converged well.  \n",
    "Let's check it out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prediction : 0.9951248719559743         Target : 1\n",
      "Prediction : 0.9944050473333251         Target : 1\n",
      "Prediction : -0.9952549958143145         Target : -1\n",
      "Prediction : -0.994535171191665         Target : -1\n",
      "Prediction : -0.9944050473333252         Target : -1\n",
      "Prediction : 0.9952549958143143         Target : 1\n"
     ]
    }
   ],
   "source": [
    "target = [1,1,-1,-1,-1,1]\n",
    "preds = []\n",
    "for i in range(6):\n",
    "    pred = mpsZ(param, i, mode=2)\n",
    "    preds.append(pred)\n",
    "    print(\"Prediction :\", pred, \"        Target :\", target[i])"
   ]
  }
 ],
 "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.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}