QGAN_training.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Please first ``pip install -U qiskit`` to enable related functionality in translation module\n",
      "Please first ``pip install -U cirq`` to enable related functionality in translation module\n",
      "c:\\Users\\Bingzhi\\envs\\tensorCircuit_tf\\lib\\site-packages\\ot\\backend.py:2998: UserWarning: To use TensorflowBackend, you need to activate the tensorflow numpy API. You can activate it by running: \n",
      "from tensorflow.python.ops.numpy_ops import np_config\n",
      "np_config.enable_numpy_behavior()\n",
      "  register_backend(TensorflowBackend())\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import time\n",
    "from functools import partial\n",
    "\n",
    "import numpy as np\n",
    "from opt_einsum import contract\n",
    "\n",
    "import jax\n",
    "from jax import numpy as jnp\n",
    "from jax import random\n",
    "import optax\n",
    "\n",
    "from src.QGAN import HaarSampleGeneration, QGAN\n",
    "from src.distance_jax import naturalDistance\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import rc\n",
    "rc('text', usetex=True)\n",
    "rc('axes', linewidth=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cluster0Gen(n, N_train, scale, seed):\n",
    "    # generate random quantum states close to |0...0>\n",
    "    remains = (random.normal(random.PRNGKey(seed), shape=(N_train,2**n-1)) \n",
    "                + 1j*random.normal(random.PRNGKey(seed+1), shape=(N_train,2**n-1)))\n",
    "    states = jnp.hstack((np.ones((N_train,1)), scale*remains))\n",
    "    states /= jnp.tile(jnp.linalg.norm(states, axis=1).reshape((1, N_train)), (2**n, 1)).T\n",
    "    return states.astype(jnp.complex64)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def training_generation(model, inputs, params_g, params_c, epochs):\n",
    "    '''\n",
    "    training of generator in QGAN\n",
    "    Inputs:\n",
    "        model: QGAN model\n",
    "        inputs: input states of generators\n",
    "        params_g: parameters of generator\n",
    "        params_c: parameters of classifier\n",
    "        epochs: training epochs\n",
    "    '''\n",
    "    loss_hist = [] # record of training history\n",
    "    \n",
    "    # set optimizer and learning rate decay\n",
    "    optimizer = optax.adam(learning_rate = 0.0005)\n",
    "    opt_state = optimizer.init(params_g)\n",
    "\n",
    "    def loss_func_gen(params_g, inputs, params_c):\n",
    "        states_gen = model.dataGenerate(inputs, params_g)\n",
    "        zs = model.classCircuit_vmap(states_gen, params_c)\n",
    "        # convert to the probability that determined as real data\n",
    "        prob_real = (1. + jnp.real(zs))/2.\n",
    "        return -jnp.mean(prob_real)\n",
    "\n",
    "    loss_func_gen_vg = jax.jit(jax.value_and_grad(loss_func_gen))\n",
    "    #@partial(jax.jit, static_argnums=(2, ))\n",
    "    def update(params_g, inputs, params_c, opt_state):\n",
    "        loss_value, grads = loss_func_gen_vg(params_g, inputs, params_c)\n",
    "        updates, new_opt_state = optimizer.update(grads, opt_state, params_g)\n",
    "        new_params_g = optax.apply_updates(params_g, updates)\n",
    "\n",
    "        return new_params_g, new_opt_state, loss_value\n",
    "\n",
    "    t0 = time.time()\n",
    "    for step in range(epochs):\n",
    "        params_g, opt_state, loss_value = update(params_g, inputs, params_c, opt_state)\n",
    "        \n",
    "        if step % 100 == 0:\n",
    "            print(\"Step {}, loss: {:.7f}, time elapsed: {:.4f} seconds\".format(step, loss_value, time.time() - t0))\n",
    "        \n",
    "        loss_hist.append(loss_value) # record the current loss\n",
    "\n",
    "    return params_g, params_c, loss_hist\n",
    "\n",
    "\n",
    "def training_classification(model, inputs, data_true, params_g, params_c, epochs):\n",
    "    '''\n",
    "    training of generator in QGAN\n",
    "    Inputs:\n",
    "        model: QGAN model\n",
    "        inputs: input states of generators\n",
    "        data_true: the true data\n",
    "        params_g: parameters of generator\n",
    "        params_c: parameters of classifier\n",
    "        epochs: training epochs\n",
    "    '''\n",
    "    loss_hist = [] # record of training history\n",
    "\n",
    "    # set optimizer and learning rate decay\n",
    "    optimizer = optax.adam(learning_rate = 0.0005)\n",
    "    opt_state = optimizer.init(params_c)\n",
    "\n",
    "    def loss_func_class(params_c, inputs, data_true, params_g):\n",
    "        states_gen = model.dataGenerate(inputs, params_g)\n",
    "        zs_gen = model.classCircuit_vmap(states_gen, params_c)\n",
    "        zs_true = model.classCircuit_vmap(data_true, params_c)\n",
    "        # convert to the probability that determined as real data on fake data\n",
    "        prob_real_fake = (1. + jnp.real(zs_gen))/2.\n",
    "        # convert to the probability that determined as real data on real data\n",
    "        prob_real_real = (1 + jnp.real(zs_true))/2\n",
    "        return jnp.mean(prob_real_fake - prob_real_real)\n",
    "\n",
    "    loss_func_class_vg = jax.jit(jax.value_and_grad(loss_func_class))\n",
    "    #@partial(jax.jit, static_argnums=(2, ))\n",
    "    def update(params_c, inputs, data_true, params_g, opt_state):\n",
    "        loss_value, grads = loss_func_class_vg(params_c, inputs, data_true, params_g)\n",
    "        updates, new_opt_state = optimizer.update(grads, opt_state, params_c)\n",
    "        new_params_c = optax.apply_updates(params_c, updates)\n",
    "\n",
    "        return new_params_c, new_opt_state, loss_value\n",
    "\n",
    "    t0 = time.time()\n",
    "    for step in range(epochs):\n",
    "        np.random.seed()\n",
    "        indices = np.random.choice(data_true.shape[0], size=inputs.shape[0], replace=False)\n",
    "\n",
    "        params_c, opt_state, loss_value = update(params_c, inputs, data_true[indices], \n",
    "                                                 params_g, opt_state)\n",
    "        \n",
    "        if step % 100 == 0:\n",
    "            print(\"Step {}, loss: {:.7f}, time elapsed: {:.4f} seconds\".format(step, loss_value, time.time() - t0))\n",
    "        \n",
    "        loss_hist.append(loss_value) # record the current loss\n",
    "\n",
    "    return params_g, params_c, loss_hist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def benchmarkProbs(model, inputs, data_true, params_g, params_c):\n",
    "    '''\n",
    "    benchmark function for discriminator and classifier on the probability\n",
    "    '''\n",
    "    states_gen = model.dataGenerate(inputs, params_g)\n",
    "    zs_gen = model.classCircuit_vmap(states_gen, params_c)\n",
    "    np.random.seed()\n",
    "    indices = np.random.choice(data_true.shape[0], size=inputs.shape[0], replace=False)\n",
    "    zs_true = model.classCircuit_vmap(data_true[indices], params_c)\n",
    "\n",
    "    prob_real_real = jnp.mean((1. + zs_true)/2.) # real as real\n",
    "    prob_real_fake = jnp.mean((1. + zs_gen)/2.) # fake as real\n",
    "    return prob_real_real, prob_real_fake"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 2 # data qubits\n",
    "na = 1 # ancilla qubits\n",
    "Lg = 120 # layer of generation circuit\n",
    "Lc = 16 # layer of classifier circuit\n",
    "Ndata = 100\n",
    "epochs_c = 2001\n",
    "epochs_g = 6001\n",
    "cycles = 5 # the cycles of adversarial game\n",
    "\n",
    "# create input data for generation circuit and true data\n",
    "inputs = HaarSampleGeneration(Ndata, n, 42)\n",
    "data_true = cluster0Gen(n, 10*Ndata, 0.06, seed=12)\n",
    "\n",
    "model = QGAN(n=n, na=na, Lg=Lg, Lc=Lc)\n",
    "loss_class = np.zeros((cycles, epochs_c))\n",
    "loss_gen = np.zeros((cycles, epochs_g))\n",
    "for cy in range(cycles):\n",
    "    # initialize parameters\n",
    "    key = random.PRNGKey(42)\n",
    "    params_g = random.normal(key, shape=(2*(n+na)*Lg, ))\n",
    "    params_c = random.normal(key, shape=(2*n*Lc, ))\n",
    "\n",
    "    # training classifier holding generator fixed\n",
    "    params_g, params_c, loss_hist1 = training_classification(model, inputs, data_true, \n",
    "                                                            params_g, params_c, epochs_c)\n",
    "    loss_class[cy] = loss_hist1\n",
    "    prob_rr, prob_rf = benchmarkProbs(model, inputs, data_true, params_g, params_c)\n",
    "    print('cycle=%d, discriminator, Prob(real classified as real)=%s, Prob(fake classified as real)=%s'\n",
    "          %(cy+1, prob_rr, prob_rf))\n",
    "\n",
    "    # training generator holding classier fixed\n",
    "    params_g, params_c, loss_hist2 = training_generation(model, inputs, params_g, params_c, \n",
    "                                                        epochs_g)\n",
    "    loss_gen[cy] = loss_hist2\n",
    "    prob_rr, prob_rf = benchmarkProbs(model, inputs, data_true, params_g, params_c)\n",
    "    print('cycle=%d, generator, Prob(fake classified as real)=%s, Discriminator cost=%s'\n",
    "          %(cy+1, prob_rf, prob_rf-prob_rr))\n",
    "\n",
    "np.save('data/qgan/QGANcluster0paramsGen_n2na1Lg120Lc16_cy%d.npy'%cy, params_g)\n",
    "np.save('data/qgan/QGANcluster0paramsCla_n2na1Lg120Lc16_cy%d.npy'%cy, params_c)\n",
    "np.save('data/qgan/QGANcluster0lossGen_n2na1Lg120Lc16_cy%d.npy'%cy, loss_gen)\n",
    "np.save('data/qgan/QGANcluster0lossCla_n2na1Lg120Lc16_cy%d.npy'%cy, loss_class)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Performance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## generate training and testing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 2 # data qubits\n",
    "na = 1 # ancilla qubits\n",
    "Lg = 120 # layer of generation circuit\n",
    "Lc = 16\n",
    "Ndata = 100\n",
    "\n",
    "params_g = np.load('data/qgan/QGANcluster0paramsGen_n2na1Lg120Lc16_cy5.npy')\n",
    "\n",
    "inputs_tr = HaarSampleGeneration(Ndata, n, 42)\n",
    "inputs_te = HaarSampleGeneration(Ndata, n, 50)\n",
    "model = QGAN(n, na, Lg, Lc)\n",
    "states_gen_tr = model.dataGenerate(inputs_tr, params_g)\n",
    "states_gen_te = model.dataGenerate(inputs_te, params_g)\n",
    "\n",
    "np.save('data/qgan/QGANcluster0traingen_n2na1Lg120Lc16.npy', states_gen_tr)\n",
    "np.save('data/qgan/QGANcluster0testgen_n2na1Lg120Lc16.npy', states_gen_te)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Ndata = 100\n",
    "n = 2\n",
    "states_gen_tr = np.load('data/qgan/QGANcluster0traingen_n2na1Lg120Lc16.npy')\n",
    "states_gen_te = np.load('data/qgan/QGANcluster0testgen_n2na1Lg120Lc16.npy')\n",
    "inputs_tr = HaarSampleGeneration(Ndata, n, 42)\n",
    "inputs_te = HaarSampleGeneration(Ndata, n, 50)\n",
    "\n",
    "f0_tr_qgan = np.vstack((np.abs(states_gen_tr[:, 0])**2, np.abs(inputs_tr[:, 0])**2))\n",
    "f0_te_qgan = np.vstack((np.abs(states_gen_te[:, 0])**2, np.abs(inputs_te[:, 0])**2))\n",
    "\n",
    "F0_diff = np.abs(np.load('data/cluster/n2/cluster0Diff_n2T20_N1000.npy')[:,:,0])**2\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(8, 6))\n",
    "T1 = 20\n",
    "ax.errorbar([0, T1], np.mean(f0_tr_qgan, axis=1), yerr=np.std(f0_tr_qgan, axis=1), fmt='o--',\n",
    "    lw=2, mfc='white', barsabove=True, markersize=10, c='b', capsize=4, zorder=5, label=r'$\\rm training$')\n",
    "ax.errorbar([0, T1], np.mean(f0_te_qgan,axis=1), yerr=np.std(f0_te_qgan, axis=1), fmt='o--',\n",
    "    lw=2, mfc='white', barsabove=True, markersize=10, capsize=4, c='forestgreen', zorder=5, label=r'$\\rm testing$')\n",
    "\n",
    "ax.plot(np.arange(T1+1), np.mean(F0_diff, axis=1), 'o--', mfc='white',\n",
    "    lw=2, markersize=5, c='deeppink', alpha=0.5, zorder=5)\n",
    "\n",
    "ax.hlines(0.25, xmin=-5, xmax=25, lw=2, ls='--', color='orange')\n",
    "ax.legend(fontsize=25, loc='lower center', handlelength=1, framealpha=0.3)\n",
    "ax.set_ylabel(r'$F_0$', fontsize=30)\n",
    "ax.set_xlabel(r'$t$', fontsize=30)\n",
    "ax.set_xlim(-1, 21)\n",
    "ax.set_ylim(-0.05, 1.05)\n",
    "ax.set_xticks(np.arange(3)*10)\n",
    "ax.tick_params(direction='in', length=10, width=3, top='on', right='on', labelsize=30)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tensorCircuit_tf",
   "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}