/**
* The function calculates for each derivation (d) that belongs to "individuals", the
* entropy-based fitness function of the rule set associated to d, over the isokinetic curves
* sample set "features".
*
* @param individuals The derivations with the rule set associated to each one.
* @param features The sample set of isokinetic curves.
*/
private Map<Derivation, Double> fitness(
Collection<Derivation> individuals, DoubleMatrix2D features, boolean applyEnt)
throws GggpExceptionImpl {
Map<Derivation, Double> res = null;
Collection<AuxFeatureFitnessImpl> auxFit;
Iterator<AuxFeatureFitnessImpl> itAux;
AuxFeatureFitnessImpl auxFitE;
Iterator<Derivation> it;
Derivation d;
Collection<Rules> cr;
Iterator<Rules> itr;
Rules r;
int normalClass;
int injuryClass;
double notSuccess;
boolean evaluation;
double success;
double ebff;
double efc;
double H;
double auxFitness;
if ((individuals != null) && (features != null)) {
auxFit = new LinkedList<AuxFeatureFitnessImpl>();
auxFitE = new AuxFeatureFitnessImpl();
auxFit = auxFitE.mapFeaturesWithLabel(this.getFeatures());
res = new ConcurrentHashMap<Derivation, Double>();
it = individuals.iterator();
while (it.hasNext()) {
d = it.next();
cr = parseRules(d, "real");
itAux = auxFit.iterator();
success = 0;
H = 0;
/**
* To each isokinetic curve auxFitE, all the DB's rules are applied. Only the rules that
* returns TRUE are considered, and depending of the class (normal or injury) associated to
* the rule and to auxFitE, one of two variables are incremented ("normalClass" = normal
* class, and "injuryClass" = normal class). At the end, the class with more hits is
* returned.
*/
while (itAux.hasNext()) {
auxFitE = itAux.next();
itr = cr.iterator();
normalClass = 0;
injuryClass = 0;
notSuccess = 0;
/** Applies all the rules over the isokinetic curve auxFiteE */
while (itr.hasNext()) {
r = itr.next();
evaluation = r.evaluatesRule(auxFitE.getFeatures(), r.getAntecedent());
if (evaluation) {
if (((r.getConsecuent()).toUpperCase()).equals("NORMAL")) {
if (auxFitE.getLabel().equals(new Double(1))) {
/** The rule misclassify the isokinetic curve. */
notSuccess++;
}
normalClass++;
} else {
if (auxFitE.getLabel().equals(new Double(0))) {
/** The rule misclassify the isokinetic curve. */
notSuccess++;
}
injuryClass++;
}
}
}
if (applyEnt) {
if (cr.size() != 0) {
/**
* The entropy function component of the rule set over the isokinetic curve auxFitE.
*/
efc = notSuccess / (2 * cr.size());
} else {
efc = 0;
}
/**
* The entropy funtion of the distribution of the rule set's non success results, over
* the sample of isokinect curves.
*/
if (efc != 0) {
H = H - efc * Math.log(efc);
}
}
/**
* Classification of the result, that is: if the rules made a right prognosis, increment
* success, otherwise it does nothing.
*/
if (auxFitE.getLabel().equals(new Double(0))) {
if (normalClass > injuryClass) {
/** The rule set classify properly the isokinetic curve. */
success++;
}
} else {
if (injuryClass > normalClass) {
/** The rule set classify properly the isokinetic curve. */
success++;
}
}
}
if (applyEnt) {
auxFitness = (success - H);
} else {
auxFitness = success;
}
if (auxFitness != 0) {
/**
* The entropy-based fitness function of the rule set over the isokinetic curves sample
* set.
*/
ebff = auxFitness / features.rows();
} else {
ebff = 0;
}
res.put(d, ebff);
}
}
return res;
}
/**
* @param individual The derivation to be tested.
* @param d The features used to test the derivation.
* @return A list with the test results.
* @throws GggpExceptionImpl
*/
public List<Integer> test(Derivation individual, DoubleMatrix2D d) throws GggpExceptionImpl {
List<Integer> res = null;
Collection<AuxFeatureFitnessImpl> auxFit;
Iterator<AuxFeatureFitnessImpl> itAux;
AuxFeatureFitnessImpl auxFitE;
Collection<Rules> cr;
Iterator<Rules> itr;
Rules r;
int normalClass;
int injuryClass;
int fit;
int falsePositive;
int falseNegative;
int indefined;
boolean evaluation;
if ((individual != null) && (d != null)) {
auxFitE = new AuxFeatureFitnessImpl();
auxFit = auxFitE.mapFeaturesWithLabel(d);
cr = parseRules(individual, "real");
itAux = auxFit.iterator();
fit = 0;
falsePositive = 0;
falseNegative = 0;
indefined = 0;
/**
* To each feature, all the rules are applied. Only the rules that returns TRUE are
* considered, and in function of the class (normal or injury) associated to the rule, one of
* two variables are incremented ("normalClass" = normal class, and "injuryClass" = normal
* class). At the end, the result is classified in FIT (a right prognosis), FALSE_NEGATIVE,
* FALSE_POSITIVE or INDEFINED.
*/
while (itAux.hasNext()) {
auxFitE = itAux.next();
itr = cr.iterator();
normalClass = 0;
injuryClass = 0;
while (itr.hasNext()) {
r = itr.next();
evaluation = r.evaluatesRule(auxFitE.getFeatures(), r.getAntecedent());
if (evaluation) {
if (((r.getConsecuent()).toUpperCase()).equals("NORMAL")) {
normalClass++;
} else {
injuryClass++;
}
}
}
/** Classification of the results. */
if (auxFitE.getLabel().equals(new Double(0))) {
if (normalClass > injuryClass) {
fit++;
} else {
if (normalClass < injuryClass) {
falsePositive++;
} else {
indefined++;
}
}
} else {
if (injuryClass > normalClass) {
fit++;
} else {
if (injuryClass < normalClass) {
falseNegative++;
} else {
indefined++;
}
}
}
}
res = new LinkedList<Integer>();
/** Add the amount of classified items (series). */
res.add(new Integer(d.rows()));
/** Add the amount of right prognosis (FIT). */
res.add(new Integer(fit));
/** Add the amount of false negatives. */
res.add(new Integer(falseNegative));
/** Add the amount of false positives. */
res.add(new Integer(falsePositive));
/** Add the amount of indefined. */
res.add(new Integer(indefined));
}
return res;
}
