|
CARLsim
3.1.3
CARLsim: a GPU-accelerated SNN simulator
|
|
CARLsim
3.1.3
CARLsim: a GPU-accelerated SNN simulator
|
CARLsim now has a software interface to an evolutionary computation system written in Java (ECJ) (Luke et al., 2006) to provide an automated parameter tuning framework. We found that an automated tuning framework became increasingly useful as our SNN models became more complex. Evolutionary Algorithms (EAs) enable flexible parameter tuning by means of optimizing a generic fitness function. The first version of the automated parameter-tuning framework used an EA library called Evolving Objects (EO) as the EA engine (Carlson et al., 2014). ECJ was chosen to supercede EO because it is under active development (Linux), supports multi-threading, has excellent documentation, and implements a variety of EAs (Luke at al., 2006).
Source: Beyeler et al., 2015
Fig. 1 shows the general approach of the automated parameter tuning framework. ECJ implements an EA with a parameter file that includes: EA parameters, the number of individuals per generation, and parameter ranges. Each step of the EA is executed by ECJ except for the evaluation of the fitness function, which is completed by CARLsim. CARLsim evaluates the fitness function in parallel by running multiple SNN individuals simultaneously on the GPU, where the bulk of the computations occur. The majority of the execution time is spent running CARLsim’s optimized C++/CUDA code, and the overhead created by ECJ's operations is negligible.
PTI consists of two components which serve to define a standard interface for executing CARLsim models with ECJ. On the C++ side, PTI provides a small library that helps load a population of parameter vectors, and provides a standard mechanism for returning information about their performance (such as a fitness value) after the simulation has completed. On the ECJ side, PTI provides a Jar file with a number of ECJ extensions. These extensions allow ECJ to easily invoke and communicate with an external simulator when an evolutionary algorithm is launched. Communcation between the ECJ process and the simulator processes it launches is effected automatically via standard UNIX input/output streams.
In a typical usage scenario, at the beginning of every generation of the evolutionary algorithm, the parameters to be tuned are passed from ECJ to an SNN model that has been implemented in CARLsim, and which uses the PTI interface to define its input-output behavior. The model evaluates individuals in parallel and returns the resulting fitness values to ECJ via standard streams. The tuning framework allows users to tune virtually any SNN parameter, while the fitness functions can be written to depend on the neuronal activity or synaptic weights of the SNN.
The current version of the CARLsim paramter-tuning interface (PTI) uses Evolutionary Computations in Java (ECJ) (version 22 or greater is required). For information on how to install ECJ, please go here.
After ECJ version 22 or greater has been installed the user then needs to set the ECJ_JAR and ECJ_PTI_DIR environment variables in either the .bashrc file or the user.mk file located in the tools/ecj_pti subdirectory. The ECJ_JAR environment variable points to the current installation location of the ECJ jar file. The ECJ_PTI_DIR environment variable points to the desired location of the CARLsim-ECJ PTI code. The code below shows the default values that can be changed in the user.mk file:
As an alternative, users can set these environment variables in their .bashrc files if they are using a Unix-like OS. The following lines would be appended to .bashrc.
Once the environment variables have been set. Navigate to tools/ecj_pti and run:
This will install the CARLsim-ECJ PTI library into the location pointed to by ECJ_PTI_DIR. Both the static C++ library and the Jar with the Java extensions for ECJ will be installed in this directory.
To operate an evolutionary algorithm with ECJ, users define a parameter file that details all the algorithm components, parameters, and data-logging mechanisms that will go into the experiment. Creating experiments in this way is a form of declarative programming or inversion of control. This paradigm offers a great deal of flexibility and makes automation of experiments easy in many ways, but it can have a steep learning curve for users who aren't accustomed to programming in this way.
A thorough introduction to using ECJ and its parameter language is beyond the scope of CARLsim's documentation. We encourage CARLsim users to make use of the ECJ tutorials and the fantastic manual that Sean Luke maintains over on the ECJ website.
In general, to use the CARLsim-ECJ PTI, users will create an SNN modeled after the tutorial program found in Tutorial 7: Parameter Tuning Interface (PTI). This program is responsible for reading a collection of parameters, instantiating a number of neural networks, executing them, and returning information about the behavior of each parameterized network (typically a scalar fitness value).
The user then must configure an ECJ parameter file defining the evolutionary search mechanism that will be used to search the parameter space for high-performing network configurations. Here we give a few relevant parts of an example parameter file that you may customize to your own purposes:
It's probably easiest to start with this ECJ parameter file and modify it to your project's needs. The particular variables the user needs to edit are:
eval.problem.simulationCommand: which is the name of the carlsim binary ECJ executes every generation to evaluate the fitness function. The $ sign means the path is relative to the location of the parameter file.
generations: number of maximum generations to run.
pop.subpop.0.size: number of individuals in each generation.
pop.subpop.0.species.genome-size: total number of parameters to be tuned in each individual.
pop.subpop.0.species.min-gene: default minimum range value for all parameters to be tuned
pop.subpop.0.species.max-gene: default maximum range value for all parameters to be tuned
To specify the parameter range for each parameter individually, you define min-gene and max.gene values for additional pop.subpop members as is shown in the code below:
However,you still need to keep the pop.subpop.0.species.min-gene and pop.subpop.0.species.max-gene in the parameter file.
for more information about the ECJ configuration file, please visit the ECJ homepage.
Users then need to implement their own CARLsim evaluation function. The overall structure is as follows. A specific Experiment class is implemented and inherited from the base Experiment class:
The only class functions functions are the default class constructor and the run function. The run function is where CARLsim code is written and executed. At the final step, the fitness values are output back to ECJ using standard Linux streams.
Most of what you need to know to write an ECJ parameter file is covered in the ECJ manual. PTI does add some non-standard extensions to ECJ, however, which can be used by setting parameters appropriately. This section serves as the canonical reference for these extensions.
The core extention that PTI adds to ECJ is a mechanism that allows us to evaluate multiple individuals via a single call to an external simulator. This allows us to, for instance, execute multiple individuals in parallel on a GPU (something that is not possible with ECJ's built-in mechanisms).
To use PTI's grouped evaluation feature, set the eval parameter in the ECJ parameter file like so:
The SimpleGroupedEvaluator class is a version of ECJ's SimpleEvaluator that has been modified so that individuals are evaluated in batches. It accepts the following additional parameters:
eval.chunk-size (optional):eval.measureEvalTimes (optional):true, the number of milliseconds that elapse between generations will be printed. The output is in CSV format. Each row shows the job number, generation, and milliseconds, in that order.eval.evalTimesFile (optional):measureEvalTimes mechanism will be written to this file instead of to stdout.SimpleGroupedEvaluator also responds to the same parameters as SimpleEvaluator, such as num-tests and, importantly, problem (see the ECJ manual).
In ECJ, objective functions are defined by custom implementations of the Problem class. The CARLsim-ECJ jar file includes a special Problem that is meant to be used in conjunction with SimpleGroupedEvaluator to launch an external simulator. This is called CommandProblem, since it launches an external command:
This object accepts a number of crucially important parameters:
eval.problem.simulationCommand:eval.problem.errorGenesFile:eval.problem.errorResultsFile:eval.problem.objective:ObjectiveFunction that is used to convert the output of the external simulation into a scalar fitness value (See 10.4.3 ObjectiveFunction).eval.problem.simulationCommandArguments (optional):eval.problem.dynamicArguments (optional):DynamicArguments for passing information about the evolutionary algorithm's state to the external simulation as command-line arguments (See 10.4.4 DynamicArguments and Multi-GPU Evolution).eval.problem.reevaluate (optional):true, individuals will have their fitness re-evaluated each generation. You may want to reevaluate fitnesses if there is noise in your objective function, for instance. Defaults to false.In some applications, it's useful to think of the external simulator as performing a genotype-to-phenotype mapping: the genotype of each individual (a vector of parameters) is mapped to a phenotype that describes the resulting behavior of the simulation. An ObjectiveFunction in PTI's extension of ECJ performs the final step of converting the phenotype value into a scalar fitness value.
Preferably, the phenotype returned by the simulator is just a single scalar value: the individual's fitness. In CARLsim models, this means that we expect any extraction of features or other data from the SNN execution, and its synthesis into a fitness value, to be performed in the C++ model implementation.
When this is the case, the StringToDoubleObjective object allows ECJ to recognize the output of your model as a stream of fitness values:
This objective accepts one optional parameter:
eval.problem.objective.idealFitnessValue (optional):There may be some cases where you wish to perform some post-processing in Java to convert more complex information on a network's behavior into a fitness value. If this is the case, then you may create your own ECJ extention by defining a subclass of ObjectiveFunction. Creating custom classes and using them with ECJ is beyond the scope of this documentation, however.
In some applications, your CARLsim model may need to know some specific information about the evolutionary algorithm state, beyond the genomes of individuals. In PTI's ECJ extension, a DynamicArguments object plays the role of taking data from variables in ECJ and sending it to the simulator as command-line arguments.
One important use of DynamicArguments is to invoke different simultaneous CARLsim instances on different GPU cards. The ThreadDynamicArguments object makes this possible by passing a thread ID to each instance of the simulator that is launched in a generation.
Say, for example, that your evolutionary algorithm produces 100 children, but that you can only evaluated 50 individuals at a time in your simulation. If you have set eval.chunk-size = 50, and if you have configured ECJ to use 2 evaluation threads, then two threads will be launched, each of which will send its 50 individuals to your CARLsim model to be evaluated on a GPU. ThreadDynamicArguments will assign one of these simulations a thread ID of 0, and the other one a thread ID of 1.
The following parameters are available when using this mechanism:
eval.problem.dynamicArguments.option:eval.problem.dynamicArguments.modulo (optional):eval.problem.dynamicArguments.dynamicArguments (optional):DynamicArguments object. Use this if you want to chain arguments together to pass more information to the simulator.If, for instance, option is set to '-device', then the simulator launched by thread 1 will have the argument '-device 1' passed to it as a command-line option.
PTI's ECJ extension also includes a DynamicArguments for telling the simulator what generation the evolutionary algorithm is on:
It accepts the following parameters:
eval.problem.dynamicArguments.option:eval.problem.dynamicArguments.dynamicArguments (optional):DynamicArguments object. Use this if you want to chain arguments together to pass more information to the simulator.By default, ECJ produces an out.stat file that records the genome and fitness of the best individual in each generation, and of the best individual from the entire run. When it comes time to analyze the results of an EA, this file can be difficult to parse, and it may not contain all the information you need.
PTI's extension provides two addition ECJ Statistics objects that you may use to collect and store commonly-needed EA data in CSV format: ecjapp.statistics.FitnessStatistics and ecjapp.statistics.DoubleVectorGenomeStatistics.
To add a Statistics class to an EA configuration, we add them as children of the default stat object. To do so, first specify the number of children you wish to add, and then define the parameters for each child. In the following example we configure ECJ to collect both FitnessStatistics and DoubleVectorGenomeStatistics.
FitnessStatistics records the minimum, maximum, and average fitness, and the standard deviation of fitnesses in the entire population at each generation. It also records the time (in milliseconds) that each generation finished evaluating. Alternatively, FitnessStatistics can be used to record the fitness of every individual in the population (see the individuals option below).
The following parameters are available for configuring FitnessStatistics:
stat.child.0.file:jobs parameter), then the filename will be prefixed with 'job.[jobnumber].', and one file will be created for each job.stat.child.0.gzip (optional):gzip.stat.child.0.individuals (optional):DoubleVectorGenomeStatistics records the genome and fitness of all individuals in the population. The following parameters are available:
stat.child.1.filejobs parameter), then the filename will be prefixed with 'job.[jobnumber].', and one file will be created for each job.stat.child.1.pVectorLength:DoubleVectorGenomeStatistics how many parameter columns need to be in its output. Typically you'll want to point this to the genome-size parameter of your species.stat.child.1.compress (optional):gzip.stat.child.1.initOnly (optional):After running an evolutionary algorithm a number of times to tune a spiking neural network, we often wish to retrieve the best individual found in each run for further analysis. This can be done by examining the output recorded by DoubleVectorGenomeStatistics and finding the individual with the highest fitness.
Alternatively, the following shell script can be copied and pasted to automatically extract the best individual. It assumes that we have run ECJ for 10 jobs, and that the output of DoubleVectorGenomeStatistics has been written to files named 'job.[num].genomes.csv', where [num] ranges from 0 to 9:
Equally often, we want to run and analyze a simulation using high-fitness parameters that were found by ECJ.
Because PTI models use the stanard input stream to receive simulation parameters, you can always execute your simulation with any set of parameters by piping the vector of parameters into the simulation. For instance, if I want to use the parameters '0.1, 0.2, 0.3, 0.4, 0.5' to run a simulation whose binary is named 'carlsim_myModel', then I can do so like this:
Similarly, if I would like to run several networks in parallel with the same parameters, I can repeat the parameter vector several times:
Say that I have stored the best genome found from each run in a file, as described in the previous section. Perhaps my fitness evaluation is rather noisy, and I want to get a good estimate of the true expected fitness value of each job's best individual. With the following script, I can take 40 fitness samples from each job's best individual in parallel:
Beyeler, M., Carlson, K. D., Chou, T. S., Dutt, N., Krichmar, J. L., CARLsim 3: A user-friendly and highly optimized library for the creation of neurobiologically detailed spiking neural networks. (Submitted)
Carlson, K. D., Nageswaran, J. M., Dutt, N., Krichmar, J. L., An efficient automated parameter tuning framework for spiking neural networks, Front. Neurosci., vol. 8, no. 10, 2014.
Luke, S., Panait, L., Balan, G., Paus, S., Skolicki, Z., Bassett, J., Hubley, R., and Chircop, A., ECJ: A java-based evolutionary computation research system, http://cs.gmu.edu/eclab/projects/ecj, 2006.
1.8.11