Task_03_Class_balanced_training_and_test_data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 3: Class balanced training and test data split\n",
    "-----------------------------------------------------------------------------------\n",
    "Author: Rajesh Siraskar\n",
    "Created: 14-Dec-2018\n",
    "- 15-Dec-2018: Define approach\n",
    "- 16-Dec-2018: Develop code for class balancing, and creating the tuples\n",
    "\n",
    "\n",
    "**Instructions:**\n",
    "- Function that performs a class-balanced random train/test split\n",
    "- Parameter: fraction specifying training split\n",
    "- Use sklearn.model_selection methods\n",
    "- Output two lists of (filename, class) tuples\n",
    "- The proportion of positive and negative instances in each list should be approx. equal\n",
    "\n",
    "**Approach:**\n",
    "- Use 'glob' module to get all positive and negative instance image files\n",
    "- Create two separate lists\n",
    "- Class balance them based on the length of the smaller list\n",
    "- Convert to tuples with the class label added to file name\n",
    "- Shuffle\n",
    "- Draw N samples from both - we now have a class balanced list\n",
    "- Split both lists into into 70:30 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Import modules\n",
    "import glob\n",
    "import numpy as np\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Top level parameters\n",
    "path_positive = 'images/training_positive_instances/'\n",
    "path_negative = 'images/training_negative_instances/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positive instances:  1824\n",
      "Negative instances:  2393\n",
      "Minimum instances for class balancing:  1824\n"
     ]
    }
   ],
   "source": [
    "# Import all image files and read into separate arrays\n",
    "positive_instances = []\n",
    "negative_instances = []\n",
    "\n",
    "# Gather all .png file names\n",
    "positive_instances = glob.glob (path_positive + '*.png')\n",
    "negative_instances = glob.glob (path_negative + '*.png')\n",
    "\n",
    "# Get number of instances\n",
    "print('Positive instances: ', len(positive_instances))\n",
    "print('Negative instances: ', len(negative_instances))\n",
    "\n",
    "# Minimum instances for class balancing\n",
    "min_instances = min (len(positive_instances), len(negative_instances))\n",
    "print('Minimum instances for class balancing: ', min_instances)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Limit each array to min instances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positive instances:  1824\n",
      "Negative instances:  1824\n"
     ]
    }
   ],
   "source": [
    "positive_instances = positive_instances[0:min_instances]\n",
    "negative_instances = negative_instances[0:min_instances]\n",
    "\n",
    "# Get number of instances\n",
    "print('Positive instances: ', len(positive_instances))\n",
    "print('Negative instances: ', len(negative_instances))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classes are now balanced. Randomly shuffle the instances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "random.shuffle(positive_instances)\n",
    "random.shuffle(negative_instances)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create list of labels and zip them up with the file names to create tuples of the form:\n",
    "    \n",
    "    (class_label, file_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "positive_labels = min_instances*['positive']\n",
    "negative_labels = min_instances*['negative']\n",
    "\n",
    "class_balanced_positive_instances = list(zip(positive_labels, positive_instances))\n",
    "class_balanced_negative_instances = list(zip(negative_labels, negative_instances))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test print 3 tuples from each class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positive instances:\n",
      "[('positive', 'images/training_positive_instances\\\\PED_T400_00122_001.png'), ('positive', 'images/training_positive_instances\\\\PED_T400_00298_001_R.png'), ('positive', 'images/training_positive_instances\\\\PED_T210_00088_001_B.png')]\n",
      "\n",
      "\n",
      " Negative instances:\n",
      "[('negative', 'images/training_negative_instances\\\\PBG_X_T210_00009__V01.png'), ('negative', 'images/training_negative_instances\\\\BKG_T400_00080.png'), ('negative', 'images/training_negative_instances\\\\PBG_X_T210_00208__V00.png')]\n"
     ]
    }
   ],
   "source": [
    "print('Positive instances:')\n",
    "print(class_balanced_positive_instances[0:3])\n",
    "print('\\n\\n Negative instances:')\n",
    "print(class_balanced_negative_instances[0:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def SplitInstancesIntoTrainingAndTestSets(path_positive, path_negative, file_type='*.png', \n",
    "                                          training_proportion = 0.7):\n",
    "    # Import all image files and read into separate arrays\n",
    "    positive_instances = []\n",
    "    negative_instances = []\n",
    "\n",
    "    # Gather all .png file names\n",
    "    positive_instances = glob.glob (path_positive + file_type)\n",
    "    negative_instances = glob.glob (path_negative + file_type)\n",
    "\n",
    "    # Get number of instances\n",
    "    print('Positive instances: ', len(positive_instances))\n",
    "    print('Negative instances: ', len(negative_instances))\n",
    "\n",
    "    # Minimum instances for class balancing\n",
    "    min_instances = min (len(positive_instances), len(negative_instances))\n",
    "    print('Minimum instances for class balancing: ', min_instances)\n",
    "    \n",
    "    positive_instances = positive_instances[0:min_instances]\n",
    "    negative_instances = negative_instances[0:min_instances]\n",
    "\n",
    "    # Check that classes are balanced\n",
    "    if (len(positive_instances) == len(negative_instances)):\n",
    "        print('CHECK: Classes balanced. Number of instances in both: ', len(positive_instances))\n",
    "    \n",
    "    # Randomly shuffle instances\n",
    "    random.shuffle(positive_instances)\n",
    "    random.shuffle(negative_instances)\n",
    "    \n",
    "    positive_labels = min_instances*['positive']\n",
    "    negative_labels = min_instances*['negative']\n",
    "\n",
    "    class_balanced_positive_instances = list(zip(positive_labels, positive_instances))\n",
    "    class_balanced_negative_instances = list(zip(negative_labels, negative_instances))\n",
    "    \n",
    "    # Build the complete data set by appending both lists\n",
    "    data_set = class_balanced_positive_instances\n",
    "    [data_set.append(ni) for ni in class_balanced_negative_instances]\n",
    "    \n",
    "    total_instances = len(data_set)\n",
    "    print('\\nSPLIT DATA SET\\n- Total instances:', total_instances)\n",
    "    \n",
    "    # Shuffle the data\n",
    "    random.shuffle(data_set)\n",
    "    \n",
    "    # Split the data set into training and test\n",
    "    len_training = int(training_proportion * total_instances)\n",
    "    training_set = data_set[0:len_training]\n",
    "    test_set = data_set[len_training:total_instances]\n",
    "    \n",
    "    print('- Training instances:', len(training_set))\n",
    "    print('- Test instances:', len(test_set))\n",
    "    \n",
    "    return(training_set, test_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positive instances:  1824\n",
      "Negative instances:  2393\n",
      "Minimum instances for class balancing:  1824\n",
      "CHECK: Classes balanced. Number of instances in both:  1824\n",
      "\n",
      "SPLIT DATA SET\n",
      "- Total instances: 3648\n",
      "- Training instances: 2553\n",
      "- Test instances: 1095\n",
      "\n",
      " Training set: Ratio of positive/negative: 1.02\n",
      "\n",
      " Test set: Ratio of positive/negative: 0.94\n"
     ]
    }
   ],
   "source": [
    "train, test = SplitInstancesIntoTrainingAndTestSets(path_positive, path_negative)\n",
    "\n",
    "# Test to see proportion of positive and negatives\n",
    "l_classes = [i[0] for i in train]\n",
    "np = 0\n",
    "nn = 0\n",
    "for class_type in l_classes:\n",
    "    if (class_type == 'positive'): np += 1\n",
    "    if (class_type == 'negative'): nn += 1\n",
    "\n",
    "print('\\n Training set: Ratio of positive/negative: {:.2f}'.format(np/nn))\n",
    "\n",
    "l_classes = [i[0] for i in test]\n",
    "np = 0\n",
    "nn = 0\n",
    "for class_type in l_classes:\n",
    "    if (class_type == 'positive'): np += 1\n",
    "    if (class_type == 'negative'): nn += 1\n",
    "\n",
    "print('\\n Test set: Ratio of positive/negative: {:.2f}'.format(np/nn))"
   ]
  }
 ],
 "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
}