/**
* Inserts the classifier in the population. Before that, it looks if there is a classifier in the
* population with the same action and condition (in this case, increments its numerosity). After,
* it checks that the number of micro classifiers is less than the maximum population size. If it
* isn't, it deletes one classifier from the population calling the deleteClassifier function. It
* inserts the classifier in the population and in the action set if it's not null.
*
* @param cl is the classifier that has to be inserted in the population.
* @param ASet Population where the classifier will be inserted.
*/
public void insertInPopulation(Classifier cl, Population ASet) {
boolean found = false;
int i = 0;
while (i < macroClSum && !found) {
if (set[i].equals(cl)) {
set[i].increaseNumerosity(cl.getNumerosity());
microClSum += cl.getNumerosity();
if (ASet != null) {
if (ASet.isThereClassifier(set[i]) >= 0) ASet.microClSum += cl.getNumerosity();
}
found = true;
}
i++;
}
if (!found) {
addClassifier(cl);
}
// Here, the classifier has been added to the population
if (microClSum
> Config.popSize) { // If we have inserted to many classifiers, we have to delete one.
deleteClFromPopulation(ASet);
}
} // end insertInPopulation
/**
* Unmarshall a Genotype instance from a given XML Element representation. Its population of
* Chromosomes will be unmarshalled from the Chromosome sub-elements.
*
* @param a_activeConfiguration the current active Configuration object that is to be used during
* construction of the Genotype and Chromosome instances
* @param a_xmlElement the XML Element representation of the Genotype
* @return a new Genotype instance, complete with a population of Chromosomes, setup with the data
* from the XML Element representation
* @throws ImproperXMLException if the given Element is improperly structured or missing data
* @throws InvalidConfigurationException if the given Configuration is in an inconsistent state
* @throws UnsupportedRepresentationException if the actively configured Gene implementation does
* not support the string representation of the alleles used in the given XML document
* @throws GeneCreationException if there is a problem creating or populating a Gene instance
* @author Neil Rotstan
* @author Klaus Meffert
* @since 1.0
*/
public static Genotype getGenotypeFromElement(
Configuration a_activeConfiguration, Element a_xmlElement)
throws ImproperXMLException, InvalidConfigurationException,
UnsupportedRepresentationException, GeneCreationException {
// Sanity check. Make sure the XML element isn't null and that it
// actually represents a genotype.
if (a_xmlElement == null || !(a_xmlElement.getTagName().equals(GENOTYPE_TAG))) {
throw new ImproperXMLException(
"Unable to build Genotype instance from XML Element: "
+ "given Element is not a 'genotype' element.");
}
// Fetch all of the nested chromosome elements and convert them
// into Chromosome instances.
// ------------------------------------------------------------
NodeList chromosomes = a_xmlElement.getElementsByTagName(CHROMOSOME_TAG);
int numChromosomes = chromosomes.getLength();
Population population = new Population(a_activeConfiguration, numChromosomes);
for (int i = 0; i < numChromosomes; i++) {
population.addChromosome(
getChromosomeFromElement(a_activeConfiguration, (Element) chromosomes.item(i)));
}
// Construct a new Genotype with the chromosomes and return it.
// ------------------------------------------------------------
return new Genotype(a_activeConfiguration, population);
}
/**
* It creates a new Population with only the sufficiently experienced classifiers.
*
* @param maxReward is the maximum reward of the environment.
* @return a Population with the experienced population
*/
public Population deleteNotExpClassifiers(double maxReward) {
// We create a Config.popSize population instead of a macroClSum classifier, because, if it's
// used in a training execution, this population can increase (new classifiers can be added).
Population pExp = new Population(Config.popSize);
for (int i = 0; i < macroClSum; i++) {
if (set[i].couldReduce(maxReward)) {
pExp.addClassifier(set[i]);
}
}
return pExp;
} // end deleteNotExpClassifiers
public boolean needsToRun(Run run, int generation) {
Population pop = getPopulationFor(run, generation);
int count = run.getIntProperty(GenetikConstants.POPULATION, Integer.MAX_VALUE, true);
int scoreCount = 0;
for (int i = 0, max = pop.size(); i < max; i++) {
Individual ind = pop.get(i);
if (ind.hasFitness() && ind.hasScores()) {
scoreCount++;
}
}
return scoreCount != count;
}
/**
* This constructor creates the match set of the population. It has to cover the uncovered actions
* while, at least, the theta_mna actions aren't covered. It uses the actionCovered variable to do
* this.
*
* @param envState is the state of the input (it has to take the classifiers that match with it).
* @param pop is the population of the system (it contains all the classifiers).
* @param tStamp it's the actual time. It's needed to create the new classifiers).
* @param isExploreExecution indicates if the current step is an explore or an exploit trail,
* because the covering operator will be applied or not.
*/
public Population(double[] envState, Population pop, int tStamp, boolean isExploreExecution) {
int pos = 0;
// A population of size parent.numerosity + numberOfActions is needed,
// because in the worst case, it will have to cover all the actions.
set = new Classifier[pop.macroClSum + Config.numberOfActions];
microClSum = 0;
macroClSum = 0;
parentRef = pop;
specify = new Specify();
boolean[] actionCovered = new boolean[Config.numberOfActions];
for (pos = 0; pos < actionCovered.length; pos++) {
actionCovered[pos] = false;
}
for (pos = 0; pos < pop.getMacroClSum(); pos++) {
if (pop.set[pos].match(envState)) {
addClassifier(pop.set[pos]);
actionCovered[pop.set[pos].getAction()] = true;
}
}
if (isExploreExecution) {
Covering cov = new Covering();
cov.coverActions(pop, this, envState, tStamp, actionCovered);
}
} // end Population
/**
* Marshall a Genotype instance into an XML Element representation, including its population of
* Chromosome instances as sub-elements. This may be useful in scenarios where representation as
* an entire Document is undesirable, such as when the representation of this Genotype is to be
* combined with other elements in a single Document.
*
* @param a_subject the genotype to represent as an XML element
* @param a_xmlDocument a Document instance that will be used to create the Element instance. Note
* that the element will NOT be added to the document by this method
* @return an Element object representing the given Genotype
* @author Neil Rotstan
* @since 1.0
* @deprecated use XMLDocumentBuilder instead
*/
public static Element representGenotypeAsElement(
final Genotype a_subject, final Document a_xmlDocument) {
Population population = a_subject.getPopulation();
// Start by creating the genotype element and its size attribute,
// which represents the number of chromosomes present in the
// genotype.
// --------------------------------------------------------------
Element genotypeTag = a_xmlDocument.createElement(GENOTYPE_TAG);
genotypeTag.setAttribute(SIZE_ATTRIBUTE, Integer.toString(population.size()));
// Next, add nested elements for each of the chromosomes in the
// genotype.
// ------------------------------------------------------------
for (int i = 0; i < population.size(); i++) {
Element chromosomeElement =
representChromosomeAsElement(population.getChromosome(i), a_xmlDocument);
genotypeTag.appendChild(chromosomeElement);
}
return genotypeTag;
}
/** This method applies the action set subsumption */
public void doActionSetSubsumption() {
int i, pos = 0;
Classifier cl = null;
for (i = 0; i < macroClSum; i++) {
if (set[i].couldSubsume()) {
if (cl == null
|| set[i].numberOfDontCareSymbols() > cl.numberOfDontCareSymbols()
|| (set[i].numberOfDontCareSymbols() == cl.numberOfDontCareSymbols()
&& Config.rand() < 0.5)) {
cl = set[i];
pos = i;
}
}
}
if (cl != null) {
for (i = 0; i < macroClSum; i++) {
if (cl != set[i] && cl.isMoreGeneral(set[i])) {
cl.increaseNumerosity(set[i].getNumerosity());
// Now, the classifier has to be removed from the actionSet and the population.
// It's deleted from the action set.
Classifier clDeleted = set[i];
deleteClassifier(i);
// And now, it's deleted from the population
Population p = parentRef;
while (p.parentRef != null) {
p = p.parentRef;
}
pos =
p.isThereClassifier(
clDeleted); // The classifier is searched in the initial population.
if (pos >= 0) p.deleteClassifier(pos);
}
}
}
} // end doActionSetSubsumption
/**
* It creates the D population defined by Wilson 2002. It creates a population with the minimum
* number of classifiers that cover all the input examples.
*
* @param env Environment to be set in the new population.
* @return the D population created
*/
public Population createMCompPopulation(Environment env) {
int moreMatches = 0, maxMatched = 0;
// We create a Config.popSize population instead of a macroClSum classifier, because, if it's
// used in a training execution, this population can increase (new classifiers can be added).
Population Mcomp = new Population(Config.popSize);
while (env.getNumberOfExamples() > 0 && macroClSum > 0) {
moreMatches = 0;
maxMatched = set[0].getNumberMatches();
for (int i = 1; i < macroClSum; i++) {
if (set[i].getNumberMatches() > maxMatched) {
maxMatched = set[i].getNumberMatches();
moreMatches = i;
}
}
Mcomp.addClassifier(set[moreMatches]);
env.deleteMatchedExamples(set[moreMatches]);
deleteClassifier(moreMatches);
}
return Mcomp;
} // end createMcompPopulation
/**
* Deletes one classifier from the population. After that, if the population passed as a parameter
* is not null, it looks for the deleted classifier. If it is in the second population, it will
* delete it too.
*
* @param aSet is the population where the deleted classifier has to be searched.
* @return a Classifier that contains the deleted classifier.
*/
public Classifier deleteClFromPopulation(Population aSet) {
// A classifier has been deleted from the population
Classifier clDeleted = deleteClassifier();
if (aSet
!= null) { // Now, this classifier has to be deleted from the action set (if it exists in).
int pos = aSet.isThereClassifier(clDeleted); // It is searched in the action set.
if (pos >= 0) { // It has to be deleted from the action set too.
aSet.microClSum--;
// If the classifier has 0 numerosity, we remove it from the population.
if (clDeleted.getNumerosity() == 0) { // It has to be completely deleted from action set.
aSet.macroClSum--; // Decrements the number of macroclassifiers
aSet.set[pos] = aSet.set[aSet.macroClSum]; // Moves the last classifier to the deleted one
aSet.set[aSet.macroClSum] = null; // Puts the last classifier to null.
}
}
}
return clDeleted;
} // end deleteClFromPopulation
private static void showPrograms(Population population) throws IllegalAccessException {
for (ProgramInfo programInfo : population.getProgramInfoList()) {
String info = getProgramInfoString(programInfo);
System.out.println(info);
}
}
/** It's the new reduction algorithm. (Experimental phase) */
private void reductInTrain() {
double averageUseful = 0.0, stdUseful = 0.0;
int i = 0;
int numSum = 0;
// A reference to the population is gotten.
Population pop = this.getParentRef().getParentRef();
while (i < macroClSum) {
if (!set[i].couldComp()) {
numSum += set[i].getNumerosity();
set[i].setNumerosity(0);
// The classifier is removed from the [A]
set[i] = set[macroClSum - 1];
macroClSum--;
/////
numAplicacions++;
} else {
averageUseful += set[i].getUsefulTimes();
stdUseful += (set[i].getUsefulTimes() * set[i].getUsefulTimes());
i++;
}
}
if (macroClSum > 0) {
if (macroClSum > 1)
stdUseful =
Math.sqrt(
(stdUseful - ((averageUseful * averageUseful) / macroClSum)) / (macroClSum - 1));
averageUseful = averageUseful / (double) macroClSum;
// With the "thres" parameter you can control the compactation pressure (add or substract the
// stdUseful)
int thres = (int) (averageUseful - stdUseful);
i = 0;
averageUseful = 0;
while (i < macroClSum) {
if (set[i].getUsefulTimes() < thres && set[i].getPrediction() > Config.Preduct) {
numSum += set[i].getNumerosity();
set[i].setNumerosity(0);
set[i] = set[macroClSum - 1];
macroClSum--;
/////
numAplicacions++;
} else {
// We add the contribuion of each classifier to distribute the numerosity at the end
averageUseful += set[i].getUsefulTimes();
i++;
}
}
// The numerosity of classifiers deleted are set to other classifiers in the population.
int addNum = 0;
int discount = 0;
for (i = 0; i < macroClSum - 1; i++) {
addNum = (int) (((double) set[i].getUsefulTimes() / averageUseful) * (double) numSum);
set[i].increaseNumerosity(addNum);
discount += addNum;
}
if (macroClSum > 0) set[macroClSum - 1].increaseNumerosity(numSum - discount);
} else {
microClSum -= numSum;
pop.microClSum -= numSum;
}
pop.deleteClWithZeroNum();
}