CRVAE.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as patches\n",
    "import matplotlib.gridspec as gridspec\n",
    "import time\n",
    "from tensorflow.python.layers.base import Layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-f60bac30592a>:3: read_data_sets (from nodule_util) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From G:\\mine\\third\\IVRAE-master\\nodule_util.py:245: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From G:\\mine\\third\\IVRAE-master\\nodule_util.py:247: extract_images (from nodule_util) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting nodule/train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From G:\\mine\\third\\IVRAE-master\\nodule_util.py:252: extract_labels (from nodule_util) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting nodule/train-labels-idx1-ubyte.gz\n",
      "Extracting nodule/t10k-images-idx3-ubyte.gz\n",
      "Extracting nodule/t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From G:\\mine\\third\\IVRAE-master\\nodule_util.py:275: DataSet.__init__ (from nodule_util) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(3000, 1024)\n",
      "(700, 1024)\n",
      "(409, 1024)\n"
     ]
    }
   ],
   "source": [
    "import nodule_util\n",
    "# mnist = input_data.read_data_sets(\"mnist/\")\n",
    "nodule = nodule_util.read_data_sets(\"nodule/\")\n",
    "print(nodule.train.images.shape)\n",
    "print(nodule.validation.images.shape)\n",
    "print(nodule.test.images.shape)\n",
    "# num_train=mnist.train.num_examples\n",
    "# num_val=mnist.validation.num_examples\n",
    "# num_test=mnist.test.num_examples\n",
    "num_train = nodule.train.num_examples\n",
    "num_val = nodule.validation.num_examples\n",
    "num_test = nodule.test.num_examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "transform_mean = np.ones(1024)*0.5\n",
    "transform_std = np.ones(1024)*0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "width = 32\n",
    "height = 32\n",
    "channel = 1\n",
    "Gaussian_scale = 1.0\n",
    "learning_label = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:\n",
      "The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
      "For more information, please see:\n",
      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
      "  * https://github.com/tensorflow/addons\n",
      "  * https://github.com/tensorflow/io (for I/O related ops)\n",
      "If you depend on functionality not listed there, please file an issue.\n",
      "\n",
      "WARNING:tensorflow:From <ipython-input-5-791894be19d3>:64: GRUCell.__init__ (from tensorflow.python.ops.rnn_cell_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "This class is equivalent as tf.keras.layers.GRUCell, and will be replaced by that in Tensorflow 2.0.\n",
      "WARNING:tensorflow:From <ipython-input-5-791894be19d3>:68: Normal.__init__ (from tensorflow.python.ops.distributions.normal) is deprecated and will be removed after 2019-01-01.\n",
      "Instructions for updating:\n",
      "The TensorFlow Distributions library has moved to TensorFlow Probability (https://github.com/tensorflow/probability). You should update all references to use `tfp.distributions` instead of `tf.distributions`.\n",
      "WARNING:tensorflow:From c:\\users\\707\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\tensorflow_core\\python\\ops\\distributions\\normal.py:160: Distribution.__init__ (from tensorflow.python.ops.distributions.distribution) is deprecated and will be removed after 2019-01-01.\n",
      "Instructions for updating:\n",
      "The TensorFlow Distributions library has moved to TensorFlow Probability (https://github.com/tensorflow/probability). You should update all references to use `tfp.distributions` instead of `tf.distributions`.\n",
      "WARNING:tensorflow:From <ipython-input-5-791894be19d3>:77: flatten (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.flatten instead.\n",
      "WARNING:tensorflow:From c:\\users\\707\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\tensorflow_core\\python\\layers\\core.py:332: Layer.apply (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `layer.__call__` method instead.\n",
      "WARNING:tensorflow:From c:\\users\\707\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\tensorflow_core\\python\\ops\\losses\\losses_impl.py:121: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
      "WARNING:tensorflow:From <ipython-input-5-791894be19d3>:121: dense (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.Dense instead.\n",
      "WARNING:tensorflow:From c:\\users\\707\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\tensorflow_core\\python\\ops\\rnn_cell_impl.py:559: Layer.add_variable (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `layer.add_weight` method instead.\n",
      "WARNING:tensorflow:From c:\\users\\707\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\tensorflow_core\\python\\ops\\rnn_cell_impl.py:565: calling Constant.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "WARNING:tensorflow:From c:\\users\\707\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\tensorflow_core\\python\\ops\\rnn_cell_impl.py:575: calling Zeros.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "WARNING:tensorflow:From <ipython-input-5-791894be19d3>:129: kl_divergence (from tensorflow.python.ops.distributions.kullback_leibler) is deprecated and will be removed after 2019-01-01.\n",
      "Instructions for updating:\n",
      "The TensorFlow Distributions library has moved to TensorFlow Probability (https://github.com/tensorflow/probability). You should update all references to use `tfp.distributions` instead of `tf.distributions`.\n",
      "WARNING:tensorflow:From c:\\users\\707\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\tensorflow_core\\python\\training\\rmsprop.py:119: calling Ones.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "X=tf.placeholder(dtype=tf.float32,shape=[None,height*width*channel],name='input_image')\n",
    "y=tf.placeholder(dtype=tf.int32,shape=[None])\n",
    "\n",
    "mask_psed_neg=tf.reshape(tf.cast(tf.equal(y,1),tf.float32),(-1,1))\n",
    "mask_not_psed_neg=tf.reshape(tf.cast(tf.logical_not(tf.equal(y,1)),tf.float32),(-1,1))\n",
    "\n",
    "y_onehot=tf.one_hot(y,3)\n",
    "\n",
    "class CNN_bn_Classifier(Layer):\n",
    "    def __init__(self):\n",
    "        self.conv1=tf.layers.Conv2D(filters=64,kernel_size=3,strides=1,padding='same',activation=tf.nn.relu,name='conv1',_reuse=tf.AUTO_REUSE)\n",
    "        self.conv2=tf.layers.Conv2D(filters=64,kernel_size=3,strides=1,padding='same',activation=tf.nn.relu,name='conv2',_reuse=tf.AUTO_REUSE)\n",
    "        self.conv3=tf.layers.Conv2D(filters=64,kernel_size=3,strides=1,padding='same',activation=tf.nn.relu,name='conv3',_reuse=tf.AUTO_REUSE)\n",
    "        self.batch_norm1=tf.layers.BatchNormalization(axis=3,name='bn1',_reuse=tf.AUTO_REUSE)\n",
    "        self.batch_norm2=tf.layers.BatchNormalization(axis=3,name='bn2',_reuse=tf.AUTO_REUSE)\n",
    "        self.batch_norm3=tf.layers.BatchNormalization(axis=3,name='bn3',_reuse=tf.AUTO_REUSE)\n",
    "        self.max_pool=tf.layers.MaxPooling2D(pool_size=2,strides=2,_reuse=tf.AUTO_REUSE)\n",
    "        self.fc=tf.layers.Dense(units=3,_reuse=tf.AUTO_REUSE)\n",
    "    \n",
    "    def __call__(self,inputs,is_training):\n",
    "        out1=self.max_pool(self.batch_norm1(self.conv1(inputs),training=is_training))\n",
    "        out2=self.max_pool(self.batch_norm2(self.conv2(out1),training=is_training))\n",
    "        out3=self.max_pool(self.batch_norm3(self.conv3(out2),training=is_training))\n",
    "        score=self.fc(tf.layers.flatten(out3))\n",
    "        return score\n",
    "    \n",
    "class CNN_Classifier(Layer):\n",
    "    def __init__(self):\n",
    "        self.conv1=tf.layers.Conv2D(filters=64,kernel_size=3,strides=1,padding='same',activation=tf.nn.relu,name='conv1',_reuse=tf.AUTO_REUSE)\n",
    "        self.conv2=tf.layers.Conv2D(filters=64,kernel_size=3,strides=1,padding='same',activation=tf.nn.relu,name='conv2',_reuse=tf.AUTO_REUSE)\n",
    "        self.conv3=tf.layers.Conv2D(filters=64,kernel_size=3,strides=1,padding='same',activation=tf.nn.relu,name='conv3',_reuse=tf.AUTO_REUSE)\n",
    "        self.max_pool=tf.layers.MaxPooling2D(pool_size=2,strides=2,_reuse=tf.AUTO_REUSE)\n",
    "        self.avg_pool=tf.layers.AveragePooling2D(pool_size=7,strides=7,_reuse=tf.AUTO_REUSE)\n",
    "        self.fc=tf.layers.Dense(units=3,_reuse=tf.AUTO_REUSE)\n",
    "    \n",
    "    def __call__(self,inputs):\n",
    "        out1=self.max_pool(self.conv1(inputs))\n",
    "        out2=self.max_pool(self.conv2(out1))\n",
    "        out3=self.avg_pool(self.conv3(out2))\n",
    "        score=self.fc(tf.layers.flatten(out3))\n",
    "        return score\n",
    "    \n",
    "class NN_Classifier(Layer):\n",
    "    def __init__(self):\n",
    "        self.linear1=tf.layers.Dense(units=512,name='linear1',activation=tf.nn.relu,_reuse=tf.AUTO_REUSE)\n",
    "        self.linear2=tf.layers.Dense(units=256,name='linear2',activation=tf.nn.relu,_reuse=tf.AUTO_REUSE)\n",
    "        self.linear3=tf.layers.Dense(units=256,name='linear3',activation=tf.nn.relu,_reuse=tf.AUTO_REUSE)\n",
    "        self.linear4=tf.layers.Dense(units=3,name='linear4',_reuse=tf.AUTO_REUSE)\n",
    "    \n",
    "    def __call__(self,inputs):\n",
    "        score=self.linear4(self.linear3(self.linear2(self.linear1(inputs))))\n",
    "        return score    \n",
    "\n",
    "# emit_initializer=tf.initializers.random_normal(mean=0.0,stddev=0.15)\n",
    "    \n",
    "class VAE(Layer):\n",
    "    def __init__(self):\n",
    "        self.lstm_hidden_dim=256\n",
    "        self.latent_dim=512\n",
    "        self.n_time=15\n",
    "#         self.encoder_lstm=tf.contrib.rnn.LSTMCell(self.lstm_hidden_dim)\n",
    "#         self.decoder_lstm=tf.contrib.rnn.LSTMCell(self.lstm_hidden_dim)\n",
    "        self.encoder_lstm=tf.contrib.rnn.GRUCell(self.lstm_hidden_dim)\n",
    "        self.decoder_lstm=tf.contrib.rnn.GRUCell(self.lstm_hidden_dim)\n",
    "        self.encode_mean=tf.layers.Dense(units=self.latent_dim,name='encode_mean')   # calculate mean of z\n",
    "        self.encode_std=tf.layers.Dense(units=self.latent_dim,name='encode_std')   # calculate std of z\n",
    "        self.unit_gaussian=tf.distributions.Normal(loc=tf.zeros(self.latent_dim),scale=Gaussian_scale*tf.ones(self.latent_dim))\n",
    "#         self.emit_net=tf.layers.Dense(units=height*width*channel,name='emit_net',kernel_initializer=emit_initializer)\n",
    "        self.emit_net=tf.layers.Dense(units=height*width*channel,name='emit_net')\n",
    "        \n",
    "        \n",
    "    def __call__(self,inputs):\n",
    "        batch_size=tf.shape(inputs)[0]\n",
    "        state_encode=self.encoder_lstm.zero_state(batch_size, tf.float32)   # lstm tuple (c,h)\n",
    "        state_decode=self.decoder_lstm.zero_state(batch_size, tf.float32)   # lstm tuple (c,h)\n",
    "        original_image=tf.layers.flatten(inputs)\n",
    "        output_image=None\n",
    "        latent_loss_his=[]\n",
    "        classifier_loss_his=[]\n",
    "        likelihood_his=[]\n",
    "        predict_his=[]\n",
    "        image_his=[]\n",
    "        \n",
    "        for t in range(self.n_time):\n",
    "            if t==0:\n",
    "                image=original_image\n",
    "            else:\n",
    "                # use output_image for fake images, use original image for real image\n",
    "                image=mask_psed_neg*output_image+mask_not_psed_neg*original_image\n",
    "            image_his.append(image)\n",
    "            '''\n",
    "            Part I: Classifier\n",
    "            '''\n",
    "            classifier_scope=\"CNN_classifier_\"+str(t)\n",
    "#             input_image=tf.reshape(image,(-1,height,width,channel))\n",
    "            input_image=tf.reshape(image,(-1,height*width*channel))\n",
    "            with tf.variable_scope(classifier_scope) as vs:\n",
    "#                 classifier=CNN_Classifier()\n",
    "#                 score_likelihood=classifier(input_image)\n",
    "                classifier=NN_Classifier()\n",
    "                score_likelihood=classifier(input_image)\n",
    "            with tf.variable_scope(classifier_scope) as vs:\n",
    "#                 classifier=CNN_Classifier()\n",
    "#                 score_classifier=classifier(tf.stop_gradient(input_image))\n",
    "                classifier=NN_Classifier()\n",
    "                score_classifier=classifier(tf.stop_gradient(input_image))\n",
    "            \n",
    "            score_likelihood=tf.reshape(score_likelihood[:,0]-score_likelihood[:,1],(-1,1))*mask_psed_neg\n",
    "            likelihood_his.append(score_likelihood) # only record score for fake images\n",
    "            classifier_loss_his.append(tf.losses.softmax_cross_entropy(logits=score_classifier,onehot_labels=y_onehot))\n",
    "            predict_his.append(score_classifier)\n",
    "            \n",
    "            '''\n",
    "            Part II: Recurrent VAE\n",
    "            '''\n",
    "            # add noise\n",
    "            image+=tf.random_normal(shape=tf.shape(image),mean=0.0,stddev=1.0)\n",
    "#             image=tf.clip_by_value(image,clip_value_min=0.0,clip_value_max=1.0)\n",
    "            with tf.variable_scope(\"pre_encoder\") as vs:\n",
    "                image=tf.layers.dense(image,units=512,activation=tf.nn.relu,name='dense_preencoder',reuse=tf.AUTO_REUSE)\n",
    "            with tf.variable_scope(\"LSTM_encoder\") as vs:\n",
    "                encode_out,state_encode=self.encoder_lstm(image,state_encode)\n",
    "            z_mean=self.encode_mean(encode_out)\n",
    "            z_std=tf.exp(self.encode_std(encode_out))\n",
    "            distrib_encode=tf.distributions.Normal(loc=z_mean,scale=z_std)\n",
    "            Z=distrib_encode.sample()\n",
    "            \n",
    "            latent_loss=tf.reduce_sum(mask_psed_neg*tf.distributions.kl_divergence(distrib_encode,self.unit_gaussian),axis=1)\n",
    "            latent_loss_his.append(latent_loss)\n",
    "            \n",
    "            with tf.variable_scope(\"LSTM_decoder\") as vs:\n",
    "                decode_out,state_decode=self.decoder_lstm(Z,state_decode)\n",
    "                \n",
    "            output_image=self.emit_net(decode_out)\n",
    "            \n",
    "        tot_latent_loss=tf.reduce_mean(latent_loss_his)\n",
    "        tot_classifier_loss=tf.reduce_mean(classifier_loss_his)\n",
    "        tot_likelihood_loss=tf.reduce_sum(likelihood_his,axis=0)  # accumulate score through time\n",
    "        tot_likelihood_loss=tf.reduce_mean(-tot_likelihood_loss)\n",
    "        \n",
    "        tot_loss=tot_latent_loss+tot_classifier_loss+tot_likelihood_loss\n",
    "            \n",
    "        return image_his,tot_loss,tot_latent_loss,tot_classifier_loss,tot_likelihood_loss,predict_his\n",
    "\n",
    "\n",
    "vae=VAE()\n",
    "image_his,tot_loss,tot_latent_loss,tot_classifier_loss,tot_likelihood_loss,predict_his=vae(X)\n",
    "tot_classifier_loss=tot_classifier_loss\n",
    "tot_loss2=tot_latent_loss+tot_likelihood_loss\n",
    "\n",
    "classifier_variables=[]\n",
    "vae_variables=[]\n",
    "for v in tf.global_variables():\n",
    "    if v.name.find('CNN_classifier')!=-1:\n",
    "        classifier_variables.append(v)\n",
    "    else:\n",
    "        vae_variables.append(v)\n",
    "\n",
    "\n",
    "global_step1 = tf.Variable(0, trainable=False)\n",
    "starter_learning_rate1 = 1e-3\n",
    "learning_rate1 = tf.train.exponential_decay(starter_learning_rate1, global_step1,300, 0.98, staircase=True)\n",
    "optimizier1=tf.train.AdamOptimizer(learning_rate=learning_rate1)\n",
    "train_step1 = optimizier1.minimize(tot_classifier_loss,global_step=global_step1,var_list=classifier_variables)\n",
    "\n",
    "global_step2 = tf.Variable(0, trainable=False)\n",
    "starter_learning_rate2 = 4e-4\n",
    "learning_rate2 = tf.train.exponential_decay(starter_learning_rate2, global_step2,100, 0.98, staircase=True)\n",
    "optimizier2=tf.train.RMSPropOptimizer(learning_rate=learning_rate2)\n",
    "train_step2 = optimizier2.minimize(tot_loss2,var_list=vae_variables)\n",
    "# train_step2 = optimizier2.minimize(tot_loss2,global_step=global_step2,var_list=vae_variables)\n",
    "\n",
    "# optimizier3=tf.train.AdamOptimizer(learning_rate=1e-3)\n",
    "# train_step3 = optimizier3.minimize(tot_loss)\n",
    "\n",
    "# extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate process\n",
    "G_batch_size=tf.placeholder(shape=(),dtype=tf.int32,name='batch_size')\n",
    "G_state_decode=vae.decoder_lstm.zero_state(G_batch_size, tf.float32)\n",
    "G_unit_gaussian=tf.distributions.Normal(loc=tf.zeros((G_batch_size,vae.latent_dim)),scale=Gaussian_scale*tf.ones((G_batch_size,vae.latent_dim)))\n",
    "\n",
    "G_output_his=[]\n",
    "\n",
    "for t in range(vae.n_time):\n",
    "    G_Z=G_unit_gaussian.sample()\n",
    "    with tf.variable_scope(\"LSTM_decoder\") as vs:\n",
    "        G_decode_out,G_state_decode=vae.decoder_lstm(G_Z,G_state_decode)\n",
    "    G_output_image=vae.emit_net(G_decode_out)\n",
    "    G_output_his.append(G_output_image)\n",
    "G_output_result=G_output_his[-2]  # last output images is meaningless(no gradient on this image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def display():\n",
    "    output_images=sess.run(G_output_result,feed_dict={G_batch_size:9})  # (9,784)\n",
    "#     output_images=output_images*0.5+0.5\n",
    "#     output_images=(output_images+0.3)/0.6\n",
    "    output_images=output_images+0.5\n",
    "    \n",
    "    plt.figure(figsize = (3,3))\n",
    "    gs1 = gridspec.GridSpec(3,3)\n",
    "    gs1.update(wspace=0.025, hspace=0.05)\n",
    "\n",
    "    for i in range(9):\n",
    "        plt.subplot(gs1[i])\n",
    "        plt.imshow(output_images[i,:].reshape(32,32))\n",
    "        plt.axis('off')\n",
    "#     plt.savefig('a.png')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_batch(batch_size,fake_size,noise_size):\n",
    "    X_true,labels=nodule.train.next_batch(batch_size)\n",
    "    index=np.where(labels==learning_label)[0]\n",
    "    X_true=X_true[index,:]\n",
    "#     X_true=X_true*2-1  # range=(-1,1)\n",
    "#     X_true=X_true*0.6-0.3  # range=(-0.3,0.3)\n",
    "    X_true=X_true-0.5  # range=(-0.5,0.5)\n",
    "    X_fake=np.random.uniform(low=-1.5,high=1.5,size=(fake_size,height*width*channel))\n",
    "    X_noise=np.random.uniform(low=-1.5,high=1.5,size=(noise_size,height*width*channel))\n",
    "#     X_fake=np.random.normal(loc=0.0,scale=5.0,size=(fake_size,height*width*channel))\n",
    "#     X_noise=np.random.normal(loc=0.0,scale=5.0,size=(noise_size,height*width*channel))\n",
    "    image=np.vstack((X_true,X_fake,X_noise))\n",
    "    label=np.concatenate((np.zeros(X_true.shape[0]),np.ones(fake_size),2*np.ones(noise_size)))\n",
    "    return image,label,X_true.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2020-12-01 16:49:38 iteration 1/1000: current training loss = 11.923803 (=10.520566+1.171706+0.231531)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x268b48a2780>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "batch_size=640\n",
    "fake_size=128\n",
    "noise_size=512\n",
    "num_iteration=1000\n",
    "print_every=100\n",
    "test_every=100\n",
    "\n",
    "\n",
    "classifier_train=3\n",
    "vae_train=1\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    tf.global_variables_initializer().run()\n",
    "    for it in range(num_iteration):\n",
    "        image,label,true_num=make_batch(batch_size,fake_size,noise_size)\n",
    "#         image,label=make_batch_new(batch_size,fake_size)\n",
    "        feed_dict={X:image,y:label}\n",
    "        loss_num,l1,l2,l3=sess.run([tot_loss,tot_latent_loss,tot_classifier_loss,tot_likelihood_loss],feed_dict=feed_dict)\n",
    "        for t in range(classifier_train):\n",
    "#             _,__=sess.run([train_step1,extra_update_ops],feed_dict={X:image,y:label})\n",
    "            _=sess.run([train_step1],feed_dict={X:image,y:label})\n",
    "        for t in range(vae_train):\n",
    "            _=sess.run([train_step2],feed_dict={X:image,y:label})\n",
    "        \n",
    "        if it==0 or (it+1)%print_every==0 or it==num_iteration-1:\n",
    "            print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())),\n",
    "                  'iteration %d/%d:' % (it+1,num_iteration),'current training loss = %f (=%f+%f+%f)' % (loss_num,l1,l2,l3))\n",
    "        \n",
    "        if it==0 or (it+1)%test_every==0 or it==num_iteration-1:\n",
    "            display()"
   ]
  },
  {
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}