qgan+qpca.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pennylane as qml\n",
    "import numpy as np\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "metadata": {},
   "outputs": [],
   "source": [
    "dev = qml.device('default.qubit', wires=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {},
   "outputs": [],
   "source": [
    "def real(angles, **kwargs):\n",
    "    qml.Hadamard(wires=0)\n",
    "    qml.RY(np.pi / 4, wires=1)\n",
    "    qml.RX(np.pi / 4, wires=0)\n",
    "    qml.CNOT(wires=[0, 1])\n",
    "    qml.Rot(*angles, wires=0)\n",
    "    qml.CNOT(wires=[0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generator(w, wires, **kwargs):\n",
    "    qml.Hadamard(wires=wires[0])\n",
    "    qml.RX(w[0], wires=wires[0])\n",
    "    qml.RX(w[1], wires=wires[1])\n",
    "    qml.RY(w[2], wires=wires[0])\n",
    "    qml.RY(w[3], wires=wires[1])\n",
    "    qml.RZ(w[4], wires=wires[0])\n",
    "    qml.RZ(w[5], wires=wires[1])\n",
    "    qml.CNOT(wires=[wires[0], wires[1]])\n",
    "    qml.RX(w[6], wires=wires[0])\n",
    "    qml.RY(w[7], wires=wires[0])\n",
    "    qml.RZ(w[8], wires=wires[0])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [],
   "source": [
    "def utheta(theta, wires, **kwargs):\n",
    "    qml.Hadamard(wires=wires[0])\n",
    "    qml.RX(theta[0], wires=wires[0])\n",
    "    qml.RY(theta[2], wires=wires[0])\n",
    "    qml.RZ(theta[4], wires=wires[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {},
   "outputs": [],
   "source": [
    "def utheta_dagger(theta, wires, **kwargs):\n",
    "    qml.RZ(-theta[4], wires=wires[0])\n",
    "    qml.RY(-theta[2], wires=wires[0])\n",
    "    qml.RX(-theta[0], wires=wires[0])\n",
    "    qml.Hadamard(wires=wires[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diag(wires):\n",
    "    qml.Hadamard(wires=4)\n",
    "    qml.CZ(wires=[4, wires])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qml.qnode(dev, interface=\"tf\")\n",
    "def qpca_train(angles, theta_weights, **kwargs):\n",
    "    real(angles)\n",
    "    utheta(theta_weights, [0, 1])\n",
    "    z0 = qml.expval(qml.PauliZ(0))\n",
    "    z1 = qml.expval(qml.PauliZ(1))\n",
    "    return z0, z1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qml.qnode(dev, interface=\"tf\")\n",
    "def qpca(angles, theta_weights, **kwargs):\n",
    "    real(angles)\n",
    "    utheta(theta_weights, [0, 1])\n",
    "    z0 = qml.expval(qml.PauliX(0))\n",
    "    z1 = qml.expval(qml.PauliX(1))\n",
    "    return z0, z1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pcaloss(angles, theta_weights, **kwargs):\n",
    "    z0, z1 = qpca_train(angles, theta_weights)\n",
    "    return 0.5 * ((z0 + 1) + 2 * (z1 + 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {},
   "outputs": [],
   "source": [
    "angles = [np.pi / 6, np.pi / 2, np.pi / 7]\n",
    "\n",
    "np.random.seed(0)\n",
    "eps = 1e-2\n",
    "init_theta_weights = np.array([0] + [0] * 8) + \\\n",
    "                   np.random.normal(scale=eps, size=(9,))\n",
    "theta_weights = tf.Variable(init_theta_weights)\n",
    "\n",
    "opt = tf.keras.optimizers.SGD(0.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 0: cost = 1.3343848928140136\n",
      "Step 5: cost = 1.1669167553300674\n",
      "Step 10: cost = 1.124091565221662\n",
      "Step 15: cost = 1.1130562258685588\n",
      "Step 20: cost = 1.108921407716011\n",
      "Step 25: cost = 1.1069228758807754\n",
      "Step 30: cost = 1.1058774166505283\n",
      "Step 35: cost = 1.1053246881146088\n",
      "Step 40: cost = 1.1050337388797096\n",
      "Step 45: cost = 1.10488134690854\n",
      "Step 50: cost = 1.104801783672349\n",
      "Step 55: cost = 1.104760316863267\n",
      "Step 60: cost = 1.1047387243076106\n",
      "Step 65: cost = 1.104727485456612\n",
      "Step 70: cost = 1.1047216368448922\n",
      "Step 75: cost = 1.1047185935528765\n",
      "Step 80: cost = 1.1047170100595192\n",
      "Step 85: cost = 1.1047161861478896\n",
      "Step 90: cost = 1.1047157574599034\n",
      "Step 95: cost = 1.1047155344108808\n",
      "Step 100: cost = 1.1047154183572903\n",
      "Step 105: cost = 1.104715357974038\n",
      "Step 110: cost = 1.1047153265563472\n",
      "Step 115: cost = 1.1047153102095775\n",
      "Step 120: cost = 1.104715301704278\n",
      "Step 125: cost = 1.1047152972789314\n",
      "Step 130: cost = 1.1047152949764036\n",
      "Step 135: cost = 1.1047152937783884\n",
      "Step 140: cost = 1.104715293155055\n",
      "Step 145: cost = 1.1047152928307318\n",
      "Step 150: cost = 1.104715292661985\n",
      "Step 155: cost = 1.1047152925741857\n",
      "Step 160: cost = 1.1047152925285029\n",
      "Step 165: cost = 1.1047152925047339\n",
      "Step 170: cost = 1.104715292492367\n",
      "Step 175: cost = 1.1047152924859325\n",
      "Step 180: cost = 1.1047152924825845\n",
      "Step 185: cost = 1.1047152924808423\n",
      "Step 190: cost = 1.1047152924799362\n",
      "Step 195: cost = 1.1047152924794645\n"
     ]
    }
   ],
   "source": [
    "cost = lambda: pcaloss(angles, theta_weights)\n",
    "for step in range(200):\n",
    "    opt.minimize(cost, theta_weights)\n",
    "    if step % 5 == 0:\n",
    "        cost_val = cost().numpy()\n",
    "        print(\"Step {}: cost = {}\".format(step, cost_val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qml.qnode(dev, interface=\"tf\")\n",
    "def get_real_prob(angles, theta_weights, **kwargs):\n",
    "    real(angles)\n",
    "    utheta(theta_weights, [0, 1])\n",
    "    return qml.probs(wires=[0])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([0.10471529 0.89528471], shape=(2,), dtype=float64)\n",
      "0.8124999999995197\n"
     ]
    }
   ],
   "source": [
    "prob_real = get_real_prob(angles, theta_weights)\n",
    "purity_real = np.linalg.norm(prob_real) ** 2\n",
    "print(prob_real)\n",
    "print(purity_real)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qml.qnode(dev, interface=\"tf\")\n",
    "def get_gen_prob(gen_weights, theta_weights, **kwargs):\n",
    "    generator(gen_weights, [2, 3])\n",
    "    utheta(theta_weights, [2, 3])\n",
    "    return qml.probs(wires=[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qml.qnode(dev, interface=\"tf\")\n",
    "def get_gen_purity(gen_weights, theta_weights, **kwargs):\n",
    "    generator(gen_weights, [0, 1])\n",
    "    utheta(theta_weights, [0, 1])\n",
    "    generator(gen_weights, [2, 3])\n",
    "    utheta(theta_weights, [2, 3])\n",
    "    qml.Hadamard(wires=4)\n",
    "    qml.CSWAP(wires=[4, 0, 2])\n",
    "    qml.Hadamard(wires=4)\n",
    "    return qml.expval(qml.PauliZ(4))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {},
   "outputs": [],
   "source": [
    "init_gen_weights = np.array([np.pi] + [0] * 8) + \\\n",
    "                   np.random.normal(scale=eps, size=(9,))\n",
    "gen_weights = tf.Variable(init_gen_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_loss(gen_weights, theta_weights):\n",
    "    global prob_real\n",
    "    prob_gen = get_gen_prob(gen_weights, theta_weights)\n",
    "    #purity_gen = get_gen_purity(gen_weights, theta_weights)\n",
    "    return - tf.reduce_mean(tf.reduce_sum(prob_real*tf.math.log(prob_gen)))# - (purity_real * tf.math.log(purity_gen) + (1 - purity_real) * tf.math.log(1 - purity_gen))\n",
    "    #return tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits = prob_gen, labels = prob_real))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 0: cost = 0.5418757806332488\n",
      "Step 5: cost = 0.3456920095912377\n",
      "Step 10: cost = 0.3355782625431037\n",
      "Step 15: cost = 0.33532687896085056\n",
      "Step 20: cost = 0.3353217947530322\n",
      "Step 25: cost = 0.3353216953925264\n",
      "Step 30: cost = 0.3353216934602643\n",
      "Step 35: cost = 0.33532169342271395\n",
      "Step 40: cost = 0.3353216934219846\n",
      "Step 45: cost = 0.33532169342197\n",
      "Step 50: cost = 0.3353216934219705\n",
      "Step 55: cost = 0.33532169342197027\n",
      "Step 60: cost = 0.33532169342197\n",
      "Step 65: cost = 0.33532169342197055\n",
      "Step 70: cost = 0.33532169342197016\n",
      "Step 75: cost = 0.3353216934219697\n",
      "Step 80: cost = 0.33532169342196994\n",
      "Step 85: cost = 0.3353216934219701\n",
      "Step 90: cost = 0.3353216934219696\n",
      "Step 95: cost = 0.3353216934219695\n"
     ]
    }
   ],
   "source": [
    "cost = lambda: gen_loss(gen_weights, theta_weights)\n",
    "for step in range(100):\n",
    "    opt.minimize(cost, gen_weights)\n",
    "    if step % 5 == 0:\n",
    "        cost_val = cost().numpy()\n",
    "        print(\"Step {}: cost = {}\".format(step, cost_val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[1.04715292e-01+0.00000000e+00j 9.14546025e-09+4.89576263e-07j]\n",
      " [9.14546025e-09-4.89576263e-07j 8.95284708e-01+0.00000000e+00j]], shape=(2, 2), dtype=complex128)\n",
      "tf.Tensor(\n",
      "[[ 0.10471529+0.j         -0.12751678-0.03828425j]\n",
      " [-0.12751678+0.03828425j  0.89528471+0.j        ]], shape=(2, 2), dtype=complex128)\n"
     ]
    }
   ],
   "source": [
    "@qml.qnode(dev, interface=\"tf\")\n",
    "def show_real_diag(angles, theta_weights, **kwargs):\n",
    "    real(angles)\n",
    "    utheta(theta_weights, [0, 1])\n",
    "    return qml.density_matrix([0])\n",
    "\n",
    "@qml.qnode(dev, interface=\"tf\")\n",
    "def show_gen_diag(gen_weights, theta_weights, **kwargs):\n",
    "    generator(gen_weights, [2, 3])\n",
    "    utheta(theta_weights, [2, 3])\n",
    "    return qml.density_matrix([2])\n",
    "    \n",
    "print(show_real_diag(angles, theta_weights))\n",
    "print(show_gen_diag(gen_weights, theta_weights))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[ 0.19381378+0.j         -0.10847093-0.22524222j]\n",
      " [-0.10847093+0.22524222j  0.80618622+0.j        ]], shape=(2, 2), dtype=complex128)\n",
      "tf.Tensor(\n",
      "[[ 0.19381378+0.j       -0.10847138-0.225242j]\n",
      " [-0.10847138+0.225242j  0.80618622+0.j      ]], shape=(2, 2), dtype=complex128)\n"
     ]
    }
   ],
   "source": [
    "@qml.qnode(dev, interface=\"tf\")\n",
    "def show_real(angles):\n",
    "    real(angles)\n",
    "    return qml.density_matrix([0])\n",
    "\n",
    "@qml.qnode(dev, interface=\"tf\")\n",
    "def show_gen(gen_weights, theta_weights):\n",
    "    generator(gen_weights, [2, 3])\n",
    "    utheta(theta_weights, [2, 3])\n",
    "    diag(2)\n",
    "    utheta_dagger(theta_weights, [2, 3])\n",
    "    return qml.density_matrix([2])\n",
    "    \n",
    "print(show_real(angles))\n",
    "print(show_gen(gen_weights, theta_weights))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_generator(weights, **kwargs):\n",
    "    gen_weights, theta_weights = weights[0], weights[1]\n",
    "    generator(gen_weights, [0, 1])\n",
    "    utheta(theta_weights, [0, 1])\n",
    "    diag(0)\n",
    "    utheta_dagger(theta_weights, [0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Real Bloch vector: [-0.21694187  0.45048443 -0.61237244]\n",
      "Generator Bloch vector: [-0.21694275  0.45048401 -0.61237244]\n"
     ]
    }
   ],
   "source": [
    "obs = [qml.PauliX(0), qml.PauliY(0), qml.PauliZ(0)]\n",
    "\n",
    "bloch_vector_real = qml.map(real, obs, dev, interface=\"tf\")\n",
    "bloch_vector_generator = qml.map(new_generator, obs, dev, interface=\"tf\")\n",
    "\n",
    "print(\"Real Bloch vector: {}\".format(bloch_vector_real(angles)))\n",
    "print(\"Generator Bloch vector: {}\".format(bloch_vector_generator([gen_weights, theta_weights])))"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
  },
  "kernelspec": {
   "display_name": "Python 3.8.10 64-bit",
   "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.5"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}