public int chooseTerminalSymbol(EvolutionState state, int thread) {
int terminalChoice =
RandomChoice.pickFromDistribution(
cumulativeNormalizedTerminalWeights, state.random[thread].nextFloat(), CHECK_BOUNDARY);
// the value returned is the function index from 0 to number of functions ...
// need to get the index into the set of symbols
return terminals[terminalChoice];
}
/** Sets up all the GEPSymbolSet symbols, loading them from the parameter file. */
public void setup(
final EvolutionState state, final Parameter base, final Parameter def, GEPSpecies species) {
// Name of file with the terminal (variable) definitions and training values
String terminalFilename;
// Name of file with the test data values if specified
String testingTerminalFilename;
// keep track of the maximum arity of any function
maxArity = 0;
// What's my name? Don't really use this at this time ...
name = state.parameters.getString(base.push(P_NAME), def.push(P_NAME));
if (name == null || name.equals(""))
state.output.warning(
"No name was given for this GEP symbol set...not required at this time.",
base.push(P_NAME),
def.push(P_NAME));
// How many functions do I have?
numberOfFunctions =
state.parameters.getInt(base.push(P_FUNCTIONSIZE), def.push(P_FUNCTIONSIZE), 1);
numberOfSymbols = numberOfFunctions;
// How many terminals do I have? Check for a data file first ...
// if time series problem type and using raw time series data then
// number of terminals will be specified in the embedding dimension value
// provided in the parameter file
// else if a file specified
// get the 1st line of the file and count the fields in it (#terminals is number of fields
// minus
// the number of chromosomes/dependent variables)
// else
// use the number of terminals specified in the parameter file
terminalFilename =
state.parameters.getStringWithDefault(
base.push(P_TERMINALFILENAME), def.push(P_TERMINALFILENAME), "");
testingTerminalFilename =
state.parameters.getStringWithDefault(
base.push(P_TESTINGTERMINALFILENAME), def.push(P_TESTINGTERMINALFILENAME), "");
String terminalSymbolsfromFile[] = null;
CsvReader terminalFileCSV = null;
CsvReader testingTerminalFileCSV = null;
// Are we processing raw time series data?
boolean timeseriesWithRawDataValues =
species.problemType == GEPSpecies.PT_TIMESERIES && species.timeseriesEmbeddingDimension > 0;
if (!terminalFilename.equals("")) {
String defaultTerminalFileSeparator = ","; // default field separator is comma
try {
// allow for gzip files .... end with .gz or .gzip\
if (terminalFilename.endsWith(".gz") || terminalFilename.endsWith(".gzip")) {
terminalFileCSV =
new CsvReader(
(InputStream) (new GZIPInputStream(new FileInputStream(terminalFilename))),
Charset.forName("ISO-8859-1"));
// set terminal file name to be the one with gzip or gz removed from the end
if (terminalFilename.endsWith(".gz"))
terminalFilename = terminalFilename.substring(0, terminalFilename.length() - 3);
else terminalFilename = terminalFilename.substring(0, terminalFilename.length() - 5);
} else terminalFileCSV = new CsvReader(terminalFilename);
} catch (FileNotFoundException e) {
state.output.fatal(
"The file with terminal definitions and/or values ("
+ terminalFilename
+ ") could not be found",
base.push(P_TERMINALFILENAME),
def.push(P_TERMINALFILENAME));
} catch (IOException e) {
state.output.fatal(
"The file with terminal definitions and/or values ("
+ terminalFilename
+ ") could not be found or the expected GZIP file could nor be opened",
base.push(P_TERMINALFILENAME),
def.push(P_TERMINALFILENAME));
}
// if filename has extension .dat it is space delimited, if .csv (or anything else
// for that matter) it is comma delimited
// (separator can still be changed with the terminalfileseparator parameter)
if (terminalFilename.endsWith(".dat")) defaultTerminalFileSeparator = "space";
// if using a file for the terminals and their values then check for a non-default separator
String terminalFileSeparator =
state.parameters.getStringWithDefault(
base.push(P_TERMINALFILESEPARATOR),
def.push(P_TERMINALFILESEPARATOR),
defaultTerminalFileSeparator);
if (terminalFileSeparator.toLowerCase().equals("comma")) terminalFileSeparator = ",";
else if (terminalFileSeparator == "\\t" || terminalFileSeparator.toLowerCase().equals("tab"))
terminalFileSeparator = "\t";
else if (terminalFileSeparator == "space") terminalFileSeparator = " ";
terminalFileCSV.setDelimiter(terminalFileSeparator.charAt(0));
// let's check for a testing data file at this time as well .. if no file for
// names and training data no need to worry about this one.
if (!testingTerminalFilename.equals("")) {
try {
// allow for gzip files .... end with .gz or .gzip\
if (testingTerminalFilename.endsWith(".gz") || testingTerminalFilename.endsWith(".gzip"))
testingTerminalFileCSV =
new CsvReader(
(InputStream)
(new GZIPInputStream(new FileInputStream(testingTerminalFilename))),
Charset.forName("ISO-8859-1"));
else testingTerminalFileCSV = new CsvReader(testingTerminalFilename);
testingTerminalFileCSV.setDelimiter(terminalFileSeparator.charAt(0));
} catch (FileNotFoundException e) {
state.output.fatal(
"The file with testing data values ("
+ testingTerminalFilename
+ ") could not be found",
base.push(P_TERMINALFILENAME),
def.push(P_TERMINALFILENAME));
} catch (IOException e) {
state.output.fatal(
"The file with testing data values ("
+ terminalFilename
+ ") could not be found or the expected GZIP file could nor be opened",
base.push(P_TERMINALFILENAME),
def.push(P_TERMINALFILENAME));
}
}
}
if (timeseriesWithRawDataValues) numberOfTerminals = species.timeseriesEmbeddingDimension;
else if (terminalFileCSV != null) {
// get the terminal symbols for the independent and dependent variables
try {
terminalFileCSV.readHeaders();
terminalSymbolsfromFile = terminalFileCSV.getHeaders();
} catch (IOException e) {
state.output.fatal(
"The file with variable (terminal) definitions and values ("
+ terminalFilename
+ ") failed to read the headers"
+ e,
base.push(P_TERMINALFILENAME),
def.push(P_TERMINALFILENAME));
}
// 1 less for each dependent variable (number of chromosomes) at the end
numberOfTerminals = terminalSymbolsfromFile.length - species.numberOfChromosomes;
if (numberOfTerminals < 1)
state.output.fatal(
"The file with terminal definitions and data values ("
+ terminalFilename
+ ") has no independent variables specified in record 1",
base.push(P_TERMINALFILENAME),
def.push(P_TERMINALFILENAME));
// if using a file for the terminals and their values then check for a non-default separator
} else {
numberOfTerminals =
state.parameters.getInt(base.push(P_TERMINALSIZE), def.push(P_TERMINALSIZE), 1);
}
numberOfSymbols += numberOfTerminals;
if (numberOfSymbols < 1)
state.output.error(
"The GEPSymbolSet \"" + name + "\" have at least 1 terminal symbol defined.",
base.push(P_TERMINALSIZE),
def.push(P_TERMINALSIZE));
// add a special Symbol for constants if we are using them ... it will be added to the
// end of the array of symbols!
if (species.useConstants) {
numberOfTerminals++; // special constant terminal
numberOfSymbols++;
}
symbols = new GEPSymbol[numberOfSymbols];
int numberOfSymbolsWithoutConstantSymbol = numberOfSymbols;
if (species.useConstants) // add the constant terminal symbol to the end
{
symbols[numberOfSymbols - 1] = (GEPSymbol) (new GEPConstantTerminalSymbol());
symbols[numberOfSymbols - 1].id = numberOfSymbols - 1;
numberOfSymbolsWithoutConstantSymbol--;
}
Parameter pTerminal = base.push(P_TERMINAL);
Parameter pdefTerminal = def.push(P_TERMINAL);
Parameter pFunction = base.push(P_FUNCTION);
Parameter pdefFunction = def.push(P_FUNCTION);
// create hashtable of names of terminals and hash table with names of functions
// so we can easily check that they are not duplicates
Hashtable functionHT = new Hashtable();
Hashtable terminalHT = new Hashtable();
// process the functions
for (int x = 0; x < numberOfFunctions; x++) {
Parameter pp = pFunction.push("" + x);
Parameter ppdef = pdefFunction.push("" + x);
String function = state.parameters.getStringWithDefault(pp, ppdef, "");
if (function.equals("")) // no name for the function
state.output.fatal("Invalid function specifier: '" + function + "'", pp, ppdef);
// make sure not specifying the same function more than once
if (functionHT.get(function) != null)
state.output.fatal(
"Function '" + function + "' was specified more than once in list of function symbols");
else functionHT.put(function, function);
GEPFunctionSymbol fs = null;
try {
Class classDefinition = Class.forName(LOCATION_OF_FUNCTION_CLASSES + "." + function);
fs = (GEPFunctionSymbol) classDefinition.newInstance();
} catch (InstantiationException e) {
state.output.fatal(
"Unable to create GEPFunctionSymbol class for function '" + function + "'. " + e);
} catch (IllegalAccessException e) {
state.output.fatal(
"Unable to create GEPFunctionSymbol class for function '" + function + "' " + e);
} catch (ClassNotFoundException e) {
state.output.fatal(
"Unable to create GEPFunctionSymbol class for function '" + function + "' " + e);
}
// if using a logical function must be a logical problem
if (fs.isLogicalFunction() && (species.problemType != GEPSpecies.PT_LOGICAL))
state.output.fatal(
"Can only use logical functions with a logical problem type. Function "
+ function
+ " is a logical function.",
pp,
ppdef);
// if using a numerical function must be an non logical problem
if (!fs.isLogicalFunction() && (species.problemType == GEPSpecies.PT_LOGICAL))
state.output.fatal(
"Can only use logical functions with a non logical problem type. Function "
+ function
+ " is a numerical function.",
pp,
ppdef);
symbols[x] = (GEPSymbol) fs;
// symbols[x].setup(state, base);
if (fs.arity < 1) state.output.fatal("Arity must be > 0 for a GEPTerminalSymbol)", pp, ppdef);
symbols[x].id = x;
int weight =
state.parameters.getInt(pp.push(P_FUNCTIONWEIGHT), ppdef.push(P_FUNCTIONWEIGHT), 1);
if (weight < 1) {
state.output.warning(
"Weight for GEP Function must be > 0; defaulting to 1)",
pp.push(P_FUNCTIONWEIGHT),
ppdef.push(P_FUNCTIONWEIGHT));
weight = 1;
}
symbols[x].weight = weight;
if (symbols[x].arity > maxArity) maxArity = symbols[x].arity;
}
// process the terminals ... defined by default for timeseries data, in the
// CSV file if specified and not timeseries, or in the params file if neither of those.
for (int x = numberOfFunctions;
x < numberOfSymbolsWithoutConstantSymbol;
x++) { // load the terminal symbols
int index = x - numberOfFunctions;
String terminal = "";
if (timeseriesWithRawDataValues) {
// terminals get default names v0, v1, v2, v3, ... vn-1
terminal = "v" + index;
} else if (terminalFileCSV == null) // terminals defined in param file
{
Parameter pp = pTerminal.push("" + index);
Parameter ppdef = pdefTerminal.push("" + index);
terminal = state.parameters.getStringWithDefault(pp, ppdef, "");
} else { // terminals defined in CSV file
terminal = terminalSymbolsfromFile[index];
}
if (terminal.equals("")) // no name for the terminal
state.output.fatal("Invalid terminal specifier: '" + terminal + "' for terminal # " + index);
// make sure not specifying the same function more than once
if (terminalHT.get(terminal) != null)
state.output.fatal(
"Terminal symbol (indep var) '"
+ terminal
+ "' was specified more than once in list of terminal symbols (independent variables)");
else terminalHT.put(terminal, terminal);
GEPTerminalSymbol ts = new GEPTerminalSymbol(terminal, this);
symbols[x] = (GEPSymbol) ts;
// symbols[x].setup(state, base);
if (ts.arity != 0) // cannot happen
state.output.fatal("Arity must be exactly 0 for a GEPTerminalSymbol)");
symbols[x].id = x;
symbols[x].weight = 1; // all Terminal symbols have weight of 1
}
// must be at least 1 Terminal symbol in the SymbolSet.
// If not then the user didn't specify the terminals in the param file or in the data file
if (numberOfTerminals < 1)
state.output.fatal(
"Must be at least one Terminal Symbol in the set of GEPSymbols\n"
+ "Either did not specify the terminal symbols in the param file or\n"
+ "did not specify the appropriate data file with the terminals specified in the first line.");
// collect the id's (indices) of the terminal and function symbols that
// are in the set of symbols
terminals = new int[numberOfTerminals];
int terminalNum = 0;
functions = new int[numberOfFunctions];
int functionNum = 0;
for (int x = 0; x < numberOfSymbols; x++) {
if (symbols[x] instanceof GEPConstantTerminalSymbol) terminals[terminalNum++] = x;
else if (symbols[x] instanceof GEPTerminalSymbol) terminals[terminalNum++] = x;
else if (symbols[x] instanceof GEPFunctionSymbol) functions[functionNum++] = x;
}
// collect the weights for symbols and terminals and normalize and cumulate them.
// Then we can use these arrays to pick appropriate symbols or terminals according to
// their weights ... using the RandomChooser.PickFromDistribution
cumulativeNormalizedSymbolWeights = new float[numberOfSymbols];
cumulativeNormalizedTerminalWeights = new float[numberOfTerminals];
cumulativeNormalizedFunctionWeights = new float[numberOfFunctions];
int j = 0, k = 0;
for (int i = 0; i < numberOfSymbols; i++) {
float weight = (float) (symbols[i].weight);
cumulativeNormalizedSymbolWeights[i] = weight;
if (symbols[i] instanceof GEPTerminalSymbol
|| symbols[i] instanceof GEPConstantTerminalSymbol)
cumulativeNormalizedTerminalWeights[j++] = weight;
if (symbols[i] instanceof GEPFunctionSymbol)
cumulativeNormalizedFunctionWeights[k++] = weight;
}
RandomChoice.organizeDistribution(cumulativeNormalizedSymbolWeights);
RandomChoice.organizeDistribution(cumulativeNormalizedTerminalWeights);
RandomChoice.organizeDistribution(cumulativeNormalizedFunctionWeights);
// use the 2/3 rule if fewer functions else the 1/2 rule (don't count the constant
// terminal here)
if (numberOfFunctions < (numberOfTerminals - (species.useConstants ? 1 : 0)))
probabilityOfChoosingFunction = 2.0 / 3.0;
else probabilityOfChoosingFunction = 0.5;
// ... and finally get the training and testing data values for the terminals and dependent
// variable
// and put them into the Terminal instances (creating a 'special' Terminal Symbol to
// hold the dependent variable training and testing values)
// If this is a time series problem AND we are using the raw time series data then
// we named the terminals v1, v2, ..., nn where n is the number of independent
// variables as specified in the embedding dimension (which) was used to
// determine the number of terminals. But we have to process the time series data
// to get the values for each terminal ... get the raw data from the CSV file
// if specified or from the user program ... then process it into rows of data
// representing the independent variables and the dependent variable.
//
// timeseries-delay -- if 1 uses each time series value, if 2 uses every other one, etc.
// timeseries-embeddingdimension -- determines the number of timeseries points to use
// as independent variables when transforming the set of time series data. Another
// data point is used as the dependent variable value. So the time series 'raw' data
// consisting of a list of single values is processed by splitting the data into
// groups (rows) of size embeddingdimension+1. From the end of the time series data
// embeddingdimension+1 values are chosen (if delay is 1 all values are chosen, if
// 2 every other one is chosen). The last value is the independent variable value.
// Then the next row is selected by moving 'delay'
// values from the end and chosing embeddingdimension+1 values. This is repeated
// until no more sets of size embeddingdimension+1 can be chosen. If this produces
// n sets of data then testingprediction of them are used for testing and
// (n - testingpredictions) are used for training.
//
// So if we had the data:
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
// and delay was 1 and embeddingdimension was 4 then we'd process the set into
// the following 17 data sets. If testingpredictions was 6 then the 1st 11
// would be used for training and the last 6 for testing
// iv1 iv2 iv3 iv4 dv
// 1 2 3 4 5
// 2 3 4 5 6
// 3 4 5 6 7
// . . .
// 14 15 16 17 18
// 15 16 17 18 19
// 16 17 18 19 20
// 17 18 19 20 21
// If delay was 2 then 7 sets would be formed as:
// iv1 iv2 iv3 iv4 dv
// 1 3 5 7 9
// 3 5 7 9 11
// . . .
// 9 11 13 15 17
// 11 13 15 17 19
// 13 15 17 19 21
// timeseries-testingpredictions -- specifies the number of sets of data to devote to testing
if (timeseriesWithRawDataValues) {
GEPDependentVariable.symbol = "dependentVariable";
double rawTimeSeriesValues[] = null;
if (terminalFileCSV == null)
rawTimeSeriesValues = ((GEPProblem) state.evaluator.p_problem).getTimeSeriesDataValues();
else rawTimeSeriesValues = getRawTimeSeriesValuesFromCSVfile(state, terminalFileCSV);
if (rawTimeSeriesValues == null)
state.output.fatal("Unable to get time series data values from User Program or CSV file");
Vector values[] = processRawTimeSeriesValues(state, species, rawTimeSeriesValues);
// have an array of vectors; 1 vector for each indep variable and the dep variable(s)
for (int i = 0; i < values.length; i++) {
// get the values for training ... and testing (specified by timeseriesTestingPredictions)
int sizeOfTrainingData = values[i].size() - species.timeseriesTestingPredictions;
double v[] = new double[sizeOfTrainingData];
double testingV[] = new double[species.timeseriesTestingPredictions];
for (int m = 0; m < v.length; m++) v[m] = ((Double) values[i].elementAt(m)).doubleValue();
for (int n = 0; n < testingV.length; n++)
testingV[n] = ((Double) values[i].elementAt(n + sizeOfTrainingData)).doubleValue();
int depVarIndex = i - values.length + species.numberOfChromosomes;
if (depVarIndex >= 0) // last column(s) in file is(are) the dependent variable(s)
{
GEPDependentVariable.trainingData.setValues(v, depVarIndex);
GEPDependentVariable.testingData.setValues(testingV, depVarIndex);
} else {
((GEPTerminalSymbol) symbols[numberOfFunctions + i]).setTrainingValues(v);
((GEPTerminalSymbol) symbols[numberOfFunctions + i]).setTestingValues(testingV);
}
}
}
// else If there is a file with the terminals and dep variable(s) use this else ask for
// the values from the User Program (problem).
else if (terminalFileCSV != null) // terminals defined in CSV file
{
GEPDependentVariable.symbol = terminalSymbolsfromFile[terminalSymbolsfromFile.length - 1];
// get all the values into an array of vectors (each vector holds the values for a
// single terminal (dep or indep variable)
Vector values[] = new Vector[terminalSymbolsfromFile.length];
for (int i = 0; i < terminalSymbolsfromFile.length; i++) values[i] = new Vector();
try {
while (terminalFileCSV.readRecord()) {
for (int i = 0; i < terminalSymbolsfromFile.length; i++)
values[i].add(terminalFileCSV.get(i));
}
} catch (IOException e) {
state.output.fatal(
"The file with terminal definitions/values failed when reading records. " + e);
}
for (int i = 0; i < terminalSymbolsfromFile.length; i++) {
double v[] = new double[values[i].size()];
for (int m = 0; m < v.length; m++)
try {
v[m] = Double.parseDouble((String) values[i].elementAt(m));
} catch (Exception e) {
state.output.fatal(
"Failed trying to read a training data set value. The field is supposed to be a number but was the string '"
+ (String) values[i].elementAt(m)
+ "'.\n"
+ e);
}
int jj = terminalSymbolsfromFile.length - species.numberOfChromosomes;
if (i >= jj) // last column(s) in file is(are) the dependent variable(s)
GEPDependentVariable.trainingData.setValues(v, i - jj);
else ((GEPTerminalSymbol) symbols[numberOfFunctions + i]).setTrainingValues(v);
}
// get the testing data as well if a file was specified
if (testingTerminalFileCSV != null) // testing data defined in CSV file
{
// get all the values into an array of vectors (each vector holds the values for a
// single terminal (dep or indep variable)
Vector testingValues[] = new Vector[terminalSymbolsfromFile.length];
for (int i = 0; i < terminalSymbolsfromFile.length; i++) testingValues[i] = new Vector();
try {
while (testingTerminalFileCSV.readRecord()) {
for (int i = 0; i < terminalSymbolsfromFile.length; i++)
testingValues[i].add(testingTerminalFileCSV.get(i));
}
} catch (IOException e) {
state.output.fatal(
"The file with testing data values failed when reading records. "
+ "\nMake sure the file has the same column separators as the testing data file."
+ "\nAlso check that it has the same as the number of columns as the testing file"
+ e);
}
for (int i = 0; i < terminalSymbolsfromFile.length; i++) {
double v[] = new double[testingValues[i].size()];
for (int m = 0; m < v.length; m++)
try {
v[m] = Double.parseDouble((String) testingValues[i].elementAt(m));
} catch (Exception e) {
state.output.fatal(
"Failed trying to read a testing data set value. The field is supposed to be a number but was the string '"
+ (String) testingValues[i].elementAt(m)
+ "'.\n"
+ e);
}
int jj = terminalSymbolsfromFile.length - species.numberOfChromosomes;
if (i >= jj) // last column(s) in file is(are) the dependent variable(s)
GEPDependentVariable.testingData.setValues(v, i - jj);
else ((GEPTerminalSymbol) symbols[numberOfFunctions + i]).setTestingValues(v);
}
}
}
// else terminals were defined in the param file and no CSV file
// defined so .... ask User Problem for the values, training and testing (if there are any)
else {
GEPDependentVariable.symbol = "dependentVariable";
GEPProblem prob = (GEPProblem) state.evaluator.p_problem;
double vals[] = null;
for (int i = numberOfFunctions; i < numberOfSymbolsWithoutConstantSymbol; i++) {
GEPTerminalSymbol ts = (GEPTerminalSymbol) symbols[i];
vals = prob.getDataValues(ts.symbol);
if (vals == null)
state.output.fatal(
"Expecting user problem (GEPProblem/ProblemForm) to supply training data values for terminal symbol '"
+ ts
+ "'.");
ts.setTrainingValues(vals);
vals = prob.getTestingDataValues(ts.symbol);
if (vals != null) // don't have to supply testing data
ts.setTestingValues(vals);
}
// if just one dep var then ask user by requesting with getdataValues("dependentVariable")
// and if more than one dep var (more than 1 chromosome) then ask for dep variables
// with getDataValues("dependentVariable0"), getDataValues("dependentVariable1"), ...
for (int i = 0; i < species.numberOfChromosomes; i++) {
String depVarSym = GEPDependentVariable.symbol;
if (species.numberOfChromosomes > 1) depVarSym = depVarSym + i;
vals = prob.getDataValues(depVarSym);
if (vals == null)
state.output.fatal(
"Expecting user problem (GEPProblem/ProblemForm) to supply training data values for dependent variable '"
+ depVarSym
+ "'.");
GEPDependentVariable.trainingData.setValues(vals, i);
vals = prob.getTestingDataValues(depVarSym);
if (vals != null) // don't have to supply testing data
GEPDependentVariable.testingData.setValues(vals, i);
}
}
// Some checking of data values to ensure they meet the requirements for the various problem
// types.
// For all problem types need to make sure all indep vars and the dep var have the same number
// of values!
int numValues = GEPDependentVariable.trainingData.values[0].length;
for (int i = numberOfFunctions; i < numberOfSymbolsWithoutConstantSymbol; i++)
if (((GEPTerminalSymbol) symbols[i]).trainingValues.length != numValues)
state.output.fatal(
"Must have same number of values for all independent variables and the dependent variable."
+ "/nNumber of values for Dependent Variable is: "
+ numValues
+ "/nNumber of values for Independent Variable '"
+ symbols[i].symbol
+ "' is: "
+ ((GEPTerminalSymbol) symbols[i]).trainingValues.length);
// For Classification and logical problems all dependent variable values must be either 0 or 1
if (species.problemType == GEPSpecies.PT_CLASSIFICATION
|| species.problemType == GEPSpecies.PT_LOGICAL) {
double dvVals[] = GEPDependentVariable.trainingData.values[0];
for (int i = 0; i < numValues; i++)
if (dvVals[i] != 0.0 && dvVals[i] != 1.0)
state.output.fatal(
"For classification/logical problems all dependent variable values must be either 1 or 0.\nFound value "
+ dvVals[i]
+ " at index "
+ i
+ "in the values.");
}
// For Logical problems all independent variable values must be 0 or 1
if (species.problemType == GEPSpecies.PT_LOGICAL) { // for each indep variable symbol
for (int i = numberOfFunctions; i < numberOfSymbolsWithoutConstantSymbol; i++) {
double ivVals[] = ((GEPTerminalSymbol) symbols[i]).trainingValues;
for (int m = 0; m < numValues; m++)
if (ivVals[m] != 0.0 && ivVals[m] != 1.0)
state.output.fatal(
"For logical problems all independent variable values must be either 1 or 0.\nFound value "
+ ivVals[m]
+ " at index '"
+ m
+ "' in the variable '"
+ ((GEPTerminalSymbol) symbols[i]).symbol
+ "'.");
}
}
state.output.exitIfErrors();
}
public GPNode newRootedTree(
final EvolutionState state,
GPType type,
final int thread,
final GPNodeParent parent,
final GPFunctionSet set,
final int argposition,
int requestedSize) {
// ptc2 can mess up if there are no available terminals for a given type. If this occurs,
// and we find ourselves unable to pick a terminal when we want to do so, we will issue a
// warning,
// and pick a nonterminal, violating the ptc2 size and depth contracts. This can lead to
// pathological situations
// where the system will continue to go on and on unable to stop because it can't pick a
// terminal,
// resulting in running out of memory or some such. But there are cases where we'd want to let
// this work itself out.
boolean triedTerminals = false;
if (!(set instanceof PTCFunctionSetForm))
state.output.fatal(
"Set "
+ set.name
+ " is not of the class ec.gp.build.PTCFunctionSetForm, and so cannot be used with PTC Nodebuilders.");
PTCFunctionSetForm pset = (PTCFunctionSetForm) set;
// pick a size from the distribution
if (requestedSize == NOSIZEGIVEN) requestedSize = pickSize(state, thread);
GPNode root;
int t = type.type;
GPNode[] terminals = set.terminals[t];
GPNode[] nonterminals = set.nonterminals[t];
GPNode[] nodes = set.nodes[t];
if (nodes.length == 0) errorAboutNoNodeWithType(type, state); // total failure
// return a terminal
if ((requestedSize == 1
|| // Now pick a terminal if our size is 1
warnAboutNonterminal(nonterminals.length == 0, type, false, state))
&& // OR if there are NO nonterminals!
(triedTerminals = true)
&& // [first set triedTerminals]
terminals.length != 0) // AND if there are available terminals
{
root =
(GPNode)
terminals[
RandomChoice.pickFromDistribution(
pset.terminalProbabilities(t),
state.random[thread].nextFloat(),
CHECK_BOUNDARY)]
.lightClone();
root.resetNode(state, thread); // give ERCs a chance to randomize
root.argposition = (byte) argposition;
root.parent = parent;
} else // return a nonterminal-rooted tree
{
if (triedTerminals)
warnAboutNoTerminalWithType(
type, false, state); // we tried terminals and we're here because there were none!
// pick a nonterminal
root =
(GPNode)
nonterminals[
RandomChoice.pickFromDistribution(
pset.nonterminalProbabilities(t),
state.random[thread].nextFloat(),
CHECK_BOUNDARY)]
.lightClone();
root.resetNode(state, thread); // give ERCs a chance to randomize
root.argposition = (byte) argposition;
root.parent = parent;
// set the depth, size, and enqueuing, and reset the random dequeue
s_size = 0; // pretty critical!
int s = 1;
GPInitializer initializer = ((GPInitializer) state.initializer);
GPType[] childtypes = root.constraints(initializer).childtypes;
for (int x = 0; x < childtypes.length; x++) enqueue(root, x, 1); /* depth 1 */
while (s_size > 0) {
triedTerminals = false;
randomDequeue(state, thread);
type = dequeue_node.constraints(initializer).childtypes[dequeue_argpos];
int y = type.type;
terminals = set.terminals[y];
nonterminals = set.nonterminals[y];
nodes = set.nodes[y];
if (nodes.length == 0) errorAboutNoNodeWithType(type, state); // total failure
// pick a terminal
if ((s_size + s >= requestedSize
|| // if we need no more nonterminal nodes
dequeue_depth == maxDepth
|| // OR if we're at max depth and must pick a terminal
warnAboutNonterminal(nonterminals.length == 0, type, false, state))
&& // OR if there are NO nonterminals!
(triedTerminals = true)
&& // [first set triedTerminals]
terminals.length != 0) // AND if there are available terminals
{
GPNode n =
(GPNode)
terminals[
RandomChoice.pickFromDistribution(
pset.terminalProbabilities(y),
state.random[thread].nextFloat(),
CHECK_BOUNDARY)]
.lightClone();
dequeue_node.children[dequeue_argpos] = n;
n.resetNode(state, thread); // give ERCs a chance to randomize
n.argposition = (byte) dequeue_argpos;
n.parent = dequeue_node;
}
// pick a nonterminal and enqueue its children
else {
if (triedTerminals)
warnAboutNoTerminalWithType(
type, false, state); // we tried terminals and we're here because there were none!
GPNode n =
(GPNode)
nonterminals[
RandomChoice.pickFromDistribution(
pset.nonterminalProbabilities(y),
state.random[thread].nextFloat(),
CHECK_BOUNDARY)]
.lightClone();
dequeue_node.children[dequeue_argpos] = n;
n.resetNode(state, thread); // give ERCs a chance to randomize
n.argposition = (byte) dequeue_argpos;
n.parent = dequeue_node;
childtypes = n.constraints(initializer).childtypes;
for (int x = 0; x < childtypes.length; x++) enqueue(n, x, dequeue_depth + 1);
}
s++;
}
}
return root;
}