notebooks/Dimensionality Reduction Using Principal Component Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dimensionality Reduction Using Principal Component Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python version     : 3.6\n",
      "Tensorflow version : 1.4.0\n",
      "numpy version      : 1.13.3\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import os\n",
    "from datetime import datetime\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sn\n",
    "\n",
    "print('Python version     :', '{0[0]}.{0[1]}'.format(sys.version_info))\n",
    "print('Tensorflow version :', tf.__version__)\n",
    "print('numpy version      :', np.__version__)\n",
    "np.random.seed(0)\n",
    "tf.set_random_seed(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset\n",
    "\n",
    "Our dataset consists of total of over 12,000 cells with a total of 2 categories; over 2,000 cells in sequential category (labelled SQNC) and over 10,000 in combinational category (labelled COMB). Each cell in the dataset is represented as a 2D matrix of transistor devices and their parameters given below:\n",
    "\n",
    "\n",
    "| Device | param1 | param2 | param3 | param4 | param5 | ...... | ...... | param13 |\n",
    "|--------|--------|--------|--------|--------|--------|--------|--------|---------|\n",
    "|   10   |    6   |    6   |    3   |    3   |    5   |        |        |    2    |\n",
    "|   10   |    8   |    3   |    2   |    4   |    4   |    2   |    3   |    6    |\n",
    "|   20   |    7   |    3   |    2   |    4   |    4   |    2   |    3   |    2    |\n",
    "|  ...   |  ...   |  ...   |  ...   |  ...   |  ...   |  ...   |  ...   |  ...    |\n",
    "|  ...   |  ...   |  ...   |  ...   |  ...   |  ...   |  ...   |  ...   |  ...    |\n",
    "|   20   |    7   |    3   |    2   |    4   |    5   |    2   |    3   |    2    |\n",
    "\n",
    "\n",
    "Entire dataset consists of 20,000 such tables is shown in the next picture."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "![Cell Dataset As Stack Of Tables](https://github.com/srohit0/mida/blob/master/data/CellDatasetAsStackOfTables.jpg?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Feature Selection\n",
    "\n",
    "Each cell in the dataset has size of 351x14, which gives us dimension of approximately 5000 features. As a domain expert in the circuit analysis we’ve identified column 0,2,5,8, and 11 are relevant to circuit classification. In this process, we’ve reduced our dataset to 351x5 features from 351x14. This gives us a total savings of over 35 percent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# max_devices_per_cell is also max number of rows in circuit files in the training set\n",
    "max_devices_per_cell = 351; \n",
    "# feature_per_device is different from max number of cols (14) in circuit files in training set\n",
    "feature_per_device   = 5; \n",
    "# Feature Selection\n",
    "feature_indices = (0,2,5,8,11)\n",
    "\n",
    "def load_one_cell(cell_file):\n",
    "    cell_cols = 14\n",
    "    cell_data = np.zeros(shape=(max_devices_per_cell, cell_cols), dtype=np.float32)\n",
    "    cell_mat  = np.loadtxt(cell_file, dtype=np.float32, ndmin=2)\n",
    "    nrows     = cell_mat.shape[0]\n",
    "    ncols     = cell_mat.shape[1]\n",
    "    cell_data[:nrows, :ncols] = cell_mat\n",
    "    cell_data = cell_data[:, feature_indices]\n",
    "    return cell_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "COMB : shape= (10096, 351, 5) , Mean= 0.686939 , sigma= 2.95702\n",
      "SQNC : shape= (2096, 351, 5) , Mean= 1.36903 , sigma= 4.67975\n"
     ]
    }
   ],
   "source": [
    "def load_cells(folder):\n",
    "  #Load the data for a single label.\n",
    "  cell_files = os.listdir(folder)\n",
    "  dataset = np.zeros(shape=(len(cell_files), max_devices_per_cell, feature_per_device),\n",
    "                         dtype=np.float32)\n",
    "  cell_index = 0\n",
    "  for cell in cell_files:\n",
    "    cell_file = os.path.join(folder, cell)\n",
    "    try:\n",
    "      cell_data = load_one_cell(cell_file)\n",
    "\n",
    "      cell_rows = cell_data.shape[0]\n",
    "      cell_cols = cell_data.shape[1]\n",
    "      dataset[cell_index, :cell_rows, :cell_cols] = cell_data\n",
    "\n",
    "      cell_index = cell_index + 1\n",
    "    except IOError as e:\n",
    "      print('Could not read:', cell_file, ':', e, '- it\\'s ok, skipping.')\n",
    "    \n",
    "  dataset = dataset[0:cell_index, :, :]\n",
    "\n",
    "  print(os.path.basename(folder), ': shape=', dataset.shape, ', Mean=', np.mean(dataset),\n",
    "        ', sigma=', np.std(dataset))\n",
    "  return dataset\n",
    "\n",
    "comb_dataset = load_cells(os.path.join('..','data','2classes','COMB'))\n",
    "sqnc_dataset = load_cells(os.path.join('..','data','2classes','SQNC'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create one hot labels\n",
    "#         COMB_LABEL=[1.0, 0.0], SQNC_LABEL=[0.0, 1.0]\n",
    "labels = np.asarray([[1.0, 0.0] if (i<comb_dataset.shape[0]) else [0.0, 1.0] for i in \\\n",
    "                     range(comb_dataset.shape[0]+sqnc_dataset.shape[0])])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Randomize Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Full dataset: no. of cells= (12192, 351, 5) Min= 0.0 Max= 50.0 Mean= 0.804202 Sigma= 3.32745\n"
     ]
    }
   ],
   "source": [
    "# randomize comb and sqnc dataset\n",
    "np.random.shuffle(comb_dataset)\n",
    "np.random.shuffle(sqnc_dataset)\n",
    "\n",
    "# Create a combined dataset\n",
    "dataset = np.append(comb_dataset, sqnc_dataset, axis=0)\n",
    "\n",
    "# randomize dataset and labels together to keep'em in sync.\n",
    "def randomize(dataset, labels):\n",
    "  permutation = np.random.permutation(labels.shape[0])\n",
    "  shuffled_dataset = dataset[permutation,:,:]\n",
    "  shuffled_labels = labels[permutation]\n",
    "  return shuffled_dataset, shuffled_labels\n",
    "\n",
    "# randomize dataset\n",
    "dataset, labels = randomize(dataset, labels)\n",
    "\n",
    "print('Full dataset: no. of cells=', dataset.shape, 'Min=', np.min(dataset), 'Max=',np.max(dataset), \n",
    "      'Mean=', np.mean(dataset), 'Sigma=', np.std(dataset))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reformat Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reformat(dataset):\n",
    "    dataset = dataset.reshape((-1, max_devices_per_cell*feature_per_device))\n",
    "    return dataset\n",
    "\n",
    "dataset = reformat(dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Normalize Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min= 0.0 Max= 1.0 Mean= 0.016084 sigma= 0.066549\n",
      "Dataset size (12192, 1755)\n"
     ]
    }
   ],
   "source": [
    "# normalize the dataset between 0 and 1.\n",
    "data_mean = 0;\n",
    "data_std  = (np.max(dataset)-np.min(dataset));\n",
    "\n",
    "def normalize(d, mean, std):\n",
    "    return (d - mean) / std\n",
    "\n",
    "def denormalize(d, mean, std):\n",
    "    return (d * std) + mean\n",
    "\n",
    "dataset = normalize(dataset, data_mean, data_std)\n",
    "\n",
    "print('Min=', np.min(dataset), 'Max=',np.max(dataset), 'Mean=',np.mean(dataset), 'sigma=', np.std(dataset))\n",
    "print('Dataset size', dataset.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Divide Dataset\n",
    "into training and test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(9753, 1755)\n"
     ]
    }
   ],
   "source": [
    "# training dataset percentage is 80%\n",
    "def divide_dataset(dataset, labels):\n",
    "    train_pct = 0.8; \n",
    "    # divide dataset into training and validation set\n",
    "    train_index = int(dataset.shape[0]*train_pct)\n",
    "    t_X = dataset[:train_index, :]\n",
    "    t_Y = labels[:train_index,:]\n",
    "    v_X = dataset[train_index:,:]\n",
    "    v_Y = labels[train_index:,:]\n",
    "    \n",
    "    return t_X, t_Y, v_X, v_Y\n",
    "\n",
    "train_X, train_Y, valid_X, valid_Y = divide_dataset(dataset, labels)\n",
    "\n",
    "print(train_X.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# Principal Component Analysis\n",
    "\n",
    "---\n",
    "\n",
    "Remember to apply PCA only to the training set to find feature projection matrix. This projection matrix will then be used to transform validation set into lower dimensional space."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Singular Value Decomposition\n",
    "\n",
    "__NOTE__ : couple of issues uncovered  in tensorflow:\n",
    "\n",
    "1. *tf.matmul(a=dataset, b=dataset, transpose_a=True)* \n",
    "   - symptom: Segfault. \n",
    "   - Bug id: https://github.com/tensorflow/tensorflow/issues/9234\n",
    "2. *tf.svd(covariance)* \n",
    "   - is giving 'Nan' values. \n",
    "   - Bug id: https://github.com/tensorflow/tensorflow/issues/8905\n",
    "\n",
    "Using numpy as a workaround for now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_samples  = train_X.shape[0]\n",
    "n_features = train_X.shape[1]\n",
    "# Threshold for keeping the variance in reduced training dataset\n",
    "keep_variance = 0.9997"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVD:\n",
      "U= (1755, 1755) \n",
      "S= (1755,) \n",
      "V= (1755, 1755)\n"
     ]
    }
   ],
   "source": [
    "# Co variance\n",
    "covariance = np.matmul(np.transpose(train_X), train_X)/n_samples\n",
    "\n",
    "# Perform SVD\n",
    "U, singular_values, V = np.linalg.svd(covariance)\n",
    "print('SVD:\\nU=', U.shape, '\\nS=', singular_values.shape, '\\nV=', V.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reduce Dimension\n",
    "A useful measure is the so-called \"explained variance,\" which is nothing but normalized singular values. The explained variance tells us how much information (variance) can be attributed to each of the principal components."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Normalize Singular values\n",
    "normalized_singular_values = singular_values / np.sum(singular_values)\n",
    "\n",
    "# Create a ladder of cumulative sum of normalized singular values\n",
    "# This represents array of 'explained variance'\n",
    "cumulative_sum = np.cumsum(normalized_singular_values)\n",
    "\n",
    "# Find first index, which is above given threshold: 'variance_kept'\n",
    "n_dimension = next(idx for idx, value in enumerate(cumulative_sum) \n",
    "                   if value >= keep_variance) + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reduced dataset\n",
    "\n",
    "The construction of the projection matrix that will be used to transform the original dataset onto the new feature subspace. The term \"projection matrix\" is a fancy term for top *'n_dimension'* singular vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dataset before (9753, 1755)\n",
      "dataset after (9753, 386)\n",
      "\tMin= -7.67917 Max= 10.4665 Mean= -0.00620747 sigma= 0.145357\n"
     ]
    }
   ],
   "source": [
    "def reduceDataset(train_X):\n",
    "    return np.matmul(train_X, U[:,:n_dimension])\n",
    "\n",
    "print('dataset before', train_X.shape)\n",
    "rtrain_X = reduceDataset(train_X)\n",
    "print('dataset after', rtrain_X.shape)\n",
    "print('\\tMin=', np.min(rtrain_X), 'Max=',np.max(rtrain_X), \n",
    "      'Mean=',np.mean(rtrain_X), 'sigma=', np.std(rtrain_X))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Project Back to Higher Dimension\n",
    "\n",
    "After projecting original dataset onto the lower dimensional feature space, you can somewhat recover the data (with some loss) by projecting it back onto the original high dimensional space.\n",
    "\n",
    "One can validate recovered results by asserting that variance lost in the recovery is less than variance kept."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dataset recovered successfully.\n",
      "\n",
      "Variance Keep: 0.9997\n",
      "Variance Lost: 1.37535e-06\n",
      "ORIGINAL : (9753, 1755) Mean= 0.0159829 , sigma= 0.0663437 , norm= 282.341\n",
      "REDUCED  : (9753, 1755) Mean= 0.0159829 , sigma= 0.0663333 , norm= 282.294\n"
     ]
    }
   ],
   "source": [
    "recovered_train_X = np.matmul(rtrain_X, np.transpose(U[:,:n_dimension]))\n",
    "\n",
    "lost_variance = ((train_X-recovered_train_X)**2).mean(axis=None)\n",
    "\n",
    "if ( lost_variance <= keep_variance ):\n",
    "    print(\"dataset recovered successfully.\\n\")\n",
    "\n",
    "print('Variance Keep:', keep_variance)\n",
    "print('Variance Lost:', lost_variance)\n",
    "print('ORIGINAL :', train_X.shape, 'Mean=',np.mean(train_X), ', sigma=', np.std(train_X), \n",
    "      ', norm=', np.linalg.norm(train_X))\n",
    "print('REDUCED  :', recovered_train_X.shape, 'Mean=',np.mean(recovered_train_X), ', sigma=', np.std(recovered_train_X), \n",
    "      ', norm=', np.linalg.norm(recovered_train_X))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Effectiveness of Transformed Features \n",
    "\n",
    "Following two bar charts show effectiveness of transformed features. First feature covers over 52% variance, next 5 cover a total of 75% variance and next 15 cover over 85% variance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7MAAAHwCAYAAAB0TTiEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSb3zJ3X/+zKFiDXeAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x13b28fcc390>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display_limit = 50\n",
    "plt_features = normalized_singular_values[:display_limit]\n",
    "plt_cumsum   = cumulative_sum[:display_limit]\n",
    "\n",
    "plt.figure(figsize = (16,8))\n",
    "\n",
    "plt.subplot(1,2,1)\n",
    "y_pos = np.arange(len(plt_features)) \n",
    "plt.bar(y_pos, plt_features, align='center', alpha=1.0)\n",
    "plt.xlabel('Features')\n",
    "plt.ylabel('Feature Variance')\n",
    "plt.title('Effectiveness of Transformed Features') \n",
    "\n",
    "\n",
    "plt.subplot(1,2,2)\n",
    "y_pos = np.arange(len(plt_cumsum)) \n",
    "plt.bar(y_pos, plt_cumsum, align='center', alpha=1.0)\n",
    "plt.xlabel('Features')\n",
    "plt.ylabel('Cumulative Feature Variance')\n",
    "plt.title('Effectiveness of Transformed Features')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# Using Reduced Dataset Binary Classification Of Cells \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Declare Graph Variables\n",
    "\n",
    "Place to declare plave holders and variables for compute graph## "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "SIGMA      = np.sqrt(2.0/rtrain_X.shape[0])\n",
    "n_features = rtrain_X.shape[1]\n",
    "n_labels   = 2\n",
    "\n",
    "\n",
    "Weights = tf.Variable(tf.truncated_normal(shape=[n_features, n_labels], mean=3.0*SIGMA, \n",
    "                                          stddev=SIGMA, dtype=tf.float32), trainable=True)\n",
    "Biases  = tf.Variable(tf.constant(value=SIGMA, dtype=tf.float32, shape=[n_labels]), \n",
    "                      trainable=True)\n",
    "\n",
    "t_dataset = tf.placeholder(tf.float32, shape=(None, n_features), name='t_dataset');\n",
    "t_labels  = tf.placeholder(tf.float32, shape=(None, n_labels), name='t_labels'); "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute Graph\n",
    "Construct a Logistic Regression model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions        = tf.matmul(t_dataset, Weights) + Biases\n",
    "\n",
    "t_labels_cls       = tf.argmax(t_labels, axis=1)\n",
    "predictions_cls    = tf.argmax(predictions, axis=1)\n",
    "correct_prediction = tf.equal(predictions_cls, t_labels_cls)\n",
    "accuracy           = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "\n",
    "# change it to sigmoid_cross_entropy_with_logits\n",
    "cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=predictions,\n",
    "                                                               labels=t_labels_cls)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hyper Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyper parameters\n",
    "learning_rate = 100\n",
    "training_epochs = 1000\n",
    "display_step = 50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cost Function and Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "cost = tf.reduce_mean(cross_entropy)\n",
    "\n",
    "# Optimization algorithm\n",
    "optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0050 cost= 0.370120525 accuracy= 0.983902395\n",
      "Epoch: 0100 cost= 0.170708343 accuracy= 0.987593532\n",
      "Epoch: 0150 cost= 0.081086650 accuracy= 0.991182208\n",
      "Epoch: 0200 cost= 0.048267752 accuracy= 0.992720187\n",
      "Epoch: 0250 cost= 0.032852538 accuracy= 0.994053125\n",
      "Epoch: 0300 cost= 0.024037912 accuracy= 0.995386064\n",
      "Epoch: 0350 cost= 0.019059572 accuracy= 0.997026563\n",
      "Epoch: 0400 cost= 0.015804980 accuracy= 0.997744262\n",
      "Epoch: 0450 cost= 0.013557364 accuracy= 0.998359501\n",
      "Epoch: 0500 cost= 0.011665552 accuracy= 0.998462021\n",
      "Epoch: 0550 cost= 0.010154917 accuracy= 0.998564541\n",
      "Epoch: 0600 cost= 0.008933584 accuracy= 0.998667061\n",
      "Epoch: 0650 cost= 0.007752864 accuracy= 0.999282300\n",
      "Epoch: 0700 cost= 0.006932915 accuracy= 0.999384820\n",
      "Epoch: 0750 cost= 0.006195107 accuracy= 0.999487340\n",
      "Epoch: 0800 cost= 0.005498202 accuracy= 0.999589860\n",
      "Epoch: 0850 cost= 0.004831293 accuracy= 0.999589860\n",
      "Epoch: 0900 cost= 0.004195624 accuracy= 0.999589860\n",
      "Epoch: 0950 cost= 0.003615930 accuracy= 0.999589860\n",
      "Epoch: 1000 cost= 0.003156423 accuracy= 0.999589860\n",
      "\n",
      "Optimization Finished!\n"
     ]
    }
   ],
   "source": [
    "# Initialize the variables (i.e. assign their default value)\n",
    "init = tf.global_variables_initializer()\n",
    "\n",
    "# Start training\n",
    "sess = tf.Session()\n",
    "sess.run(init)\n",
    "\n",
    "for epoch in range(training_epochs):\n",
    "    sess.run(optimizer, feed_dict={t_dataset:rtrain_X, t_labels:train_Y})\n",
    "\n",
    "    #Display logs per epoch step\n",
    "    if (epoch+1) % display_step == 0:\n",
    "        c, a = sess.run([cost, accuracy], feed_dict={t_dataset:rtrain_X, t_labels:train_Y})\n",
    "        print (\"Epoch:\", '%04d' % (epoch+1), \"cost=\", \"{:.9f}\".format(c), \n",
    "               \"accuracy=\", \"{:.9f}\".format(a))\n",
    "\n",
    "print( \"\\nOptimization Finished!\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cost and Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training   cost    = 0.00315642\n",
      "Validation cost    = 0.031999 \n",
      "\n",
      "Training   Accuracy = 0.99959\n",
      "Validation Accuracy = 0.99508\n"
     ]
    }
   ],
   "source": [
    "rvalid_X = reduceDataset(valid_X)\n",
    "# Find cost on training dataset.\n",
    "t_cost, t_acc = sess.run([cost, accuracy], feed_dict={t_dataset:rtrain_X, t_labels:train_Y})\n",
    "v_cost, v_acc = sess.run([cost, accuracy], feed_dict={t_dataset:rvalid_X, t_labels:valid_Y})\n",
    "\n",
    "print (\"Training   cost    =\", t_cost)\n",
    "print (\"Validation cost    =\", v_cost, '\\n')\n",
    "print(\"Training   Accuracy =\", t_acc)\n",
    "print(\"Validation Accuracy =\", v_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "W = Weights.eval(session=sess)\n",
    "B = Biases.eval(session=sess)\n",
    "\n",
    "def classifier(X):\n",
    "    #prediction = predictions_cls.eval(session=sess, feed_dict={t_dataset:X, t_labels:[[0, 0]]})\n",
    "    prediction = np.argmax((np.matmul(X, W) + B), axis=1)\n",
    "    cell_type = 'COMB' if (prediction == 0 ) else 'SQNC'\n",
    "    return cell_type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test Few Cells"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "..\\data\\2classes\\COMB\\AN2_1.mat          CLASS is : COMB\n",
      "..\\data\\2classes\\SQNC\\FSDNQO_2.mat       CLASS is : SQNC\n",
      "..\\data\\2classes\\COMB\\AN5_Y2_8_6.mat     CLASS is : SQNC\n",
      "..\\data\\2classes\\COMB\\OAI22_TY2_16.mat   CLASS is : COMB\n",
      "..\\data\\2classes\\COMB\\MUX5_CTY2_24_1.mat CLASS is : COMB\n",
      "..\\data\\2classes\\SQNC\\FSDPQO_6_2.mat     CLASS is : SQNC\n",
      "..\\data\\2classes\\COMB\\MUX3_CTY2_32.mat   CLASS is : COMB\n",
      "..\\data\\2classes\\SQNC\\FSDNQ_V2_1.mat     CLASS is : SQNC\n"
     ]
    }
   ],
   "source": [
    "sample_cells = [os.path.join('..','data','2classes','COMB', 'AN2_1.mat'), \n",
    "                os.path.join('..','data','2classes','SQNC', 'FSDNQO_2.mat'),\n",
    "                os.path.join('..','data','2classes','COMB', 'AN5_Y2_8_6.mat'),\n",
    "                os.path.join('..','data','2classes','COMB', 'OAI22_TY2_16.mat'),\n",
    "                os.path.join('..','data','2classes','COMB', 'MUX5_CTY2_24_1.mat'),\n",
    "                os.path.join('..','data','2classes','SQNC', 'FSDPQO_6_2.mat'),\n",
    "                os.path.join('..','data','2classes','COMB', 'MUX3_CTY2_32.mat'),\n",
    "                os.path.join('..','data','2classes','SQNC', 'FSDNQ_V2_1.mat')]\n",
    "\n",
    "for cell_file in sample_cells:\n",
    "    cell_data = normalize(reformat(load_one_cell(cell_file)), data_mean, data_std)\n",
    "    print (cell_file.ljust(40), 'CLASS is :', classifier(reduceDataset(cell_data)))\n",
    "    \n",
    "#Find all incorrectly predicted cells\n",
    "# print('Cells with incorrect classification: ')\n",
    "# incorrect_lbls = 0\n",
    "# for label in ('COMB', 'SQNC'):\n",
    "#     cell_files = os.listdir(os.path.join('..','data','2classes',label))\n",
    "#     for cell_file in cell_files:\n",
    "#         cell_data = normalize(reformat(\n",
    "#             load_one_cell(\n",
    "#                 os.path.join('..','data','2classes',label,cell_file)\n",
    "#             )\n",
    "#         ), data_mean, data_std)\n",
    "#         predicted_label = classifier(reduceDataset(cell_data))\n",
    "#         if ( label != predicted_label ):\n",
    "#             print(cell_file, end=', ')\n",
    "#             incorrect_lbls += 1\n",
    "# print ('\\nTotal number of incrrection prediction is ', incorrect_lbls)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Confusion Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAG3CAYAAACQSq0QAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nkiRlypCWJClThrQkSZkypCVJytT/A5HiVsDdTMcTAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x13b28f07240>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "t_predictions = sess.run(predictions, feed_dict={t_dataset:reduceDataset(dataset), t_labels:labels})\n",
    "cm = tf.confusion_matrix(labels=np.argmax(labels, axis=1), \n",
    "                         predictions=tf.argmax(t_predictions, axis=1), num_classes=2)\n",
    "cm_ary = cm.eval(session=sess)\n",
    "\n",
    "plt.figure(figsize = (8,8))\n",
    "ax = sn.heatmap(cm_ary, xticklabels=['COMB', 'SQNC'], yticklabels=['COMB', 'SQNC'], \n",
    "                cmap=\"Blues\", annot=True, fmt='d', annot_kws={\"size\": 16}, \n",
    "                cbar_kws={\"orientation\": \"horizontal\"})\n",
    "ax.set_title('Confusion Matrix with REDUCED Dataset')\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusion\n",
    "\n",
    "Using PCA, we reduced our feature set set by over 77% as shown below with 99.97% of variance of our dataset kept.\n",
    "\n",
    "---\n",
    "__`dataset before (12192, 1755)`__\n",
    "\n",
    "__`dataset  after (12192,  397)`__\n",
    "\n",
    "\n",
    "We used this new dataset with reduced dimensionality as our new dataset for \"Binary Classification Of Cells Using Logistic Regression\". Resulting confusion matrix was very close to classes predicted with full dataset.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAG3CAYAAACQSq0QAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x13b2ea6d048>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Copy cm_ary from orig notebook on \"Binary Classification Of Cells Using Logistic Regression\".\n",
    "cm_ary_orig = [[10085, 11], [5, 2091]]\n",
    "\n",
    "plt.figure(figsize = (8,8))\n",
    "ax = sn.heatmap(cm_ary, xticklabels=['COMB', 'SQNC'], yticklabels=['COMB', 'SQNC'], \n",
    "                cmap=\"Blues\", annot=True, fmt='d', annot_kws={\"size\": 16}, \n",
    "                cbar_kws={\"orientation\": \"horizontal\"})\n",
    "ax.set_title('Confusion Matrix with ORIGINAL Dataset')\n",
    "\n",
    "#sn.set(font_scale=1.4)#for label size\n",
    "plt.show()"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}