/**
* Function that determines the cromosomes who have to be crossed and the other ones who have to
* be removed It returns the number of remaining cromosomes in the poblation
*/
private int recombinar(Chromosome C[], int d, int nNeg, int nPos, boolean majSelection) {
int i, j;
int distHamming;
int tamC = 0;
int n;
if (majSelection) n = nNeg;
else n = nNeg + nPos;
for (i = 0; i < C.length / 2; i++) {
distHamming = 0;
for (j = 0; j < n; j++) if (C[i * 2].getGen(j) != C[i * 2 + 1].getGen(j)) distHamming++;
if ((distHamming / 2) > d) {
for (j = 0; j < n; j++) {
if ((C[i * 2].getGen(j) != C[i * 2 + 1].getGen(j)) && Randomize.Rand() < 0.5) {
if (C[i * 2].getGen(j)) C[i * 2].setGen(j, false);
else if (Randomize.Rand() < prob0to1Rec) C[i * 2].setGen(j, true);
if (C[i * 2 + 1].getGen(j)) C[i * 2 + 1].setGen(j, false);
else if (Randomize.Rand() < prob0to1Rec) C[i * 2 + 1].setGen(j, true);
}
}
tamC += 2;
} else {
C[i * 2].borrar();
C[i * 2 + 1].borrar();
}
}
return tamC;
}
private void interpola(
double ra[],
double rb[],
int na[],
int nb[],
boolean ma[],
boolean mb[],
double resS[],
double resR[],
int resN[],
boolean resM[]) {
int i;
double diff;
double gap;
int suerte;
for (i = 0; i < ra.length; i++) {
if (ma[i] == true && mb[i] == true) {
resM[i] = true;
resS[i] = 0;
} else {
resM[i] = false;
if (entradas[i].getType() == Attribute.REAL) {
diff = rb[i] - ra[i];
gap = Randomize.Rand();
resR[i] = ra[i] + gap * diff;
resS[i] =
(ra[i] + entradas[i].getMinAttribute())
/ (entradas[i].getMaxAttribute() - entradas[i].getMinAttribute());
} else if (entradas[i].getType() == Attribute.INTEGER) {
diff = rb[i] - ra[i];
gap = Randomize.Rand();
resR[i] = Math.round(ra[i] + gap * diff);
resS[i] =
(ra[i] + entradas[i].getMinAttribute())
/ (entradas[i].getMaxAttribute() - entradas[i].getMinAttribute());
} else {
suerte = Randomize.Randint(0, 2);
if (suerte == 0) {
resN[i] = na[i];
} else {
resN[i] = nb[i];
}
resS[i] = (double) resN[i] / (double) (entradas[i].getNominalValuesList().size() - 1);
}
}
}
}
/** Applies a roulette wheel selection */
public void selection() {
RuleSet temp[];
double probability[] = new double[long_poblacion];
double total;
double prob;
int sel;
temp = new RuleSet[long_poblacion];
// sort the poblation in order of fitness
Arrays.sort(poblacion, Collections.reverseOrder());
probability[0] = poblacion[0].getFitness();
for (int i = 1; i < long_poblacion; i++) {
probability[i] = probability[i - 1] + poblacion[i].getFitness();
}
total = probability[long_poblacion - 1];
for (int i = 0; i < long_poblacion; i++) {
probability[i] /= total;
}
for (int i = 0; i < long_poblacion; i++) {
prob = Randomize.Rand();
sel = -1;
for (int j = 0; j < long_poblacion && sel == -1; j++) {
if (probability[j] > prob) sel = j;
}
temp[i] = new RuleSet(poblacion[sel]);
}
previousPob = poblacion;
poblacion = temp;
}
/** Applies mutation in the new poblation */
public void mutate() {
int posiciones, i, j;
double m;
posiciones = n_genes * long_poblacion;
if (prob_mutacion > 0)
while (Mu_next < posiciones) {
/* Se determina el cromosoma y el gen que corresponden a la posicion que
se va a mutar */
i = Mu_next / n_genes;
j = Mu_next % n_genes;
/* Se efectua la mutacion sobre ese gen */
poblacion[i].mutate(j);
/* Se marca el cromosoma mutado para su posterior evaluacion */
poblacion[i].setEvaluated(false);
/* Se calcula la siguiente posicion a mutar */
if (prob_mutacion < 1) {
m = Randomize.Rand();
Mu_next += Math.ceil(Math.log(m) / Math.log(1.0 - prob_mutacion));
} else Mu_next += 1;
}
Mu_next -= posiciones;
}
/**
* It performs a one point crossover in the new poblation, using adjacent chromosomes as parents
*/
public void crossOver() {
int parentspreserved = (int) (long_poblacion * survivorsPercent);
for (int i = 0; i < long_poblacion; i = i + 2) {
if (Randomize.Rand() < this.crossoverRate && i + 1 < long_poblacion)
onePointCrossover(i, i + 1);
}
}
/**
* KMeans constructor: the cluster centroids are obtained for the given dataset. Firstly, the
* cluster's centroids are randomly chosen. Then the centroids are updated as the mean vlaue of
* nearest examples in the dataset. The updating is carried out until no changes in the centroids
* is achieved.
*
* @param X The dataset to be clusterized
* @param nclusters The desired number of clusters
* @param vrand The Randomize object to be used
*/
public KMeans(double[][] X, int nclusters, Randomize vrand) {
rand = vrand;
train = X;
clusters = nclusters;
cclusters = new double[nclusters][X[0].length];
for (int i = 0; i < nclusters; i++) {
int pos = (int) (rand.Rand() * X.length);
for (int j = 0; j < cclusters[i].length; j++) cclusters[i][j] = X[pos][j];
}
int[] C = new int[X.length];
int[] C_old = new int[X.length];
for (int i = 0; i < X.length; i++) {
C_old[i] = nearestCentroid(X[i]);
}
centroidsUpdating(C_old);
int cambios = 0, iteracion = 0;
do {
iteracion++;
System.out.println("Iter=" + iteracion + " changes=" + cambios);
cambios = 0;
for (int i = 0; i < X.length; i++) {
C[i] = nearestCentroid(X[i]);
if (C[i] != C_old[i]) cambios++;
C_old[i] = C[i];
}
centroidsUpdating(C);
} while (cambios > 0);
}
/* Selection based on the Baker's Estocastic Universal Sampling */
void Select() {
double expected, factor, perf, ptr, sum, rank_max, rank_min;
int i, j, k, best, temp;
rank_min = 0.75;
/* we assign the ranking to each element:
The best: ranking = long_poblacion-1
The worse: ranking = 0 */
for (i = 0; i < long_poblacion; i++) Old[i].n_e = 0;
/* we look for the best ordered non element */
for (i = 0; i < long_poblacion - 1; i++) {
best = -1;
perf = 0.0;
for (j = 0; j < long_poblacion; j++) {
if ((Old[j].n_e == 0) && (best == -1 || Old[j].Perf < perf)) {
perf = Old[j].Perf;
best = j;
}
}
/* we assign the ranking */
Old[best].n_e = long_poblacion - 1 - i;
}
/* we normalize the ranking */
rank_max = 2.0 - rank_min;
factor = (rank_max - rank_min) / (double) (long_poblacion - 1);
/* we assign the number of replicas of each chormosome according to the select probability */
k = 0;
ptr = Randomize.Rand();
for (sum = i = 0; i < long_poblacion; i++) {
expected = rank_min + Old[i].n_e * factor;
for (sum += expected; sum >= ptr; ptr++) sample[k++] = i;
}
/* we complete the population if necessary */
if (k != long_poblacion) {
for (; k < long_poblacion; k++) sample[k] = Randomize.RandintClosed(0, long_poblacion - 1);
}
/* we shuffle the selected chromosomes */
for (i = 0; i < long_poblacion; i++) {
j = Randomize.RandintClosed(i, long_poblacion - 1);
temp = sample[j];
sample[j] = sample[i];
sample[i] = temp;
}
/* we create the new population */
for (i = 0; i < long_poblacion; i++) {
k = sample[i];
for (j = 0; j < n_genes; j++) New[i].Gene[j] = Old[k].Gene[j];
New[i].Perf = Old[k].Perf;
New[i].n_e = 0;
}
}
/* Operador de Mutacion Uniforme */
void Mutacion_Uniforme() {
int posiciones, i, j;
double m;
posiciones = n_genes * long_poblacion;
if (prob_mutacion > 0) {
while (Mu_next < posiciones) {
/* we determinate the chromosome and the gene */
i = Mu_next / n_genes;
j = Mu_next % n_genes;
/* we mutate the gene */
if (New[i].Gene[j] == '0') New[i].Gene[j] = '1';
else New[i].Gene[j] = '0';
New[i].n_e = 1;
/* we calculate the next position */
if (prob_mutacion < 1) {
m = Randomize.Rand();
Mu_next += (int) (Math.log(m) / Math.log(1.0 - prob_mutacion)) + 1;
} else Mu_next += 1;
}
}
Mu_next -= posiciones;
}
/** Inicialization of the population */
public void Initialize() {
int i, j;
last = (int) ((prob_cruce * long_poblacion) - 0.5);
Trials = 0;
if (prob_mutacion < 1.0) {
Mu_next = (int) (Math.log(Randomize.Rand()) / Math.log(1.0 - prob_mutacion));
Mu_next++;
} else {
Mu_next = 1;
}
for (j = 0; j < n_genes; j++) {
New[0].GeneSel[j] = '1';
}
New[0].n_e = 1;
for (i = 1; i < long_poblacion; i++) {
for (j = 0; j < n_genes; j++) {
if (Randomize.RandintClosed(0, 1) == 0) {
New[i].GeneSel[j] = '0';
} else {
New[i].GeneSel[j] = '1';
}
}
New[i].n_e = 1;
}
}
public void crossover() {
int j, countCross = 0;
Sampling samp = new Sampling(popSize);
int p1 = -1;
for (j = 0; j < popSize; j++) {
if (Randomize.Rand() < Parameters.crossoverProbability) {
if (p1 == -1) {
p1 = samp.getSample();
} else {
int p2 = samp.getSample();
crossTwoParents(p1, p2, countCross, countCross + 1);
countCross += 2;
p1 = -1;
}
} else {
crossOneParent(samp.getSample(), countCross++);
}
}
if (p1 != -1) {
crossOneParent(p1, countCross++);
}
}
public void individualMutation() {
int i;
for (i = 0; i < popSize; i++) {
if (Randomize.Rand() < Parameters.mutationProbability) {
offspringPopulation[i].mutation();
}
}
}
/**
* Reinitializes the chromosome by using CHC diverge procedure
*
* @param r R factor of diverge
* @param mejor Best chromosome found so far
* @param prob Probability of setting a gen to 1
*/
public void divergeCHC(double r, Cromosoma mejor, double prob) {
int i;
for (i = 0; i < cuerpo.length; i++) {
if (Randomize.Rand() < r) {
if (Randomize.Rand() < prob) {
cuerpo[i] = true;
} else {
cuerpo[i] = false;
}
} else {
cuerpo[i] = mejor.getGen(i);
}
}
cruzado = true;
} // end-method
/**
* Builder. Generates a new subpopulation from a subset of the entire training set
*
* @param id Identifier of the population
* @param train Subset of training data
* @param out Output attribute of the subset of training data
*/
public Subpopulation(int id, double train[][], int out[]) {
// identify it
ID = id;
IDs = new int[size];
for (int i = 0; i < size; i++) {
IDs[i] = i;
}
// set data
trainData = new double[train.length][train[0].length];
trainOutput = new int[out.length];
for (int i = 0; i < trainData.length; i++) {
for (int j = 0; j < trainData[0].length; j++) {
trainData[i][j] = train[i][j];
}
trainOutput[i] = out[i];
}
// Getting the number of different classes
nClasses = 0;
for (int i = 0; i < trainOutput.length; i++) {
if (trainOutput[i] > nClasses) {
nClasses = trainOutput[i];
}
}
nClasses++;
// create population
population = new int[size][trainData.length];
for (int i = 0; i < size; i++) {
for (int j = 0; j < trainData.length; j++) {
if (Randomize.Rand() < 0.5) {
population[i][j] = 1;
} else {
population[i][j] = 0;
}
}
}
fitness = new double[size];
Arrays.fill(fitness, -1.0);
// initialize cache of distances
generateCache();
// initialize structures
ISSelection = new int[trainData.length];
selectedClasses = new int[nClasses];
nearestN = new int[K];
minDist = new double[K];
} // end-method
/**
* Mutation operator
*
* @param pMutacion1to0 Probability of change 1 to 0
* @param pMutacion0to1 Probability of change 0 to 1
*/
public void mutacion(double pMutacion1to0, double pMutacion0to1) {
int i;
for (i = 0; i < cuerpo.length; i++) {
if (cuerpo[i]) {
if (Randomize.Rand() < pMutacion1to0) {
cuerpo[i] = false;
cruzado = true;
}
} else {
if (Randomize.Rand() < pMutacion0to1) {
cuerpo[i] = true;
cruzado = true;
}
}
}
} // end-method
/**
* Returns a vector with the discretized values.
*
* @param attribute
* @param values
* @param begin
* @param end
* @return vector with the discretized values
*/
protected Vector discretizeAttribute(int attribute, int[] values, int begin, int end) {
double quota = (end - begin + 1) / numInt;
double dBound = 0.0;
int i;
int oldBound = 0;
Vector cp = new Vector();
for (i = 0; i < numInt - 1; i++) {
dBound += quota;
int iBound = (int) Math.round(dBound);
if (iBound <= oldBound) continue;
if (realValues[attribute][values[iBound - 1]] != realValues[attribute][values[iBound]]) {
double cutPoint =
(realValues[attribute][values[iBound - 1]] + realValues[attribute][values[iBound]])
/ 2.0;
cp.addElement(new Double(cutPoint));
} else {
double val = realValues[attribute][values[iBound]];
int numFW = 1;
while (iBound + numFW <= end && realValues[attribute][values[iBound + numFW]] == val)
numFW++;
if (iBound + numFW > end) numFW = end - begin + 2;
int numBW = 1;
while (iBound - numBW > oldBound && realValues[attribute][values[iBound - numBW]] == val)
numBW++;
if (iBound - numBW == oldBound) numBW = end - begin + 2;
if (numFW < numBW) {
iBound += numFW;
} else if (numBW < numFW) {
iBound -= numBW;
} else {
if (numFW == end - begin + 2) {
return cp;
}
if (Randomize.Rand() < 0.5) {
iBound += numFW;
} else {
iBound -= numBW;
iBound++;
}
}
double cutPoint =
(realValues[attribute][values[iBound - 1]] + realValues[attribute][values[iBound]])
/ 2.0;
cp.addElement(new Double(cutPoint));
}
oldBound = iBound;
}
return cp;
}
/**
* It calculates PCBLX
*
* @param d it multiplies the module of the difference of the parents
* @param P1 it is a father to cross
* @param P2 it is the other father to do the cross
* @param Hijo1 the son obtained
* @param Hijo2 the other obtained
* @param gens the size of the vector
*/
private void xPC_BLX(
double d, double[] P1, double[] P2, double[] Hijo1, double[] Hijo2, int gens) {
double I, A1, C1;
int i;
for (i = 0; i < gens; i++) {
I = d * Math.abs(P1[i] - P2[i]);
A1 = P1[i] - I;
if (A1 < Gene[i].min()) A1 = Gene[i].min();
C1 = P1[i] + I;
if (C1 > Gene[i].max()) C1 = Gene[i].max();
Hijo1[i] = A1 + Randomize.Rand() * (C1 - A1);
A1 = P2[i] - I;
if (A1 < Gene[i].min()) A1 = Gene[i].min();
C1 = P2[i] + I;
if (C1 > Gene[i].max()) C1 = Gene[i].max();
Hijo2[i] = A1 + Randomize.Rand() * (C1 - A1);
}
}
private void crossover() {
boolean[] mascara = new boolean[train.getnInputs() + 1];
for (int i = 0; i < selectos.length / 2; i++) {
for (int j = 0; j < mascara.length; j++) {
mascara[j] = (Randomize.Rand() > 0.5);
}
Individuo padre = cromosomas.get(selectos[i]);
Individuo madre = cromosomas.get(selectos[i + 1]);
Individuo hijo1 = new Individuo(padre, madre, mascara);
Individuo hijo2 = new Individuo(madre, padre, mascara);
hijos.add(hijo1);
hijos.add(hijo2);
}
}
/**
* Builder. Construct a random chromosome of specified size
*
* @param size Size of the chromosome
*/
public Cromosoma(int size) {
double u;
int i;
cuerpo = new boolean[size];
for (i = 0; i < size; i++) {
u = Randomize.Rand();
if (u < 0.5) {
cuerpo[i] = false;
} else {
cuerpo[i] = true;
}
}
cruzado = true;
valido = true;
} // end-method
/** Process the training and test files provided in the parameters file to the constructor. */
public void process() {
// declarations
double[] outputs;
double[] outputs2;
Instance neighbor;
double dist, mean;
int actual;
Randomize rnd = new Randomize();
Instance ex;
gCenter kmeans = null;
int iterations = 0;
double E;
double prevE;
int totalMissing = 0;
boolean allMissing = true;
rnd.setSeed(semilla);
// PROCESS
try {
// Load in memory a dataset that contains a classification problem
IS.readSet(input_train_name, true);
int in = 0;
int out = 0;
ndatos = IS.getNumInstances();
nvariables = Attributes.getNumAttributes();
nentradas = Attributes.getInputNumAttributes();
nsalidas = Attributes.getOutputNumAttributes();
X = new String[ndatos][nvariables]; // matrix with transformed data
kmeans = new gCenter(K, ndatos, nvariables);
timesSeen = new FreqList[nvariables];
mostCommon = new String[nvariables];
// first, we choose k 'means' randomly from all
// instances
totalMissing = 0;
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
if (inst.existsAnyMissingValue()) totalMissing++;
}
if (totalMissing == ndatos) allMissing = true;
else allMissing = false;
for (int numMeans = 0; numMeans < K; numMeans++) {
do {
actual = (int) (ndatos * rnd.Rand());
ex = IS.getInstance(actual);
} while (ex.existsAnyMissingValue() && !allMissing);
kmeans.copyCenter(ex, numMeans);
}
// now, iterate adjusting clusters' centers and
// instances to them
prevE = 0;
iterations = 0;
do {
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
kmeans.setClusterOf(inst, i);
}
// set new centers
kmeans.recalculateCenters(IS);
// compute RMSE
E = 0;
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
E += kmeans.distance(inst, kmeans.getClusterOf(i));
}
iterations++;
// System.out.println(iterations+"\t"+E);
if (Math.abs(prevE - E) == 0) iterations = maxIter;
else prevE = E;
} while (E > minError && iterations < maxIter);
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
in = 0;
out = 0;
for (int j = 0; j < nvariables; j++) {
Attribute a = Attributes.getAttribute(j);
direccion = a.getDirectionAttribute();
tipo = a.getType();
if (direccion == Attribute.INPUT) {
if (tipo != Attribute.NOMINAL && !inst.getInputMissingValues(in)) {
X[i][j] = new String(String.valueOf(inst.getInputRealValues(in)));
} else {
if (!inst.getInputMissingValues(in)) X[i][j] = inst.getInputNominalValues(in);
else {
actual = kmeans.getClusterOf(i);
X[i][j] = new String(kmeans.valueAt(actual, j));
}
}
in++;
} else {
if (direccion == Attribute.OUTPUT) {
if (tipo != Attribute.NOMINAL && !inst.getOutputMissingValues(out)) {
X[i][j] = new String(String.valueOf(inst.getOutputRealValues(out)));
} else {
if (!inst.getOutputMissingValues(out)) X[i][j] = inst.getOutputNominalValues(out);
else {
actual = kmeans.getClusterOf(i);
X[i][j] = new String(kmeans.valueAt(actual, j));
}
}
out++;
}
}
}
}
} catch (Exception e) {
System.out.println("Dataset exception = " + e);
e.printStackTrace();
System.exit(-1);
}
write_results(output_train_name);
/** ************************************************************************************ */
// does a test file associated exist?
if (input_train_name.compareTo(input_test_name) != 0) {
try {
// Load in memory a dataset that contains a classification problem
IStest.readSet(input_test_name, false);
int in = 0;
int out = 0;
ndatos = IStest.getNumInstances();
nvariables = Attributes.getNumAttributes();
nentradas = Attributes.getInputNumAttributes();
nsalidas = Attributes.getOutputNumAttributes();
for (int i = 0; i < ndatos; i++) {
Instance inst = IStest.getInstance(i);
in = 0;
out = 0;
for (int j = 0; j < nvariables; j++) {
Attribute a = Attributes.getAttribute(j);
direccion = a.getDirectionAttribute();
tipo = a.getType();
if (direccion == Attribute.INPUT) {
if (tipo != Attribute.NOMINAL && !inst.getInputMissingValues(in)) {
X[i][j] = new String(String.valueOf(inst.getInputRealValues(in)));
} else {
if (!inst.getInputMissingValues(in)) X[i][j] = inst.getInputNominalValues(in);
else {
actual = kmeans.getClusterOf(i);
X[i][j] = new String(kmeans.valueAt(actual, j));
}
}
in++;
} else {
if (direccion == Attribute.OUTPUT) {
if (tipo != Attribute.NOMINAL && !inst.getOutputMissingValues(out)) {
X[i][j] = new String(String.valueOf(inst.getOutputRealValues(out)));
} else {
if (!inst.getOutputMissingValues(out)) X[i][j] = inst.getOutputNominalValues(out);
else {
actual = kmeans.getClusterOf(i);
X[i][j] = new String(kmeans.valueAt(actual, j));
}
}
out++;
}
}
}
}
} catch (Exception e) {
System.out.println("Dataset exception = " + e);
e.printStackTrace();
System.exit(-1);
}
write_results(output_test_name);
}
}
/** Function which restart the population */
public void ReStart() {
int i, j, i_mejor;
if (Ajuste == 1) {
if (BEST_CROM.entrado() == 1) {
/* BUSCAR EL MEJOR ELEMENTO */
for (i = i_mejor = 0; i < Popsize; i++)
if (Better(Poblacion[i].perf(), Poblacion[i_mejor].perf())) i_mejor = i;
for (j = 0; j < Genes; j++) Poblacion[0].set_gene(j, BEST_CROM.gene(j));
for (j = 0; j < GenesA; j++) Poblacion[0].set_geneA(j, BEST_CROM.geneA(j));
for (j = 0; j < n_reglas_total; j++) Poblacion[0].set_geneR(j, (char) 1);
Poblacion[0].set_perf(BEST_CROM.perf());
i = 1;
} else {
i = 0;
}
/* REINICIALIZAR TODOS MENOS EL PRIMERO */
for (; i < Popsize; i++) {
for (j = 0; j < Genes; j++) {
Poblacion[i].set_gene(j, BEST_CROM.gene(j) + ((Randomize.Rand() - 0.5) / 4.0));
if (Poblacion[i].gene(j) > Gene[j].max()) Poblacion[i].set_gene(j, Gene[j].max());
if (Poblacion[i].gene(j) < Gene[j].min()) Poblacion[i].set_gene(j, Gene[j].min());
}
for (j = 0; j < GenesA; j++) {
Poblacion[i].set_geneA(j, BEST_CROM.geneA(j) + ((Randomize.Rand() - 0.5) / 4.0));
if (Poblacion[i].geneA(j) > Gene[j].max()) Poblacion[i].set_geneA(j, Gene[j].max());
if (Poblacion[i].geneA(j) < Gene[j].min()) Poblacion[i].set_geneA(j, Gene[j].min());
}
for (j = 0; j < n_reglas_total; j++) Poblacion[i].set_geneR(j, (char) 1);
}
THRESHOLD = (double) ((Genes + GenesA) * BITS_GEN / 4.0);
reduccionIni = THRESHOLD * 0.001;
} else {
if (BEST_CROM.entrado() == 1) {
/* BUSCAR EL MEJOR ELEMENTO */
for (i = i_mejor = 0; i < Popsize; i++)
if (Better(Poblacion[i].perf(), Poblacion[i_mejor].perf())) i_mejor = i;
/* COLOCAR EL MEJOR EN LA PRIMERA POSICION */
for (j = 0; j < Genes; j++) Poblacion[0].set_gene(j, BEST_CROM.gene(j));
for (j = 0; j < GenesA; j++) Poblacion[0].set_geneA(j, BEST_CROM.geneA(j));
for (j = 0; j < n_reglas_total; j++) Poblacion[0].set_geneR(j, (char) 1);
Poblacion[0].set_perf(BEST_CROM.perf());
i = 1;
} else i = 0;
/* REINICIALIZAR TODOS MENOS EL PRIMERO */
for (; i < Popsize; i++) {
for (j = 0; j < Genes; j++) Poblacion[i].set_gene(j, BEST_CROM.gene(j));
for (j = 0; j < GenesA; j++)
Poblacion[i].set_geneA(
j, Gene[j].min() + (Gene[j].max() - Gene[j].min()) * Randomize.Rand());
for (j = 0; j < n_reglas_total; j++) Poblacion[i].set_geneR(j, '1');
}
THRESHOLD = (double) (GenesA / 4.5);
reduccionIni = THRESHOLD * 0.001;
}
Reiniciado = 1;
}
/** Performs a new generation of the subpopulation */
public void doGeneration() {
int notSave;
int father, mother;
// evaluate population
for (int i = 0; i < size; i++) {
fitness[i] = evaluateFitness(i);
}
sortPopulation();
// apply elitism
notSave = size - ((int) ((double) size * Elitism));
newPopulation = new int[size][trainData.length];
// generate new population
for (int i = 0; i < notSave; i += 2) {
// selection of parents
father = Randomize.RandintClosed(0, size - notSave - 1);
do {
mother = Randomize.RandintClosed(0, size - notSave - 1);
} while (mother == father);
// crossover
HUX(father, mother, i);
}
// merge new population
int basis = size - notSave;
for (int i = 0; i < notSave; i++) {
for (int j = 0; j < population[i].length; j++) {
population[basis + i][j] = newPopulation[i][j];
}
fitness[basis + i] = -1.0;
CoCoIS.RequestReevaluation(ID, getKey(basis + i));
}
// apply random mutation
for (int i = 0; i < size; i++) {
if (Randomize.Rand() < PRandom) {
for (int j = 0; j < population[i].length; j++) {
if (Randomize.Rand() < PBit) {
population[i][j] = (population[i][j] + 1) % 2;
}
}
fitness[i] = -1.0;
CoCoIS.RequestReevaluation(ID, getKey(i));
}
}
// apply Rnn mutation
for (int i = 0; i < size; i++) {
if (Randomize.Rand() < PRnn) {
rnnMutation(i);
fitness[i] = -1.0;
CoCoIS.RequestReevaluation(ID, getKey(i));
}
}
} // end-method
/** It launches the algorithm */
public void execute() {
int i, j, k, l;
int t;
int ele;
double prob[];
double aux;
double NUmax = 1.5; // used for lineal ranking
double NUmin = 0.5; // used for lineal ranking
double pos1, pos2;
int sel1, sel2;
int data[][];
int infoAttr[];
int classData[];
Vector<Rule> contenedor = new Vector<Rule>();
Vector<Rule> conjR = new Vector<Rule>();
Rule tmpRule;
Condition tmpCondition[] = new Condition[1];
RuleSet population[];
RuleSet hijo1, hijo2;
if (somethingWrong) { // We do not execute the program
System.err.println("An error was found, the data-set has numerical values.");
System.err.println("Aborting the program");
// We should not use the statement: System.exit(-1);
} else {
Randomize.setSeed(seed);
nClasses = train.getnClasses();
/*Build the nominal data information*/
infoAttr = new int[train.getnInputs()];
for (i = 0; i < infoAttr.length; i++) {
infoAttr[i] = train.numberValues(i);
}
data = new int[train.getnData()][train.getnInputs()];
for (i = 0; i < data.length; i++) {
for (j = 0; j < data[i].length; j++) {
if (train.isMissing(i, j)) data[i][j] = -1;
else data[i][j] = train.valueExample(i, j);
}
}
classData = new int[train.getnData()];
for (i = 0; i < classData.length; i++) {
classData[i] = train.getOutputAsInteger(i);
}
/*Find first-order rules which result interesting*/
for (i = 0; i < nClasses; i++) {
for (j = 0; j < infoAttr.length; j++) {
for (k = 0; k < infoAttr[j]; k++) {
tmpCondition[0] = new Condition(j, k);
tmpRule = new Rule(tmpCondition);
if (Math.abs(computeAdjustedResidual(data, classData, tmpRule, i)) > 1.96) {
if (!contenedor.contains(tmpRule)) {
contenedor.add(tmpRule);
conjR.add(tmpRule);
}
}
}
}
}
// Construct the Baker selection roulette
prob = new double[popSize];
for (j = 0; j < popSize; j++) {
aux = (double) (NUmax - NUmin) * ((double) j / (popSize - 1));
prob[j] = (double) (1.0 / (popSize)) * (NUmax - aux);
}
for (j = 1; j < popSize; j++) prob[j] = prob[j] + prob[j - 1];
/*Steady-State Genetic Algorithm*/
ele = 2;
population = new RuleSet[popSize];
while (conjR.size() >= 2) {
t = 0;
System.out.println("Producing rules of level " + ele);
for (i = 0; i < population.length; i++) {
population[i] = new RuleSet(conjR);
population[i].computeFitness(data, classData, infoAttr, contenedor, nClasses);
}
Arrays.sort(population);
while (t < numGenerations && !population[0].equals(population[popSize - 1])) {
System.out.println("Generation " + t);
t++;
/*Baker's selection*/
pos1 = Randomize.Rand();
pos2 = Randomize.Rand();
for (l = 0; l < popSize && prob[l] < pos1; l++) ;
sel1 = l;
for (l = 0; l < popSize && prob[l] < pos2; l++) ;
sel2 = l;
hijo1 = new RuleSet(population[sel1]);
hijo2 = new RuleSet(population[sel2]);
if (Randomize.Rand() < pCross) {
RuleSet.crossover1(hijo1, hijo2);
} else {
RuleSet.crossover2(hijo1, hijo2);
}
RuleSet.mutation(hijo1, conjR, pMut, data, classData, infoAttr, contenedor, nClasses);
RuleSet.mutation(hijo2, conjR, pMut, data, classData, infoAttr, contenedor, nClasses);
hijo1.computeFitness(data, classData, infoAttr, contenedor, nClasses);
hijo2.computeFitness(data, classData, infoAttr, contenedor, nClasses);
population[popSize - 2] = new RuleSet(hijo1);
population[popSize - 1] = new RuleSet(hijo2);
Arrays.sort(population);
}
/*Decode function*/
ele++;
conjR.removeAllElements();
System.out.println(
"Fitness of the best chromosome in rule level " + ele + ": " + population[0].fitness);
for (i = 0; i < population[0].getRuleSet().length; i++) {
if (Math.abs(computeAdjustedResidual(data, classData, population[0].getRule(i), i))
> 1.96) {
if (validarRegla(population[0].getRule(i))
&& !contenedor.contains(population[0].getRule(i))) {
contenedor.add(population[0].getRule(i));
conjR.add(population[0].getRule(i));
}
}
}
}
// Finally we should fill the training and test output files
doOutput(this.val, this.outputTr, data, classData, infoAttr, contenedor, nClasses);
doOutput(this.test, this.outputTst, data, classData, infoAttr, contenedor, nClasses);
/*Print the rule obtained*/
for (i = contenedor.size() - 1; i >= 0; i--) {
if (reglaPositiva(
this.train, data, classData, infoAttr, nClasses, contenedor.elementAt(i))) {
Fichero.AnadirtoFichero(outputRule, contenedor.elementAt(i).toString(train));
Fichero.AnadirtoFichero(
outputRule,
" -> "
+ consecuente(
this.train, data, classData, infoAttr, nClasses, contenedor.elementAt(i))
+ "\n");
}
}
System.out.println("Algorithm Finished");
}
}
/** Executes the algorithm */
public void ejecutar() {
int i, j, l;
int nClases;
double conjS[][];
double conjR[][];
int conjN[][];
boolean conjM[][];
int clasesS[];
int nSel = 0;
Cromosoma poblacion[];
int ev = 0;
double prob[];
double NUmax = 1.5;
double NUmin = 0.5; // used for lineal ranking
double aux;
double pos1, pos2;
int sel1, sel2, comp1, comp2;
Cromosoma newPob[];
long tiempo = System.currentTimeMillis();
/*Getting the number of different clases*/
nClases = 0;
for (i = 0; i < clasesTrain.length; i++) if (clasesTrain[i] > nClases) nClases = clasesTrain[i];
nClases++;
/*Random inicialization of the population*/
Randomize.setSeed(semilla);
poblacion = new Cromosoma[tamPoblacion];
for (i = 0; i < tamPoblacion; i++) poblacion[i] = new Cromosoma(datosTrain.length);
/*Initial evaluation of the population*/
for (i = 0; i < tamPoblacion; i++)
poblacion[i].evalua(
datosTrain,
realTrain,
nominalTrain,
nulosTrain,
clasesTrain,
alfa,
kNeigh,
nClases,
distanceEu);
if (torneo) {
while (ev < nEval) {
newPob = new Cromosoma[2];
/*Binary tournament selection*/
comp1 = Randomize.Randint(0, tamPoblacion - 1);
do {
comp2 = Randomize.Randint(0, tamPoblacion - 1);
} while (comp2 == comp1);
if (poblacion[comp1].getCalidad() > poblacion[comp2].getCalidad()) sel1 = comp1;
else sel1 = comp2;
comp1 = Randomize.Randint(0, tamPoblacion - 1);
do {
comp2 = Randomize.Randint(0, tamPoblacion - 1);
} while (comp2 == comp1);
if (poblacion[comp1].getCalidad() > poblacion[comp2].getCalidad()) sel2 = comp1;
else sel2 = comp2;
if (Randomize.Rand() < pCruce) { // there is cross
crucePMX(poblacion, newPob, sel1, sel2);
} else { // there is not cross
newPob[0] = new Cromosoma(datosTrain.length, poblacion[sel1]);
newPob[1] = new Cromosoma(datosTrain.length, poblacion[sel2]);
}
/*Mutation of the cromosomes*/
for (i = 0; i < 2; i++) newPob[i].mutacion(pMutacion1to0, pMutacion0to1);
/*Evaluation of the population*/
for (i = 0; i < 2; i++)
if (!(newPob[i].estaEvaluado())) {
newPob[i].evalua(
datosTrain,
realTrain,
nominalTrain,
nulosTrain,
clasesTrain,
alfa,
kNeigh,
nClases,
distanceEu);
ev++;
}
/*Replace the two worst*/
Arrays.sort(poblacion);
poblacion[tamPoblacion - 2] = new Cromosoma(datosTrain.length, newPob[0]);
poblacion[tamPoblacion - 1] = new Cromosoma(datosTrain.length, newPob[1]);
}
} else {
/*Get the probabilities of lineal ranking in case of not use binary tournament*/
prob = new double[tamPoblacion];
for (i = 0; i < tamPoblacion; i++) {
aux = (double) (NUmax - NUmin) * ((double) i / (tamPoblacion - 1));
prob[i] = (double) (1.0 / (tamPoblacion)) * (NUmax - aux);
}
for (i = 1; i < tamPoblacion; i++) prob[i] = prob[i] + prob[i - 1];
while (ev < nEval) {
/*Sort the population by quality criterion*/
Arrays.sort(poblacion);
newPob = new Cromosoma[2];
pos1 = Randomize.Rand();
pos2 = Randomize.Rand();
for (j = 0; j < tamPoblacion && prob[j] < pos1; j++) ;
sel1 = j;
for (j = 0; j < tamPoblacion && prob[j] < pos2; j++) ;
sel2 = j;
if (Randomize.Rand() < pCruce) { // there is cross
crucePMX(poblacion, newPob, sel1, sel2);
} else { // there is not cross
newPob[0] = new Cromosoma(datosTrain.length, poblacion[sel1]);
newPob[1] = new Cromosoma(datosTrain.length, poblacion[sel2]);
}
/*Mutation of the cromosomes*/
for (i = 0; i < 2; i++) newPob[i].mutacion(pMutacion1to0, pMutacion0to1);
/*Evaluation of the population*/
for (i = 0; i < 2; i++)
if (!(newPob[i].estaEvaluado())) {
newPob[i].evalua(
datosTrain,
realTrain,
nominalTrain,
nulosTrain,
clasesTrain,
alfa,
kNeigh,
nClases,
distanceEu);
ev++;
}
/*Replace the two worst*/
poblacion[tamPoblacion - 2] = new Cromosoma(datosTrain.length, newPob[0]);
poblacion[tamPoblacion - 1] = new Cromosoma(datosTrain.length, newPob[1]);
}
}
nSel = poblacion[0].genesActivos();
/*Building of S set from the best cromosome obtained*/
conjS = new double[nSel][datosTrain[0].length];
conjR = new double[nSel][datosTrain[0].length];
conjN = new int[nSel][datosTrain[0].length];
conjM = new boolean[nSel][datosTrain[0].length];
clasesS = new int[nSel];
for (i = 0, l = 0; i < datosTrain.length; i++) {
if (poblacion[0].getGen(i)) { // the instance must be copied to the solution
for (j = 0; j < datosTrain[0].length; j++) {
conjS[l][j] = datosTrain[i][j];
conjR[l][j] = realTrain[i][j];
conjN[l][j] = nominalTrain[i][j];
conjM[l][j] = nulosTrain[i][j];
}
clasesS[l] = clasesTrain[i];
l++;
}
}
System.out.println(
"SGA " + relation + " " + (double) (System.currentTimeMillis() - tiempo) / 1000.0 + "s");
OutputIS.escribeSalida(
ficheroSalida[0], conjR, conjN, conjM, clasesS, entradas, salida, nEntradas, relation);
OutputIS.escribeSalida(ficheroSalida[1], test, entradas, salida, nEntradas, relation);
} // end-method
/**
* It initialize the population
*
* @param tam1 It contains the size of the table of training
* @param v1 It contains the training input values
* @param s1 It contains the training output values
* @param tam2 It contains the size of the table of test
* @param v2 It contains the test input values
* @param s2 It contains the test output values
* @param n_variables It contains the number of variables
* @param reglas It contains the number of rules
* @param var It contains the number of state variables
* @param sal It contains the exit value
* @param v It contains the values of data base
* @param semilla It contains the value of the seed
*/
public void Initialize(
int tam1,
double[][] v1,
double[] s1,
int tam2,
double[][] v2,
double[] s2,
int n_variables,
int reglas,
int var,
double sal,
double[] v,
long semilla) {
/* INICIALIZAR VARIABLES */
int i, j;
Genes = 0;
contador = contador2 = 0;
Reiniciado = 0;
Randomize.setSeed(semilla);
E = new Ecm(tam1, v1, s1, tam2, v2, s2, n_variables, reglas, var, sal, v);
Poblacion = new Cromosoma[2 * Popsize];
Trials = 0;
for (i = 0; i < n_variables; i++) {
Genes += E.base().getN_etiquetas(i);
}
Ajuste = 1;
Gene = new Gen[Genes];
GenesA = Genes - E.base().getN_etiquetas(E.base().getN_var_estado());
THRESHOLD = (double) ((Genes + GenesA) * BITS_GEN / 4.0);
reduccionIni = THRESHOLD * 0.001;
n_reglas_total = reglas;
Gen aux = new Gen();
aux.set_min(0.0);
aux.set_max(1.0);
for (i = 0; i < Genes; i++) {
Gene[i] = aux;
}
for (i = 0; i < 2 * Popsize; i++) {
Poblacion[i] = new Cromosoma(Genes, GenesA, n_reglas_total);
}
sample = new int[Popsize];
BEST_CROM = new Cromosoma(Genes, Genes, n_reglas_total);
for (j = 0; j < Genes; j++) {
BEST_CROM.set_gene(j, Gene[j].min() + (Gene[j].max() - Gene[j].min()) / 2.);
Poblacion[0].set_gene(j, BEST_CROM.gene(j));
}
for (j = 0; j < GenesA; j++) {
BEST_CROM.set_geneA(j, Gene[j].min() + (Gene[j].max() - Gene[j].min()) / 2.);
Poblacion[0].set_geneA(j, BEST_CROM.gene(j));
}
for (j = 0; j < n_reglas_total; j++) {
BEST_CROM.set_geneR(j, (char) 1);
Poblacion[0].set_geneR(j, (char) 1);
}
for (i = 1; i < Popsize; i++) {
for (j = 0; j < Genes; j++)
Poblacion[i].set_gene(
j, Gene[j].min() + (Gene[j].max() - Gene[j].min()) * Randomize.Rand());
for (j = 0; j < GenesA; j++)
Poblacion[i].set_geneA(
j, Gene[j].min() + (Gene[j].max() - Gene[j].min()) * Randomize.Rand());
for (j = 0; j < n_reglas_total; j++) Poblacion[i].set_geneR(j, (char) 1);
}
F = new Funciones();
}
