QWGAN_PennyLane .ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext jupyternotify\n",
    "import pennylane as qml\n",
    "from pennylane import numpy as np\n",
    "import tensorflow as tf\n",
    "from sympy.physics.quantum.dagger import Dagger\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "px = np.array([[0 + 0j, 1 + 0j] , [1 + 0j, 0+0j]])\n",
    "py = np.array( [[0 + 0j, 0 - 1j] , [0 + 1j, 0+0j]])\n",
    "pz = np.array( [[1 + 0j, 0 + 0j] , [0 + 0j, -1+0j]])\n",
    "iden = np.array( [[1 + 0j, 0 + 0j] , [0 + 0j, 1+0j]])\n",
    "\n",
    "n = 1\n",
    "lamb = np.float(2)\n",
    "s = np.exp(-1 / (2 * lamb)) - 1\n",
    "cst1 = (s / 2 + 1) ** 2\n",
    "cst2 = (s / 2) * (s / 2 + 1)\n",
    "cst3 = (s / 2) ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fidelity(rsv, gsv):\n",
    "    \n",
    "    rsv_conj = np.conj(rsv)\n",
    "    fid = sum(rsv_conj*gsv) * np.conj(sum(rsv_conj*gsv))\n",
    "    \n",
    "    return fid\n",
    "\n",
    "dev1 = qml.device('default.qubit', wires=1) #real\n",
    "dev2 = qml.device('default.qubit', wires=1) #generator\n",
    "\n",
    "obs_list = [qml.Identity(0), qml.PauliX(0) , qml.PauliY(0), qml.PauliZ(0)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def real_circuit(real_weights, wires, **kwargs):\n",
    "    \n",
    "    qml.RX(real_weights[0], wires=0)\n",
    "    qml.RY(real_weights[1], wires=0)\n",
    "    qml.RZ(real_weights[2], wires=0)\n",
    "\n",
    "qnodes_real = qml.map(real_circuit, obs_list, dev1, measure=\"expval\",  interface=\"tf\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_circuit(gen_weights, wires, **kwargs):\n",
    "    \n",
    "    qml.RX(gen_weights[0], wires=0)\n",
    "    qml.RY(gen_weights[1], wires=0)\n",
    "    qml.RZ(gen_weights[2], wires=0)\n",
    "\n",
    "qnodes_gen = qml.map(gen_circuit, obs_list, dev2, measure=\"expval\",  interface=\"tf\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def discriminator(real_exp, gen_exp, disc_weights):\n",
    "    \n",
    "    phi_matrix = disc_weights[0]*iden + disc_weights[1]*px + disc_weights[2]*py + disc_weights[3]*pz \n",
    "    psi_matrix = disc_weights[4]*iden + disc_weights[5]*px + disc_weights[6]*py + disc_weights[7]*pz \n",
    "    \n",
    "    phi_exp = disc_weights[0]*gen_exp[0] + disc_weights[1]*gen_exp[1] + disc_weights[2]*gen_exp[2] + disc_weights[3]*gen_exp[3]\n",
    "    psi_exp = disc_weights[4]*real_exp[0] + disc_weights[5]*real_exp[1] + disc_weights[6]*real_exp[2] + disc_weights[7]*real_exp[3]\n",
    "\n",
    "    A = tf.linalg.expm( (-1/lamb) * phi_matrix )\n",
    "    B = tf.linalg.expm( (1/lamb) * psi_matrix )\n",
    "    \n",
    "    term1 = np.matmul( Dagger(gen_sv) , np.matmul(A.numpy(), gen_sv) )\n",
    "    term2 = np.matmul( Dagger(real_sv) , np.matmul(B.numpy(), real_sv) )\n",
    "    term3 = np.matmul( Dagger(gen_sv) , np.matmul(B.numpy(), real_sv) )\n",
    "    term4 = np.matmul( Dagger(real_sv) , np.matmul(A.numpy(), gen_sv) )\n",
    "    term5 = np.matmul( Dagger(gen_sv) , np.matmul(A.numpy(), real_sv) )\n",
    "    term6 = np.matmul( Dagger(real_sv) , np.matmul(B.numpy(), gen_sv) )\n",
    "    term7 = np.matmul( Dagger(gen_sv) , np.matmul(B.numpy(), gen_sv) )\n",
    "    term8 = np.matmul( Dagger(real_sv) , np.matmul(A.numpy(), real_sv) )\n",
    "\n",
    "    regterm = (lamb / np.e * (cst1 * term1 * term2 - cst2 * term3 * term4 - cst2 * term5 * term6 + cst3 * term7 * term8)).item()\n",
    "\n",
    "    return psi_exp , phi_exp , regterm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def disc_loss(disc_weights):\n",
    "    \n",
    "    psi_exp , phi_exp , regterm = discriminator(real_exp, gen_exp, disc_weights)\n",
    "    loss = np.real(psi_exp - phi_exp - regterm)\n",
    "    \n",
    "    return -loss \n",
    "\n",
    "\n",
    "def gen_loss(gen_weights):\n",
    "     \n",
    "    gen_exp = qnodes_gen(gen_weights)\n",
    "    gen_sv = dev2.state\n",
    "\n",
    "    psi_exp , phi_exp , regterm = discriminator(real_exp, gen_exp, disc_weights)\n",
    "    loss = np.real(psi_exp - phi_exp - regterm)\n",
    "    \n",
    "    return loss \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "real_weights = np.random.uniform(0,2,3)\n",
    "real_exp = qnodes_real(real_weights)\n",
    "real_sv = dev1.state\n",
    "\n",
    "gen_weights = np.random.uniform(0,2,3)\n",
    "gen_exp = qnodes_gen(gen_weights)\n",
    "gen_sv = dev2.state\n",
    "\n",
    "disc_weights = np.random.uniform(1,1,8)\n",
    "\n",
    "discriminator(real_exp, gen_exp, disc_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "discriminator_optimizer = tf.keras.optimizers.Adam(0.1)\n",
    "generator_optimizer = tf.keras.optimizers.Adam(0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "%%notify\n",
    "\n",
    "fid = fidelity(real_sv, gen_sv)\n",
    "\n",
    "f = []\n",
    "f.append(fid)\n",
    "dloss=[]\n",
    "gloss=[]\n",
    "\n",
    "niter = 0 \n",
    "\n",
    "\n",
    "while fid <0.99:\n",
    "    \n",
    "    costd = lambda: disc_loss(disc_weights)\n",
    "    discriminator_optimizer.minimize(costd, disc_weights)\n",
    "    dloss.append(disc_loss(disc_weights))\n",
    "    \n",
    "    costg = lambda: gen_loss(gen_weights)\n",
    "    generator_optimizer.minimize(costg, gen_weights)\n",
    "    gloss.append(gen_loss(gen_weights))\n",
    "\n",
    "    gen_exp = qnodes_gen(gen_weights)\n",
    "    gen_sv = dev2.state\n",
    "\n",
    "\n",
    "    fid = fidelity(real_sv, gen_sv)\n",
    "    \n",
    "    f.append(fid)\n",
    "             \n",
    "    niter += 1\n",
    "\n",
    "    if niter == 1000:\n",
    "\n",
    "        break \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}