5_public_gan_v2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import pickle\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "import tflib as lib\n",
    "import tflib.ops.linear\n",
    "import matplotlib.pyplot as plt\n",
    "from random import randint\n",
    "from scipy.stats import wasserstein_distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>...</th>\n",
       "      <th>150</th>\n",
       "      <th>151</th>\n",
       "      <th>152</th>\n",
       "      <th>153</th>\n",
       "      <th>154</th>\n",
       "      <th>155</th>\n",
       "      <th>156</th>\n",
       "      <th>157</th>\n",
       "      <th>158</th>\n",
       "      <th>159</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.460752</td>\n",
       "      <td>0.690727</td>\n",
       "      <td>0.289209</td>\n",
       "      <td>...</td>\n",
       "      <td>0.459836</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.704294</td>\n",
       "      <td>0.457027</td>\n",
       "      <td>0.217206</td>\n",
       "      <td>...</td>\n",
       "      <td>0.565490</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.763681</td>\n",
       "      <td>0.690727</td>\n",
       "      <td>0.289209</td>\n",
       "      <td>...</td>\n",
       "      <td>0.314966</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0.463889</td>\n",
       "      <td>0.690727</td>\n",
       "      <td>0.289209</td>\n",
       "      <td>...</td>\n",
       "      <td>0.681866</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0.743854</td>\n",
       "      <td>0.690727</td>\n",
       "      <td>0.289209</td>\n",
       "      <td>...</td>\n",
       "      <td>0.314966</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 160 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   0    1    2    3    4    5    6         7         8         9    ...  \\\n",
       "0    1    0    0    0    0    0    0  0.460752  0.690727  0.289209  ...   \n",
       "1    1    0    0    0    0    0    0  0.704294  0.457027  0.217206  ...   \n",
       "2    0    0    0    0    1    0    0  0.763681  0.690727  0.289209  ...   \n",
       "3    0    0    0    0    0    1    0  0.463889  0.690727  0.289209  ...   \n",
       "4    0    0    0    0    0    1    0  0.743854  0.690727  0.289209  ...   \n",
       "\n",
       "        150  151  152  153  154  155  156  157  158  159  \n",
       "0  0.459836    0    0    0    0    0    0    1    0    0  \n",
       "1  0.565490    0    1    0    0    1    0    1    0    0  \n",
       "2  0.314966    0    1    0    0    0    0    1    0    0  \n",
       "3  0.681866    0    1    0    0    1    0    1    0    0  \n",
       "4  0.314966    0    1    0    0    0    0    1    0    0  \n",
       "\n",
       "[5 rows x 160 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(260391, 160)\n"
     ]
    }
   ],
   "source": [
    "def loadfile(filename):\n",
    "    pickle_in = open(\"C:/Users/Akarsh/Downloads/DP_scripts/store_emb/\" + filename + \".pickle\",\"rb\")\n",
    "    return pickle.load(pickle_in)\n",
    "\n",
    "def save2file(filename, data):\n",
    "    pickle_out = open(\"C:/Users/Akarsh/Downloads/DP_scripts/store_emb/\" + filename + \".pickle\", \"wb\")\n",
    "    pickle.dump(data, pickle_out, protocol=pickle.HIGHEST_PROTOCOL)\n",
    "    pickle_out.close()\n",
    "\n",
    "main_str = str(437)\n",
    "\n",
    "filename = \"gan_train_\" + main_str\n",
    "gan_data = loadfile(filename)\n",
    "display(gan_data.head())\n",
    "print(gan_data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "65\n"
     ]
    }
   ],
   "source": [
    "# Configuration Parameter\n",
    "DEVICES = ['/cpu:0']\n",
    "MODE = \"wgan_gp\" #wgan #wgan_gp\n",
    "num_epochs = int(10);             BATCH_SIZE = int(128);   input_length_noise = int(100)\n",
    "fully_connected_dim = int(80);    LAMBDA = 10 # Gradient penalty lambda hyperparameter\n",
    "TTUR = False;      gen_examples = len(gan_data);\n",
    "\n",
    "trial_str = str(randint(0, 100))\n",
    "print(trial_str)\n",
    "\n",
    "if TTUR:\n",
    "    CRITIC_ITERS = 1 # disc train iterations\n",
    "    D_LR = 0.0003\n",
    "    G_LR = 0.0001\n",
    "    BETA1_D = 0.0\n",
    "    BETA1_G = 0.0\n",
    "else:\n",
    "    CRITIC_ITERS = 5 # disc train iterations\n",
    "    D_LR = 0.0005\n",
    "    G_LR = 0.0005\n",
    "    BETA1_D = 0.0\n",
    "    BETA1_G = 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converting data...\n",
      "Read lines:  50000\n",
      "Read lines:  100000\n",
      "Read lines:  150000\n",
      "Read lines:  200000\n",
      "Read lines:  250000\n",
      "Data converted\n",
      "260391\n",
      "Data_DIM, Training_rows:  160 , 260391\n"
     ]
    }
   ],
   "source": [
    "counter_read = 0;      input_length_data = -1;     add_noise_to_real_data = True;\n",
    "class NetflowDataFlow():\n",
    "    def __init__(self, data_file):\n",
    "        def prepare_data(dp):\n",
    "            global input_length_data\n",
    "            global counter_read\n",
    "            if input_length_data == -1: \n",
    "                input_length_data = dp.shape[1]\n",
    "            lst = []\n",
    "            for val in list(dp.values):\n",
    "                counter_read += 1\n",
    "                if counter_read % 50000 == 0:\n",
    "                    print(\"Read lines: \", str(counter_read))\n",
    "                lst.append(val)\n",
    "            return lst\n",
    "        print(\"Converting data...\")\n",
    "        self.data = prepare_data(gan_data)\n",
    "        print(\"Data converted\")\n",
    "        random.shuffle(self.data)\n",
    "        \n",
    "        self.size = len(self.data)\n",
    "        print(self.size)\n",
    "        self.pointer = 0\n",
    "    \n",
    "    def sample(self, N):\n",
    "        if self.pointer + N > self.size -1: \n",
    "            self.pointer = 0 \n",
    "            random.shuffle(self.data)\n",
    "        samples = self.data[self.pointer:self.pointer+N]\n",
    "        if add_noise_to_real_data: \n",
    "            for q in range(0,N):\n",
    "                noise = np.random.uniform(-0.05,0.05, input_length_data)\n",
    "                samples[q] = samples[q] + noise\n",
    "        self.pointer = self.pointer + N\n",
    "        return samples\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.size\n",
    "\n",
    "ndf = NetflowDataFlow(gan_data)\n",
    "DIM = input_length_data\n",
    "print(\"Data_DIM, Training_rows: \", DIM, ',', counter_read)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def GeneratorAndDiscriminator():\n",
    "    return FCGenerator, FCDiscriminator\n",
    "\n",
    "def LeakyReLU(x, alpha=0.2):\n",
    "    return tf.maximum(alpha*x, x)\n",
    "\n",
    "def ReLULayer(name, n_in, n_out, inputs):\n",
    "    output = lib.ops.linear.Linear(name+'.Linear', n_in, n_out, inputs, initialization='he')\n",
    "    return tf.nn.relu(output)\n",
    "\n",
    "def LeakyReLULayer(name, n_in, n_out, inputs):\n",
    "    output = lib.ops.linear.Linear(name+'.Linear', n_in, n_out, inputs, initialization='he')\n",
    "    return LeakyReLU(output)\n",
    "\n",
    "def FCGenerator(n_samples, noise=None, FC_DIM=fully_connected_dim):\n",
    "    if noise is None:\n",
    "        noise = tf.random_normal([n_samples, input_length_noise])\n",
    "\n",
    "    output = ReLULayer('Generator.1', input_length_noise, FC_DIM, noise)\n",
    "    output = ReLULayer('Generator.2', FC_DIM, FC_DIM, output)\n",
    "    output = ReLULayer('Generator.3', FC_DIM, FC_DIM, output)\n",
    "    output = ReLULayer('Generator.4', FC_DIM, FC_DIM, output)\n",
    "    output = ReLULayer('Generator.Out', FC_DIM, input_length_data, output)\n",
    "    #output = tf.tanh(output)\n",
    "    return output\n",
    "\n",
    "def FCDiscriminator(inputs, FC_DIM=fully_connected_dim, n_layers=3):\n",
    "    output = LeakyReLULayer('Discriminator.Input', input_length_data, FC_DIM, inputs)\n",
    "    for i in range(n_layers):\n",
    "        output = LeakyReLULayer('Discriminator.{}'.format(i), FC_DIM, FC_DIM, output)\n",
    "    output = lib.ops.linear.Linear('Discriminator.Out', FC_DIM, 1, output)\n",
    "    return tf.reshape(output, [-1])\n",
    "\n",
    "Generator, Discriminator = GeneratorAndDiscriminator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\users\\akarsh\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorflow_core\\python\\ops\\math_grad.py:1424: 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",
      "Step  0  From  20343 ( Epoch 0 ): Disc_cost: -0.27167922  Gen_cost: 0\n",
      "Wasserstein dist: 0 \n",
      "\n",
      "Step  2034  From  20343 ( Epoch 0 ): Disc_cost: -0.7376862  Gen_cost: 1.634345\n",
      "Wasserstein dist: 0 \n",
      "\n",
      "Step  4068  From  20343 ( Epoch 1 ): Disc_cost: -0.51762086  Gen_cost: 1.6361891\n",
      "Wasserstein dist: 0.045189504545005685 \n",
      "\n",
      "Step  6102  From  20343 ( Epoch 2 ): Disc_cost: -0.46007854  Gen_cost: 1.5831397\n",
      "Wasserstein dist: 0.03583141134054382 \n",
      "\n",
      "Step  8136  From  20343 ( Epoch 3 ): Disc_cost: -0.40747404  Gen_cost: 1.5769234\n",
      "Wasserstein dist: 0.03223700894354691 \n",
      "\n",
      "Step  10170  From  20343 ( Epoch 4 ): Disc_cost: -0.33558002  Gen_cost: 1.2895074\n",
      "Wasserstein dist: 0.031223845462770107 \n",
      "\n",
      "Step  12204  From  20343 ( Epoch 5 ): Disc_cost: -0.29197896  Gen_cost: 1.1616955\n",
      "Wasserstein dist: 0.02812383479276742 \n",
      "\n",
      "Step  14238  From  20343 ( Epoch 6 ): Disc_cost: -0.3059942  Gen_cost: 1.0722555\n",
      "Wasserstein dist: 0.026731903234243126 \n",
      "\n",
      "Step  16272  From  20343 ( Epoch 7 ): Disc_cost: -0.23837827  Gen_cost: 1.0136249\n",
      "Wasserstein dist: 0.02631729647418064 \n",
      "\n",
      "Step  18306  From  20343 ( Epoch 8 ): Disc_cost: -0.22205052  Gen_cost: 0.9163389\n",
      "Wasserstein dist: 0.027388804864124094 \n",
      "\n",
      "Step  20340  From  20343 ( Epoch 9 ): Disc_cost: -0.14028321  Gen_cost: 1.0288382\n",
      "Wasserstein dist: 0.02520714416835263 \n",
      "\n",
      "Final Wasserstein dist: 0.02498242584407289\n",
      "training finished...\n"
     ]
    }
   ],
   "source": [
    "with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as session:\n",
    "\n",
    "    all_real_data_conv = tf.placeholder(tf.float32, shape=[BATCH_SIZE, input_length_data])\n",
    "    \n",
    "    if tf.__version__.startswith('1.'):\n",
    "        split_real_data_conv = tf.split(all_real_data_conv, len(DEVICES))\n",
    "    else:\n",
    "        split_real_data_conv = tf.split(0, len(DEVICES), all_real_data_conv)\n",
    "    gen_costs, disc_costs = [],[]\n",
    "\n",
    "    for device_index, (device, real_data_conv) in enumerate(zip(DEVICES, split_real_data_conv)):\n",
    "        with tf.device(device):\n",
    "            \n",
    "            real_data = real_data_conv\n",
    "            fake_data = Generator(BATCH_SIZE//len(DEVICES))\n",
    " \n",
    "            disc_fake = Discriminator(fake_data)\n",
    "            disc_real = Discriminator(real_data)\n",
    "            \n",
    "            if MODE == 'wgan':\n",
    "                gen_cost = -tf.reduce_mean(disc_fake)\n",
    "                disc_cost = tf.reduce_mean(disc_fake) - tf.reduce_mean(disc_real)\n",
    "\n",
    "            elif MODE == 'wgan_gp':\n",
    "                gen_cost = -tf.reduce_mean(disc_fake)\n",
    "                disc_cost = tf.reduce_mean(disc_fake) - tf.reduce_mean(disc_real)\n",
    "\n",
    "                alpha = tf.random_uniform(shape=[BATCH_SIZE//len(DEVICES),1], minval=0., maxval=1.)\n",
    "                differences = fake_data - real_data\n",
    "                interpolates = real_data + (alpha*differences)\n",
    "                gradients = tf.gradients(Discriminator(interpolates), interpolates)[0]\n",
    "                slopes = tf.sqrt(tf.reduce_sum(tf.square(gradients), reduction_indices=[1]))\n",
    "                gradient_penalty = tf.reduce_mean((slopes-1.)**2)\n",
    "                disc_cost += LAMBDA*gradient_penalty\n",
    "            else:\n",
    "                raise Exception()\n",
    "            \n",
    "            gen_costs.append(gen_cost)\n",
    "            disc_costs.append(disc_cost)\n",
    "\n",
    "    gen_cost = tf.add_n(gen_costs) / len(DEVICES)\n",
    "    disc_cost = tf.add_n(disc_costs) / len(DEVICES)\n",
    "\n",
    "    if MODE == 'wgan':\n",
    "        gen_train_op = tf.train.RMSPropOptimizer(learning_rate=G_LR).minimize(gen_cost,\n",
    "                                             var_list=lib.params_with_name('Generator'), colocate_gradients_with_ops=True)\n",
    "        disc_train_op = tf.train.RMSPropOptimizer(learning_rate=D_LR).minimize(disc_cost,\n",
    "                                             var_list=lib.params_with_name('Discriminator.'), colocate_gradients_with_ops=True)\n",
    "        clip_ops = []\n",
    "        for var in lib.params_with_name('Discriminator'):\n",
    "            clip_bounds = [-.01, .01]\n",
    "            clip_ops.append(tf.assign(var, tf.clip_by_value(var, clip_bounds[0], clip_bounds[1])))\n",
    "        clip_disc_weights = tf.group(*clip_ops)\n",
    "\n",
    "    elif MODE == 'wgan_gp':\n",
    "        gen_train_op = tf.train.AdamOptimizer(learning_rate=G_LR, beta1=BETA1_G, beta2=0.9).minimize(gen_cost,\n",
    "                                          var_list=lib.params_with_name('Generator'), colocate_gradients_with_ops=True)\n",
    "        disc_train_op = tf.train.AdamOptimizer(learning_rate=D_LR, beta1=BETA1_D, beta2=0.9).minimize(disc_cost,\n",
    "                                           var_list=lib.params_with_name('Discriminator.'), colocate_gradients_with_ops=True)\n",
    "        \n",
    "    # generating samples\n",
    "    fixed_noise = tf.constant(np.random.normal(size=(BATCH_SIZE, input_length_noise)).astype('float32'))\n",
    "    all_fixed_noise_samples = []\n",
    "    for device_index, device in enumerate(DEVICES):\n",
    "        n_samples = BATCH_SIZE // len(DEVICES)\n",
    "        all_fixed_noise_samples.append(Generator(n_samples,\n",
    "                                                 noise=fixed_noise[device_index*n_samples:(device_index+1)*n_samples]))\n",
    "    if tf.__version__.startswith('1.'):\n",
    "        all_fixed_noise_samples = tf.concat(all_fixed_noise_samples, axis=0)\n",
    "    else:\n",
    "        all_fixed_noise_samples = tf.concat(0, all_fixed_noise_samples)\n",
    "\n",
    "    session.run(tf.global_variables_initializer())\n",
    "\n",
    "    # generating samples\n",
    "    samples_examples = Generator(gen_examples)\n",
    "    def generate_final_flows(out_text):\n",
    "        samples = session.run(samples_examples)\n",
    "        \n",
    "        was = 0\n",
    "        for i in range(samples.shape[1]):\n",
    "            was += wasserstein_distance(samples[:, i], gan_data.values[:, i])         \n",
    "        was /= samples.shape[1]\n",
    "        \n",
    "        filename = out_text + '_' + main_str\n",
    "        save2file(filename, samples)\n",
    "        return was\n",
    "\n",
    "    ITERS = int((num_epochs * counter_read) / BATCH_SIZE )\n",
    "    epoch = 0; train_loss = []; w_dis = []; epoch_wdis = 0;\n",
    "    _gen_cost = 0; old_epoch = 0;\n",
    "    \n",
    "    for iteration in range(ITERS):\n",
    "        epoch = int((iteration * BATCH_SIZE) / counter_read)\n",
    "        if epoch > old_epoch:\n",
    "            epoch_wdis = generate_final_flows(MODE + \"_epoch\" + str(epoch))\n",
    "            w_dis.append(epoch_wdis)\n",
    "            \n",
    "        old_epoch = epoch\n",
    "        \n",
    "        # Train generator\n",
    "        if iteration > 0:\n",
    "            _gen_cost, _ = session.run([gen_cost, gen_train_op])\n",
    "        \n",
    "        # Train discriminator\n",
    "        disc_iters = CRITIC_ITERS\n",
    "        for i in range(disc_iters):\n",
    "            _data = ndf.sample(BATCH_SIZE)\n",
    "            _disc_cost, _ = session.run([disc_cost, disc_train_op], feed_dict={all_real_data_conv: _data})\n",
    "            \n",
    "            if MODE == \"wgan\":\n",
    "                _ = session.run([clip_disc_weights])\n",
    "        \n",
    "        if iteration % int((counter_read) / BATCH_SIZE ) == 0:\n",
    "            print(\"Step \", iteration, \" From \", ITERS, \"(\",\"Epoch\", epoch,\"): Disc_cost:\", _disc_cost, \" Gen_cost:\", _gen_cost)\n",
    "            print(\"Wasserstein dist:\", epoch_wdis, '\\n')\n",
    "            \n",
    "        train_loss.append([_gen_cost, _disc_cost])\n",
    "    \n",
    "    # Store final outputs\n",
    "    finalwdis = generate_final_flows(MODE + \"_final\")\n",
    "    print(\"Final Wasserstein dist:\", finalwdis)\n",
    "    w_dis.append(epoch_wdis)\n",
    "    \n",
    "print('training finished...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "filename = MODE + '_train_loss_' + main_str\n",
    "save2file(filename, train_loss)\n",
    "\n",
    "filename = MODE + '_wass_dis'\n",
    "save2file(filename, w_dis)\n",
    "\n",
    "tt = np.arange(ITERS)\n",
    "plt.plot(tt, np.array(train_loss)[:, 1], label='d_loss')\n",
    "plt.plot(tt, np.array(train_loss)[:, 0], label='g_loss')\n",
    "plt.legend()\n",
    "plt.xlabel('GAN iterations')\n",
    "plt.ylabel('Training Loss')\n",
    "plt.savefig('C:/Users/Akarsh/Downloads/DP_scripts/store_emb/' + MODE + '_gan_loss_' + main_str +'.png')\n",
    "plt.show()\n",
    "\n",
    "X = list(range(0, len(w_dis)))\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1)\n",
    "ax.plot(X, w_dis)\n",
    "ax.set_xlabel(\"Number of WGAN iterations\")\n",
    "ax.set_ylabel(\"Wasserstein distance\")\n",
    "fig.savefig(\"C:/Users/Akarsh/Downloads/DP_scripts/store_emb/\" +  MODE + \"_wasserstein_plot.png\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data and hyperparams saved...\n"
     ]
    }
   ],
   "source": [
    "save = True\n",
    "if save:\n",
    "    df = pd.DataFrame.from_records([{'operation': 'gan_train', 'main_str': main_str, 'trial_str': trial_str, 'MODE': MODE, \n",
    "                                     'fully_connected_dim': fully_connected_dim, 'ITERS': ITERS,\n",
    "                                     'batch_size': BATCH_SIZE, 'gradient_pen': LAMBDA, 'clip_weights': 0.01,\n",
    "                                     'TTUR': 'yes_keep_default', 'gen_examples_len': gen_examples, \n",
    "                                     'add_noise_to_real_data': add_noise_to_real_data}])\n",
    "\n",
    "    df.to_csv(\"C:/Users/Akarsh/Downloads/DP_scripts/store_emb/store_params.csv\", mode='a', index=False)\n",
    "    print('data and hyperparams saved...')"
   ]
  }
 ],
 "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
}