eLCS_3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LCS Demo 3\n",
    "\n",
    "**LCS Workshop- Educational LCS - eLCS**\n",
    "\n",
    "Outcome: *Learn the concept and use of Learning Classifier Systems *(*LCSs*)\n",
    "\n",
    "Instructors: [Dr Ryan Urbanowicz](http://www.ryanurbanowicz.com/), [Dr Will Browne](http://ecs.victoria.ac.nz/Main/WillBrowne) And [Dr Karthik Kuber](http://kkuber.mysite.syr.edu/),\n",
    "\n",
    "The following topics will be covered in a series of hands-on exercises and demonstrations:\n",
    "1. LCS in a Nutshell \n",
    "2. LCS Concepts \n",
    "3. LCS Functional Cycle \n",
    "4. LCS Adaptability \n",
    "5. LCS Applications (toy and real problems) \n",
    "\n",
    "<p style=\"color:red;\">Welcome to the Educational Learning Classifier System (eLCS).</p> \n",
    "It has the core elements of the functionality that help define the concept of LCSs. It’s the same family as the fully featured ExSTraCS system, so it is easy to transfer to a state-of-the-art LCS from this shallow learning curve.\n",
    "\n",
    "eLCS complements the forthcoming *Textbook on Learning Classifier Systems*. Each demo is paired with one of the chapters in the textbook. Therefore, there are 5 different versions of an educational learning classiﬁer system (eLCS), as relevant functionality (code) is added to eLCS at each stage. This builds up the eLCS algorithm in its entirety from Demo 1 through to 5. Demo 6 showcases how ExSTraCS may be applied to a real-world data mining example, i.e. large scale bioinformatics. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Demo 1 Understanding of what an LCS is attempting – how does it classify the training data?\n",
    "- Demo 2 Matching and Covering\n",
    "- **Demo 3 Prediction, Rule Population Evaluations, GA Rule Discovery and Parental Selection**\n",
    "- Demo 4 Deletion and Niche GA + Subsumption\n",
    "- Demo 5 Complete eLCS applied to a complex (toy) problem\n",
    "- Bonus Demo 6 ExSTraCS applied to a real-world data mining example \n",
    "\n",
    "All code is in Python. This newest version is coded in Python 3.4. Here it is to be run in the Jupyter platform (http://jupyter.org/), as it supports interactive data science.\n",
    "\n",
    "Each demo version only includes the minimum code needed to perform the functions they were designed for. This way users can start by examining the simplest version of the code and progress onwards. The demo exercises are to implement several functions in eLCS and view results in spreadsheet, text ﬁle or Python based graphics (preferable).\n",
    "\n",
    "## Set-up and introduction to Jupyter\n",
    "\n",
    "Please see http://jupyter.org/ on how to set-up Jupyter with Python 3.\n",
    "Please download eLCS_1.ipynb, … , eLCS_5.ipynb from Github \n",
    "Please see earlier demos for hide_code and initial introductions\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Name:        eLCS_Run.py\n",
    " - Authors:     Ryan Urbanowicz - Written at Dartmouth College, Hanover, NH, USA\n",
    " - Contact:     ryan.j.urbanowicz@darmouth.edu\n",
    " - Created:     November 1, 2013\n",
    " - Description: To run e-LCS, run this module.  A properly formatted configuration file, including all run parameters must be included with the path to that file given below.  In this example, the configuration file has been included locally, so only the file name is required.\n",
    "             \n",
    "--------------------------------------------------------------------------------------------------------------------------------\n",
    "eLCS: Educational Learning Classifier System - A basic LCS coded for educational purposes.  This LCS algorithm uses supervised learning, and thus is most \n",
    "similar to \"UCS\", an LCS algorithm published by Ester Bernado-Mansilla and Josep Garrell-Guiu (2003) which in turn is based heavily on \"XCS\", an LCS \n",
    "algorithm published by Stewart Wilson (1995).  \n",
    "\n",
    "Copyright (C) 2013 Ryan Urbanowicz \n",
    "This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the \n",
    "Free Software Foundation; either version 3 of the License, or (at your option) any later version.\n",
    "\n",
    "This program is distributed in the hope that it will be useful but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABLILITY \n",
    "or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.\n",
    "\n",
    "You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, \n",
    "Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p class=MsoNormal>3.1. <span style='color:red'>Demo 3.1 </span>(<b\n",
    "style='mso-bidi-font-weight:normal'>Code Demo: Prediction and Rule Population\n",
    "Evaluations</b>) In this implementation, we have added the <span\n",
    "style='font-family:\"Courier New\"'>prediction array</span>, which allows\n",
    "tracking <span style='font-family:\"Courier New\"'>accuracy</span> of the rule\n",
    "population as an estimate of prediction accuracy, over the last <i\n",
    "style='mso-bidi-font-style:normal'>n </i>iterations where <i style='mso-bidi-font-style:\n",
    "normal'>n</i> is the tracking frequency (set to the dataset size by default).\n",
    "Rule <span style='font-family:\"Courier New\"'>numerosity</span> is also added to\n",
    "the algorithm at this point, since <span style='font-family:\"Courier New\"'>numerosity</span>\n",
    "plays a role in prediction. However since the only discovery mechanism in the\n",
    "system so far is covering, if we load an existing rule population, instead of\n",
    "running the algorithm from scratch, only a classi&#64257;er numerosity of 1 is\n",
    "possible. This version is encoded to print statements showing the current\n",
    "instance in the dataset, all rules in the current <span style='font-family:\n",
    "\"Courier New\"'>matchset </span>(including their respective <span class=SpellE>&#64257;tnesses</span>)\n",
    "and then the prediction vote for each class, along with the selected\n",
    "prediction. Readers can compare this prediction to the true phenotype of the\n",
    "current instance.<o:p></o:p></p>\n",
    "\n",
    "<p class=MsoNormal>3.2. <span style='color:red'>Demo 3.2 </span>(Code Demo: <b\n",
    "style='mso-bidi-font-weight:normal'>GA Rule Discovery and Parental Selection</b>)\n",
    "This implementation introduces a panmictic GA for <b style='mso-bidi-font-weight:\n",
    "normal'>rule discovery</b> including <b style='mso-bidi-font-weight:normal'>parental\n",
    "selection</b> (<span style='font-family:\"Courier New\"'>tournament</span> or <span\n",
    "style='font-family:\"Courier New\"'>roulette wheel selection </span>are options),\n",
    "<b style='mso-bidi-font-weight:normal'>mutation,</b> and <b style='mso-bidi-font-weight:\n",
    "normal'>uniform crossover</b>. Also we introduce code for two key output\n",
    "&#64257;les (a print out of the saved <span style='font-family:\"Courier New\"'>rule\n",
    "population</span>, as well as a &#64257;le with <span style='font-family:\"Courier New\"'>population\n",
    "summary statistics</span>). They are included in this and the following\n",
    "implementations, as it is the &#64257;rst time that eLCS can learn anything\n",
    "interesting enough to be saved and explored. This is also the &#64257;rst time\n",
    "that code for complete rule population evaluations is included. Complete\n",
    "evaluations are included at learning checkpoints, speci&#64257;ed in the\n",
    "parameter <span class=SpellE><span style='font-family:\"Courier New\"'>learningIterations</span></span>\n",
    "in the con&#64257;guration &#64257;le. Note that there is no deletion mechanism\n",
    "yet, so the population size blows up pretty quickly, but the algorithm still\n",
    "works, able to obtain perfect prediction accuracy within 10,000 iterations.<o:p></o:p></p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "hideCode": true
   },
   "outputs": [],
   "source": [
    "# Import useful prewritten code from Python libraries\n",
    "import random\n",
    "import copy\n",
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Configure the parameters, usually from a txt file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "hideCode": false
   },
   "outputs": [],
   "source": [
    "###### Configuration File (eLCS)\n",
    "#     In the pure Python eLCS the list  'parameters[parameter] = value #Store parameters in a dictionary' is used \n",
    "######--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "###### Major Run Parameters - Essential to be set correctly for a successful run of the algorithm\n",
    "######--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "trainFile=\"6Multiplexer_Data_Complete.txt\"\t\t# Path/FileName of training dataset\n",
    "testFile='None'\t\t\t\t\t\t\t\t\t# Path/FileName of testing dataset.  If no testing data available or desired, put 'None'.  \n",
    "outFileName=\"ExampleRun\"\t\t\t\t\t\t# Path/NewName for new algorithm output files. Note: Do not give a file extension, this is done automatically.\n",
    "learningIterations='1000.4000'\t\t#changed from 64 # Specify complete algorithm evaluation checkpoints and maximum number of learning iterations (e.g. 1000.2000.5000 = A maximum of 5000 learning iterations with evaluations at 1000, 2000, and 5000 iterations)\n",
    "N=1000\t\t\t\t\t\t\t\t\t\t\t# Maximum size of the rule population (a.k.a. Micro-classifier population size, where N is the sum of the classifier numerosities in the population)\n",
    "p_spec=0.5\t\t\t\t\t\t\t\t\t\t# The probability of specifying an attribute when covering. (1-p_spec = the probability of adding '#' in ternary rule representations). Greater numbers of attributes in a dataset will require lower values of p_spec.\n",
    "\n",
    "######--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "###### Logistical Run Parameters\n",
    "######--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "randomSeed=True #False\t\t\t\t\t\t\t\t# Set a constant random seed value to some integer (in order to obtain reproducible results). Put 'False' if none (for pseudo-random algorithm runs).\n",
    "labelInstanceID=\"InstanceID\"\t\t\t\t\t# Label for the data column header containing instance ID's.  If included label not found, algorithm assumes that no instance ID's were included.\n",
    "labelPhenotype=\"Class\"\t\t\t\t\t\t\t# Label for the data column header containing the phenotype label. (Typically 'Class' for case/control datasets)\n",
    "labelMissingData=\"NA\"\t\t\t\t\t\t\t# Label used for any missing data in the data set.\n",
    "discreteAttributeLimit=10\t\t\t\t\t\t# The maximum number of attribute states allowed before an attribute or phenotype is considered to be continuous (Set this value >= the number of states for any discrete attribute or phenotype in their dataset).\n",
    "trackingFrequency=100\t\t\t\t\t\t\t\t# Specifies the number of iterations before each estimated learning progress report by the algorithm ('0' = report progress every epoch, i.e. every pass through all instances in the training data).\n",
    "\n",
    "######--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "###### Supervised Learning Parameters - Generally just use default values.\n",
    "######--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "nu=5\t\t\t\t\t\t\t\t\t\t\t# (v) Power parameter used to determine the importance of high accuracy when calculating fitness. (typically set to 5, recommended setting of 1 in noisy data)\n",
    "init_fit=0.01\t\t\t\t\t\t\t\t\t# The initial fitness for a new classifier. (typically very small, approaching but not equal to zero)\n",
    "    #New for this demo as parameters to control the GA\n",
    "chi=0.8\t\t\t\t\t\t\t\t\t\t\t# (X) The probability of applying crossover in the GA. (typically set to 0.5-1.0)\n",
    "upsilon=0.04\t\t\t\t\t\t\t\t\t# (u) The probability of mutating an allele within an offspring.(typically set to 0.01-0.05)\n",
    "theta_GA=25\t\t\t\t\t\t\t\t\t\t# The GA threshold; The GA is applied in a set when the average time since the last GA in the set is greater than theta_GA.\n",
    "fitnessReduction=0.1\t\t\t\t\t\t\t# Initial fitness reduction in GA offspring rules.\n",
    "\n",
    "######------New section for GA parent selection---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "###### Algorithm Heuristic Options\n",
    "######--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "selectionMethod='roulette'#'tournament'\t\t\t# Select GA parent selection strategy ('tournament' or 'roulette')\n",
    "theta_sel=0.5\t\t\t\t\t\t\t\t\t# The fraction of the correct set to be included in tournament selection.\n",
    "\n",
    "######--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "###### PopulationReboot - An option to begin e-LCS learning from an existing, saved rule population. Note that the training data is re-shuffled during a reboot.\n",
    "######--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "doPopulationReboot=0\t\t\t\t\t\t\t# Start eLCS from an existing rule population? (1 is True, 0 is False).\n",
    "popRebootPath=\"ExampleRun_eLCS_50000\"\t\t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Offline environment: class to cycle through an offline dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true,
    "hideCode": false
   },
   "outputs": [],
   "source": [
    "class Offline_Environment:\n",
    "    def __init__(self):\n",
    "        #Initialize global variables-------------------------------------------------\n",
    "        self.dataRef = 0\n",
    "        self.storeDataRef = 0\n",
    "        self.formatData = DataManagement(cons.trainFile, cons.testFile)\n",
    "        \n",
    "        #Initialize the first dataset instance to be passed to eLCS\n",
    "        self.currentTrainState = self.formatData.trainFormatted[self.dataRef][0]\n",
    "        self.currentTrainPhenotype = self.formatData.trainFormatted[self.dataRef][1]\n",
    "        if cons.testFile == 'None':\n",
    "            pass\n",
    "        else:\n",
    "            self.currentTestState = self.formatData.testFormatted[self.dataRef][0]\n",
    "            self.currentTestPhenotype = self.formatData.testFormatted[self.dataRef][1]\n",
    "        \n",
    "\n",
    "    def getTrainInstance(self):\n",
    "        \"\"\" Returns the current training instance. \"\"\" \n",
    "        return [self.currentTrainState, self.currentTrainPhenotype]\n",
    "        \n",
    "        \n",
    "    def getTestInstance(self):\n",
    "        \"\"\" Returns the current training instance. \"\"\"\n",
    "        return [self.currentTestState, self.currentTestPhenotype]\n",
    "    \n",
    "    \n",
    "    def newInstance(self, isTraining): \n",
    "        \"\"\"  Shifts the environment to the next instance in the data. \"\"\"\n",
    "        #-------------------------------------------------------\n",
    "        # Training Data\n",
    "        #-------------------------------------------------------\n",
    "        if isTraining: \n",
    "            if self.dataRef < (self.formatData.numTrainInstances-1):\n",
    "                self.dataRef += 1\n",
    "                self.currentTrainState = self.formatData.trainFormatted[self.dataRef][0]\n",
    "                self.currentTrainPhenotype = self.formatData.trainFormatted[self.dataRef][1]\n",
    "            else:  #Once learning has completed an epoch (i.e. a cycle of iterations though the entire training dataset) it starts back at the first instance in the data)\n",
    "                self.resetDataRef(isTraining)\n",
    "                \n",
    "        #-------------------------------------------------------\n",
    "        # Testing Data\n",
    "        #-------------------------------------------------------\n",
    "        else:\n",
    "            if self.dataRef < (self.formatData.numTestInstances-1):\n",
    "                self.dataRef += 1\n",
    "                self.currentTestState = self.formatData.testFormatted[self.dataRef][0]\n",
    "                self.currentTestPhenotype = self.formatData.testFormatted[self.dataRef][1]\n",
    "      \n",
    "      \n",
    "    def resetDataRef(self, isTraining):\n",
    "        \"\"\" Resets the environment back to the first instance in the current data set. \"\"\"\n",
    "        self.dataRef = 0 \n",
    "        if isTraining:\n",
    "            self.currentTrainState = self.formatData.trainFormatted[self.dataRef][0]\n",
    "            self.currentTrainPhenotype = self.formatData.trainFormatted[self.dataRef][1]\n",
    "        else:\n",
    "            self.currentTestState = self.formatData.testFormatted[self.dataRef][0]\n",
    "            self.currentTestPhenotype = self.formatData.testFormatted[self.dataRef][1]\n",
    "\n",
    "\n",
    "    def startEvaluationMode(self):\n",
    "        \"\"\" Turns on evaluation mode.  Saves the instance we left off in the training data. \"\"\"\n",
    "        self.storeDataRef = self.dataRef\n",
    "        \n",
    "        \n",
    "    def stopEvaluationMode(self):\n",
    "        \"\"\" Turns off evaluation mode.  Re-establishes place in dataset.\"\"\"\n",
    "        self.dataRef = self.storeDataRef"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the constants that control the evolutionary process [i.e. the 'cons' object from Constants class]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "hideCode": false
   },
   "outputs": [],
   "source": [
    "class Constants:\n",
    "    def setConstants(self):\n",
    "        \"\"\" Takes the parameters parsed as a dictionary from eLCS_ConfigParser and saves them as global constants. \"\"\"\n",
    "        \n",
    "        # Major Run Parameters -----------------------------------------------------------------------------------------\n",
    "        self.trainFile = trainFile # par['trainFile']                                       #Saved as text\n",
    "        self.testFile = testFile #par['testFile']                                         #Saved as text\n",
    "        self.originalOutFileName = outFileName #str(par['outFileName'])                      #Saved as text\n",
    "        self.outFileName = outFileName +'_eLCS'  #str(par['outFileName'])+'_eLCS'                  #Saved as text\n",
    "        self.learningIterations = learningIterations #par['learningIterations']                     #Saved as text\n",
    "        self.N = N #int(par['N'])                                                  #Saved as integer\n",
    "        self.p_spec = p_spec # float(par['p_spec'])                                      #Saved as float\n",
    "        \n",
    "        # Logistical Run Parameters ------------------------------------------------------------------------------------\n",
    "        # if par['randomSeed'] == 'False' or par['randomSeed'] == 'false':\n",
    "        if randomSeed == False:\n",
    "            self.useSeed = False                                                #Saved as Boolean\n",
    "        else:\n",
    "            self.useSeed = True                                                 #Saved as Boolean\n",
    "            self.randomSeed = randomSeed #int(par['randomSeed'])                #Saved as integer\n",
    "            \n",
    "        self.labelInstanceID = labelInstanceID  #par['labelInstanceID']                           #Saved as text\n",
    "        self.labelPhenotype = labelPhenotype # par['labelPhenotype']                             #Saved as text\n",
    "        self.labelMissingData = labelMissingData  #par['labelMissingData']                         #Saved as text\n",
    "        self.discreteAttributeLimit = discreteAttributeLimit # int(par['discreteAttributeLimit'])        #Saved as integer\n",
    "        self.trackingFrequency = trackingFrequency  #int(par['trackingFrequency'])                  #Saved as integer\n",
    "        \n",
    "        # Supervised Learning Parameters -------------------------------------------------------------------------------\n",
    "        self.nu = nu #int(par['nu'])                                                #Saved as integer\n",
    "        self.init_fit = init_fit #float(par['init_fit'])                                  #Saved as float\n",
    "        #new\n",
    "        self.chi = chi #float(par['chi'])                                            #Saved as float\n",
    "        self.upsilon = upsilon #float(par['upsilon'])                                    #Saved as float\n",
    "        self.theta_GA = theta_GA #int(par['theta_GA'])                                    #Saved as integer\n",
    "        self.fitnessReduction = fitnessReduction #float(par['fitnessReduction'])                  #Saved as float\n",
    "        \n",
    "        # Algorithm Heuristic Options -------------------------------------------------------------------------------\n",
    "        self.selectionMethod = selectionMethod #par['selectionMethod']                           #Saved as text\n",
    "        self.theta_sel = theta_sel #float(par['theta_sel'])                                #Saved as float\n",
    "        \n",
    "        # PopulationReboot -------------------------------------------------------------------------------\n",
    "        self.doPopulationReboot = doPopulationReboot # bool(int(par['doPopulationReboot']))          #Saved as Boolean\n",
    "        self.popRebootPath = popRebootPath #par['popRebootPath']                               #Saved as text\n",
    "        \n",
    "        \n",
    "    def referenceEnv(self, e):\n",
    "        \"\"\" Store reference to environment object. \"\"\"\n",
    "        self.env = e\n",
    " \n",
    "        \n",
    "    def parseIterations(self):\n",
    "        \"\"\" Parse the 'learningIterations' string to identify the maximum number of learning iterations as well as evaluation checkpoints. \"\"\"\n",
    "        checkpoints = self.learningIterations.split('.') \n",
    "        for i in range(len(checkpoints)): \n",
    "            checkpoints[i] = int(checkpoints[i])\n",
    "            \n",
    "        self.learningCheckpoints = checkpoints\n",
    "        self.maxLearningIterations = self.learningCheckpoints[(len(self.learningCheckpoints)-1)] \n",
    "        \n",
    "        if self.trackingFrequency == 0:#throws an odd error???\n",
    "            self.trackingFrequency = self.env.formatData.numTrainInstances  #Adjust tracking frequency to match the training data size - learning tracking occurs once every epoch\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "hideCode": true
   },
   "outputs": [],
   "source": [
    "\n",
    "#To access one of the above constant values from another module, import GHCS_Constants * and use \"cons.something\"\n",
    "cons = Constants() \n",
    "cons.setConstants() #Store run parameters in the 'Constants' module.\n",
    "cons.parseIterations() #Store run parameters in the 'Constants' module.\n",
    "#print(cons.maxLearningIterations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false
   },
   "source": [
    "Data management, e.g. load data from a file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true,
    "hideCode": true
   },
   "outputs": [],
   "source": [
    "class DataManagement:\n",
    "    def __init__(self, trainFile, testFile, infoList = None):\n",
    "        #Set random seed if specified.-----------------------------------------------\n",
    "        if cons.useSeed:\n",
    "            random.seed(cons.randomSeed)\n",
    "        else:\n",
    "            random.seed(None)\n",
    "\n",
    "        #Initialize global variables-------------------------------------------------\n",
    "        self.numAttributes = None       # The number of attributes in the input file. \n",
    "        self.areInstanceIDs = False     # Does the dataset contain a column of Instance IDs? (If so, it will not be included as an attribute)\n",
    "        self.instanceIDRef = None       # The column reference for Instance IDs\n",
    "        self.phenotypeRef = None        # The column reference for the Class/Phenotype column\n",
    "        self.discretePhenotype = True   # Is the Class/Phenotype Discrete? (False = Continuous)\n",
    "        self.attributeInfo = []         # Stores Discrete (0) or Continuous (1) for each attribute\n",
    "        self.phenotypeList = []         # Stores all possible discrete phenotype states/classes or maximum and minimum values for a continuous phenotype\n",
    "        self.phenotypeRange = None      # Stores the difference between the maximum and minimum values for a continuous phenotype\n",
    "        \n",
    "        #Train/Test Specific-----------------------------------------------------------------------------\n",
    "        self.trainHeaderList = []       # The dataset column headers for the training data\n",
    "        self.testHeaderList = []        # The dataset column headers for the testing data\n",
    "        self.numTrainInstances = None   # The number of instances in the training data\n",
    "        self.numTestInstances = None    # The number of instances in the testing data\n",
    "        \n",
    "        print(\"----------------------------------------------------------------------------\")\n",
    "        print(\"Environment: Formatting Data... \")\n",
    "        \n",
    "        #Detect Features of training data--------------------------------------------------------------------------\n",
    "        rawTrainData = self.loadData(trainFile, True) #Load the raw data.\n",
    "\n",
    "        self.characterizeDataset(rawTrainData)  #Detect number of attributes, instances, and reference locations.\n",
    "        \n",
    "        if cons.testFile == 'None': #If no testing data is available, formatting relies solely on training data.\n",
    "            data4Formating = rawTrainData\n",
    "        else:\n",
    "            rawTestData = self.loadData(testFile, False) #Load the raw data.\n",
    "            self.compareDataset(rawTestData) #Ensure that key features are the same between training and testing datasets.\n",
    "            data4Formating = rawTrainData + rawTestData #Merge Training and Testing datasets\n",
    "\n",
    "        self.discriminatePhenotype(data4Formating) #Determine if endpoint/phenotype is discrete or continuous.\n",
    "        if self.discretePhenotype:\n",
    "            self.discriminateClasses(data4Formating) #Detect number of unique phenotype identifiers.\n",
    "        else:\n",
    "            self.characterizePhenotype(data4Formating)\n",
    "            \n",
    "        self.discriminateAttributes(data4Formating) #Detect whether attributes are discrete or continuous.\n",
    "        self.characterizeAttributes(data4Formating) #Determine potential attribute states or ranges.\n",
    "        \n",
    "        #Format and Shuffle Datasets----------------------------------------------------------------------------------------\n",
    "        if cons.testFile != 'None':\n",
    "            self.testFormatted = self.formatData(rawTestData) #Stores the formatted testing data set used throughout the algorithm.\n",
    "\n",
    "        self.trainFormatted = self.formatData(rawTrainData) #Stores the formatted training data set used throughout the algorithm.       \n",
    "        print(\"----------------------------------------------------------------------------\")\n",
    "\n",
    "        \n",
    "    def loadData(self, dataFile, doTrain):\n",
    "        \"\"\" Load the data file. \"\"\"     \n",
    "        print(\"DataManagement: Loading Data... \" + str(dataFile))\n",
    "        datasetList = []\n",
    "        try:       \n",
    "            f = open(dataFile,'r')\n",
    "        except Exception as inst:\n",
    "            print(type(inst))\n",
    "            print(inst.args)\n",
    "            print(inst)\n",
    "            print('cannot open', dataFile)\n",
    "            raise\n",
    "            \n",
    "        else:\n",
    "            if doTrain:\n",
    "                self.trainHeaderList = f.readline().rstrip('\\n').split('\\t')   #strip off first row\n",
    "            else:\n",
    "                self.testHeaderList = f.readline().rstrip('\\n').split('\\t')   #strip off first row\n",
    "            for line in f:\n",
    "                lineList = line.strip('\\n').split('\\t')\n",
    "                datasetList.append(lineList)\n",
    "            f.close()\n",
    "\n",
    "        return datasetList\n",
    "    \n",
    "    \n",
    "    def characterizeDataset(self, rawTrainData):\n",
    "        \" Detect basic dataset parameters \" \n",
    "        #Detect Instance ID's and save location if they occur.  Then save number of attributes in data.\n",
    "        if cons.labelInstanceID in self.trainHeaderList:\n",
    "            self.areInstanceIDs = True\n",
    "            self.instanceIDRef = self.trainHeaderList.index(cons.labelInstanceID)\n",
    "            print(\"DataManagement: Instance ID Column location = \"+str(self.instanceIDRef))\n",
    "            self.numAttributes = len(self.trainHeaderList)-2 #one column for InstanceID and another for the phenotype.\n",
    "        else:\n",
    "            self.numAttributes = len(self.trainHeaderList)-1\n",
    "        \n",
    "        #Identify location of phenotype column\n",
    "        if cons.labelPhenotype in self.trainHeaderList:\n",
    "            self.phenotypeRef = self.trainHeaderList.index(cons.labelPhenotype)\n",
    "            print(\"DataManagement: Phenotype Column Location = \"+str(self.phenotypeRef))\n",
    "        else:\n",
    "            print(\"DataManagement: Error - Phenotype column not found!  Check data set to ensure correct phenotype column label, or inclusion in the data.\")\n",
    "\n",
    "        #Adjust training header list to just include attributes labels\n",
    "        if self.areInstanceIDs:\n",
    "            if self.phenotypeRef > self.instanceIDRef:\n",
    "                self.trainHeaderList.pop(self.phenotypeRef)\n",
    "                self.trainHeaderList.pop(self.instanceIDRef)\n",
    "            else:\n",
    "                self.trainHeaderList.pop(self.instanceIDRef)\n",
    "                self.trainHeaderList.pop(self.phenotypeRef)\n",
    "        else:\n",
    "            self.trainHeaderList.pop(self.phenotypeRef)\n",
    "        \n",
    "        #Store number of instances in training data\n",
    "        self.numTrainInstances = len(rawTrainData)\n",
    "        print(\"DataManagement: Number of Attributes = \" + str(self.numAttributes)) \n",
    "        print(\"DataManagement: Number of Instances = \" + str(self.numTrainInstances)) \n",
    "\n",
    "\n",
    "    def discriminatePhenotype(self, rawData):\n",
    "        \"\"\" Determine whether the phenotype is Discrete(class-based) or Continuous \"\"\"\n",
    "        print(\"DataManagement: Analyzing Phenotype...\")\n",
    "        inst = 0\n",
    "        classDict = {}\n",
    "        while self.discretePhenotype and len(list(classDict.keys())) <= cons.discreteAttributeLimit and inst < self.numTrainInstances:  #Checks which discriminate between discrete and continuous attribute\n",
    "            target = rawData[inst][self.phenotypeRef]\n",
    "            if target in list(classDict.keys()):  #Check if we've seen this attribute state yet.\n",
    "                classDict[target] += 1\n",
    "            elif target == cons.labelMissingData: #Ignore missing data\n",
    "                print(\"DataManagement: Warning - Individual detected with missing phenotype information!\")\n",
    "                pass\n",
    "            else: #New state observed\n",
    "                classDict[target] = 1\n",
    "            inst += 1\n",
    "\n",
    "        if len(list(classDict.keys())) > cons.discreteAttributeLimit:\n",
    "            self.discretePhenotype = False\n",
    "            self.phenotypeList = [float(target),float(target)]\n",
    "            print(\"DataManagement: Phenotype Detected as Continuous.\")\n",
    "        else:\n",
    "            print(\"DataManagement: Phenotype Detected as Discrete.\")\n",
    "            \n",
    "    \n",
    "    def discriminateClasses(self, rawData):\n",
    "        \"\"\" Determines number of classes and their identifiers. Only used if phenotype is discrete. \"\"\"\n",
    "        print(\"DataManagement: Detecting Classes...\")\n",
    "        inst = 0\n",
    "        classCount = {}\n",
    "        while inst < self.numTrainInstances:\n",
    "            target = rawData[inst][self.phenotypeRef]\n",
    "            if target in self.phenotypeList:\n",
    "                classCount[target] += 1 \n",
    "            else:\n",
    "                self.phenotypeList.append(target)\n",
    "                classCount[target] = 1\n",
    "            inst += 1\n",
    "        print(\"DataManagement: Following Classes Detected:\" + str(self.phenotypeList))\n",
    "        for each in list(classCount.keys()):\n",
    "            print(\"Class: \"+str(each)+ \" count = \"+ str(classCount[each]))\n",
    "            \n",
    "                     \n",
    "    def compareDataset(self, rawTestData):\n",
    "        \" Ensures that the attributes in the testing data match those in the training data.  Also stores some information about the testing data. \"\n",
    "        if self.areInstanceIDs:\n",
    "            if self.phenotypeRef > self.instanceIDRef:\n",
    "                self.testHeaderList.pop(self.phenotypeRef)\n",
    "                self.testHeaderList.pop(self.instanceIDRef)\n",
    "            else:\n",
    "                self.testHeaderList.pop(self.instanceIDRef)\n",
    "                self.testHeaderList.pop(self.phenotypeRef)\n",
    "        else:\n",
    "            self.testHeaderList.pop(self.phenotypeRef)\n",
    "            \n",
    "        if self.trainHeaderList != self.testHeaderList:\n",
    "            print(\"DataManagement: Error - Training and Testing Dataset Headers are not equivalent\")\n",
    "\n",
    "        # Stores the number of instances in the testing data.\n",
    "        self.numTestInstances = len(rawTestData)\n",
    "        print(\"DataManagement: Number of Attributes = \" + str(self.numAttributes)) \n",
    "        print(\"DataManagement: Number of Instances = \" + str(self.numTestInstances)) \n",
    "\n",
    "\n",
    "    def discriminateAttributes(self, rawData):\n",
    "        \"\"\" Determine whether attributes in dataset are discrete or continuous and saves this information. \"\"\"\n",
    "        print(\"DataManagement: Detecting Attributes...\")\n",
    "        self.discreteCount = 0\n",
    "        self.continuousCount = 0\n",
    "        for att in range(len(rawData[0])):\n",
    "            if att != self.instanceIDRef and att != self.phenotypeRef:  #Get just the attribute columns (ignores phenotype and instanceID columns)\n",
    "                attIsDiscrete = True\n",
    "                inst = 0\n",
    "                stateDict = {}\n",
    "                while attIsDiscrete and len(list(stateDict.keys())) <= cons.discreteAttributeLimit and inst < self.numTrainInstances:  #Checks which discriminate between discrete and continuous attribute\n",
    "                    target = rawData[inst][att]\n",
    "                    if target in list(stateDict.keys()):  #Check if we've seen this attribute state yet.\n",
    "                        stateDict[target] += 1\n",
    "                    elif target == cons.labelMissingData: #Ignore missing data\n",
    "                        pass\n",
    "                    else: #New state observed\n",
    "                        stateDict[target] = 1\n",
    "                    inst += 1\n",
    "\n",
    "                if len(list(stateDict.keys())) > cons.discreteAttributeLimit:\n",
    "                    attIsDiscrete = False\n",
    "                if attIsDiscrete:\n",
    "                    self.attributeInfo.append([0,[]])    \n",
    "                    self.discreteCount += 1\n",
    "                else:\n",
    "                    self.attributeInfo.append([1,[float(target),float(target)]])   #[min,max]\n",
    "                    self.continuousCount += 1\n",
    "        print(\"DataManagement: Identified \"+str(self.discreteCount)+\" discrete and \"+str(self.continuousCount)+\" continuous attributes.\") #Debug\n",
    "\n",
    "            \n",
    "    def characterizeAttributes(self, rawData):\n",
    "        \"\"\" Determine range (if continuous) or states (if discrete) for each attribute and saves this information\"\"\"\n",
    "        print(\"DataManagement: Characterizing Attributes...\")\n",
    "        attributeID = 0\n",
    "        for att in range(len(rawData[0])):\n",
    "            if att != self.instanceIDRef and att != self.phenotypeRef:  #Get just the attribute columns (ignores phenotype and instanceID columns)\n",
    "                for inst in range(len(rawData)):\n",
    "                    target = rawData[inst][att]\n",
    "                    if not self.attributeInfo[attributeID][0]: #If attribute is discrete\n",
    "                        if target in self.attributeInfo[attributeID][1] or target == cons.labelMissingData:\n",
    "                            pass  #NOTE: Could potentially store state frequency information to guide learning.\n",
    "                        else:\n",
    "                            self.attributeInfo[attributeID][1].append(target)\n",
    "                    else: #If attribute is continuous\n",
    "                        \n",
    "                        #Find Minimum and Maximum values for the continuous attribute so we know the range.\n",
    "                        if target == cons.labelMissingData:\n",
    "                            pass\n",
    "                        elif float(target) > self.attributeInfo[attributeID][1][1]:  #error\n",
    "                            self.attributeInfo[attributeID][1][1] = float(target)\n",
    "                        elif float(target) < self.attributeInfo[attributeID][1][0]:\n",
    "                            self.attributeInfo[attributeID][1][0] = float(target)\n",
    "                        else:\n",
    "                            pass\n",
    "                attributeID += 1\n",
    "                \n",
    "\n",
    "    def characterizePhenotype(self, rawData):\n",
    "        \"\"\" Determine range of phenotype values. \"\"\"\n",
    "        print(\"DataManagement: Characterizing Phenotype...\")\n",
    "        for inst in range(len(rawData)):\n",
    "            target = rawData[inst][self.phenotypeRef]\n",
    "            \n",
    "            #Find Minimum and Maximum values for the continuous phenotype so we know the range.\n",
    "            if target == cons.labelMissingData:\n",
    "                pass\n",
    "            elif float(target) > self.phenotypeList[1]:  \n",
    "                self.phenotypeList[1] = float(target)\n",
    "            elif float(target) < self.phenotypeList[0]:\n",
    "                self.phenotypeList[0] = float(target)\n",
    "            else:\n",
    "                pass\n",
    "        self.phenotypeRange = self.phenotypeList[1] - self.phenotypeList[0]\n",
    "                \n",
    "            \n",
    "    def formatData(self,rawData):\n",
    "        \"\"\" Get the data into a format convenient for the algorithm to interact with. Specifically each instance is stored in a list as follows; [Attribute States, Phenotype, InstanceID] \"\"\"\n",
    "        formatted = []\n",
    "        #Initialize data format---------------------------------------------------------\n",
    "        for i in range(len(rawData)):  \n",
    "            formatted.append([None,None,None]) #[Attribute States, Phenotype, InstanceID]\n",
    "\n",
    "        for inst in range(len(rawData)):\n",
    "            stateList = []\n",
    "            attributeID = 0\n",
    "            for att in range(len(rawData[0])):\n",
    "                if att != self.instanceIDRef and att != self.phenotypeRef:  #Get just the attribute columns (ignores phenotype and instanceID columns)\n",
    "                    target = rawData[inst][att]\n",
    "                    \n",
    "                    if self.attributeInfo[attributeID][0]: #If the attribute is continuous\n",
    "                        if target == cons.labelMissingData:\n",
    "                            stateList.append(target) #Missing data saved as text label\n",
    "                        else:\n",
    "                            stateList.append(float(target)) #Save continuous data as floats. \n",
    "                    else: #If the attribute is discrete - Format the data to correspond to the GABIL (DeJong 1991)\n",
    "                        stateList.append(target) #missing data, and discrete variables, all stored as string objects   \n",
    "                    attributeID += 1\n",
    "            \n",
    "            #Final Format-----------------------------------------------\n",
    "            formatted[inst][0] = stateList                           #Attribute states stored here\n",
    "            if self.discretePhenotype:\n",
    "                formatted[inst][1] = rawData[inst][self.phenotypeRef]        #phenotype stored here\n",
    "            else:\n",
    "                formatted[inst][1] = float(rawData[inst][self.phenotypeRef])\n",
    "            if self.areInstanceIDs:\n",
    "                formatted[inst][2] = rawData[inst][self.instanceIDRef]   #Instance ID stored here\n",
    "            else:\n",
    "                pass    #instance ID neither given nor required.\n",
    "            #-----------------------------------------------------------\n",
    "        random.shuffle(formatted) #One time randomization of the order the of the instances in the data, so that if the data was ordered by phenotype, this potential learning bias (based on instance ordering) is eliminated.  \n",
    "        return formatted\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classifier class! Worth reading :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true,
    "hideCode": false
   },
   "outputs": [],
   "source": [
    "class Classifier:\n",
    "    def __init__(self,a=None,b=None,c=None,d=None):\n",
    "        #Major Parameters --------------------------------------------------\n",
    "        self.specifiedAttList = []      # Attribute Specified in classifier: Similar to Bacardit 2009 - ALKR + GABIL, continuous and discrete rule representation\n",
    "        self.condition = []             # States of Attributes Specified in classifier: Similar to Bacardit 2009 - ALKR + GABIL, continuous and discrete rule representation\n",
    "        self.phenotype = None           # Class if the endpoint is discrete, and a continuous phenotype if the endpoint is continuous\n",
    "        \n",
    "        self.fitness = cons.init_fit    # Classifier fitness - initialized to a constant initial fitness value\n",
    "        self.accuracy = 0.0             # Classifier accuracy - Accuracy calculated using only instances in the dataset which this rule matched.\n",
    "        self.numerosity = 1   #new but not fully used yet!  # The number of rule copies stored in the population.  (Indirectly stored as incremented numerosity)\n",
    "     \n",
    "        #Experience Management ---------------------------------------------\n",
    "        self.initTimeStamp = None       # Iteration in which the rule first appeared.\n",
    "        \n",
    "        #Classifier Accuracy Tracking --------------------------------------\n",
    "        self.matchCount = 0             # Known in many LCS implementations as experience i.e. the total number of times this classifier was in a match set\n",
    "        self.correctCount = 0           # The total number of times this classifier was in a correct set\n",
    "        \n",
    "        if isinstance(b,list):\n",
    "            self.classifierCovering(a,b,c)\n",
    "        elif isinstance(a,Classifier):\n",
    "            self.classifierCopy(a, b)\n",
    "        elif isinstance(a,list) and b == None:\n",
    "            self.rebootClassifier(a)\n",
    "        else:\n",
    "            print(\"Classifier: Error building classifier.\")\n",
    "            \n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # CLASSIFIER CONSTRUCTION METHODS\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------       \n",
    "    def classifierCovering(self, exploreIter, state, phenotype):\n",
    "        \"\"\" Makes a new classifier when the covering mechanism is triggered.  The new classifier will match the current training instance. \n",
    "        Covering will NOT produce a default rule (i.e. a rule with a completely general condition). \"\"\"\n",
    "        #Initialize new classifier parameters----------\n",
    "        self.timeStampGA = exploreIter #new and important for triggering the ga when appropriate\n",
    "        self.initTimeStamp = exploreIter\n",
    "        dataInfo = cons.env.formatData\n",
    "        #-------------------------------------------------------\n",
    "        # DISCRETE PHENOTYPE\n",
    "        #-------------------------------------------------------\n",
    "        if dataInfo.discretePhenotype: \n",
    "            self.phenotype = phenotype\n",
    "        #-------------------------------------------------------\n",
    "        # CONTINUOUS PHENOTYPE\n",
    "        #-------------------------------------------------------\n",
    "        else:\n",
    "            phenotypeRange = dataInfo.phenotypeList[1] - dataInfo.phenotypeList[0]\n",
    "            rangeRadius = random.randint(25,75)*0.01*phenotypeRange / 2.0 #Continuous initialization domain radius.\n",
    "            Low = float(phenotype) - rangeRadius\n",
    "            High = float(phenotype) + rangeRadius\n",
    "            self.phenotype = [Low,High] #ALKR Representation, Initialization centered around training instance  with a range between 25 and 75% of the domain size.      \n",
    "        #-------------------------------------------------------\n",
    "        # GENERATE MATCHING CONDITION\n",
    "        #-------------------------------------------------------\n",
    "        while len(self.specifiedAttList) < 1:\n",
    "            for attRef in range(len(state)):\n",
    "                if random.random() < cons.p_spec and state[attRef] != cons.labelMissingData:\n",
    "                    self.specifiedAttList.append(attRef)\n",
    "                    self.condition.append(self.buildMatch(attRef, state))\n",
    "        \n",
    "    #new method tp copy a classifier prior to evolving it              \n",
    "    def classifierCopy(self, clOld, exploreIter):\n",
    "        \"\"\"  Constructs an identical Classifier.  However, the experience of the copy is set to 0 and the numerosity \n",
    "        is set to 1 since this is indeed a new individual in a population. Used by the genetic algorithm to generate \n",
    "        offspring based on parent classifiers.\"\"\"\n",
    "        self.specifiedAttList = copy.deepcopy(clOld.specifiedAttList)\n",
    "        self.condition = copy.deepcopy(clOld.condition) \n",
    "        self.phenotype = copy.deepcopy(clOld.phenotype)\n",
    "        self.timeStampGA = exploreIter\n",
    "        self.initTimeStamp = exploreIter\n",
    "        self.fitness = clOld.fitness\n",
    "        self.accuracy = clOld.accuracy\n",
    "          \n",
    "    def rebootClassifier(self, classifierList): \n",
    "        \"\"\" Rebuilds a saved classifier as part of the population Reboot \"\"\"\n",
    "        numAttributes = cons.env.formatData.numAttributes\n",
    "        attInfo = cons.env.formatData.attributeInfo\n",
    "        for attRef in range(0,numAttributes):\n",
    "            if classifierList[attRef] != '#':  #Attribute in rule is not wild\n",
    "                if attInfo[attRef][0]: #Continuous Attribute\n",
    "                    valueRange = classifierList[attRef].split(';')\n",
    "                    self.condition.append(valueRange)\n",
    "                    self.specifiedAttList.append(attRef)\n",
    "                else:\n",
    "                    self.condition.append(classifierList[attRef])\n",
    "                    self.specifiedAttList.append(attRef)\n",
    "        #-------------------------------------------------------\n",
    "        # DISCRETE PHENOTYPE\n",
    "        #-------------------------------------------------------\n",
    "        if cons.env.formatData.discretePhenotype: \n",
    "            self.phenotype = str(classifierList[numAttributes])\n",
    "        #-------------------------------------------------------\n",
    "        # CONTINUOUS PHENOTYPE\n",
    "        #-------------------------------------------------------\n",
    "        else:\n",
    "            self.phenotype = classifierList[numAttributes].split(';')\n",
    "            for i in range(2): \n",
    "                self.phenotype[i] = float(self.phenotype[i])\n",
    "\n",
    "        self.fitness = float(classifierList[numAttributes+1])\n",
    "        self.accuracy = float(classifierList[numAttributes+2])\n",
    "        self.initTimeStamp = int(classifierList[numAttributes+6])\n",
    "        self.numerosity = int(classifierList[numAttributes+3]) #new\n",
    "        self.timeStampGA = int(classifierList[numAttributes+5]) #new\n",
    "        \n",
    "        self.correctCount = int(classifierList[numAttributes+9])\n",
    "        self.matchCount = int(classifierList[numAttributes+10])\n",
    "\n",
    "\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # MATCHING\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------  \n",
    "    def match(self, state):\n",
    "        \"\"\" Returns if the classifier matches in the current situation. \"\"\" \n",
    "        for i in range(len(self.condition)):\n",
    "            attributeInfo = cons.env.formatData.attributeInfo[self.specifiedAttList[i]]\n",
    "            #-------------------------------------------------------\n",
    "            # CONTINUOUS ATTRIBUTE\n",
    "            #-------------------------------------------------------\n",
    "            if attributeInfo[0]:\n",
    "                instanceValue = state[self.specifiedAttList[i]]\n",
    "                if self.condition[i][0] < instanceValue < self.condition[i][1] or instanceValue == cons.labelMissingData:\n",
    "                    pass\n",
    "                else:\n",
    "                    return False  \n",
    "            #-------------------------------------------------------\n",
    "            # DISCRETE ATTRIBUTE\n",
    "            #-------------------------------------------------------\n",
    "            else:\n",
    "                stateRep = state[self.specifiedAttList[i]]  \n",
    "                if stateRep == self.condition[i] or stateRep == cons.labelMissingData:\n",
    "                    pass\n",
    "                else:\n",
    "                    return False \n",
    "        return True\n",
    "        \n",
    "    #--------This whole block is new as is the Rule Discovery (GA)--------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # GENETIC ALGORITHM MECHANISMS\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------  \n",
    "    def uniformCrossover(self, cl):\n",
    "        \"\"\" Applies uniform crossover and returns if the classifiers changed. Handles both discrete and continuous attributes. \"\"\"\n",
    "        if cons.env.formatData.discretePhenotype or random.random() < 0.5: #Always crossover condition if the phenotype is discrete (if continuous phenotype, half the time phenotype crossover is performed instead)\n",
    "            p_self_specifiedAttList = copy.deepcopy(self.specifiedAttList)\n",
    "            p_cl_specifiedAttList = copy.deepcopy(cl.specifiedAttList)\n",
    "                \n",
    "            #Make list of attribute references appearing in at least one of the parents.-----------------------------\n",
    "            comboAttList = []\n",
    "            for i in p_self_specifiedAttList:\n",
    "                comboAttList.append(i)\n",
    "            for i in p_cl_specifiedAttList:\n",
    "                if i not in comboAttList:\n",
    "                    comboAttList.append(i)\n",
    "                elif not cons.env.formatData.attributeInfo[i][0]: #Attribute specified in both parents, and the attribute is discrete (then no reason to cross over)\n",
    "                    comboAttList.remove(i)\n",
    "            comboAttList.sort()\n",
    "            #--------------------------------------------------------------------------------------------------------\n",
    "            changed = False;   \n",
    "            for attRef in comboAttList:  #Each condition specifies different attributes, so we need to go through all attributes in the dataset.\n",
    "                attributeInfo = cons.env.formatData.attributeInfo[attRef]\n",
    "                probability = 0.5  #Equal probability for attribute alleles to be exchanged.\n",
    "                #-----------------------------\n",
    "                ref = 0\n",
    "                #if attRef in self.specifiedAttList:\n",
    "                if attRef in p_self_specifiedAttList:\n",
    "                    ref += 1\n",
    "                #if attRef in cl.specifiedAttList:\n",
    "                if attRef in p_cl_specifiedAttList:\n",
    "                    ref += 1\n",
    "                #-----------------------------\n",
    "\n",
    "                if ref == 0:    #Attribute not specified in either condition (Attribute type makes no difference)\n",
    "                    print(\"Error: UniformCrossover!\")\n",
    "                    pass\n",
    "                \n",
    "                elif ref == 1:  #Attribute specified in only one condition - do probabilistic switch of whole attribute state (Attribute type makes no difference)\n",
    "                    if attRef in p_self_specifiedAttList and random.random() > probability: \n",
    "                        i = self.specifiedAttList.index(attRef) #reference to the position of the attribute in the rule representation\n",
    "                        cl.condition.append(self.condition.pop(i)) #Take attribute from self and add to cl\n",
    "                        cl.specifiedAttList.append(attRef)\n",
    "                        self.specifiedAttList.remove(attRef)\n",
    "                        changed = True #Remove att from self and add to cl\n",
    "\n",
    "                        \n",
    "                    if attRef in p_cl_specifiedAttList and random.random() < probability: \n",
    "                        i = cl.specifiedAttList.index(attRef) #reference to the position of the attribute in the rule representation\n",
    "                        self.condition.append(cl.condition.pop(i)) #Take attribute from self and add to cl\n",
    "                        self.specifiedAttList.append(attRef)\n",
    "                        cl.specifiedAttList.remove(attRef)\n",
    "                        changed = True #Remove att from cl and add to self.\n",
    "\n",
    "    \n",
    "                else: #Attribute specified in both conditions - do random crossover between state alleles.  The same attribute may be specified at different positions within either classifier\n",
    "                    #-------------------------------------------------------\n",
    "                    # CONTINUOUS ATTRIBUTE\n",
    "                    #-------------------------------------------------------\n",
    "                    if attributeInfo[0]: \n",
    "                        i_cl1 = self.specifiedAttList.index(attRef) #pairs with self (classifier 1)\n",
    "                        i_cl2 = cl.specifiedAttList.index(attRef)   #pairs with cl (classifier 2)\n",
    "                        tempKey = random.randint(0,3) #Make random choice between 4 scenarios, Swap minimums, Swap maximums, Self absorbs cl, or cl absorbs self.\n",
    "                        if tempKey == 0:    #Swap minimum\n",
    "                            temp = self.condition[i_cl1][0]\n",
    "                            self.condition[i_cl1][0] = cl.condition[i_cl2][0]\n",
    "                            cl.condition[i_cl2][0] = temp\n",
    "                        elif tempKey == 1:  #Swap maximum\n",
    "                            temp = self.condition[i_cl1][1]\n",
    "                            self.condition[i_cl1][1] = cl.condition[i_cl2][1]\n",
    "                            cl.condition[i_cl2][1] = temp\n",
    "                        else: #absorb range\n",
    "                            allList = self.condition[i_cl1] + cl.condition[i_cl2]\n",
    "                            newMin = min(allList)\n",
    "                            newMax = max(allList)\n",
    "                            if tempKey == 2:  #self absorbs cl\n",
    "                                self.condition[i_cl1] = [newMin,newMax]\n",
    "                                #Remove cl\n",
    "                                cl.condition.pop(i_cl2)\n",
    "                                cl.specifiedAttList.remove(attRef)\n",
    "                            else: #cl absorbs self\n",
    "                                cl.condition[i_cl2] = [newMin,newMax]\n",
    "                                #Remove self\n",
    "                                self.condition.pop(i_cl1)\n",
    "                                self.specifiedAttList.remove(attRef)\n",
    "                    #-------------------------------------------------------\n",
    "                    # DISCRETE ATTRIBUTE\n",
    "                    #-------------------------------------------------------\n",
    "                    else: \n",
    "                        pass\n",
    "\n",
    "            tempList1 = copy.deepcopy(p_self_specifiedAttList)\n",
    "            tempList2 = copy.deepcopy(cl.specifiedAttList)\n",
    "            tempList1.sort()\n",
    "            tempList2.sort()\n",
    "            \n",
    "            if changed and (tempList1 == tempList2):\n",
    "                changed = False\n",
    "                \n",
    "            return changed\n",
    "        #-------------------------------------------------------\n",
    "        # CONTINUOUS PHENOTYPE CROSSOVER\n",
    "        #-------------------------------------------------------\n",
    "        else: \n",
    "            return self.phenotypeCrossover(cl)\n",
    "        \n",
    "        \n",
    "    def phenotypeCrossover(self, cl):\n",
    "        \"\"\" Crossover a continuous phenotype \"\"\"\n",
    "        changed = False\n",
    "        if self.phenotype[0] == cl.phenotype[0] and self.phenotype[1] == cl.phenotype[1]:\n",
    "            return changed\n",
    "        else:\n",
    "            tempKey = random.random() < 0.5 #Make random choice between 4 scenarios, Swap minimums, Swap maximums, Children preserve parent phenotypes.\n",
    "            if tempKey: #Swap minimum\n",
    "                temp = self.phenotype[0]\n",
    "                self.phenotype[0] = cl.phenotype[0]\n",
    "                cl.phenotype[0] = temp\n",
    "                changed = True\n",
    "            elif tempKey:  #Swap maximum\n",
    "                temp = self.phenotype[1]\n",
    "                self.phenotype[1] = cl.phenotype[1]\n",
    "                cl.phenotype[1] = temp\n",
    "                changed = True\n",
    "            \n",
    "        return changed\n",
    "        \n",
    "        \n",
    "    def Mutation(self, state, phenotype):\n",
    "        \"\"\" Mutates the condition of the classifier. Also handles phenotype mutation. This is a niche mutation, which means that the resulting classifier will still match the current instance.  \"\"\"               \n",
    "        changed = False;   \n",
    "        #-------------------------------------------------------\n",
    "        # MUTATE CONDITION\n",
    "        #-------------------------------------------------------\n",
    "        for attRef in range(cons.env.formatData.numAttributes):  #Each condition specifies different attributes, so we need to go through all attributes in the dataset.\n",
    "            attributeInfo = cons.env.formatData.attributeInfo[attRef]\n",
    "            if random.random() < cons.upsilon and state[attRef] != cons.labelMissingData:\n",
    "                #MUTATION--------------------------------------------------------------------------------------------------------------\n",
    "                if attRef not in self.specifiedAttList: #Attribute not yet specified\n",
    "                    self.specifiedAttList.append(attRef)\n",
    "                    self.condition.append(self.buildMatch(attRef, state)) #buildMatch handles both discrete and continuous attributes\n",
    "                    changed = True\n",
    "                    \n",
    "                elif attRef in self.specifiedAttList: #Attribute already specified\n",
    "                    i = self.specifiedAttList.index(attRef) #reference to the position of the attribute in the rule representation\n",
    "                    #-------------------------------------------------------\n",
    "                    # DISCRETE OR CONTINUOUS ATTRIBUTE - remove attribute specification with 50% chance if we have continuous attribute, or 100% if discrete attribute.\n",
    "                    #-------------------------------------------------------\n",
    "                    if not attributeInfo[0] or random.random() > 0.5: \n",
    "                        self.specifiedAttList.remove(attRef)\n",
    "                        self.condition.pop(i) #buildMatch handles both discrete and continuous attributes\n",
    "                        changed = True\n",
    "                    #-------------------------------------------------------\n",
    "                    # CONTINUOUS ATTRIBUTE - (mutate range with 50% probability vs. removing specification of this attribute all together)\n",
    "                    #-------------------------------------------------------\n",
    "                    else: \n",
    "                        #Mutate continuous range - based on Bacardit 2009 - Select one bound with uniform probability and add or subtract a randomly generated offset to bound, of size between 0 and 50% of att domain.\n",
    "                        attRange = float(attributeInfo[1][1]) - float(attributeInfo[1][0])\n",
    "                        mutateRange = random.random()*0.5*attRange\n",
    "                        if random.random() > 0.5: #Mutate minimum \n",
    "                            if random.random() > 0.5: #Add\n",
    "                                self.condition[i][0] += mutateRange\n",
    "                            else: #Subtract\n",
    "                                self.condition[i][0] -= mutateRange\n",
    "                        else: #Mutate maximum\n",
    "                            if random.random() > 0.5: #Add\n",
    "                                self.condition[i][1] += mutateRange\n",
    "                            else: #Subtract\n",
    "                                self.condition[i][1] -= mutateRange\n",
    "                                \n",
    "                        #Repair range - such that min specified first, and max second.\n",
    "                        self.condition[i].sort()\n",
    "                        changed = True\n",
    "                #-------------------------------------------------------\n",
    "                # NO MUTATION OCCURS\n",
    "                #-------------------------------------------------------\n",
    "                else:\n",
    "                    pass\n",
    "        #-------------------------------------------------------\n",
    "        # MUTATE PHENOTYPE\n",
    "        #-------------------------------------------------------\n",
    "        if cons.env.formatData.discretePhenotype:\n",
    "            nowChanged = self.discretePhenotypeMutation()\n",
    "        else:\n",
    "            nowChanged = self.continuousPhenotypeMutation(phenotype)\n",
    "        \n",
    "        if changed or nowChanged:\n",
    "            return True\n",
    "\n",
    "\n",
    "    def discretePhenotypeMutation(self):\n",
    "        \"\"\" Mutate this rule's discrete phenotype. \"\"\"\n",
    "        changed = False\n",
    "        if random.random() < cons.upsilon:\n",
    "            phenotypeList = copy.deepcopy(cons.env.formatData.phenotypeList)\n",
    "            phenotypeList.remove(self.phenotype)\n",
    "            newPhenotype = random.sample(phenotypeList,1)\n",
    "            self.phenotype = newPhenotype[0]\n",
    "            changed= True\n",
    "\n",
    "        return changed\n",
    "        \n",
    "        \n",
    "    def continuousPhenotypeMutation(self, phenotype):\n",
    "        \"\"\" Mutate this rule's continuous phenotype. \"\"\"\n",
    "        changed = False\n",
    "        if random.random() < cons.upsilon: #Mutate continuous phenotype\n",
    "            phenRange = self.phenotype[1] - self.phenotype[0]\n",
    "            mutateRange = random.random()*0.5*phenRange\n",
    "            tempKey = random.randint(0,2) #Make random choice between 3 scenarios, mutate minimums, mutate maximums, mutate both\n",
    "            if tempKey == 0: #Mutate minimum \n",
    "                if random.random() > 0.5 or self.phenotype[0] + mutateRange <= phenotype: #Checks that mutated range still contains current phenotype\n",
    "                    self.phenotype[0] += mutateRange\n",
    "                else: #Subtract\n",
    "                    self.phenotype[0] -= mutateRange\n",
    "                changed = True\n",
    "            elif tempKey == 1: #Mutate maximum\n",
    "                if random.random() > 0.5 or self.phenotype[1] - mutateRange >= phenotype: #Checks that mutated range still contains current phenotype\n",
    "                    self.phenotype[1] -= mutateRange\n",
    "                else: #Subtract\n",
    "                    self.phenotype[1] += mutateRange\n",
    "                changed = True\n",
    "            else: #mutate both\n",
    "                if random.random() > 0.5 or self.phenotype[0] + mutateRange <= phenotype: #Checks that mutated range still contains current phenotype\n",
    "                    self.phenotype[0] += mutateRange\n",
    "                else: #Subtract\n",
    "                    self.phenotype[0] -= mutateRange\n",
    "                if random.random() > 0.5 or self.phenotype[1] - mutateRange >= phenotype: #Checks that mutated range still contains current phenotype\n",
    "                    self.phenotype[1] -= mutateRange\n",
    "                else: #Subtract\n",
    "                    self.phenotype[1] += mutateRange\n",
    "                changed = True\n",
    "            \n",
    "            #Repair range - such that min specified first, and max second.\n",
    "            self.phenotype.sort()\n",
    "        #---------------------------------------------------------------------\n",
    "        return changed    \n",
    "        \n",
    "\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # OTHER METHODS\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------  \n",
    "    def buildMatch(self, attRef, state):\n",
    "        \"\"\" Builds a matching condition for the classifierCovering method. \"\"\"\n",
    "        attributeInfo = cons.env.formatData.attributeInfo[attRef]\n",
    "        #-------------------------------------------------------\n",
    "        # CONTINUOUS ATTRIBUTE\n",
    "        #-------------------------------------------------------\n",
    "        if attributeInfo[0]:\n",
    "            attRange = attributeInfo[1][1] - attributeInfo[1][0]\n",
    "            rangeRadius = random.randint(25,75)*0.01*attRange / 2.0 #Continuous initialization domain radius.\n",
    "            Low = state[attRef] - rangeRadius\n",
    "            High = state[attRef] + rangeRadius\n",
    "            condList = [Low,High] #ALKR Representation, Initialization centered around training instance  with a range between 25 and 75% of the domain size.\n",
    "        #-------------------------------------------------------\n",
    "        # DISCRETE ATTRIBUTE\n",
    "        #-------------------------------------------------------\n",
    "        else: \n",
    "            condList = state[attRef] #State already formatted like GABIL in DataManagement\n",
    "            \n",
    "        return condList\n",
    "     \n",
    "\n",
    "    def equals(self, cl):  \n",
    "        \"\"\" Returns if the two classifiers are identical in condition and phenotype. This works for discrete or continuous attributes or phenotypes. \"\"\" \n",
    "        if cl.phenotype == self.phenotype and len(cl.specifiedAttList) == len(self.specifiedAttList): #Is phenotype the same and are the same number of attributes specified - quick equality check first.\n",
    "            clRefs = sorted(cl.specifiedAttList)\n",
    "            selfRefs = sorted(self.specifiedAttList)\n",
    "            if clRefs == selfRefs:\n",
    "                for i in range(len(cl.specifiedAttList)):\n",
    "                    tempIndex = self.specifiedAttList.index(cl.specifiedAttList[i])\n",
    "                    if cl.condition[i] == self.condition[tempIndex]:\n",
    "                        pass\n",
    "                    else:\n",
    "                        return False\n",
    "                return True\n",
    "        return False\n",
    "\n",
    "\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # PARAMETER UPDATES\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------        \n",
    "    def updateAccuracy(self):\n",
    "        \"\"\" Update the accuracy tracker \"\"\"\n",
    "        self.accuracy = self.correctCount / float(self.matchCount)\n",
    "        \n",
    "        \n",
    "    def updateFitness(self):\n",
    "        \"\"\" Update the fitness parameter. \"\"\" \n",
    "        if cons.env.formatData.discretePhenotype or (self.phenotype[1]-self.phenotype[0])/cons.env.formatData.phenotypeRange < 0.5:\n",
    "            self.fitness = pow(self.accuracy, cons.nu)\n",
    "        else:\n",
    "            if (self.phenotype[1]-self.phenotype[0]) >= cons.env.formatData.phenotypeRange:\n",
    "                self.fitness = 0.0\n",
    "            else:\n",
    "                self.fitness = math.fabs(pow(self.accuracy, cons.nu) - (self.phenotype[1]-self.phenotype[0])/cons.env.formatData.phenotypeRange)\n",
    "\n",
    "        \n",
    "    def updateExperience(self):\n",
    "        \"\"\" Increases the experience of the classifier by one. Once an epoch has completed, rule accuracy can't change.\"\"\"\n",
    "        self.matchCount += 1 \n",
    "\n",
    "\n",
    "    def updateCorrect(self):\n",
    "        \"\"\" Increases the correct phenotype tracking by one. Once an epoch has completed, rule accuracy can't change.\"\"\"\n",
    "        self.correctCount += 1 \n",
    "\n",
    "    # new, but think whether it gets called in this version?\n",
    "    def updateNumerosity(self, num):\n",
    "        \"\"\" Updates the numberosity of the classifier.  Notice that 'num' can be negative! \"\"\"\n",
    "        self.numerosity += num\n",
    "        \n",
    "    # new, but think what happens if this doesn't get called in this version?\n",
    "    def updateTimeStamp(self, ts):\n",
    "        \"\"\" Sets the time stamp of the classifier. \"\"\"\n",
    "        self.timeStampGA = ts\n",
    "        \n",
    "        \n",
    "    def setAccuracy(self,acc):\n",
    "        \"\"\" Sets the accuracy of the classifier \"\"\"\n",
    "        self.accuracy = acc\n",
    "        \n",
    "        \n",
    "    def setFitness(self, fit):\n",
    "        \"\"\"  Sets the fitness of the classifier. \"\"\"\n",
    "        self.fitness = fit\n",
    "        \n",
    "    def reportClassifier(self):\n",
    "        \"\"\"  Transforms the rule representation used to a more standard readable format. \"\"\"\n",
    "        numAttributes = cons.env.formatData.numAttributes\n",
    "        thisClassifier = []\n",
    "        counter = 0\n",
    "        for i in range(numAttributes):\n",
    "            if i in self.specifiedAttList:\n",
    "                thisClassifier.append(self.condition[counter])\n",
    "                counter += 1\n",
    "            else:\n",
    "                thisClassifier.append('#')\n",
    "        return thisClassifier\n",
    "    \n",
    "    #-----New, but infrastructure for printing output file rather than on screen only------------------------------------------------------------------------------------------------------------------------------\n",
    "    # PRINT CLASSIFIER FOR POPULATION OUTPUT FILE\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------     \n",
    "    def printClassifier(self):\n",
    "        \"\"\" Formats and returns an output string describing this classifier. \"\"\" \n",
    "        classifierString = \"\"\n",
    "        for attRef in range(cons.env.formatData.numAttributes):\n",
    "            attributeInfo = cons.env.formatData.attributeInfo[attRef]\n",
    "            if attRef in self.specifiedAttList:  #If the attribute was specified in the rule\n",
    "                i = self.specifiedAttList.index(attRef)\n",
    "                #-------------------------------------------------------\n",
    "                # CONTINUOUS ATTRIBUTE \n",
    "                #-------------------------------------------------------\n",
    "                if attributeInfo[0]:\n",
    "                    classifierString += str(self.condition[i][0])+';'+str(self.condition[i][1]) + \"\\t\"\n",
    "                #-------------------------------------------------------\n",
    "                # DISCRETE ATTRIBUTE \n",
    "                #-------------------------------------------------------\n",
    "                else: \n",
    "                    classifierString += str(self.condition[i]) + \"\\t\"\n",
    "            else: # Attribute is wild.\n",
    "                classifierString += '#' + \"\\t\"\n",
    "        #-------------------------------------------------------------------------------\n",
    "        specificity = len(self.condition) / float(cons.env.formatData.numAttributes)\n",
    "        \n",
    "        if cons.env.formatData.discretePhenotype:\n",
    "            classifierString += str(self.phenotype)+\"\\t\"\n",
    "        else:\n",
    "            classifierString += str(self.phenotype[0])+';'+str(self.phenotype[1])+\"\\t\"\n",
    "        #------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "\n",
    "        classifierString += str(self.fitness)+\"\\t\"+str(self.accuracy)+\"\\t\"+str(self.numerosity)+\"\\t\"+str(0)+\"\\t\"+str(self.timeStampGA)+\"\\t\"+str(self.initTimeStamp)+\"\\t\"+str(specificity)+\"\\t\"\n",
    "        classifierString += str(0)+\"\\t\"+str(self.correctCount)+\"\\t\"+str(self.matchCount)+\"\\n\"\n",
    "\n",
    "        #------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "        return classifierString"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classifier Set class, again a must read :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "hideCode": false
   },
   "outputs": [],
   "source": [
    "class ClassifierSet:\n",
    "    def __init__(self, a=None):\n",
    "        \"\"\" Overloaded initialization: Handles creation of a new population or a rebooted population (i.e. a previously saved population). \"\"\"\n",
    "        # Major Parameters\n",
    "        self.popSet = []        # List of classifiers/rules\n",
    "        self.matchSet = []      # List of references to rules in population that match\n",
    "        self.correctSet = []    # List of references to rules in population that both match and specify correct phenotype\n",
    "        self.microPopSize = 0   # Tracks the current micro population size \n",
    "        \n",
    "        # Evaluation Parameters-------------------------------\n",
    "        self.aveGenerality = 0.0\n",
    "        self.expRules = 0.0\n",
    "        self.attributeSpecList = []\n",
    "        self.attributeAccList = []\n",
    "        self.avePhenotypeRange = 0.0\n",
    "\n",
    "        # Set Constructors-------------------------------------\n",
    "        if a==None:\n",
    "            self.makePop() #Initialize a new population\n",
    "        elif isinstance(a,str):\n",
    "            self.rebootPop(a) #Initialize a population based on an existing saved rule population\n",
    "        else:\n",
    "            print(\"ClassifierSet: Error building population.\")\n",
    "            \n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # POPULATION CONSTRUCTOR METHODS\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    def makePop(self):\n",
    "        \"\"\" Initializes the rule population \"\"\"\n",
    "        self.popSet = []\n",
    "            \n",
    "            \n",
    "    def rebootPop(self, remakeFile):\n",
    "        \"\"\" Remakes a previously evolved population from a saved text file. \"\"\"\n",
    "        print(\"Rebooting the following population: \" + str(remakeFile)+\"_RulePop.txt\")\n",
    "        #*******************Initial file handling**********************************************************\n",
    "        try:       \n",
    "            datasetList = []\n",
    "            f = open(remakeFile+\"_RulePop.txt\", 'r')\n",
    "        except Exception as inst:\n",
    "            print(type(inst))\n",
    "            print(inst.args)\n",
    "            print(inst)\n",
    "            print('cannot open', remakeFile+\"_RulePop.txt\")\n",
    "            raise\n",
    "        else:\n",
    "            self.headerList = f.readline().rstrip('\\n').split('\\t')   #strip off first row\n",
    "            for line in f:\n",
    "                lineList = line.strip('\\n').split('\\t')\n",
    "                datasetList.append(lineList)\n",
    "            f.close()    \n",
    "            \n",
    "        #**************************************************************************************************\n",
    "        for each in datasetList:\n",
    "            cl = Classifier(each)\n",
    "            self.popSet.append(cl) \n",
    "            numerosityRef = cons.env.formatData.numAttributes + 3 # New\n",
    "            self.microPopSize += 1\n",
    "        print(\"Rebooted Rule Population has \"+str(len(self.popSet))+\" Macro Pop Size.\")\n",
    "        \n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # CLASSIFIER SET CONSTRUCTOR METHODS\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    def makeMatchSet(self, state_phenotype, exploreIter):\n",
    "        \"\"\" Constructs a match set from the population. Covering is initiated if the match set is empty or a rule with the current correct phenotype is absent. \"\"\" \n",
    "\n",
    "        #Initial values\n",
    "        state = state_phenotype[0]\n",
    "        phenotype = state_phenotype[1]\n",
    "        doCovering = True # Covering check: Twofold (1)checks that a match is present, and (2) that at least one match dictates the correct phenotype.\n",
    "        setNumerositySum = 0 # New\n",
    "        #-------------------------------------------------------\n",
    "        # MATCHING\n",
    "        #-------------------------------------------------------\n",
    "        for i in range(len(self.popSet)):           # Go through the population\n",
    "            cl = self.popSet[i]                     # One classifier at a time\n",
    "            if cl.match(state):                     # Check for match\n",
    "                self.matchSet.append(i)            # If match - add classifier to match set\n",
    "                setNumerositySum += cl.numerosity   # New #Increment the set numerosity sum\n",
    "           \n",
    "                #Covering Check--------------------------------------------------------    \n",
    "                if cons.env.formatData.discretePhenotype:   # Discrete phenotype     \n",
    "                    if cl.phenotype == phenotype:           # Check for phenotype coverage\n",
    "                        doCovering = False\n",
    "                else:                                                                           # Continuous phenotype\n",
    "                    if float(cl.phenotype[0]) <= float(phenotype) <= float(cl.phenotype[1]):    # Check for phenotype coverage\n",
    "                        doCovering = False\n",
    "\n",
    "        #-------------------------------------------------------\n",
    "        # COVERING\n",
    "        #-------------------------------------------------------\n",
    "        while doCovering:\n",
    "            newCl = Classifier(exploreIter, state, phenotype)\n",
    "            self.addClassifierToPopulation(newCl, True) #??? needed the true\n",
    "            self.matchSet.append(len(self.popSet)-1)  # Add covered classifier to matchset\n",
    "            doCovering = False\n",
    "        \n",
    "        \n",
    "    def makeCorrectSet(self, phenotype):\n",
    "        \"\"\" Constructs a correct set out of the given match set. \"\"\"      \n",
    "        for i in range(len(self.matchSet)):\n",
    "            ref = self.matchSet[i]\n",
    "            #-------------------------------------------------------\n",
    "            # DISCRETE PHENOTYPE\n",
    "            #-------------------------------------------------------\n",
    "            if cons.env.formatData.discretePhenotype: \n",
    "                if self.popSet[ref].phenotype == phenotype:\n",
    "                    self.correctSet.append(ref) \n",
    "            #-------------------------------------------------------\n",
    "            # CONTINUOUS PHENOTYPE\n",
    "            #-------------------------------------------------------\n",
    "            else: \n",
    "                if float(phenotype) <= float(self.popSet[ref].phenotype[1]) and float(phenotype) >= float(self.popSet[ref].phenotype[0]):\n",
    "                    self.correctSet.append(ref)\n",
    "\n",
    "    #--- New - select Parents and run the GA----------------------------------------------------------------------------------------\n",
    "    # GENETIC ALGORITHM\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    def runGA(self, exploreIter, state, phenotype): \n",
    "        \"\"\" The genetic discovery mechanism in eLCS is controlled here. \"\"\"\n",
    "        self.setIterStamps(exploreIter) #Updates the iteration time stamp for all rules in the correct set.\n",
    "        changed = False\n",
    "        \n",
    "        #-------------------------------------------------------\n",
    "        # SELECT PARENTS - Panmictic GA - selects parents from the entire rule population\n",
    "        #-------------------------------------------------------\n",
    "        if cons.selectionMethod == \"roulette\": \n",
    "            selectList = self.selectClassifierRW()\n",
    "            clP1 = selectList[0]\n",
    "            clP2 = selectList[1]\n",
    "        elif cons.selectionMethod == \"tournament\":\n",
    "            selectList = self.selectClassifierT()\n",
    "            clP1 = selectList[0]\n",
    "            clP2 = selectList[1]\n",
    "        else:\n",
    "            print(\"ClassifierSet: Error - requested GA selection method not available.\")\n",
    "\n",
    "        #-------------------------------------------------------\n",
    "        # INITIALIZE OFFSPRING \n",
    "        #-------------------------------------------------------\n",
    "        cl1  = Classifier(clP1, exploreIter)\n",
    "        if clP2 == None:\n",
    "            cl2 = Classifier(clP1, exploreIter)\n",
    "        else:\n",
    "            cl2 = Classifier(clP2, exploreIter)\n",
    "            \n",
    "        #-------------------------------------------------------\n",
    "        # CROSSOVER OPERATOR - Uniform Crossover Implemented (i.e. all attributes have equal probability of crossing over between two parents)\n",
    "        #-------------------------------------------------------\n",
    "        if not cl1.equals(cl2) and random.random() < cons.chi:  \n",
    "            changed = cl1.uniformCrossover(cl2) \n",
    "\n",
    "        #-------------------------------------------------------\n",
    "        # INITIALIZE KEY OFFSPRING PARAMETERS\n",
    "        #-------------------------------------------------------\n",
    "        if changed:\n",
    "            cl1.setAccuracy((cl1.accuracy + cl2.accuracy)/2.0)\n",
    "            cl1.setFitness(cons.fitnessReduction * (cl1.fitness + cl2.fitness)/2.0)\n",
    "            cl2.setAccuracy(cl1.accuracy)\n",
    "            cl2.setFitness(cl1.fitness)\n",
    "        else:\n",
    "            cl1.setFitness(cons.fitnessReduction * cl1.fitness)\n",
    "            cl2.setFitness(cons.fitnessReduction * cl2.fitness)\n",
    "            \n",
    "        #-------------------------------------------------------\n",
    "        # MUTATION OPERATOR \n",
    "        #-------------------------------------------------------\n",
    "        nowchanged = cl1.Mutation(state, phenotype)\n",
    "        howaboutnow = cl2.Mutation(state, phenotype)\n",
    "\n",
    "        #-------------------------------------------------------\n",
    "        # ADD OFFSPRING TO POPULATION\n",
    "        #-------------------------------------------------------\n",
    "        if changed or nowchanged or howaboutnow:\n",
    "            self.insertDiscoveredClassifiers(cl1, cl2, clP1, clP2, exploreIter) \n",
    "        \n",
    "        \n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # SELECTION METHODS\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    def selectClassifierRW(self):\n",
    "        \"\"\" Selects parents using roulette wheel selection according to the fitness of the classifiers. \"\"\"\n",
    "        selectList = [None, None]\n",
    "        setList = [] \n",
    "        for i in range(len(self.popSet)): #The set of potential parents includes all rules in the population\n",
    "            setList.append(i)\n",
    "\n",
    "        if len(setList) < 2:\n",
    "            currentCount = 1 #Pick only one parent\n",
    "        else:\n",
    "            currentCount = 0 #Pick two parents\n",
    "        #-----------------------------------------------\n",
    "        while currentCount < 2:\n",
    "            fitSum = self.getFitnessSum(setList)\n",
    "            \n",
    "            choiceP = random.random() * fitSum\n",
    "            i=0\n",
    "            ref = setList[i]\n",
    "            sumCl = self.popSet[ref].fitness\n",
    "            while choiceP > sumCl:\n",
    "                i=i+1\n",
    "                ref = setList[i]       #WnB must be added to increment fitness???\n",
    "                sumCl += self.popSet[ref].fitness\n",
    "                \n",
    "            selectList[currentCount] = self.popSet[ref]\n",
    "            setList.remove(ref)\n",
    "            currentCount += 1\n",
    "        #-----------------------------------------------\n",
    "        if selectList[0] == None:\n",
    "            selectList[0] = selectList[1]\n",
    "\n",
    "        return selectList\n",
    "\n",
    "\n",
    "    def selectClassifierT(self):\n",
    "        \"\"\"  Selects parents using tournament selection according to the fitness of the classifiers. \"\"\"\n",
    "        selectList = [None, None]\n",
    "        currentCount = 0 \n",
    "        setList = [] \n",
    "        for i in range(len(self.popSet)): #The set of potential parents includes all rules in the population\n",
    "            setList.append(i)\n",
    "\n",
    "        while currentCount < 2:\n",
    "            tSize = int(len(setList)*cons.theta_sel)\n",
    "            posList = random.sample(setList,tSize) \n",
    "\n",
    "            bestF = 0\n",
    "            bestC = self.correctSet[0]\n",
    "            for j in posList:\n",
    "                if self.popSet[j].fitness > bestF:\n",
    "                    bestF = self.popSet[j].fitness\n",
    "                    bestC = j\n",
    "\n",
    "            selectList[currentCount] = self.popSet[bestC]\n",
    "            currentCount += 1\n",
    "\n",
    "        return selectList \n",
    "    \n",
    "   \n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # OTHER KEY METHODS\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # New code to update method to check for duplicates\n",
    "    def addClassifierToPopulation(self, cl, covering):\n",
    "        \"\"\" Adds a classifier to the set and increases the microPopSize value accordingly.\"\"\"\n",
    "        oldCl = None\n",
    "        if not covering:\n",
    "            oldCl = self.getIdenticalClassifier(cl)\n",
    "        if oldCl != None: #found identical classifier\n",
    "            oldCl.updateNumerosity(1)\n",
    "            self.microPopSize += 1\n",
    "        else:\n",
    "            self.popSet.append(cl)\n",
    "            self.microPopSize += 1\n",
    "            \n",
    "    # New - insert newly evolved (non-duplicate) classifiers into population\n",
    "    def insertDiscoveredClassifiers(self, cl1, cl2, clP1, clP2, exploreIter):\n",
    "        \"\"\" Inserts both discovered classifiers  Also checks for default rule (i.e. rule with completely general condition) and \n",
    "        prevents such rules from being added to the population, as it offers no predictive value within eLCS. \"\"\"\n",
    "        if len(cl1.specifiedAttList) > 0:\n",
    "            self.addClassifierToPopulation(cl1, False) #False passed because this is not called for a covered rule.\n",
    "        if len(cl2.specifiedAttList) > 0:\n",
    "            self.addClassifierToPopulation(cl2, False) #False passed because this is not called for a covered rule.\n",
    "                \n",
    "             \n",
    "\n",
    "    def updateSets(self, exploreIter):\n",
    "        \"\"\" Updates all relevant parameters in the current match and correct sets. \"\"\"\n",
    "        for ref in self.matchSet:\n",
    "            self.popSet[ref].updateExperience()    \n",
    "            if ref in self.correctSet:\n",
    "                self.popSet[ref].updateCorrect()\n",
    "\n",
    "            self.popSet[ref].updateAccuracy()\n",
    "            self.popSet[ref].updateFitness()\n",
    "\n",
    "\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # OTHER METHODS\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    def setIterStamps(self, exploreIter):\n",
    "        \"\"\" Sets the time stamp of all classifiers in the set to the current time. The current time\n",
    "        is the number of exploration steps executed so far.  \"\"\"\n",
    "        for i in range(len(self.correctSet)):\n",
    "            ref = self.correctSet[i]\n",
    "            self.popSet[ref].updateTimeStamp(exploreIter)\n",
    " \n",
    "    # New to monitor progress of evolution\n",
    "    def getFitnessSum(self, setList):\n",
    "        \"\"\" Returns the sum of the fitnesses of all classifiers in the set. \"\"\"\n",
    "        sumCl=0.0\n",
    "        for i in range(len(setList)):\n",
    "            ref = setList[i]\n",
    "            sumCl += self.popSet[ref].fitness\n",
    "        return sumCl\n",
    "\n",
    "    # New to check for duplicates prior to inserting a classifier or increasing numerously of existing classifier\n",
    "    def getIdenticalClassifier(self, newCl):\n",
    "        \"\"\" Looks for an identical classifier in the population. \"\"\"\n",
    "        for cl in self.popSet:\n",
    "            if newCl.equals(cl):\n",
    "                return cl\n",
    "        return None\n",
    "            \n",
    "                \n",
    "     \n",
    "    def clearSets(self):\n",
    "        \"\"\" Clears out references in the match and correct sets for the next learning iteration. \"\"\"\n",
    "        self.matchSet = []\n",
    "        self.correctSet = []\n",
    "        \n",
    "            \n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # EVALUTATION METHODS\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    def runPopAveEval(self, exploreIter):\n",
    "        \"\"\" Calculates some summary evaluations across the rule population including average generality. \"\"\"\n",
    "        genSum = 0\n",
    "        agedCount = 0\n",
    "        for cl in self.popSet: # New in genSum below!Must take into account numerosity now\n",
    "            genSum += ((cons.env.formatData.numAttributes - len(cl.condition)) / float(cons.env.formatData.numAttributes)) * cl.numerosity\n",
    "        if self.microPopSize == 0:\n",
    "            self.aveGenerality = 'NA'\n",
    "        else:\n",
    "            self.aveGenerality = genSum / float(self.microPopSize) \n",
    "\n",
    "        #-------------------------------------------------------\n",
    "        # CONTINUOUS PHENOTYPE\n",
    "        #-------------------------------------------------------\n",
    "        if not cons.env.formatData.discretePhenotype:\n",
    "            sumRuleRange = 0\n",
    "            for cl in self.popSet: # New in sumRuleRange below!Must take into account numeros\n",
    "                sumRuleRange += (cl.phenotype[1] - cl.phenotype[0])*cl.numerosity\n",
    "            phenotypeRange = cons.env.formatData.phenotypeList[1] - cons.env.formatData.phenotypeList[0]\n",
    "            self.avePhenotypeRange = (sumRuleRange / float(self.microPopSize)) / float(phenotypeRange)\n",
    "  \n",
    "    # New determine the specificity of attributes \n",
    "    def runAttGeneralitySum(self, isEvaluationSummary):\n",
    "        \"\"\" Determine the population-wide frequency of attribute specification, and accuracy weighted specification.  Used in complete rule population evaluations. \"\"\"\n",
    "        if isEvaluationSummary:\n",
    "            self.attributeSpecList = []\n",
    "            self.attributeAccList = []\n",
    "            for i in range(cons.env.formatData.numAttributes):\n",
    "                self.attributeSpecList.append(0)\n",
    "                self.attributeAccList.append(0.0)\n",
    "            for cl in self.popSet:\n",
    "                for ref in cl.specifiedAttList: #for each attRef\n",
    "                    self.attributeSpecList[ref] += cl.numerosity\n",
    "                    self.attributeAccList[ref] += cl.numerosity * cl.accuracy\n",
    "              \n",
    "    def getPopTrack(self, accuracy, exploreIter, trackingFrequency):\n",
    "        \"\"\" Returns a formated output string to be printed to the Learn Track output file. \"\"\"\n",
    "        trackString = str(exploreIter)+ \"\\t\" + str(len(self.popSet)) + \"\\t\" + str(self.microPopSize) + \"\\t\" + str(accuracy) + \"\\t\" + str(\"%.2f\" %self.aveGenerality)  +  \"\\n\"\n",
    "        if cons.env.formatData.discretePhenotype: #discrete phenotype\n",
    "            print((\"Epoch: \"+str(int(exploreIter/trackingFrequency))+\"\\t Iteration: \" + str(exploreIter) + \"\\t MacroPop: \" + str(len(self.popSet))+ \"\\t MicroPop: \" + str(self.microPopSize) + \"\\t AccEstimate: \" + str(\"%.2f\" %accuracy) + \"\\t AveGen: \" + str(\"%.2f\" %self.aveGenerality)))\n",
    "        else: # continuous phenotype\n",
    "            print((\"Epoch: \"+str(int(exploreIter/trackingFrequency))+\"\\t Iteration: \" + str(exploreIter) + \"\\t MacroPop: \" + str(len(self.popSet))+ \"\\t MicroPop: \" + str(self.microPopSize) + \"\\t AccEstimate: \" + str(\"%.2f\" %accuracy) + \"\\t AveGen: \" + str(\"%.2f\" %self.aveGenerality) + \"\\t PhenRange: \" +str(\"%.2f\" %self.avePhenotypeRange)))\n",
    "       \n",
    "        return trackString\n",
    "         "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**New** Prediction array code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true,
    "hideCode": false
   },
   "outputs": [],
   "source": [
    "class Prediction:\n",
    "    def __init__(self, population):\n",
    "        \"\"\" Constructs the voting array and determines the prediction decision. \"\"\"\n",
    "        self.decision = None\n",
    "        #-------------------------------------------------------\n",
    "        # DISCRETE PHENOTYPES (CLASSES)\n",
    "        #-------------------------------------------------------\n",
    "        if cons.env.formatData.discretePhenotype: \n",
    "            self.vote = {}\n",
    "            self.tieBreak_Numerosity = {}\n",
    "            self.tieBreak_TimeStamp = {}\n",
    "            \n",
    "            for eachClass in cons.env.formatData.phenotypeList:\n",
    "                self.vote[eachClass] = 0.0\n",
    "                self.tieBreak_Numerosity[eachClass] = 0.0\n",
    "                self.tieBreak_TimeStamp[eachClass] = 0.0\n",
    "                \n",
    "            for ref in population.matchSet:\n",
    "                cl = population.popSet[ref]\n",
    "                self.vote[cl.phenotype] += cl.fitness * cl.numerosity\n",
    "                self.tieBreak_Numerosity[cl.phenotype] += cl.numerosity\n",
    "                self.tieBreak_TimeStamp[cl.phenotype] += cl.initTimeStamp\n",
    "                \n",
    "            highVal = 0.0\n",
    "            bestClass = [] #Prediction is set up to handle best class ties for problems with more than 2 classes\n",
    "            for thisClass in cons.env.formatData.phenotypeList:\n",
    "                if self.vote[thisClass] >= highVal:\n",
    "                    highVal = self.vote[thisClass]\n",
    "                    \n",
    "            for thisClass in cons.env.formatData.phenotypeList:\n",
    "                if self.vote[thisClass] == highVal: #Tie for best class\n",
    "                    bestClass.append(thisClass)\n",
    "            #---------------------------\n",
    "            if highVal == 0.0:\n",
    "                self.decision = None\n",
    "            #-----------------------------------------------------------------------\n",
    "            elif len(bestClass) > 1: #Randomly choose between the best tied classes\n",
    "                bestNum = 0\n",
    "                newBestClass = []\n",
    "                for thisClass in bestClass:\n",
    "                    if self.tieBreak_Numerosity[thisClass] >= bestNum:\n",
    "                        bestNum = self.tieBreak_Numerosity[thisClass]\n",
    "                        \n",
    "                for thisClass in bestClass:\n",
    "                    if self.tieBreak_Numerosity[thisClass] == bestNum:\n",
    "                        newBestClass.append(thisClass)\n",
    "                #-----------------------------------------------------------------------\n",
    "                if len(newBestClass) > 1:  #still a tie\n",
    "                    bestStamp = 0\n",
    "                    newestBestClass = []\n",
    "                    for thisClass in newBestClass:\n",
    "                        if self.tieBreak_TimeStamp[thisClass] >= bestStamp:\n",
    "                            bestStamp = self.tieBreak_TimeStamp[thisClass]\n",
    "                            \n",
    "                    for thisClass in newBestClass:\n",
    "                        if self.tieBreak_TimeStamp[thisClass] == bestStamp:\n",
    "                            newestBestClass.append(thisClass)\n",
    "                    #-----------------------------------------------------------------------\n",
    "                    if len(newestBestClass) > 1: # Prediction is completely tied - eLCS has no useful information for making a prediction\n",
    "                        self.decision = 'Tie'\n",
    "                else:\n",
    "                    self.decision = newBestClass[0]\n",
    "            #----------------------------------------------------------------------\n",
    "            else: #One best class determined by fitness vote\n",
    "                self.decision = bestClass[0]\n",
    "        \n",
    "        #-------------------------------------------------------\n",
    "        # CONTINUOUS PHENOTYPES\n",
    "        #-------------------------------------------------------\n",
    "        else: \n",
    "            if len(population.matchSet) < 1:\n",
    "                print(\"empty matchSet\")\n",
    "                self.decision = None\n",
    "            else:\n",
    "                #IDEA - outputs a single continuous prediction value(closeness to this prediction accuracy will dictate accuracy). In determining this value we examine all ranges\n",
    "                phenotypeRange = cons.env.formatData.phenotypeList[1] - cons.env.formatData.phenotypeList[0] #Difference between max and min phenotype values observed in data.\n",
    "                predictionValue = 0\n",
    "                valueWeightSum = 0\n",
    "                for ref in population.matchSet:\n",
    "                    cl = population.popSet[ref]\n",
    "                    localRange = cl.phenotype[1] - cl.phenotype[0]\n",
    "                    valueWeight = (phenotypeRange/float(localRange))\n",
    "                    localAverage = (cl.phenotype[1]+cl.phenotype[0])/ 2.0\n",
    "                    \n",
    "                    valueWeightSum += valueWeight\n",
    "                    predictionValue += valueWeight * localAverage\n",
    "                if valueWeightSum == 0.0:\n",
    "                    self.decision = None\n",
    "                else:\n",
    "                    self.decision = predictionValue / float(valueWeightSum)\n",
    "\n",
    "                        \n",
    "    def getFitnessSum(self,population,low,high):\n",
    "        \"\"\" Get the fitness sum of rules in the rule-set. For continuous phenotype prediction. \"\"\"\n",
    "        fitSum = 0\n",
    "        for ref in population.matchSet:\n",
    "            cl = population.popSet[ref]\n",
    "            if cl.phenotype[0] <= low and cl.phenotype[1] >= high: #if classifier range subsumes segment range.\n",
    "                fitSum += cl.fitness\n",
    "        return fitSum\n",
    "    \n",
    "                    \n",
    "    def getDecision(self):\n",
    "        \"\"\" Returns prediction decision. \"\"\"\n",
    "        return self.decision"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Output file generation and management. New, but infrastructure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true,
    "hideCode": true
   },
   "outputs": [],
   "source": [
    "class OutputFileManager:     \n",
    "    def writePopStats(self, outFile, exploreIter, pop, correct):\n",
    "        \"\"\" Makes output text file which includes all of the evaluation statistics for a complete analysis of all training and testing data on the current eLCS rule population. \"\"\"\n",
    "        try:  \n",
    "            popStatsOut = open(outFile + '_'+ str(exploreIter)+'_PopStats.txt','w') \n",
    "        except Exception as inst:\n",
    "            print(type(inst))\n",
    "            print(inst.args)\n",
    "            print(inst)\n",
    "            print('cannot open', outFile + '_'+ str(exploreIter)+'_PopStats.txt')\n",
    "            raise \n",
    "        else:\n",
    "            print(\"Writing Population Statistical Summary File...\")\n",
    "            \n",
    "        #Evaluation of pop      \n",
    "        popStatsOut.write(\"Population Characterization:------------------------------------------------------------------------\\n\")  \n",
    "        popStatsOut.write(\"MacroPopSize\\tMicroPopSize\\tGenerality\\n\") \n",
    "        popStatsOut.write(str(len(pop.popSet))+\"\\t\"+ str(pop.microPopSize)+\"\\t\"+str(pop.aveGenerality)+\"\\n\\n\")\n",
    "\n",
    "        popStatsOut.write(\"SpecificitySum:------------------------------------------------------------------------\\n\")       \n",
    "        headList = cons.env.formatData.trainHeaderList #preserve order of original dataset\n",
    "\n",
    "        for i in range(len(headList)): \n",
    "            if i < len(headList)-1:\n",
    "                popStatsOut.write(str(headList[i])+\"\\t\")\n",
    "            else:\n",
    "                popStatsOut.write(str(headList[i])+\"\\n\")\n",
    "                \n",
    "        # Prints out the Specification Sum for each attribute \n",
    "        for i in range(len(pop.attributeSpecList)):\n",
    "            if i < len(pop.attributeSpecList)-1:\n",
    "                popStatsOut.write(str(pop.attributeSpecList[i])+\"\\t\")\n",
    "            else:\n",
    "                popStatsOut.write(str(pop.attributeSpecList[i])+\"\\n\")  \n",
    "                      \n",
    "        popStatsOut.write(\"\\nAccuracySum:------------------------------------------------------------------------\\n\")\n",
    "        for i in range(len(headList)): \n",
    "            if i < len(headList)-1:\n",
    "                popStatsOut.write(str(headList[i])+\"\\t\")\n",
    "            else:\n",
    "                popStatsOut.write(str(headList[i])+\"\\n\")\n",
    "                \n",
    "        # Prints out the Accuracy Weighted Specification Count for each attribute \n",
    "        for i in range(len(pop.attributeAccList)):\n",
    "            if i < len(pop.attributeAccList)-1:\n",
    "                popStatsOut.write(str(pop.attributeAccList[i])+\"\\t\")\n",
    "            else:\n",
    "                popStatsOut.write(str(pop.attributeAccList[i])+\"\\n\")    \n",
    "                  \n",
    "        #Correct Track ---------------------------------------------------------------------------------------------------------     \n",
    "        popStatsOut.write(\"\\nCorrectTrackerSave:------------------------------------------------------------------------\\n\")\n",
    "        for i in range(len(correct)):\n",
    "            popStatsOut.write(str(correct[i])+\"\\t\")\n",
    "                \n",
    "        popStatsOut.close() \n",
    "        \n",
    "            \n",
    "    def writePop(self, outFile, exploreIter, pop):\n",
    "        \"\"\" Writes a tab delimited text file outputting the entire evolved rule population, including conditions, phenotypes, and all rule parameters. \"\"\"\n",
    "        try:  \n",
    "            rulePopOut = open(outFile + '_'+ str(exploreIter)+'_RulePop.txt','w') \n",
    "        except Exception as inst:\n",
    "            print(type(inst))\n",
    "            print(inst.args)\n",
    "            print(inst)\n",
    "            print('cannot open', outFile + '_'+ str(exploreIter)+'_RulePop.txt')\n",
    "            raise \n",
    "        else:\n",
    "            print(\"Writing Population as Data File...\")\n",
    "\n",
    "        #Write Header-----------------------------------------------------------------------------------------------------------------------------------------------\n",
    "        dataLink = cons.env.formatData\n",
    "        headList = dataLink.trainHeaderList\n",
    "        for i in range(len(headList)):   \n",
    "            rulePopOut.write(str(headList[i])+\"\\t\")\n",
    "        rulePopOut.write(\"Phenotype\\tFitness\\tAccuracy\\tNumerosity\\tAveMatchSetSize\\tTimeStampGA\\tInitTimeStamp\\tSpecificity\\tDeletionProb\\tCorrectCount\\tMatchCount\\n\")\n",
    "\n",
    "        #Write each classifier--------------------------------------------------------------------------------------------------------------------------------------\n",
    "        for cl in pop.popSet:\n",
    "            rulePopOut.write(str(cl.printClassifier())) \n",
    "\n",
    "        rulePopOut.close() \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LCS class to run the code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "hideCode": false
   },
   "outputs": [],
   "source": [
    "class eLCS:\n",
    "    def __init__(self):\n",
    "        \"\"\" Initializes the eLCS algorithm \"\"\"\n",
    "        print(\"eLCS: Initializing Algorithm...\")\n",
    "        #Global Parameters-------------------------------------------------------------------------------------\n",
    "        self.population = None          # The rule population (the 'solution/model' evolved by eLCS)\n",
    "        self.learnTrackOut = None       # Output file that will store tracking information during learning\n",
    "        \n",
    "        #-------------------------------------------------------\n",
    "        # POPULATION REBOOT - Begin eLCS learning from an existing saved rule population\n",
    "        #-------------------------------------------------------\n",
    "        if cons.doPopulationReboot:    \n",
    "            self.populationReboot()\n",
    "            \n",
    "        #-------------------------------------------------------\n",
    "        # NORMAL eLCS - Run eLCS from scratch on given data\n",
    "        #-------------------------------------------------------\n",
    "        else:\n",
    "            try:\n",
    "                self.learnTrackOut = open(cons.outFileName+'_LearnTrack.txt','w')     \n",
    "            except Exception as inst:\n",
    "                print(type(inst))\n",
    "                print(inst.args)\n",
    "                print(inst)\n",
    "                print('cannot open', cons.outFileName+'_LearnTrack.txt')\n",
    "                raise\n",
    "            else:# \"tr(exploreIter)+ \"\\t\" + str(len(self.popSet)) + \"\\t\" + str(self.microPopSize) + \"\\t\" + str(accuracy) + \"\\t\" + str(\"%.2f\" %self.aveGenerality)\n",
    "                self.learnTrackOut.write(\"Explore_Iteration\\tPopSize\\tMicroPopSize\\tAccuracy\\tAveGenerality\\n\")#Explore_Iteration\\tPopSize\\tAccuracy_Estimate\\tAveGenerality\\tExpRules\\tTime(min)\\n\")\n",
    "            # Instantiate Population---------\n",
    "            self.population = ClassifierSet()\n",
    "            self.exploreIter = 0\n",
    "            self.correct  = [0.0 for i in range(cons.trackingFrequency)]\n",
    "            \n",
    "        #Run the eLCS algorithm-------------------------------------------------------------------------------\n",
    "        self.run_eLCS()\n",
    "\n",
    "\n",
    "    def run_eLCS(self):\n",
    "        \"\"\" Runs the initialized eLCS algorithm. \"\"\"\n",
    "        #--------------------------------------------------------------\n",
    "        print(\"Learning Checkpoints: \" +str(cons.learningCheckpoints))\n",
    "        print(\"Maximum Iterations: \" +str(cons.maxLearningIterations))\n",
    "        print(\"Beginning eLCS learning iterations.\")\n",
    "        print(\"------------------------------------------------------------------------------------------------------------------------------------------------------\")\n",
    "        #-------------------------------------------------------\n",
    "        # MAJOR LEARNING LOOP\n",
    "        #-------------------------------------------------------\n",
    "        while self.exploreIter < cons.maxLearningIterations: \n",
    "            \n",
    "            #-------------------------------------------------------\n",
    "            # GET NEW INSTANCE AND RUN A LEARNING ITERATION\n",
    "            #-------------------------------------------------------\n",
    "            state_phenotype = cons.env.getTrainInstance() \n",
    "            self.runIteration(state_phenotype, self.exploreIter)\n",
    "            \n",
    "            #---New, but infrastructure------------------------------------\n",
    "            # TRACK PROGRESS\n",
    "            #-------------------------------------------------------\n",
    "            if (self.exploreIter%cons.trackingFrequency) == (cons.trackingFrequency - 1) and self.exploreIter > 0:\n",
    "                self.population.runPopAveEval(self.exploreIter) \n",
    "                trackedAccuracy = sum(self.correct)/float(cons.trackingFrequency) #Accuracy over the last \"trackingFrequency\" number of iterations.\n",
    "                # getPopTrack(self, exploreIter, trackingFrequency):\n",
    "                self.learnTrackOut.write(self.population.getPopTrack(trackedAccuracy, self.exploreIter+1,cons.trackingFrequency)) #??? mismatch in arguments\n",
    "                #self.learnTrackOut.write(self.population.getPopTrack(self.exploreIter+1,cons.trackingFrequency)) #Report learning progress to standard out and tracking file.\n",
    "            \n",
    "            #------New, but infrastructure---------------------------------\n",
    "            # CHECKPOINT - OUTPUT CURRENT POPULATION\n",
    "            #-------------------------------------------------------\n",
    "            if (self.exploreIter + 1) in cons.learningCheckpoints:\n",
    "                print(\"------------------------------------------------------------------------------------------------------------------------------------------------------\")\n",
    "                print(\"Output rule population after \" + str(self.exploreIter + 1)+ \" iterations.\")\n",
    "                \n",
    "                self.population.runPopAveEval(self.exploreIter)\n",
    "                self.population.runAttGeneralitySum(True)\n",
    "\n",
    "                #Write output files----------------------------------------------------------------------------------------------------------\n",
    "                OutputFileManager().writePopStats(cons.outFileName, self.exploreIter + 1, self.population, self.correct)\n",
    "                OutputFileManager().writePop(cons.outFileName, self.exploreIter + 1, self.population)\n",
    "                #----------------------------------------------------------------------------------------------------------------------------\n",
    "\n",
    "                print(\"Continue Learning...\")\n",
    "                print(\"------------------------------------------------------------------------------------------------------------------------------------------------------\")\n",
    "           \n",
    "            #-------------------------------------------------------\n",
    "            # ADJUST MAJOR VALUES FOR NEXT ITERATION\n",
    "            #-------------------------------------------------------\n",
    "            self.exploreIter += 1       # Increment current learning iteration\n",
    "            cons.env.newInstance(True)  # Step to next instance in training set\n",
    "            \n",
    "        self.learnTrackOut.close()\n",
    "        print(\"eLCS Run Complete\")\n",
    "        \n",
    "        \n",
    "    def runIteration(self, state_phenotype, exploreIter):\n",
    "        \"\"\" Run a single eLCS learning iteration. \"\"\"\n",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\n",
    "        # FORM A MATCH SET - includes covering\n",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\n",
    "        self.population.makeMatchSet(state_phenotype, exploreIter)\n",
    "        #---New and Important--------------------------------------------------------------------------------------------------------------------------------\n",
    "        # MAKE A PREDICTION - utilized here for tracking estimated learning progress.  Typically used in the explore phase of many LCS algorithms.\n",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\n",
    "        prediction = Prediction(self.population)\n",
    "        phenotypePrediction = prediction.getDecision()  \n",
    "        #----New and Important--------------------------------------\n",
    "        # PREDICTION NOT POSSIBLE\n",
    "        #-------------------------------------------------------\n",
    "        if phenotypePrediction == None or phenotypePrediction == 'Tie': \n",
    "            if cons.env.formatData.discretePhenotype:\n",
    "                phenotypePrediction = random.choice(cons.env.formatData.phenotypeList)\n",
    "            else:\n",
    "                phenotypePrediction = random.randrange(cons.env.formatData.phenotypeList[0],cons.env.formatData.phenotypeList[1],(cons.env.formatData.phenotypeList[1]-cons.env.formatData.phenotypeList[0])/float(1000))\n",
    "        else: #Prediction Successful\n",
    "            #----New and Important--------------------------------------\n",
    "            # DISCRETE PHENOTYPE PREDICTION\n",
    "            #-------------------------------------------------------\n",
    "            if cons.env.formatData.discretePhenotype:\n",
    "                if phenotypePrediction == state_phenotype[1]:\n",
    "                    self.correct[exploreIter%cons.trackingFrequency] = 1\n",
    "                else:\n",
    "                    self.correct[exploreIter%cons.trackingFrequency] = 0\n",
    "            #----New and Important---------------------------------\n",
    "            # CONTINUOUS PHENOTYPE PREDICTION\n",
    "            #-------------------------------------------------------\n",
    "            else:\n",
    "                predictionError = math.fabs(phenotypePrediction - float(state_phenotype[1]))\n",
    "                phenotypeRange = cons.env.formatData.phenotypeList[1] - cons.env.formatData.phenotypeList[0]\n",
    "                accuracyEstimate = 1.0 - (predictionError / float(phenotypeRange))\n",
    "                self.correct[exploreIter%cons.trackingFrequency] = accuracyEstimate\n",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\n",
    "        # FORM A CORRECT SET\n",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\n",
    "        self.population.makeCorrectSet(state_phenotype[1])\n",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\n",
    "        # UPDATE PARAMETERS\n",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\n",
    "        self.population.updateSets(exploreIter)\n",
    "        #---New as GA run from here---------------------------------------------------------------------------------------------------------------------------\n",
    "        # RUN THE GENETIC ALGORITHM - Discover new offspring rules from a selected pair of parents\n",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\n",
    "        self.population.runGA(exploreIter, state_phenotype[0], state_phenotype[1])\n",
    "        self.population.clearSets() #Clears the match and correct sets for the next learning iteration\n",
    "        \n",
    "    \n",
    "    def populationReboot(self):\n",
    "        \"\"\" Manages the reformation of a previously saved eLCS classifier population. \"\"\"\n",
    "        #--------------------------------------------------------------------\n",
    "        try: #Re-open track learning file for continued tracking of progress.\n",
    "            self.learnTrackOut = open(cons.outFileName+'_LearnTrack.txt','a')     \n",
    "        except Exception as inst:\n",
    "            print(type(inst))\n",
    "            print(inst.args)\n",
    "            print(inst)\n",
    "            print('cannot open', cons.outFileName+'_LearnTrack.txt')\n",
    "            raise\n",
    "\n",
    "        #Extract last iteration from file name---------------------------------------------\n",
    "        temp = cons.popRebootPath.split('_')\n",
    "        iterRef = len(temp)-1\n",
    "        completedIterations = int(temp[iterRef])\n",
    "        print(\"Rebooting rule population after \" +str(completedIterations)+ \" iterations.\")\n",
    "        self.exploreIter = completedIterations-1\n",
    "        for i in range(len(cons.learningCheckpoints)): #??? checkpoints not in demo 2\n",
    "            cons.learningCheckpoints[i] += completedIterations\n",
    "        cons.maxLearningIterations += completedIterations\n",
    "\n",
    "        #Rebuild existing population from text file.--------\n",
    "        self.population = ClassifierSet(cons.popRebootPath)\n",
    "\n",
    "        #----New infrastructure-------------------------------------\n",
    "        try: #Obtain correct track\n",
    "            f = open(cons.popRebootPath+\"_PopStats.txt\", 'r')\n",
    "        except Exception as inst:\n",
    "            print(type(inst))\n",
    "            print(inst.args)\n",
    "            print(inst)\n",
    "            print('cannot open', cons.popRebootPath+\"_PopStats.txt\")\n",
    "            raise \n",
    "        else:\n",
    "            correctRef = 14 #File reference position\n",
    "            tempLine = None\n",
    "            for i in range(correctRef):\n",
    "                tempLine = f.readline()\n",
    "            tempList = tempLine.strip().split('\\t')\n",
    "            self.correct = tempList\n",
    "            if cons.env.formatData.discretePhenotype:\n",
    "                for i in range(len(self.correct)):\n",
    "                    self.correct[i] = int(self.correct[i])\n",
    "            else:\n",
    "                for i in range(len(self.correct)):\n",
    "                    self.correct[i] = float(self.correct[i])\n",
    "            f.close()\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Actually RUN the eLCS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "hideCode": true,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------------------------------------------\n",
      "Environment: Formatting Data... \n",
      "DataManagement: Loading Data... 6Multiplexer_Data_Complete.txt\n",
      "DataManagement: Phenotype Column Location = 6\n",
      "DataManagement: Number of Attributes = 6\n",
      "DataManagement: Number of Instances = 64\n",
      "DataManagement: Analyzing Phenotype...\n",
      "DataManagement: Phenotype Detected as Discrete.\n",
      "DataManagement: Detecting Classes...\n",
      "DataManagement: Following Classes Detected:['0', '1']\n",
      "Class: 0 count = 32\n",
      "Class: 1 count = 32\n",
      "DataManagement: Detecting Attributes...\n",
      "DataManagement: Identified 6 discrete and 0 continuous attributes.\n",
      "DataManagement: Characterizing Attributes...\n",
      "----------------------------------------------------------------------------\n",
      "eLCS: Initializing Algorithm...\n",
      "Learning Checkpoints: [1000, 4000]\n",
      "Maximum Iterations: 4000\n",
      "Beginning eLCS learning iterations.\n",
      "------------------------------------------------------------------------------------------------------------------------------------------------------\n",
      "Epoch: 1\t Iteration: 100\t MacroPop: 106\t MicroPop: 139\t AccEstimate: 0.60\t AveGen: 0.43\n",
      "Epoch: 2\t Iteration: 200\t MacroPop: 184\t MicroPop: 273\t AccEstimate: 0.69\t AveGen: 0.40\n",
      "Epoch: 3\t Iteration: 300\t MacroPop: 247\t MicroPop: 415\t AccEstimate: 0.71\t AveGen: 0.38\n",
      "Epoch: 4\t Iteration: 400\t MacroPop: 304\t MicroPop: 551\t AccEstimate: 0.76\t AveGen: 0.37\n",
      "Epoch: 5\t Iteration: 500\t MacroPop: 353\t MicroPop: 681\t AccEstimate: 0.80\t AveGen: 0.36\n",
      "Epoch: 6\t Iteration: 600\t MacroPop: 393\t MicroPop: 825\t AccEstimate: 0.81\t AveGen: 0.35\n",
      "Epoch: 7\t Iteration: 700\t MacroPop: 446\t MicroPop: 965\t AccEstimate: 0.83\t AveGen: 0.34\n",
      "Epoch: 8\t Iteration: 800\t MacroPop: 485\t MicroPop: 1099\t AccEstimate: 0.83\t AveGen: 0.34\n",
      "Epoch: 9\t Iteration: 900\t MacroPop: 520\t MicroPop: 1221\t AccEstimate: 0.89\t AveGen: 0.33\n",
      "Epoch: 10\t Iteration: 1000\t MacroPop: 562\t MicroPop: 1353\t AccEstimate: 0.86\t AveGen: 0.33\n",
      "------------------------------------------------------------------------------------------------------------------------------------------------------\n",
      "Output rule population after 1000 iterations.\n",
      "Writing Population Statistical Summary File...\n",
      "Writing Population as Data File...\n",
      "Continue Learning...\n",
      "------------------------------------------------------------------------------------------------------------------------------------------------------\n",
      "Epoch: 11\t Iteration: 1100\t MacroPop: 595\t MicroPop: 1475\t AccEstimate: 0.91\t AveGen: 0.32\n",
      "Epoch: 12\t Iteration: 1200\t MacroPop: 634\t MicroPop: 1603\t AccEstimate: 0.91\t AveGen: 0.32\n",
      "Epoch: 13\t Iteration: 1300\t MacroPop: 669\t MicroPop: 1751\t AccEstimate: 0.93\t AveGen: 0.32\n",
      "Epoch: 14\t Iteration: 1400\t MacroPop: 698\t MicroPop: 1877\t AccEstimate: 0.94\t AveGen: 0.32\n",
      "Epoch: 15\t Iteration: 1500\t MacroPop: 728\t MicroPop: 1997\t AccEstimate: 0.93\t AveGen: 0.32\n",
      "Epoch: 16\t Iteration: 1600\t MacroPop: 766\t MicroPop: 2131\t AccEstimate: 0.95\t AveGen: 0.31\n",
      "Epoch: 17\t Iteration: 1700\t MacroPop: 794\t MicroPop: 2251\t AccEstimate: 0.94\t AveGen: 0.31\n",
      "Epoch: 18\t Iteration: 1800\t MacroPop: 836\t MicroPop: 2391\t AccEstimate: 0.97\t AveGen: 0.31\n",
      "Epoch: 19\t Iteration: 1900\t MacroPop: 855\t MicroPop: 2505\t AccEstimate: 0.94\t AveGen: 0.31\n",
      "Epoch: 20\t Iteration: 2000\t MacroPop: 882\t MicroPop: 2637\t AccEstimate: 0.96\t AveGen: 0.31\n",
      "Epoch: 21\t Iteration: 2100\t MacroPop: 916\t MicroPop: 2783\t AccEstimate: 0.97\t AveGen: 0.31\n",
      "Epoch: 22\t Iteration: 2200\t MacroPop: 935\t MicroPop: 2917\t AccEstimate: 0.97\t AveGen: 0.31\n",
      "Epoch: 23\t Iteration: 2300\t MacroPop: 959\t MicroPop: 3037\t AccEstimate: 0.97\t AveGen: 0.31\n",
      "Epoch: 24\t Iteration: 2400\t MacroPop: 978\t MicroPop: 3165\t AccEstimate: 0.96\t AveGen: 0.31\n",
      "Epoch: 25\t Iteration: 2500\t MacroPop: 991\t MicroPop: 3285\t AccEstimate: 0.98\t AveGen: 0.31\n",
      "Epoch: 26\t Iteration: 2600\t MacroPop: 1007\t MicroPop: 3409\t AccEstimate: 0.96\t AveGen: 0.31\n",
      "Epoch: 27\t Iteration: 2700\t MacroPop: 1023\t MicroPop: 3537\t AccEstimate: 0.97\t AveGen: 0.31\n",
      "Epoch: 28\t Iteration: 2800\t MacroPop: 1037\t MicroPop: 3653\t AccEstimate: 0.97\t AveGen: 0.30\n",
      "Epoch: 29\t Iteration: 2900\t MacroPop: 1048\t MicroPop: 3781\t AccEstimate: 0.99\t AveGen: 0.30\n",
      "Epoch: 30\t Iteration: 3000\t MacroPop: 1062\t MicroPop: 3909\t AccEstimate: 0.98\t AveGen: 0.30\n",
      "Epoch: 31\t Iteration: 3100\t MacroPop: 1077\t MicroPop: 4029\t AccEstimate: 0.99\t AveGen: 0.30\n",
      "Epoch: 32\t Iteration: 3200\t MacroPop: 1088\t MicroPop: 4169\t AccEstimate: 1.00\t AveGen: 0.30\n",
      "Epoch: 33\t Iteration: 3300\t MacroPop: 1093\t MicroPop: 4297\t AccEstimate: 0.98\t AveGen: 0.30\n",
      "Epoch: 34\t Iteration: 3400\t MacroPop: 1103\t MicroPop: 4425\t AccEstimate: 0.99\t AveGen: 0.30\n",
      "Epoch: 35\t Iteration: 3500\t MacroPop: 1115\t MicroPop: 4547\t AccEstimate: 1.00\t AveGen: 0.30\n",
      "Epoch: 36\t Iteration: 3600\t MacroPop: 1130\t MicroPop: 4691\t AccEstimate: 1.00\t AveGen: 0.30\n",
      "Epoch: 37\t Iteration: 3700\t MacroPop: 1142\t MicroPop: 4825\t AccEstimate: 1.00\t AveGen: 0.30\n",
      "Epoch: 38\t Iteration: 3800\t MacroPop: 1150\t MicroPop: 4943\t AccEstimate: 1.00\t AveGen: 0.30\n",
      "Epoch: 39\t Iteration: 3900\t MacroPop: 1163\t MicroPop: 5087\t AccEstimate: 1.00\t AveGen: 0.30\n",
      "Epoch: 40\t Iteration: 4000\t MacroPop: 1177\t MicroPop: 5211\t AccEstimate: 1.00\t AveGen: 0.30\n",
      "------------------------------------------------------------------------------------------------------------------------------------------------------\n",
      "Output rule population after 4000 iterations.\n",
      "Writing Population Statistical Summary File...\n",
      "Writing Population as Data File...\n",
      "Continue Learning...\n",
      "------------------------------------------------------------------------------------------------------------------------------------------------------\n",
      "eLCS Run Complete\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<__main__.eLCS at 0x624c4734e0>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "#Initialize the 'Environment' module which manages the data presented to the algorithm.  While e-LCS learns iteratively (one inistance at a time\n",
    "env = Offline_Environment()\n",
    "cons.referenceEnv(env) #Passes the environment to 'Constants' (cons) so that it can be easily accessed from anywhere within the code.\n",
    "cons.parseIterations() #Identify the maximum number of learning iterations as well as evaluation checkpoints.\n",
    "\n",
    "#Run the e-LCS algorithm.\n",
    "eLCS()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot diagram of Average population and Pop size per generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "hideCode": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "try:       \n",
    "    datasetList = [] #np.array([])\n",
    "    arraylist = np.array([])\n",
    "    headerList = np.array([])\n",
    "    ds = open(cons.outFileName+'_LearnTrack.txt','r')  \n",
    "except Exception as inst:\n",
    "    print(type(inst))\n",
    "    print(inst.args)\n",
    "    print(inst)\n",
    "    print('cannot open', cons.outFileName+'_LearnTrack.txt')\n",
    "    raise\n",
    "else:\n",
    "    headerList = ds.readline().rstrip('\\n').split('\\t')   #strip off first row\n",
    "    for line in ds:\n",
    "        lineList = line.strip('\\n').split('\\t')\n",
    "        arraylist = [float(i) for i in lineList]\n",
    "        datasetList.append(arraylist)\n",
    "    ds.close()  \n",
    "\n",
    "\n",
    "#maybe easier to reshape then use [:,0] but have not tried...\n",
    "a = [row[0] for row in datasetList]   \n",
    "b = [row[3] for row in datasetList]  \n",
    "c = [row[4] for row in datasetList]  \n",
    "    \n",
    "# Create plots with pre-defined labels.\n",
    "plt.plot(a, b, 'k--', label=headerList[3] )\n",
    "plt.plot(a, c, 'k:', label=headerList[4])\n",
    "\n",
    "\n",
    "plt.xlabel(headerList[0])\n",
    "legend = plt.legend(loc='center', shadow=True, fontsize='large')\n",
    "\n",
    "# Put a nicer background color on the legend.\n",
    "legend.get_frame().set_facecolor('#D2D2D2')\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Hide code",
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}