examples/tf_AutoEncoderForGeometricShapingNlinGmi.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf\n",
    "import scipy.io\n",
    "from tensorflow.python.framework import function\n",
    "\n",
    "import os, re\n",
    "\n",
    "import claude.utils as cu\n",
    "import claude.claudeflow.autoencoder as ae\n",
    "import claude.claudeflow.helper as cfh\n",
    "import claude.claudeflow.training as cft\n",
    "import claude.claudeflow.models.NLIN as cfnlin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M=64,PdBm=-2,seed=1338\n"
     ]
    }
   ],
   "source": [
    "# Parameters\n",
    "# Channel Parameters\n",
    "chParam = cu.AttrDict()\n",
    "chParam.M = 64\n",
    "chParam.w = int(np.log2(chParam.M))\n",
    "chParam.D\t\t  = 16.4640\n",
    "chParam.nPol\t  = 2\n",
    "chParam.PdBm\t  = -2\n",
    "chParam.nSpans\t  = 10\n",
    "chParam.channels = np.array([-100., -50., 0., 50., 100.])\n",
    "\n",
    "# Auto-Encoder Parameters\n",
    "aeParam = cu.AttrDict()\n",
    "aeParam.seed = 1338\n",
    "aeParam.constellationDim\t= 2\n",
    "aeParam.constellationOrder  = chParam.M\n",
    "aeParam.nLayers\t\t= 4\n",
    "aeParam.nHidden \t= 256\n",
    "aeParam.activation  = tf.nn.relu\n",
    "aeParam.dtype       = tf.float32\n",
    "aeParam.GN\t        = False\n",
    "aeParam.optimizeP   = True\n",
    "\n",
    "# Training Parameters\n",
    "trainingParam = cu.AttrDict()\n",
    "trainingParam.sampleSize\t= 16*chParam.M # Increase for better results (especially if M>16)\n",
    "trainingParam.batchSize \t= 1*chParam.M  # Increase for better results (especially if M>16)\n",
    "trainingParam.learningRate\t= 0.001\n",
    "trainingParam.displayStep\t= 25\n",
    "trainingParam.path\t\t\t= 'results_GMI_NLIN'\n",
    "trainingParam.filename\t\t= 'M{:03d}_PdBm{:.2f}_seed{:04d}'.format(chParam.M,chParam.PdBm,aeParam.seed)\n",
    "trainingParam.earlyStopping = 25\n",
    "trainingParam.iterations = 500\n",
    "trainingParam.summaries = True\n",
    "\n",
    "if trainingParam.summaries:\n",
    "    # tensorboard directory\n",
    "    chHyperParam = ['M','PdBm']\n",
    "    aeHyperParam = ['seed']\n",
    "    trainingHyperParam = []\n",
    "\n",
    "    trainingParam.summaryString = ','.join(  [ '{}={}'.format(item,chParam[item]) for item in chHyperParam ]\n",
    "                                            +[ '{}={}'.format(item,trainingParam[item]) for item in trainingHyperParam ]\n",
    "                                            +[ '{}={}'.format(item,aeParam[item]) for item in aeHyperParam ] )\n",
    "\n",
    "    print(trainingParam.summaryString,flush=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TF constants\n",
    "one = tf.constant(1,aeParam.dtype)\n",
    "two = tf.constant(2,aeParam.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from claude.models.NLIN import defaultParameters,\\\n",
    "                               calcConstants,\\\n",
    "                               calcIntraChannelNLIN,calcInterChannelNLIN,\\\n",
    "                               calcIntraChannelGN,calcInterChannelGN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NLIN model\n",
    "p = defaultParameters( D=chParam.D )\n",
    "p.PdBm = chParam.PdBm\n",
    "p.nSpans = chParam.nSpans\n",
    "p.nPol = chParam.nPol\n",
    "p.channels = chParam.channels\n",
    "p.nChannels = len(chParam.channels)\n",
    "\n",
    "aseNoisePower, interConst, intraConst, interConstAdd, intraConstAdd = calcConstants(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W0921 22:22:43.464514 139716625557312 lazy_loader.py:50] \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",
      "W0921 22:22:43.475305 139716625557312 deprecation.py:323] From /home/rasmus/.conda/envs/claudeOnline/lib/python3.6/site-packages/tensorflow/python/ops/distributions/util.py:1196: add_dispatch_support.<locals>.wrapper (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"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nPol:\t2\n",
      "lambda_:\t1.55003597538907e-06\n",
      "Fc:\t193410000000000.0\n",
      "D:\t16.464\n",
      "alpha:\t0.2\n",
      "beta2:\t2.0999953937404486e-26\n",
      "gamma:\t1.3\n",
      "nSpans:\t10\n",
      "spanLength:\t100\n",
      "noiseFigure:\t5\n",
      "PdBm:\t-2\n",
      "Rs:\t32\n",
      "channels:\t[-100.  -50.    0.   50.  100.]\n",
      "nChannels:\t5\n",
      "chSpacing:\t100.0\n",
      "kur:\t1.32\n",
      "kur3:\t1.96\n",
      "N_mc:\t1000000\n",
      "PD:\t0\n",
      "alphaNorm:\t0.04605170185988092\n",
      "T:\t31.25\n",
      "P0:\t0.000630957344480193\n",
      "beta2Norm:\t0.021503952831902196\n",
      "PDNorm:\t0.0\n",
      "chSpacingNorm:\t3.125\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Model constants to tensorflow\n",
    "intra_const = tf.expand_dims( tf.constant( intraConst, aeParam.dtype), axis=1)\n",
    "inter_const = tf.constant( interConst, aeParam.dtype)\n",
    "\n",
    "intra_const_add = tf.constant( intraConstAdd, aeParam.dtype )\n",
    "inter_const_add = tf.constant( interConstAdd, aeParam.dtype )\n",
    "\n",
    "# learn optimal power or not\n",
    "if aeParam.optimizeP:\n",
    "    P0 = cu.dB2lin( chParam.PdBm, 'dBm')\n",
    "    P0 = tf.constant(P0,aeParam.dtype)\n",
    "    P0 = tf.contrib.distributions.softplus_inverse( P0 )\n",
    "    P0 = tf.nn.softplus(tf.Variable( P0 ))    \n",
    "else:\n",
    "    P0 = tf.constant( cu.dB2lin( chParam.PdBm, 'dBm'), aeParam.dtype )\n",
    "    \n",
    "PdBm = cfh.lin2dB(P0, 'dBm')\n",
    "\n",
    "print( p )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fix gradient problems of pow\n",
    "# instead of tf.pow(x,6) do tfpow(x,6)\n",
    "from functools import reduce\n",
    "def tfpow(x,y):\n",
    "    return reduce(lambda a,b: a*b, [x]*y, one)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.set_random_seed(aeParam.seed)\n",
    "np.random.seed(aeParam.seed)\n",
    "\n",
    "# Tx Graph\n",
    "allCombinations = cu.generateUniqueBitVectors(chParam.M)\n",
    "xSeed = tf.constant(allCombinations, aeParam.dtype)\n",
    "X = tf.placeholder( aeParam.dtype, shape=(None, chParam.w) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0921 22:22:43.587495 139716625557312 deprecation.py:506] From /home/rasmus/.conda/envs/claudeOnline/lib/python3.6/site-packages/tensorflow/python/ops/init_ops.py:1251: calling VarianceScaling.__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": [
    "enc, enc_seed = ae.encoder(X, aeParam, bits=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "enc_power = tf.sqrt( P0 ) * enc\n",
    "enc_seed_power = tf.sqrt( P0 ) * enc_seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ASE\n",
    "sigma2_noise = tf.constant( aseNoisePower, aeParam.dtype)\n",
    "\n",
    "# NLIN or GN model\n",
    "if aeParam.GN:\n",
    "    sigma2_inter = cfnlin.calcInterChannelGN(inter_const,P0,chParam.nPol,dtype=aeParam.dtype)\n",
    "    sigma2_intra = cfnlin.calcIntraChannelGN(intra_const,P0,chParam.nPol,dtype=aeParam.dtype)\n",
    "    \n",
    "    sigma2_nlin = tf.reduce_sum( sigma2_intra ) + tf.reduce_sum( sigma2_inter )\n",
    "else:\n",
    "    # kur = mean(abs(const).^4)/mean(abs(const).^2).^2; % Second order modulation factor <|a|^4>/<|a|^2>^2\n",
    "    # kur3 = mean(abs(const).^6)/mean(abs(const).^2).^3; % Third order modulation factor <|a|^6>/<|a|^2>^3\n",
    "    constellation_abs = cfh.norm(enc_seed_power)\n",
    "    pow4 = tfpow(constellation_abs,4)\n",
    "    pow6 = tfpow(constellation_abs,6)\n",
    "    kur  = tf.reduce_mean(pow4)/tf.pow(P0,2)\n",
    "    kur3 = tf.reduce_mean(pow6)/tf.pow(P0,3)\n",
    "    sigma2_inter = cfnlin.calcInterChannelNLIN(inter_const,kur,P0,chParam.nPol,dtype=aeParam.dtype)\n",
    "    sigma2_intra = cfnlin.calcIntraChannelNLIN(intra_const,kur,kur3,P0,chParam.nPol,dtype=aeParam.dtype)\n",
    "    \n",
    "    sigma2_intra_add = cfnlin.calcIntraChannelNLIN(intra_const_add,kur,kur3,P0,chParam.nPol,dtype=aeParam.dtype)\n",
    "    sigma2_inter_add = cfnlin.calcInterChannelNLINAddTerms(inter_const_add,kur,P0,chParam.nPol,dtype=aeParam.dtype)\n",
    "\n",
    "    sigma2_nlin = tf.reduce_sum( sigma2_intra ) + tf.reduce_sum( sigma2_inter ) # + tf.reduce_sum( sigma2_intra_add ) + tf.reduce_sum( sigma2_inter_add ) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Channel Graph\n",
    "sigma2 = sigma2_noise + sigma2_nlin\n",
    "SNR_lin = P0 / sigma2\n",
    "noise = tf.sqrt( sigma2 )\\\n",
    "            *tf.rsqrt(two)\\\n",
    "            *tf.random_normal(shape=tf.shape(enc_power),dtype=aeParam.dtype)\n",
    "\n",
    "channel = enc_power + noise\n",
    "channel_norm = channel * tf.rsqrt( P0 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Rx Graph\n",
    "decoder = ae.decoder(channel_norm, aeParam, bits=True)\n",
    "decoder_sigmoid = tf.sigmoid(decoder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Neural Network GMI metric\n",
    "# the output of the neural network with sigmoid activation can serve as an LLR estimation :)\n",
    "# we basically assume that the decoder neural network has learned a probability distribution of the channel\n",
    "# which we use as auxiliary channel within the receiver\n",
    "sigmoid_LLRs = tf.linalg.transpose( tf.log( (one-decoder_sigmoid) / decoder_sigmoid ) )\n",
    "sigmoid_GMI = cfh.GMI( tf.linalg.transpose(X), sigmoid_LLRs )\n",
    "\n",
    "# Gaussian GMI metric\n",
    "# here we just use a Gaussian auxiliary channel assumption\n",
    "constellation = tf.expand_dims( tf.complex( enc_seed[:,0], enc_seed[:,1]), axis=0 )\n",
    "channel_norm_complex = tf.expand_dims( tf.complex( channel_norm[:,0], channel_norm[:,1]), axis=0 )\n",
    "gaussian_LLRs = cfh.gaussianLLR( constellation, tf.linalg.transpose(xSeed), channel_norm_complex, SNR_lin, chParam.M )\n",
    "gaussian_GMI = cfh.GMI( tf.linalg.transpose(X), gaussian_LLRs )\n",
    "\n",
    "# Here the channel is a Gaussian channel, so for the Gaussian GMI metric, we are actually using the optimal receiver.\n",
    "# Therefore: Gaussian GMI > Neural Network GMI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bit errors and ber\n",
    "input_bits = tf.cast( X , tf.int32 )\n",
    "output_bits = tf.cast( tf.round( tf.nn.sigmoid( decoder ) ), tf.int32 )\n",
    "bit_compare = tf.not_equal( output_bits, input_bits )\n",
    "bit_errors = tf.reduce_sum( tf.cast( bit_compare, tf.int32 ) ) \n",
    "bit_error_rate = tf.reduce_mean( tf.cast( bit_compare, aeParam.dtype ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loss\n",
    "loss = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( labels=X, logits=decoder ) )\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate=trainingParam.learningRate)\n",
    "d_sigmoid_loss = optimizer.minimize(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "metricsDict = {'loss_metric':loss,\\\n",
    "               'ber_metric':bit_error_rate,\\\n",
    "               'gaussian_gmi_metric':gaussian_GMI,\\\n",
    "               'sigmoid_gmi_metric':sigmoid_GMI}\n",
    "meanMetricOpsDict, updateOps, resetOps = cft.create_mean_metrics(metricsDict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "sess = tf.Session()\n",
    "\n",
    "if trainingParam.summaries:\n",
    "    weights_summaries = tf.summary.merge_all() # without weight/bias histograms\n",
    "    # Summaries\n",
    "    s = [tf.summary.scalar('BER', metricsDict['ber_metric']),\n",
    "         tf.summary.scalar('loss', metricsDict['loss_metric']),\n",
    "         tf.summary.scalar('gaussian_GMI', metricsDict['gaussian_gmi_metric']),\n",
    "         tf.summary.scalar('sigmoid_GMI', metricsDict['sigmoid_gmi_metric']),\n",
    "         tf.summary.scalar('Plin', P0),\n",
    "         tf.summary.scalar('PdBm', PdBm),\n",
    "         tf.summary.scalar('sigma2_noise', sigma2_noise),\n",
    "         tf.summary.scalar('sigma2_nlin', sigma2_nlin)]\n",
    "\n",
    "    epoche_summaries = tf.summary.merge(s) # without weight/bias histograms\n",
    "\n",
    "    summaries_dir = os.path.join(trainingParam.path,'tboard{}'.format(chParam.M),trainingParam.summaryString)\n",
    "    os.makedirs(summaries_dir, exist_ok=True)\n",
    "\n",
    "    train_writer = tf.summary.FileWriter(summaries_dir + '/train', sess.graph)\n",
    "else:\n",
    "    train_writer = None\n",
    "        \n",
    "sess.run(tf.global_variables_initializer())\n",
    "\n",
    "saver = tf.train.Saver()\n",
    "checkpoint_path = os.path.join(trainingParam.path,'checkpoint',trainingParam.filename,'best')\n",
    "if not os.path.exists(checkpoint_path):\n",
    "    os.makedirs(checkpoint_path)\n",
    "else:\n",
    "    pass\n",
    "#     print(\"Restoring checkpoint...\", flush=True)\n",
    "#     saver.restore(sess=sess,save_path=checkpoint_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# constellation before training\n",
    "[constellation,constellation_bits] = sess.run([enc_seed,xSeed])\n",
    "plt.figure(figsize=(8,8))\n",
    "plt.plot(constellation[:,0],constellation[:,1],'.')\n",
    "\n",
    "for ii in range(constellation.shape[0]):\n",
    "    bit_string = ''.join( [ str(int(x)) for x in allCombinations[ii,:].tolist()] )\n",
    "    plt.text(constellation[ii,0], constellation[ii,1], bit_string, fontsize=12)\n",
    "plt.axis('square');\n",
    "lim_ = 1.6\n",
    "plt.xlim(-lim_,lim_);\n",
    "plt.ylim(-lim_,lim_);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "bestLoss = 100000\n",
    "bestAcc = 0\n",
    "lastImprovement = 0\n",
    "epoche = 0\n",
    "nBatches = int(trainingParam.sampleSize/trainingParam.batchSize)\n",
    "batchSizeMultiples = 1\n",
    "batchSize = batchSizeMultiples * trainingParam.batchSize\n",
    "\n",
    "np_loss = []\n",
    "np_ber  = []\n",
    "np_gaussian_gmi  = []\n",
    "np_sigmoid_gmi  = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comment on the training procedure:\n",
    "The training gets stuck early when a large batch size is chosen. For this reason we start with a low batch size, and iterativley increase it after temporary convergence. Training with a low batch size introduces a more stochastic gradient estimation, which helps to get out of the local minima."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "START TRAINING ... \n",
      "epoche: 0025 - avgLoss: 0.16 - avgBer: 8.82e-02 - avgGaussianGmi: 4.94 - avgSigmoidGmi: 4.60\n",
      "epoche: 0050 - avgLoss: 0.14 - avgBer: 7.41e-02 - avgGaussianGmi: 5.04 - avgSigmoidGmi: 4.77\n",
      "epoche: 0075 - avgLoss: 0.14 - avgBer: 6.94e-02 - avgGaussianGmi: 5.13 - avgSigmoidGmi: 4.82\n",
      "epoche: 0100 - avgLoss: 0.12 - avgBer: 5.72e-02 - avgGaussianGmi: 5.20 - avgSigmoidGmi: 4.97\n",
      "epoche: 0125 - avgLoss: 0.11 - avgBer: 5.15e-02 - avgGaussianGmi: 5.24 - avgSigmoidGmi: 5.04\n",
      "epoche: 0150 - avgLoss: 0.11 - avgBer: 4.72e-02 - avgGaussianGmi: 5.28 - avgSigmoidGmi: 5.04\n",
      "epoche: 0175 - avgLoss: 0.11 - avgBer: 4.82e-02 - avgGaussianGmi: 5.30 - avgSigmoidGmi: 5.03\n",
      "epoche: 0200 - avgLoss: 0.11 - avgBer: 4.67e-02 - avgGaussianGmi: 5.28 - avgSigmoidGmi: 5.03\n",
      "epoche: 0225 - avgLoss: 0.10 - avgBer: 4.28e-02 - avgGaussianGmi: 5.31 - avgSigmoidGmi: 5.11\n",
      "epoche: 0250 - avgLoss: 0.10 - avgBer: 4.06e-02 - avgGaussianGmi: 5.30 - avgSigmoidGmi: 5.15\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0921 22:25:18.857707 139716625557312 deprecation.py:323] From /home/rasmus/.conda/envs/claudeOnline/lib/python3.6/site-packages/tensorflow/python/training/saver.py:1276: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "batchSize: 320, batchSizeMultiples: 5\n",
      "epoche: 0275 - avgLoss: 0.09 - avgBer: 3.61e-02 - avgGaussianGmi: 5.32 - avgSigmoidGmi: 5.24\n",
      "epoche: 0300 - avgLoss: 0.08 - avgBer: 3.39e-02 - avgGaussianGmi: 5.35 - avgSigmoidGmi: 5.27\n",
      "epoche: 0325 - avgLoss: 0.08 - avgBer: 3.17e-02 - avgGaussianGmi: 5.36 - avgSigmoidGmi: 5.32\n",
      "epoche: 0350 - avgLoss: 0.08 - avgBer: 3.37e-02 - avgGaussianGmi: 5.34 - avgSigmoidGmi: 5.28\n",
      "batchSize: 576, batchSizeMultiples: 9\n",
      "epoche: 0375 - avgLoss: 0.08 - avgBer: 3.12e-02 - avgGaussianGmi: 5.36 - avgSigmoidGmi: 5.31\n",
      "epoche: 0400 - avgLoss: 0.08 - avgBer: 3.12e-02 - avgGaussianGmi: 5.36 - avgSigmoidGmi: 5.31\n",
      "batchSize: 832, batchSizeMultiples: 13\n",
      "epoche: 0425 - avgLoss: 0.08 - avgBer: 3.17e-02 - avgGaussianGmi: 5.35 - avgSigmoidGmi: 5.32\n",
      "epoche: 0450 - avgLoss: 0.08 - avgBer: 3.13e-02 - avgGaussianGmi: 5.36 - avgSigmoidGmi: 5.31\n",
      "epoche: 0475 - avgLoss: 0.08 - avgBer: 3.05e-02 - avgGaussianGmi: 5.36 - avgSigmoidGmi: 5.33\n",
      "epoche: 0500 - avgLoss: 0.08 - avgBer: 3.09e-02 - avgGaussianGmi: 5.37 - avgSigmoidGmi: 5.32\n"
     ]
    }
   ],
   "source": [
    "print( 'START TRAINING ... ', flush=True )\n",
    "while(True):\n",
    "    epoche = epoche + 1\n",
    "\n",
    "    sess.run(resetOps)\n",
    "    \n",
    "    # train AE with iteratively increasing batch size\n",
    "    for batch in range(0,nBatches):\n",
    "        feedDict = {X: cu.generateBitVectors(batchSize,chParam.M)}\n",
    "        sess.run(d_sigmoid_loss, feed_dict=feedDict)\n",
    "\n",
    "    # gather performance metrics with large batch size\n",
    "    for batch in range(0,nBatches):\n",
    "        feedDict = {X: cu.generateBitVectors(trainingParam.sampleSize,chParam.M)}\n",
    "        sess.run(updateOps, feed_dict=feedDict)\n",
    "\n",
    "    [outAvgLoss, outAvgBer, outAvgGaussianGmi, outAvgSigmoidGmi] = sess.run(list(meanMetricOpsDict.values()), feed_dict=feedDict)\n",
    "\n",
    "    np_loss.append( outAvgLoss )\n",
    "    np_ber.append( outAvgBer )\n",
    "    np_gaussian_gmi.append( outAvgGaussianGmi )\n",
    "    np_sigmoid_gmi.append( outAvgSigmoidGmi )\n",
    "    \n",
    "    if trainingParam.summaries:\n",
    "        epocheSummaries = sess.run(epoche_summaries, feed_dict=feedDict)\n",
    "        train_writer.add_summary(epocheSummaries,epoche)\n",
    "\n",
    "    if outAvgLoss < bestLoss:\n",
    "        bestLoss = outAvgLoss\n",
    "        lastImprovement = epoche\n",
    "        saver.save(sess=sess,save_path=checkpoint_path)\n",
    "\n",
    "    # convergence check and trainingState\n",
    "    if epoche - lastImprovement > trainingParam.earlyStopping:\n",
    "\n",
    "        saver.restore(sess=sess,save_path=checkpoint_path)\n",
    "        bestLoss = 10000\n",
    "        lastImprovement = epoche\n",
    "        \n",
    "        batchSizeMultiples = batchSizeMultiples + 4\n",
    "        batchSize = batchSizeMultiples * trainingParam.batchSize        \n",
    "        if batchSizeMultiples >= 17:\n",
    "            break;\n",
    "\n",
    "        print(\"batchSize: {}, batchSizeMultiples: {}\".format(batchSize,batchSizeMultiples))\n",
    "\n",
    "    if epoche%trainingParam.displayStep == 0:\n",
    "        print('epoche: {:04d} - avgLoss: {:.2f} - avgBer: {:.2e} - avgGaussianGmi: {:.2f} - avgSigmoidGmi: {:.2f}'.format(epoche,outAvgLoss,outAvgBer,outAvgGaussianGmi,outAvgSigmoidGmi),flush=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f11e47f85c0>]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "saver.restore(sess=sess,save_path=checkpoint_path)\n",
    "np_loss = np.array( np_loss )\n",
    "np_ber  = np.array( np_ber )\n",
    "np_gaussian_gmi  = np.array( np_gaussian_gmi )\n",
    "np_sigmoid_gmi  = np.array( np_sigmoid_gmi )\n",
    "plt.plot( np_loss )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f11ff23f7f0>]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.plot( np_gaussian_gmi )\n",
    "plt.plot( np_sigmoid_gmi )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# constellation after training\n",
    "[constellation,constellation_bits] = sess.run([enc_seed,xSeed])\n",
    "plt.figure(figsize=(10,10))\n",
    "plt.plot(constellation[:,0],constellation[:,1],'x')\n",
    "\n",
    "for ii in range(constellation.shape[0]):\n",
    "    bit_string = ''.join( [ str(int(x)) for x in allCombinations[ii,:].tolist()] )\n",
    "    plt.text(constellation[ii,0]+0.01, constellation[ii,1]+0.01, bit_string, fontsize=12)\n",
    "plt.axis('square');\n",
    "lim_ = 1.6\n",
    "plt.xlim(-lim_,lim_);\n",
    "plt.ylim(-lim_,lim_);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finalMetrics: {'GaussianGMI': 5.357472, 'SigmoidGMI': 5.325186, 'BER': 0.030881666, 'xentropy': 0.077957615}\n"
     ]
    }
   ],
   "source": [
    "sess.run(resetOps)\n",
    "for batch in range(0,100):\n",
    "    feedDict = {X: cu.generateBitVectors(1000,chParam.M)}\n",
    "    sess.run(updateOps, feed_dict=feedDict)\n",
    "[outAvgLoss, outAvgBer, outAvgGaussianGmi, outAvgSigmoidGmi] = sess.run(list(meanMetricOpsDict.values()), feed_dict=feedDict)\n",
    "\n",
    "finalMetrics = { 'GaussianGMI': outAvgGaussianGmi, 'SigmoidGMI': outAvgSigmoidGmi, 'BER': outAvgBer, 'xentropy': outAvgLoss }\n",
    "print( 'finalMetrics:', finalMetrics )"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}