eLCS_5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### LCS Demo 5\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>5.1. <span style='color:red'>Demo 5.1 </span>(<b>Toy problem\n",
    "using eLCS</b>) this version of eLCS is most similar to the UCS algorithm. We\n",
    "have used the complex but toy multiplexer problem: <span style='font-family:\n",
    "\"Courier New\"'>6Multiplexer Data Complete.txt,</span> however we have also\n",
    "included the complete 11-bit multiplexer (<span style='font-family:\"Courier New\"'>11Multiplexer\n",
    "Data Complete.txt</span>), and a 2000 instance dataset sampling the 20-bit\n",
    "multiplexer problem (<span style='font-family:\"Courier New\"'>20Multiplexer Data\n",
    "2000.txt</span>).</p>\n",
    "\n",
    "<p class=MsoNormal>5.2. <span style='color:red'>Exercise:</span> Mess about with the parameter settings!</p>\n",
    "\n",
    "<p class=MsoNormal>(a) Initially, one at a time. Get a feel for the effect of\n",
    "population size. Reset to a sensible size and then get a feel for a wide range\n",
    "of learning rates. Each time noting the classification performance trend\n",
    "as well as the final achieved performance value. </p>\n",
    "\n",
    "<p class=MsoNormal>(b) Combinations of parameters. Parameters that strongly\n",
    "interacting include: Population Size and P# (particularly for sparse problems\n",
    "such as the parity problem), Population size and genetic algorithm rate (see if\n",
    "you can get the covering loop problem to occur), and Learning rate and error\n",
    "threshold &#949;<sub>0</sub>.</p>\n",
    "\n",
    "<p class=MsoNormal>eLCS does not include some of the extras from Ryan’s ExSTraCS\n",
    "algorithm such as attribute tracking or expert knowledge, as these are advanced\n",
    "features and unique to this LCS family.</p>\n",
    "\n",
    "<o:p></o:p></p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true,
    "hideCode": true
   },
   "outputs": [],
   "source": [
    "# Import useful prewritten code from Python libraries\n",
    "import random\n",
    "import copy\n",
    "import math\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Configure the parameters, usually from a txt file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "hideCode": true
   },
   "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\t# Path/NewName for new algorithm output files. Note: Do not give a file extension, this is done automatically.\n",
    "learningIterations='1000.6000'\t\t\t\t\t\t# 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=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\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\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",
    "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",
    "theta_del=20\t\t\t\t\t\t\t\t\t# The deletion experience threshold; The calculation of the deletion probability changes once this threshold is passed.\n",
    "theta_sub=20\t\t\t\t\t\t\t\t\t# The subsumption experience threshold;\n",
    "acc_sub=0.99\t\t\t\t\t\t\t\t\t# Subsumption accuracy requirement\n",
    "beta=0.2\t\t\t\t\t\t\t\t\t\t# Learning parameter; Used in calculating average correct set size\n",
    "delta=0.1\t\t\t\t\t\t\t\t\t\t# Deletion parameter; Used in determining deletion vote calculation.\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",
    "fitnessReduction=0.1\t\t\t\t\t\t\t# Initial fitness reduction in GA offspring rules.\n",
    "\n",
    "######-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "###### Algorithm Heuristic Options\n",
    "######--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "doSubsumption=1\t\t\t\t\t\t\t\t\t# Activate Subsumption? (1 is True, 0 is False).  Subsumption is a heuristic that actively seeks to increase generalization in the rule population.\n",
    "selectionMethod='tournament'\t\t\t\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_5000\"\t\t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Timer class for meta statistics rather than functionality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true,
    "hideCode": true
   },
   "outputs": [],
   "source": [
    "class Timer:\n",
    "    def __init__(self): \n",
    "        # Global Time objects\n",
    "        self.globalStartRef = time.time()\n",
    "        self.globalTime = 0.0\n",
    "        self.addedTime = 0.0\n",
    "        \n",
    "        # Match Time Variables\n",
    "        self.startRefMatching = 0.0\n",
    "        self.globalMatching = 0.0\n",
    "        \n",
    "        # Deletion Time Variables\n",
    "        self.startRefDeletion = 0.0\n",
    "        self.globalDeletion = 0.0\n",
    "\n",
    "        # Subsumption Time Variables\n",
    "        self.startRefSubsumption = 0.0\n",
    "        self.globalSubsumption = 0.0\n",
    "\n",
    "        # Selection Time Variables\n",
    "        self.startRefSelection = 0.0\n",
    "        self.globalSelection = 0.0\n",
    "        \n",
    "        # Evaluation Time Variables\n",
    "        self.startRefEvaluation = 0.0\n",
    "        self.globalEvaluation = 0.0  \n",
    "        \n",
    "        \n",
    "    # ************************************************************\n",
    "    def startTimeMatching(self):\n",
    "        \"\"\" Tracks MatchSet Time \"\"\"\n",
    "        self.startRefMatching = time.time()\n",
    "         \n",
    "    def stopTimeMatching(self):\n",
    "        \"\"\" Tracks MatchSet Time \"\"\"\n",
    "        diff = time.time() - self.startRefMatching\n",
    "        self.globalMatching += diff        \n",
    "\n",
    "    # ************************************************************\n",
    "    def startTimeDeletion(self):\n",
    "        \"\"\" Tracks Deletion Time \"\"\"\n",
    "        self.startRefDeletion = time.time()\n",
    "        \n",
    "    def stopTimeDeletion(self):\n",
    "        \"\"\" Tracks Deletion Time \"\"\"\n",
    "        diff = time.time() - self.startRefDeletion\n",
    "        self.globalDeletion += diff\n",
    "        \n",
    "    # ************************************************************\n",
    "    def startTimeSubsumption(self):\n",
    "        \"\"\"Tracks Subsumption Time \"\"\"\n",
    "        self.startRefSubsumption = time.time()\n",
    "\n",
    "    def stopTimeSubsumption(self):\n",
    "        \"\"\"Tracks Subsumption Time \"\"\"\n",
    "        diff = time.time() - self.startRefSubsumption\n",
    "        self.globalSubsumption += diff    \n",
    "        \n",
    "    # ************************************************************\n",
    "    def startTimeSelection(self):\n",
    "        \"\"\" Tracks Selection Time \"\"\"\n",
    "        self.startRefSelection = time.time()\n",
    "        \n",
    "    def stopTimeSelection(self):\n",
    "        \"\"\" Tracks Selection Time \"\"\"\n",
    "        diff = time.time() - self.startRefSelection\n",
    "        self.globalSelection += diff\n",
    "    \n",
    "    # ************************************************************\n",
    "    def startTimeEvaluation(self):\n",
    "        \"\"\" Tracks Evaluation Time \"\"\"\n",
    "        self.startRefEvaluation = time.time()\n",
    "        \n",
    "    def stopTimeEvaluation(self):\n",
    "        \"\"\" Tracks Evaluation Time \"\"\"\n",
    "        diff = time.time() - self.startRefEvaluation\n",
    "        self.globalEvaluation += diff \n",
    "    \n",
    "    # ************************************************************\n",
    "    def returnGlobalTimer(self):\n",
    "        \"\"\" Set the global end timer, call at very end of algorithm. \"\"\"\n",
    "        self.globalTime = (time.time() - self.globalStartRef) + self.addedTime #Reports time in minutes, addedTime is for population reboot.\n",
    "        return self.globalTime/ 60.0\n",
    "\n",
    "    \n",
    "    def setTimerRestart(self, remakeFile): \n",
    "        \"\"\" Sets all time values to the those previously evolved in the loaded popFile.  \"\"\"\n",
    "        try:\n",
    "            fileObject = open(remakeFile+\"_PopStats.txt\", 'r')  # opens each datafile to read.\n",
    "        except Exception as inst:\n",
    "            print(type(inst))\n",
    "            print(inst.args)\n",
    "            print(inst)\n",
    "            print('cannot open', remakeFile+\"_PopStats.txt\")\n",
    "            raise \n",
    "\n",
    "        timeDataRef = 18\n",
    "\n",
    "        tempLine = None\n",
    "        for i in range(timeDataRef):\n",
    "            tempLine = fileObject.readline()\n",
    "        tempList = tempLine.strip().split('\\t')\n",
    "        self.addedTime = float(tempList[1]) * 60 #previous global time added with Reboot.\n",
    "        \n",
    "        tempLine = fileObject.readline()\n",
    "        tempList = tempLine.strip().split('\\t') \n",
    "        self.globalMatching = float(tempList[1]) * 60\n",
    "        \n",
    "        tempLine = fileObject.readline()\n",
    "        tempList = tempLine.strip().split('\\t') \n",
    "        self.globalDeletion = float(tempList[1]) * 60\n",
    "\n",
    "        tempLine = fileObject.readline()\n",
    "        tempList = tempLine.strip().split('\\t') \n",
    "        self.globalSubsumption = float(tempList[1]) * 60\n",
    "        \n",
    "        tempLine = fileObject.readline()\n",
    "        tempList = tempLine.strip().split('\\t') \n",
    "        self.globalSelection = float(tempList[1]) * 60    \n",
    " \n",
    "        tempLine = fileObject.readline()\n",
    "        tempList = tempLine.strip().split('\\t') \n",
    "        self.globalEvaluation = float(tempList[1]) * 60\n",
    "        \n",
    "        fileObject.close()\n",
    "        \n",
    "    ##############################################################################################\n",
    "    \n",
    "    def reportTimes(self):\n",
    "        \"\"\" Reports the time summaries for this run. Returns a string ready to be printed out.\"\"\"\n",
    "        outputTime = \"Global Time\\t\"+str(self.globalTime/ 60.0)+ \\\n",
    "        \"\\nMatching Time\\t\" + str(self.globalMatching/ 60.0)+ \\\n",
    "        \"\\nDeletion Time\\t\" + str(self.globalDeletion/ 60.0)+ \\\n",
    "        \"\\nSubsumption Time\\t\" + str(self.globalSubsumption/ 60.0)+ \\\n",
    "        \"\\nSelection Time\\t\"+str(self.globalSelection/ 60.0)+ \\\n",
    "        \"\\nEvaluation Time\\t\"+str(self.globalEvaluation/ 60.0) + \"\\n\" \n",
    "        \n",
    "        return outputTime"
   ]
  },
  {
   "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": 20,
   "metadata": {
    "collapsed": false,
    "hideCode": true
   },
   "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.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.theta_del = theta_del #int(par['theta_del'])                                  #Saved as integer\n",
    "        self.theta_sub = theta_sub #int(par['theta_sub'])                                  #Saved as integer\n",
    "        self.acc_sub = acc_sub #float(par['acc_sub'])                                    #Saved as float\n",
    "        self.beta = beta #float(par['beta'])                                          #Saved as float\n",
    "        self.delta = delta #float(par['delta'])   \n",
    "        self.init_fit = init_fit #float(par['init_fit'])                                  #Saved as float\n",
    "        self.fitnessReduction = fitnessReduction #float(par['fitnessReduction'])   \n",
    "   \n",
    "        # Algorithm Heuristic Options --New-------------------------------------------------------------------------\n",
    "        self.doSubsumption = doSubsumption #bool(int(par['doSubsumption']))                    #Saved as Boolean\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",
    "    # New  \n",
    "    def referenceTimer(self, timer):\n",
    "        \"\"\" Store reference to the timer object. \"\"\"\n",
    "        self.timer = timer\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",
    "        \n",
    "        for i in range(len(checkpoints)): \n",
    "            checkpoints[i] = int(checkpoints[i])\n",
    "            \n",
    "        self.learningCheckpoints = checkpoints #next two lines needed for reboot\n",
    "        self.maxLearningIterations = self.learningCheckpoints[(len(self.learningCheckpoints)-1)] #???\n",
    "\n",
    "        #self.learningCheckpoints = 64\n",
    "        #self.maxLearningIterations = learningIterations\n",
    "        \n",
    "        if self.trackingFrequency == 0:\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": 21,
   "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": 22,
   "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": [
    "Offline environment: class to cycle through an offline dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true,
    "hideCode": true
   },
   "outputs": [],
   "source": [
    "\n",
    "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": [
    "Classifier class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true,
    "hideCode": true
   },
   "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             # The number of rule copies stored in the population.  (Indirectly stored as incremented numerosity)\n",
    "        self.aveMatchSetSize = None     # A parameter used in deletion which reflects the size of match sets within this rule has been included.\n",
    "        self.deletionVote = None        # The current deletion weight for this classifier.\n",
    " \n",
    "        #Experience Management ---------------------------------------------\n",
    "        self.timeStampGA = None         # Time since rule last in a correct set.\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(c,list): #note subtle new change\n",
    "            self.classifierCovering(a,b,c,d)\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, setSize, 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\n",
    "        self.initTimeStamp = exploreIter\n",
    "        self.aveMatchSetSize = setSize\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",
    "    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.aveMatchSetSize = copy.deepcopy(clOld.aveMatchSetSize)\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.numerosity = int(classifierList[numAttributes+3])\n",
    "        self.aveMatchSetSize = float(classifierList[numAttributes+4])\n",
    "        self.timeStampGA = int(classifierList[numAttributes+5])\n",
    "        self.initTimeStamp = int(classifierList[numAttributes+6])       \n",
    "        self.deletionVote = float(classifierList[numAttributes+8])\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",
    "   \n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\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",
    "        #SWARTZ: self. is where for the better attributes are more likely to be specified\n",
    "        #DEVITO: cl. is where less useful attribute are more likely to be specified\n",
    "        \"\"\"\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",
    "    # SUBSUMPTION METHODS\n",
    "    #-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- \n",
    "    def subsumes(self, cl):\n",
    "        \"\"\" Returns if the classifier (self) subsumes cl \"\"\"\n",
    "        #-------------------------------------------------------\n",
    "        # DISCRETE PHENOTYPE\n",
    "        #-------------------------------------------------------\n",
    "        if cons.env.formatData.discretePhenotype: \n",
    "            if cl.phenotype == self.phenotype:\n",
    "                if self.isSubsumer() and self.isMoreGeneral(cl):\n",
    "                    return True\n",
    "            return False\n",
    "        #-------------------------------------------------------\n",
    "        # CONTINUOUS PHENOTYPE -  NOTE: for continuous phenotypes, the subsumption intuition is reversed, i.e. While a subsuming rule condition is more general, a subsuming phenotype is more specific.\n",
    "        #-------------------------------------------------------\n",
    "        else:\n",
    "            if self.phenotype[0] >= cl.phenotype[0] and self.phenotype[1] <= cl.phenotype[1]:\n",
    "                if self.isSubsumer() and self.isMoreGeneral(cl):\n",
    "                    return True\n",
    "            return False  \n",
    "        \n",
    "\n",
    "    def isSubsumer(self):\n",
    "        \"\"\" Returns if the classifier (self) is a possible subsumer. A classifier must be as or more accurate than the classifier it is trying to subsume.  \"\"\"\n",
    "        if self.matchCount > cons.theta_sub and self.accuracy > cons.acc_sub: \n",
    "            return True\n",
    "        return False\n",
    "    \n",
    "    \n",
    "    def isMoreGeneral(self,cl):\n",
    "        \"\"\" Returns if the classifier (self) is more general than cl. Check that all attributes specified in self are also specified in cl. \"\"\" \n",
    "        if len(self.specifiedAttList) >= len(cl.specifiedAttList):\n",
    "            return False\n",
    "        for i in range(len(self.specifiedAttList)): #Check each attribute specified in self.condition\n",
    "            attributeInfo = cons.env.formatData.attributeInfo[self.specifiedAttList[i]]\n",
    "            if self.specifiedAttList[i] not in cl.specifiedAttList:\n",
    "                return False\n",
    "            #-------------------------------------------------------\n",
    "            # CONTINUOUS ATTRIBUTE\n",
    "            #-------------------------------------------------------\n",
    "            if attributeInfo[0]:\n",
    "                otherRef = cl.specifiedAttList.index(self.specifiedAttList[i])\n",
    "                #If self has a narrower ranger of values than it is a subsumer\n",
    "                if self.condition[i][0] < cl.condition[otherRef][0]:\n",
    "                    return False\n",
    "                if self.condition[i][1] > cl.condition[otherRef][1]:\n",
    "                    return False\n",
    "                \n",
    "        return True\n",
    "    \n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # DELETION METHOD\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------      \n",
    "    def getDelProp(self, meanFitness):\n",
    "        \"\"\"  Returns the vote for deletion of the classifier. \"\"\"\n",
    "        if self.fitness/self.numerosity >= cons.delta*meanFitness or self.matchCount < cons.theta_del:\n",
    "            self.deletionVote = self.aveMatchSetSize*self.numerosity\n",
    "\n",
    "        elif self.fitness == 0.0:\n",
    "            self.deletionVote = self.aveMatchSetSize * self.numerosity * meanFitness / (cons.init_fit/self.numerosity)\n",
    "        else:\n",
    "            self.deletionVote = self.aveMatchSetSize * self.numerosity * meanFitness / (self.fitness/self.numerosity) \n",
    "        return self.deletionVote\n",
    "\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",
    "    # New\n",
    "    def updateMatchSetSize(self, matchSetSize): \n",
    "        \"\"\"  Updates the average match set size. \"\"\"\n",
    "        if self.matchCount < 1.0 / cons.beta:\n",
    "            self.aveMatchSetSize = (self.aveMatchSetSize * (self.matchCount-1)+ matchSetSize) / float(self.matchCount)\n",
    "        else:\n",
    "            self.aveMatchSetSize = self.aveMatchSetSize + cons.beta * (matchSetSize - self.aveMatchSetSize)\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\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\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",
    "    #-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\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",
    "        #print(self.deletionVote)    does this not occur until population is full???\n",
    "        #------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "        classifierString += str(\"%.3f\" %self.fitness)+\"\\t\"+str(\"%.3f\" %self.accuracy)+\"\\t\"+str(\"%d\" %self.numerosity)+\"\\t\"+str(\"%.2f\" %self.aveMatchSetSize)+\"\\t\"+str(\"%d\" %self.timeStampGA)+\"\\t\"+str(\"%d\" %self.initTimeStamp)+\"\\t\"+str(\"%.2f\" %specificity)+\"\\t\"\n",
    "        #???classifierString += str(\"%.2f\" %self.deletionVote)+\"\\t\"+str(\"%d\" %self.correctCount)+\"\\t\"+str(\"%d\" %self.matchCount)+\"\\n\"\n",
    "        classifierString += \"\\t\"+str(\"%d\" %self.correctCount)+\"\\t\"+str(\"%d\" %self.matchCount)+\"\\n\"\n",
    "\n",
    "        #------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "        return classifierString"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "GA, Subsumption and Selection in here: Classifier Set class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "hideCode": true
   },
   "outputs": [],
   "source": [
    "\n",
    "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",
    "            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",
    "        #Print every iteration! DEMO CODE-------------------------\n",
    "        # print(\"Current instance from dataset:  \" + \"State = \"+ str(state_phenotype[0]) + \"  Phenotype = \"+ str(state_phenotype[1]))\n",
    "        #print(\"--------------------------------------------------------------------------------------\")\n",
    "        #print(\"Matching Classifiers:\")\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",
    "        #-------------------------------------------------------\n",
    "        # MATCHING\n",
    "        #-------------------------------------------------------\n",
    "        cons.timer.startTimeMatching()  \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",
    "                # print(\"Condition: \"+ str(cl.reportClassifier()) + \"  Phenotype: \"+ str(cl.phenotype)) #debug all [M]\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",
    "        #if len(self.matchSet) == 0: #not triggered now\n",
    "            # print('None found.') # debug all covering\n",
    "            \n",
    "        cons.timer.stopTimeMatching() #new\n",
    "        \n",
    "        #-------------------------------------------------------\n",
    "        # COVERING\n",
    "        #-------------------------------------------------------\n",
    "        while doCovering:\n",
    "            newCl = Classifier(setNumerositySum+1,exploreIter, state, phenotype)\n",
    "            self.addClassifierToPopulation(newCl, 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",
    "    def makeEvalMatchSet(self, state):\n",
    "        \"\"\" Constructs a match set for evaluation purposes which does not activate either covering or deletion. \"\"\"\n",
    "        for i in range(len(self.popSet)):       # Go through the population\n",
    "            cl = self.popSet[i]                 # A single classifier\n",
    "            if cl.match(state):                 # Check for match\n",
    "                self.matchSet.append(i)         # Add classifier to match set    \n",
    "\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # CLASSIFIER DELETION METHODS\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    def deletion(self, exploreIter):\n",
    "        \"\"\" Returns the population size back to the maximum set by the user by deleting rules. \"\"\"\n",
    "        cons.timer.startTimeDeletion()               \n",
    "        while self.microPopSize > cons.N:  \n",
    "            self.deleteFromPopulation() \n",
    "        cons.timer.stopTimeDeletion()  \n",
    "        \n",
    "        \n",
    "    def deleteFromPopulation(self):\n",
    "        \"\"\" Deletes one classifier in the population.  The classifier that will be deleted is chosen by roulette wheel selection\n",
    "        considering the deletion vote. Returns the macro-classifier which got decreased by one micro-classifier. \"\"\"\n",
    "        meanFitness = self.getPopFitnessSum()/float(self.microPopSize)\n",
    " \n",
    "        #Calculate total wheel size------------------------------\n",
    "        sumCl = 0.0\n",
    "        voteList = []\n",
    "        for cl in self.popSet:\n",
    "            vote = cl.getDelProp(meanFitness)\n",
    "            sumCl += vote\n",
    "            voteList.append(vote)\n",
    "        #--------------------------------------------------------\n",
    "        choicePoint = sumCl * random.random() #Determine the choice point\n",
    "\n",
    "        newSum=0.0\n",
    "        for i in range(len(voteList)):\n",
    "            cl = self.popSet[i]\n",
    "            newSum = newSum + voteList[i]\n",
    "            if newSum > choicePoint: #Select classifier for deletion\n",
    "                #Delete classifier----------------------------------\n",
    "                cl.updateNumerosity(-1)\n",
    "                self.microPopSize -= 1\n",
    "                if cl.numerosity < 1: # When all micro-classifiers for a given classifier have been depleted.\n",
    "                    self.removeMacroClassifier(i)\n",
    "                    self.deleteFromMatchSet(i)  \n",
    "                    self.deleteFromCorrectSet(i)\n",
    "                return\n",
    "\n",
    "        print(\"ClassifierSet: No eligible rules found for deletion in deleteFromPopulation.\")\n",
    "        return\n",
    "\n",
    "\n",
    "    def removeMacroClassifier(self, ref):\n",
    "        \"\"\" Removes the specified (macro-) classifier from the population. \"\"\"\n",
    "        self.popSet.pop(ref)\n",
    "\n",
    "        \n",
    "    def deleteFromMatchSet(self, deleteRef):\n",
    "        \"\"\" Delete reference to classifier in population, contained in self.matchSet.\"\"\"\n",
    "        if deleteRef in self.matchSet:\n",
    "            self.matchSet.remove(deleteRef)\n",
    "\n",
    "        #Update match set reference list--------\n",
    "        for j in range(len(self.matchSet)):\n",
    "            ref = self.matchSet[j]\n",
    "            if ref > deleteRef:\n",
    "                self.matchSet[j] -= 1\n",
    "\n",
    "        \n",
    "    def deleteFromCorrectSet(self, deleteRef):\n",
    "        \"\"\" Delete reference to classifier in population, contained in self.corectSet.\"\"\"\n",
    "        if deleteRef in self.correctSet:\n",
    "            self.correctSet.remove(deleteRef)\n",
    "\n",
    "        #Update match set reference list--------\n",
    "        for j in range(len(self.correctSet)):\n",
    "            ref = self.correctSet[j]\n",
    "            if ref > deleteRef:\n",
    "                self.correctSet[j] -= 1\n",
    "\n",
    "  \n",
    "    #------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # GENETIC ALGORITHM\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    def runGA(self, exploreIter, state, phenotype): \n",
    "        \"\"\" The genetic discovery mechanism in eLCS is controlled here. \"\"\"\n",
    "        #-------------------------------------------------------\n",
    "        # GA RUN REQUIREMENT\n",
    "        #-------------------------------------------------------\n",
    "        if (exploreIter - self.getIterStampAverage()) < cons.theta_GA:  #Does the correct set meet the requirements for activating the GA?\n",
    "            return \n",
    "        \n",
    "        self.setIterStamps(exploreIter) #Updates the iteration time stamp for all rules in the correct set (which the GA opperates in).\n",
    "        changed = False\n",
    "        \n",
    "        #-------------------------------------------------------\n",
    "        # SELECT PARENTS - Niche GA - selects parents from the correct class\n",
    "        #-------------------------------------------------------\n",
    "        cons.timer.startTimeSelection()\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",
    "        cons.timer.stopTimeSelection()\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) #Subsumption\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 = copy.deepcopy(self.correctSet)\n",
    "        if len(setList) < 2:\n",
    "            currentCount = 1 #Pick only one parent\n",
    "        else:\n",
    "            currentCount = 0 #Pick two parents\n",
    "        #-----------------------------------------------\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",
    "        #-----------------------------------------------\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 = self.correctSet #correct set is a list of reference IDs\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",
    "    # SUBSUMPTION METHODS\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    def subsumeClassifier(self, cl=None, cl1P=None, cl2P=None):\n",
    "        \"\"\" Tries to subsume a classifier in the parents. If no subsumption is possible it tries to subsume it in the current set. \"\"\"\n",
    "        if cl1P!=None and cl1P.subsumes(cl):\n",
    "            self.microPopSize += 1\n",
    "            cl1P.updateNumerosity(1)\n",
    "        elif cl2P!=None and cl2P.subsumes(cl):\n",
    "            self.microPopSize += 1\n",
    "            cl2P.updateNumerosity(1)\n",
    "        else:\n",
    "            self.subsumeClassifier2(cl); #Try to subsume in the correct set.\n",
    "\n",
    "\n",
    "    def subsumeClassifier2(self, cl):\n",
    "        \"\"\" Tries to subsume a classifier in the correct set. If no subsumption is possible the classifier is simply added to the population considering\n",
    "        the possibility that there exists an identical classifier. \"\"\"\n",
    "        choices = []\n",
    "        for ref in self.correctSet:\n",
    "            if self.popSet[ref].subsumes(cl):\n",
    "                choices.append(ref)\n",
    "\n",
    "        if len(choices) > 0: #Randomly pick one classifier to be subsumer\n",
    "            choice = int(random.random()*len(choices))\n",
    "            self.popSet[choices[choice]].updateNumerosity(1)\n",
    "            self.microPopSize += 1\n",
    "            return\n",
    "        \n",
    "        self.addClassifierToPopulation(cl,False) #If no subsumer was found, check for identical classifier, if not then add the classifier to the population\n",
    "\n",
    "\n",
    "    def doCorrectSetSubsumption(self):\n",
    "        \"\"\" Executes correct set subsumption.  The correct set subsumption looks for the most general subsumer classifier in the correct set\n",
    "        and subsumes all classifiers that are more specific than the selected one. \"\"\"\n",
    "        subsumer = None\n",
    "        for ref in self.correctSet:\n",
    "            cl = self.popSet[ref]\n",
    "            if cl.isSubsumer():\n",
    "                if subsumer == None or cl.isMoreGeneral(subsumer):\n",
    "                    subsumer = cl\n",
    "\n",
    "        if subsumer != None: #If a subsumer was found, subsume all more specific classifiers in the correct set\n",
    "            i=0\n",
    "            while i < len(self.correctSet):\n",
    "                ref = self.correctSet[i]\n",
    "                if subsumer.isMoreGeneral(self.popSet[ref]):\n",
    "                    subsumer.updateNumerosity(self.popSet[ref].numerosity)\n",
    "                    self.removeMacroClassifier(ref)\n",
    "                    self.deleteFromMatchSet(ref)\n",
    "                    self.deleteFromCorrectSet(ref)\n",
    "                    i = i - 1 \n",
    "                i = i + 1\n",
    "                \n",
    "     \n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    # OTHER KEY METHODS\n",
    "    #--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
    "    def addClassifierToPopulation(self, cl, covering):\n",
    "        \"\"\" Note new change here: 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",
    "\n",
    "    def insertDiscoveredClassifiers(self, cl1, cl2, clP1, clP2, exploreIter):\n",
    "        \"\"\" Inserts both discovered classifiers and activates GA subsumption if turned on. 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",
    "        #-------------------------------------------------------\n",
    "        # SUBSUMPTION\n",
    "        #-------------------------------------------------------\n",
    "        if cons.doSubsumption:\n",
    "            cons.timer.startTimeSubsumption()\n",
    "            \n",
    "            if len(cl1.specifiedAttList) > 0: \n",
    "                self.subsumeClassifier(cl1, clP1, clP2)\n",
    "            if len(cl2.specifiedAttList) > 0: \n",
    "                self.subsumeClassifier(cl2, clP1, clP2)\n",
    "\n",
    "            cons.timer.stopTimeSubsumption()\n",
    "        #-------------------------------------------------------\n",
    "        # ADD OFFSPRING TO POPULATION\n",
    "        #-------------------------------------------------------\n",
    "        else: #Just add the new classifiers to the population.\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",
    "    #--Note New changes here-------------\n",
    "    def updateSets(self, exploreIter):\n",
    "        \"\"\" Updates all relevant parameters in the current match and correct sets. \"\"\"\n",
    "        matchSetNumerosity = 0\n",
    "        for ref in self.matchSet:\n",
    "            matchSetNumerosity += self.popSet[ref].numerosity\n",
    "        \n",
    "        for ref in self.matchSet:\n",
    "            self.popSet[ref].updateExperience()    \n",
    "            self.popSet[ref].updateMatchSetSize(matchSetNumerosity) \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",
    "    # New method\n",
    "    def getIterStampAverage(self):\n",
    "        \"\"\" Returns the average of the time stamps in the correct set. \"\"\"\n",
    "        sumCl=0.0\n",
    "        numSum=0.0\n",
    "        for i in range(len(self.correctSet)):\n",
    "            ref = self.correctSet[i]\n",
    "            sumCl += self.popSet[ref].timeStampGA * self.popSet[ref].numerosity\n",
    "            numSum += self.popSet[ref].numerosity #numerosity sum of correct set\n",
    "        return sumCl/float(numSum)\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 method\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 method\n",
    "    def getPopFitnessSum(self):\n",
    "        \"\"\" Returns the sum of the fitnesses of all classifiers in the set. \"\"\"\n",
    "        sumCl=0.0\n",
    "        for cl in self.popSet:\n",
    "            sumCl += cl.fitness * cl.numerosity\n",
    "        return sumCl\n",
    "        \n",
    "    # New method      \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",
    "    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:\n",
    "            genSum += ((cons.env.formatData.numAttributes - len(cl.condition)) / float(cons.env.formatData.numAttributes)) \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:\n",
    "                sumRuleRange += (cl.phenotype[1] - cl.phenotype[0])\n",
    "            phenotypeRange = cons.env.formatData.phenotypeList[1] - cons.env.formatData.phenotypeList[0]\n",
    "            self.avePhenotypeRange = (sumRuleRange / float(self.microPopSize)) / float(phenotypeRange)\n",
    "\n",
    "    # New method         \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)  + \"\\t\" + str(\"%.2f\" %cons.timer.returnGlobalTimer())+ \"\\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(accuracy) + \"\\t AveGen: \" + str(\"%.2f\" %self.aveGenerality)  + \"\\t Time: \" + str(\"%.2f\" %cons.timer.returnGlobalTimer())))\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(accuracy) + \"\\t AveGen: \" + str(\"%.2f\" %self.aveGenerality) + \"\\t PhenRange: \" +str(self.avePhenotypeRange) + \"\\t Time: \" + str(\"%.2f\" %cons.timer.returnGlobalTimer())))\n",
    "\n",
    "        return trackString\n",
    "        "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "hideCode": false
   },
   "source": [
    "Prediction array code: Given a match set, this module uses a voting scheme to select the phenotype prediction.  Set up to handle both discrete and continuous phenotypes. Also set up to try and handle prediction ties if possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true,
    "hideCode": true
   },
   "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": [
    "Accuracy Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true,
    "hideCode": true
   },
   "outputs": [],
   "source": [
    "class ClassAccuracy:\n",
    "    def __init__(self):\n",
    "        \"\"\" Initialize the accuracy calculation for a single class \"\"\"\n",
    "        self.T_myClass = 0      #For binary class problems this would include true positives\n",
    "        self.T_otherClass = 0   #For binary class problems this would include true negatives \n",
    "        self.F_myClass = 0      #For binary class problems this would include false positives \n",
    "        self.F_otherClass = 0   #For binary class problems this would include false negatives \n",
    "\n",
    "\n",
    "    def updateAccuracy(self, thisIsMe, accurateClass):\n",
    "        \"\"\" Increment the appropriate cell of the confusion matrix \"\"\"\n",
    "        if thisIsMe and accurateClass:\n",
    "            self.T_myClass += 1\n",
    "        elif accurateClass:\n",
    "            self.T_otherClass += 1\n",
    "        elif thisIsMe:\n",
    "            self.F_myClass += 1\n",
    "        else:\n",
    "            self.F_otherClass += 1\n",
    "        \n",
    "        \n",
    "    def reportClassAccuracy(self):\n",
    "        \"\"\" Print to standard out, summary on the class accuracy. \"\"\"\n",
    "        print(\"-----------------------------------------------\")\n",
    "        print(\"TP = \"+str(self.T_myClass))\n",
    "        print(\"TN = \"+str(self.T_otherClass))\n",
    "        print(\"FP = \"+str(self.F_myClass))\n",
    "        print(\"FN = \"+str(self.F_otherClass))\n",
    "        print(\"-----------------------------------------------\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LCS class to run the code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "hideCode": true
   },
   "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:\n",
    "                 self.learnTrackOut.write(\"Explore_Iteration\\tMacroPopSize\\tMicroPopSize\\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",
    "\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",
    "        #-------------------------------------------------------\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",
    "            #-------------------------------------------------------------------------------------------------------------------------------\n",
    "            # EVALUATIONS OF ALGORITHM\n",
    "            #-------------------------------------------------------------------------------------------------------------------------------\n",
    "            cons.timer.startTimeEvaluation()\n",
    "            \n",
    "            #-------------------------------------------------------\n",
    "            # TRACK LEARNING ESTIMATES\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",
    "                self.learnTrackOut.write(self.population.getPopTrack(trackedAccuracy, self.exploreIter+1,cons.trackingFrequency)) #Report learning progress to standard out and tracking file.\n",
    "            cons.timer.stopTimeEvaluation()\n",
    "            \n",
    "            #-------------------------------------------------------\n",
    "            # CHECKPOINT - COMPLETE EVALUTATION OF POPULATION - strategy different for discrete vs continuous phenotypes\n",
    "            #-------------------------------------------------------\n",
    "            if (self.exploreIter + 1) in cons.learningCheckpoints:\n",
    "                cons.timer.startTimeEvaluation()\n",
    "                print(\"------------------------------------------------------------------------------------------------------------------------------------------------------\")\n",
    "                print(\"Running Population Evaluation after \" + str(self.exploreIter + 1)+ \" iterations.\")\n",
    "                \n",
    "                self.population.runPopAveEval(self.exploreIter)\n",
    "                self.population.runAttGeneralitySum(True)\n",
    "                cons.env.startEvaluationMode()  #Preserves learning position in training data\n",
    "                if cons.testFile != 'None': #If a testing file is available.\n",
    "                    if cons.env.formatData.discretePhenotype: \n",
    "                        trainEval = self.doPopEvaluation(True)\n",
    "                        testEval = self.doPopEvaluation(False)\n",
    "                    else: \n",
    "                        trainEval = self.doContPopEvaluation(True)\n",
    "                        testEval = self.doContPopEvaluation(False)\n",
    "                else:  #Only a training file is available\n",
    "                    if cons.env.formatData.discretePhenotype: \n",
    "                        trainEval = self.doPopEvaluation(True)\n",
    "                        testEval = None\n",
    "                    else: \n",
    "                        trainEval = self.doContPopEvaluation(True)\n",
    "                        testEval = None\n",
    "\n",
    "                cons.env.stopEvaluationMode() #Returns to learning position in training data\n",
    "                cons.timer.stopTimeEvaluation()\n",
    "                cons.timer.returnGlobalTimer() \n",
    "                    \n",
    "                #Write output files----------------------------------------------------------------------------------------------------------\n",
    "                OutputFileManager().writePopStats(cons.outFileName, trainEval, testEval, 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",
    "        # Once eLCS has reached the last learning iteration, close the tracking file \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. \"\"\"        #WnB\n",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\n",
    "        # FORM A MATCH SET - includes covering\n",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\n",
    "        self.population.makeMatchSet(state_phenotype, exploreIter)\n",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\n",
    "        # MAKE A PREDICTION - utilized here for tracking estimated learning progress.  Typically used in the explore phase of many LCS algorithms.\n",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\n",
    "        cons.timer.startTimeEvaluation() \n",
    "        prediction = Prediction(self.population)\n",
    "        phenotypePrediction = prediction.getDecision()  \n",
    "        #-------------------------------------------------------\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",
    "            #-------------------------------------------------------\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",
    "            #-------------------------------------------------------\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",
    "        cons.timer.stopTimeEvaluation()\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",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\n",
    "        # SUBSUMPTION - APPLIED TO CORRECT SET - A heuristic for addition additional generalization pressure to eLCS\n",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\n",
    "        if cons.doSubsumption:\n",
    "            cons.timer.startTimeSubsumption()\n",
    "            self.population.doCorrectSetSubsumption()\n",
    "            cons.timer.stopTimeSubsumption()\n",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\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",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\n",
    "        # SELECT RULES FOR DELETION - This is done whenever there are more rules in the population than 'N', the maximum population size.\n",
    "        #-----------------------------------------------------------------------------------------------------------------------------------------\n",
    "        self.population.deletion(exploreIter)\n",
    "        self.population.clearSets() #Clears the match and correct sets for the next learning iteration\n",
    "      \n",
    "    def doPopEvaluation(self, isTrain):\n",
    "        \"\"\" Performs a complete evaluation of the current rule population.  The population is unchanged throughout this evaluation. Works on both training and testing data. \"\"\"\n",
    "        if isTrain:\n",
    "            myType = \"TRAINING\"\n",
    "        else:\n",
    "            myType = \"TESTING\"\n",
    "        noMatch = 0                     # How often does the population fail to have a classifier that matches an instance in the data.\n",
    "        tie = 0                         # How often can the algorithm not make a decision between classes due to a tie.\n",
    "        cons.env.resetDataRef(isTrain)  # Go to the first instance in dataset\n",
    "        phenotypeList = cons.env.formatData.phenotypeList \n",
    "        #----------------------------------------------\n",
    "        classAccDict = {}\n",
    "        for each in phenotypeList:\n",
    "            classAccDict[each] = ClassAccuracy()\n",
    "        #----------------------------------------------\n",
    "        if isTrain:\n",
    "            instances = cons.env.formatData.numTrainInstances\n",
    "        else:\n",
    "            instances = cons.env.formatData.numTestInstances\n",
    "        #----------------------------------------------------------------------------------------------\n",
    "        for inst in range(instances):\n",
    "            if isTrain:\n",
    "                state_phenotype = cons.env.getTrainInstance()\n",
    "            else:\n",
    "                state_phenotype = cons.env.getTestInstance()\n",
    "            #-----------------------------------------------------------------------------\n",
    "            self.population.makeEvalMatchSet(state_phenotype[0])\n",
    "            prediction = Prediction(self.population)\n",
    "            phenotypeSelection = prediction.getDecision() \n",
    "            #-----------------------------------------------------------------------------\n",
    "            \n",
    "            if phenotypeSelection == None: \n",
    "                noMatch += 1\n",
    "            elif phenotypeSelection == 'Tie':\n",
    "                tie += 1\n",
    "            else: #Instances which failed to be covered are excluded from the accuracy calculation \n",
    "                for each in phenotypeList:\n",
    "                    thisIsMe = False\n",
    "                    accuratePhenotype = False\n",
    "                    truePhenotype = state_phenotype[1]\n",
    "                    if each == truePhenotype:\n",
    "                        thisIsMe = True \n",
    "                    if phenotypeSelection == truePhenotype:\n",
    "                        accuratePhenotype = True\n",
    "                    classAccDict[each].updateAccuracy(thisIsMe, accuratePhenotype)\n",
    "                        \n",
    "            cons.env.newInstance(isTrain) #next instance\n",
    "            self.population.clearSets() \n",
    "        #----------------------------------------------------------------------------------------------\n",
    "        #Calculate Standard Accuracy--------------------------------------------\n",
    "        instancesCorrectlyClassified = classAccDict[phenotypeList[0]].T_myClass + classAccDict[phenotypeList[0]].T_otherClass  \n",
    "        instancesIncorrectlyClassified = classAccDict[phenotypeList[0]].F_myClass + classAccDict[phenotypeList[0]].F_otherClass \n",
    "        standardAccuracy = float(instancesCorrectlyClassified) / float(instancesCorrectlyClassified + instancesIncorrectlyClassified)\n",
    "\n",
    "        #Calculate Balanced Accuracy---------------------------------------------\n",
    "        T_mySum = 0\n",
    "        T_otherSum = 0\n",
    "        F_mySum = 0\n",
    "        F_otherSum = 0\n",
    "        for each in phenotypeList: \n",
    "            T_mySum += classAccDict[each].T_myClass\n",
    "            T_otherSum += classAccDict[each].T_otherClass\n",
    "            F_mySum += classAccDict[each].F_myClass\n",
    "            F_otherSum += classAccDict[each].F_otherClass\n",
    "        balancedAccuracy = ((0.5*T_mySum / (float(T_mySum + F_otherSum)) + 0.5*T_otherSum / (float(T_otherSum + F_mySum)))) # BalancedAccuracy = (Specificity + Sensitivity)/2\n",
    "\n",
    "        #Adjustment for uncovered instances - to avoid positive or negative bias we incorporate the probability of guessing a phenotype by chance (e.g. 50% if two phenotypes)\n",
    "        predictionFail = float(noMatch)/float(instances)\n",
    "        predictionTies = float(tie)/float(instances)\n",
    "        instanceCoverage = 1.0 - predictionFail\n",
    "        predictionMade = 1.0 - (predictionFail + predictionTies)\n",
    "        \n",
    "        adjustedStandardAccuracy = (standardAccuracy * predictionMade) + ((1.0 - predictionMade) * (1.0 / float(len(phenotypeList))))\n",
    "        adjustedBalancedAccuracy = (balancedAccuracy * predictionMade) + ((1.0 - predictionMade) * (1.0 / float(len(phenotypeList))))\n",
    "        \n",
    "        #Adjusted Balanced Accuracy is calculated such that instances that did not match have a consistent probability of being correctly classified in the reported accuracy.\n",
    "        print(\"-----------------------------------------------\")\n",
    "        print(str(myType)+\" Accuracy Results:-------------\")\n",
    "        print(\"Instance Coverage = \"+ str(instanceCoverage*100.0)+ '%')\n",
    "        print(\"Prediction Ties = \"+ str(predictionTies*100.0)+ '%')\n",
    "        print(str(instancesCorrectlyClassified) + ' out of ' + str(instances) + ' instances covered and correctly classified.')\n",
    "        print(\"Standard Accuracy (Adjusted) = \" + str(adjustedStandardAccuracy))\n",
    "        print(\"Balanced Accuracy (Adjusted) = \" + str(adjustedBalancedAccuracy))\n",
    "        #Balanced and Standard Accuracies will only be the same when there are equal instances representative of each phenotype AND there is 100% covering.\n",
    "        resultList = [adjustedBalancedAccuracy, instanceCoverage]  \n",
    "        return resultList\n",
    "        \n",
    "    \n",
    "    def doContPopEvaluation(self, isTrain):\n",
    "        \"\"\" Performs evaluation of population via the copied environment. Specifically developed for continuous phenotype evaulation.  \n",
    "        The population is maintained unchanging throughout the evaluation.  Works on both training and testing data. \"\"\"\n",
    "        if isTrain:\n",
    "            myType = \"TRAINING\"\n",
    "        else:\n",
    "            myType = \"TESTING\"\n",
    "        noMatch = 0 #How often does the population fail to have a classifier that matches an instance in the data.\n",
    "        cons.env.resetDataRef(isTrain) #Go to first instance in data set\n",
    "        accuracyEstimateSum = 0\n",
    "\n",
    "        if isTrain:\n",
    "            instances = cons.env.formatData.numTrainInstances\n",
    "        else:\n",
    "            instances = cons.env.formatData.numTestInstances\n",
    "        #----------------------------------------------------------------------------------------------\n",
    "        for inst in range(instances):\n",
    "            if isTrain:\n",
    "                state_phenotype = cons.env.getTrainInstance()\n",
    "            else:\n",
    "                state_phenotype = cons.env.getTestInstance()\n",
    "            #-----------------------------------------------------------------------------\n",
    "            self.population.makeEvalMatchSet(state_phenotype[0])\n",
    "            prediction = Prediction(self.population)\n",
    "            phenotypePrediction = prediction.getDecision() \n",
    "            #-----------------------------------------------------------------------------\n",
    "            if phenotypePrediction == None: \n",
    "                noMatch += 1\n",
    "            else: #Instances which failed to be covered are excluded from the initial accuracy calculation\n",
    "                predictionError = math.fabs(float(phenotypePrediction) - float(state_phenotype[1]))\n",
    "                phenotypeRange = cons.env.formatData.phenotypeList[1] - cons.env.formatData.phenotypeList[0]\n",
    "                accuracyEstimateSum += 1.0 - (predictionError / float(phenotypeRange))\n",
    "                           \n",
    "            cons.env.newInstance(isTrain) #next instance\n",
    "            self.population.clearSets() \n",
    "        #----------------------------------------------------------------------------------------------\n",
    "        #Accuracy Estimate\n",
    "        if instances == noMatch:\n",
    "            accuracyEstimate = 0\n",
    "        else:\n",
    "            accuracyEstimate = accuracyEstimateSum / float(instances - noMatch)\n",
    "        \n",
    "        #Adjustment for uncovered instances - to avoid positive or negative bias we incorporate the probability of guessing a phenotype by chance (e.g. 50% if two phenotypes)\n",
    "        instanceCoverage = 1.0 - (float(noMatch)/float(instances))\n",
    "        adjustedAccuracyEstimate = accuracyEstimateSum / float(instances) #noMatchs are treated as incorrect predictions (can see no other fair way to do this)\n",
    "\n",
    "        print(\"-----------------------------------------------\")\n",
    "        print(str(myType)+\" Accuracy Results:-------------\")\n",
    "        print(\"Instance Coverage = \"+ str(instanceCoverage*100.0)+ '%')\n",
    "        print(\"Estimated Prediction Accuracy (Ignore uncovered) = \" + str(accuracyEstimate))\n",
    "        print(\"Estimated Prediction Accuracy (Penalty uncovered) = \" + str(adjustedAccuracyEstimate))\n",
    "        #Balanced and Standard Accuracies will only be the same when there are equal instances representative of each phenotype AND there is 100% covering.\n",
    "        resultList = [adjustedAccuracyEstimate, instanceCoverage]  \n",
    "        return resultList\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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Output file manager"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "hideCode": true
   },
   "outputs": [],
   "source": [
    "\n",
    "class OutputFileManager:     \n",
    "    def writePopStats(self, outFile, trainEval, testEval, 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(\"Performance Statistics:------------------------------------------------------------------------\\n\")\n",
    "        popStatsOut.write(\"Training Accuracy\\tTesting Accuracy\\tTraining Coverage\\tTesting Coverage\\n\")\n",
    "        \n",
    "        if cons.testFile != 'None':\n",
    "            popStatsOut.write(str(trainEval[0])+\"\\t\")\n",
    "            popStatsOut.write(str(testEval[0])+\"\\t\")\n",
    "            popStatsOut.write(str(trainEval[1]) +\"\\t\")\n",
    "            popStatsOut.write(str(testEval[1])+\"\\n\\n\") \n",
    "        elif cons.trainFile != 'None':\n",
    "            popStatsOut.write(str(trainEval[0])+\"\\t\")\n",
    "            popStatsOut.write(\"NA\\t\")\n",
    "            popStatsOut.write(str(trainEval[1]) +\"\\t\")\n",
    "            popStatsOut.write(\"NA\\n\\n\")\n",
    "        else:\n",
    "            popStatsOut.write(\"NA\\t\")\n",
    "            popStatsOut.write(\"NA\\t\")\n",
    "            popStatsOut.write(\"NA\\t\")\n",
    "            popStatsOut.write(\"NA\\n\\n\")\n",
    "        \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(\"%.2f\" %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",
    "        #Time Track ---------------------------------------------------------------------------------------------------------     \n",
    "        popStatsOut.write(\"\\nRun Time(in minutes):------------------------------------------------------------------------\\n\") \n",
    "        popStatsOut.write(cons.timer.reportTimes())\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": [
    "Actually RUN the eLCS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "hideCode": true,
    "scrolled": true
   },
   "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: 1 count = 32\n",
      "Class: 0 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, 6000]\n",
      "Maximum Iterations: 6000\n",
      "Beginning eLCS learning iterations.\n",
      "------------------------------------------------------------------------------------------------------------------------------------------------------\n",
      "Epoch: 1\t Iteration: 100\t MacroPop: 27\t MicroPop: 33\t AccEstimate: 0.67\t AveGen: 0.45\t Time: 0.00\n",
      "Epoch: 2\t Iteration: 200\t MacroPop: 41\t MicroPop: 57\t AccEstimate: 0.8\t AveGen: 0.39\t Time: 0.00\n",
      "Epoch: 3\t Iteration: 300\t MacroPop: 56\t MicroPop: 87\t AccEstimate: 0.78\t AveGen: 0.35\t Time: 0.00\n",
      "Epoch: 4\t Iteration: 400\t MacroPop: 59\t MicroPop: 109\t AccEstimate: 0.85\t AveGen: 0.32\t Time: 0.00\n",
      "Epoch: 5\t Iteration: 500\t MacroPop: 71\t MicroPop: 135\t AccEstimate: 0.83\t AveGen: 0.30\t Time: 0.00\n",
      "Epoch: 6\t Iteration: 600\t MacroPop: 84\t MicroPop: 165\t AccEstimate: 0.83\t AveGen: 0.29\t Time: 0.01\n",
      "Epoch: 7\t Iteration: 700\t MacroPop: 91\t MicroPop: 183\t AccEstimate: 0.88\t AveGen: 0.28\t Time: 0.01\n",
      "Epoch: 8\t Iteration: 800\t MacroPop: 103\t MicroPop: 216\t AccEstimate: 0.86\t AveGen: 0.26\t Time: 0.01\n",
      "Epoch: 9\t Iteration: 900\t MacroPop: 111\t MicroPop: 248\t AccEstimate: 0.91\t AveGen: 0.25\t Time: 0.01\n",
      "Epoch: 10\t Iteration: 1000\t MacroPop: 114\t MicroPop: 276\t AccEstimate: 0.86\t AveGen: 0.23\t Time: 0.01\n",
      "------------------------------------------------------------------------------------------------------------------------------------------------------\n",
      "Running Population Evaluation after 1000 iterations.\n",
      "-----------------------------------------------\n",
      "TRAINING Accuracy Results:-------------\n",
      "Instance Coverage = 100.0%\n",
      "Prediction Ties = 0.0%\n",
      "56 out of 64 instances covered and correctly classified.\n",
      "Standard Accuracy (Adjusted) = 0.875\n",
      "Balanced Accuracy (Adjusted) = 0.875\n",
      "Writing Population Statistical Summary File...\n",
      "Writing Population as Data File...\n",
      "Continue Learning...\n",
      "------------------------------------------------------------------------------------------------------------------------------------------------------\n",
      "Epoch: 11\t Iteration: 1100\t MacroPop: 126\t MicroPop: 308\t AccEstimate: 0.92\t AveGen: 0.23\t Time: 0.02\n",
      "Epoch: 12\t Iteration: 1200\t MacroPop: 126\t MicroPop: 326\t AccEstimate: 0.92\t AveGen: 0.22\t Time: 0.02\n",
      "Epoch: 13\t Iteration: 1300\t MacroPop: 132\t MicroPop: 362\t AccEstimate: 0.92\t AveGen: 0.20\t Time: 0.02\n",
      "Epoch: 14\t Iteration: 1400\t MacroPop: 142\t MicroPop: 390\t AccEstimate: 0.92\t AveGen: 0.20\t Time: 0.02\n",
      "Epoch: 15\t Iteration: 1500\t MacroPop: 151\t MicroPop: 418\t AccEstimate: 0.91\t AveGen: 0.20\t Time: 0.02\n",
      "Epoch: 16\t Iteration: 1600\t MacroPop: 155\t MicroPop: 448\t AccEstimate: 0.93\t AveGen: 0.19\t Time: 0.02\n",
      "Epoch: 17\t Iteration: 1700\t MacroPop: 164\t MicroPop: 484\t AccEstimate: 0.91\t AveGen: 0.19\t Time: 0.03\n",
      "Epoch: 18\t Iteration: 1800\t MacroPop: 172\t MicroPop: 509\t AccEstimate: 0.93\t AveGen: 0.19\t Time: 0.03\n",
      "Epoch: 19\t Iteration: 1900\t MacroPop: 175\t MicroPop: 543\t AccEstimate: 0.94\t AveGen: 0.18\t Time: 0.03\n",
      "Epoch: 20\t Iteration: 2000\t MacroPop: 182\t MicroPop: 575\t AccEstimate: 0.96\t AveGen: 0.18\t Time: 0.03\n",
      "Epoch: 21\t Iteration: 2100\t MacroPop: 185\t MicroPop: 599\t AccEstimate: 0.96\t AveGen: 0.17\t Time: 0.04\n",
      "Epoch: 22\t Iteration: 2200\t MacroPop: 187\t MicroPop: 622\t AccEstimate: 0.97\t AveGen: 0.17\t Time: 0.04\n",
      "Epoch: 23\t Iteration: 2300\t MacroPop: 190\t MicroPop: 642\t AccEstimate: 0.99\t AveGen: 0.16\t Time: 0.04\n",
      "Epoch: 24\t Iteration: 2400\t MacroPop: 192\t MicroPop: 670\t AccEstimate: 0.98\t AveGen: 0.16\t Time: 0.04\n",
      "Epoch: 25\t Iteration: 2500\t MacroPop: 197\t MicroPop: 694\t AccEstimate: 0.99\t AveGen: 0.16\t Time: 0.05\n",
      "Epoch: 26\t Iteration: 2600\t MacroPop: 202\t MicroPop: 724\t AccEstimate: 0.98\t AveGen: 0.16\t Time: 0.05\n",
      "Epoch: 27\t Iteration: 2700\t MacroPop: 207\t MicroPop: 752\t AccEstimate: 1.0\t AveGen: 0.15\t Time: 0.05\n",
      "Epoch: 28\t Iteration: 2800\t MacroPop: 211\t MicroPop: 786\t AccEstimate: 1.0\t AveGen: 0.15\t Time: 0.06\n",
      "Epoch: 29\t Iteration: 2900\t MacroPop: 219\t MicroPop: 814\t AccEstimate: 1.0\t AveGen: 0.15\t Time: 0.06\n",
      "Epoch: 30\t Iteration: 3000\t MacroPop: 220\t MicroPop: 840\t AccEstimate: 1.0\t AveGen: 0.15\t Time: 0.07\n",
      "Epoch: 31\t Iteration: 3100\t MacroPop: 225\t MicroPop: 876\t AccEstimate: 1.0\t AveGen: 0.14\t Time: 0.07\n",
      "Epoch: 32\t Iteration: 3200\t MacroPop: 226\t MicroPop: 902\t AccEstimate: 1.0\t AveGen: 0.14\t Time: 0.08\n",
      "Epoch: 33\t Iteration: 3300\t MacroPop: 233\t MicroPop: 930\t AccEstimate: 1.0\t AveGen: 0.14\t Time: 0.08\n",
      "Epoch: 34\t Iteration: 3400\t MacroPop: 235\t MicroPop: 952\t AccEstimate: 1.0\t AveGen: 0.14\t Time: 0.09\n",
      "Epoch: 35\t Iteration: 3500\t MacroPop: 241\t MicroPop: 986\t AccEstimate: 1.0\t AveGen: 0.13\t Time: 0.09\n",
      "Epoch: 36\t Iteration: 3600\t MacroPop: 242\t MicroPop: 1000\t AccEstimate: 1.0\t AveGen: 0.13\t Time: 0.09\n",
      "Epoch: 37\t Iteration: 3700\t MacroPop: 237\t MicroPop: 1000\t AccEstimate: 1.0\t AveGen: 0.13\t Time: 0.10\n",
      "Epoch: 38\t Iteration: 3800\t MacroPop: 231\t MicroPop: 1000\t AccEstimate: 1.0\t AveGen: 0.12\t Time: 0.10\n",
      "Epoch: 39\t Iteration: 3900\t MacroPop: 224\t MicroPop: 1000\t AccEstimate: 1.0\t AveGen: 0.12\t Time: 0.11\n",
      "Epoch: 40\t Iteration: 4000\t MacroPop: 224\t MicroPop: 1000\t AccEstimate: 1.0\t AveGen: 0.12\t Time: 0.11"
     ]
    }
   ],
   "source": [
    "#Initialize the 'Timer' module which tracks the run time of algorithm and it's different components.\n",
    "timer = Timer() \n",
    "cons.referenceTimer(timer)\n",
    "\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": "markdown",
   "metadata": {},
   "source": [
    "Plot diagrams of Average population and Pop size, and Accuracy per generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "hideCode": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\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[1] for row in datasetList]  \n",
    "c = [row[2] for row in datasetList]  \n",
    "d = [row[3] for row in datasetList]  \n",
    "e = [row[4] for row in datasetList]  \n",
    "    \n",
    "# Create plots with pre-defined labels.\n",
    "plt.figure(1)  \n",
    "plt.plot(a, b, 'k--', label=headerList[1] )\n",
    "plt.plot(a, c, 'k:', label=headerList[2])\n",
    "plt.xlabel(headerList[0])\n",
    "legend = plt.legend(loc='center', shadow=True, fontsize='large')\n",
    "\n",
    "plt.figure(2)  \n",
    "plt.plot(a, d, 'k--', label=headerList[3] )\n",
    "plt.plot(a, e, 'k:', label=headerList[4])\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()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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
}