private double Dobrota(KromosomDouble kromosom)
{
double rez = (_nn.CalculateError(kromosom.PoljeRjesenja, _data) - _nn.CalculateError(_worstPop.PoljeRjesenja, _data))
/ (_nn.CalculateError(_best.PoljeRjesenja, _data) - _nn.CalculateError(_worstPop.PoljeRjesenja, _data)); //TODO kazna(vk) = max{dobrota(vk)} - dobrota(vk)
return(rez);
}
private KromosomDouble HeuristicCrossover(KromosomDouble kromosom1, KromosomDouble kromosom2)
{
double a = GenerirajSelekcija(1, _rand);
KromosomDouble dijete1 = new KromosomDouble();
KromosomDouble bolji, losiji;
if (kromosom1._dobrota < kromosom2._dobrota)
{
bolji = kromosom2;
losiji = kromosom1;
}
else
{
bolji = kromosom1;
losiji = kromosom2;
}
for (int i = 0; i < _dimenzionalnost; i++)
{
double val = a * (bolji.Rjesenje(i) - losiji.Rjesenje(i)) + bolji.Rjesenje(i);
if (Math.Abs(val) > 20) // WARNING, heuristicni zna izletit
{
val = GenerirajSelekcija(1, _rand);
}
dijete1.PostaviRjesenje(i, val);
}
return(dijete1);
}
private void NadjiBest(KromosomDouble[] p)
{
for (int k = 0; k < _velicinaPop; k++) //nadji best
{
if (p[k]._dobrota > _best._dobrota)
{
_best = p[k]; //najbolja jedinka
_best._dobrota = p[k]._dobrota;
continue;
}
if (p[k]._dobrota < _worstPop._dobrota)
{
_worstPop = p[k]; //najgora jedinka
_worstPop._dobrota = p[k]._dobrota;
continue;
}
}
if (t > 1 && (_oldBest != _best))
{
_oldBest = _best;
_oldBest._dobrota = _best._dobrota;
if (_verbose)
{
Console.WriteLine(">>>>>>> {0} >>> Nova najbolja jedinka:", _imeAlg);
Console.WriteLine("\tGeneracija: {0}", (int)t / _velicinaPop);
Console.WriteLine("\tIteracija: {0}", t);
Console.Write("\tVrijednost funkcije: {0} \n\tParametri:", _nn.CalculateError(_best.PoljeRjesenja, _data));
for (int i = 0; i < _dimenzionalnost; i++)
{
if (i % 12 == 0)
{
Console.Write("\n");
}
Console.Write("{0:0.00} \t", _best.Rjesenje(i));
if (i == _dimenzionalnost - 1)
{
Console.Write("\n");
}
}
}
else
{
Console.Write(">>> {0}: Nova najbolja jedinka:", _imeAlg);
Console.Write("\tGeneracija: {0}", (int)t / _velicinaPop);
Console.WriteLine("\tVrijednost funkcije: {0}", _nn.CalculateError(_best.PoljeRjesenja, _data));
}
}
else if (t <= 1)
{
_oldBest = _best;
}
}
private KromosomDouble SimulatedBinaryCrossover(KromosomDouble kromosom1, KromosomDouble kromosom2)
{
double alfa = GenerirajSelekcija(1, _rand);
KromosomDouble dijete1 = new KromosomDouble();
for (int i = 0; i < _dimenzionalnost; i++)
{
double val = alfa * kromosom1.Rjesenje(i) + (1 - alfa) * kromosom2.Rjesenje(i);
dijete1.PostaviRjesenje(i, val);
}
return(dijete1);
}
private KromosomDouble[] ZamijeniDijeteZaWorst(KromosomDouble[] p0, KromosomDouble dijete, KromosomDouble _worst)
{
for (int i = 0; i < _velicinaPop; i++)
{
if (p0[i] == _worst)
{
p0[i] = dijete;
return(p0);
}
}
throw new Exception("ne radi kako bi trebalo");
}
private KromosomDouble Mutacija1(KromosomDouble kr)
{
for (int i = 0; i < _dimenzionalnost; i++)
{
double vjv = GenerirajSelekcija(1, _rand);
if (vjv <= _vjvMutKomp1)
{
var val = Distribucije.Normalna(0, _sigma1);
kr.PostaviRjesenje(i, val);
}
}
return(kr);
}
private KromosomDouble NadjiWorst(List <KromosomDouble> tr)
{
KromosomDouble worst = tr[0];
worst._dobrota = tr[0]._dobrota;
for (int k = 0; k < 3; k++)
{
if (tr[k]._dobrota < worst._dobrota)
{
worst = tr[k];
worst._dobrota = tr[k]._dobrota;
}
}
return(worst);
}
private KromosomDouble[] GenerirajPocetnu(int _velicinaPop)
{
KromosomDouble[] P_0 = new KromosomDouble[_velicinaPop];
for (int i = 0; i < _velicinaPop; i++)
{
P_0[i] = new KromosomDouble();
}
for (int i = 0; i < _velicinaPop; i++)
{
for (int j = 0; j < _dimenzionalnost; j++)
{
P_0[i].PostaviRjesenje(j, _rand.NextDouble() * (_gg - (_dg)) + (_dg));
}
}
return(P_0);
}
private void IspisiRjesenje(KromosomDouble _best)
{
Console.WriteLine("============================================================");
Console.WriteLine("\n>>>>>>> Algoritam {0} zaustavljen:", _imeAlg);
Console.WriteLine("\tBroj iteracija: {0}", _brojIteracija);
Console.WriteLine("\tGeneracija: {0}", (int)t / _velicinaPop);
Console.Write("\tVrijednost funkcije: {0} \n\tParametri:", _nn.CalculateError(_best.PoljeRjesenja, _data));
for (int i = 0; i < _dimenzionalnost; i++)
{
Console.Write(" {0} ", _best.Rjesenje(i));
if (i == _dimenzionalnost - 1)
{
Console.Write("\n");
}
}
Console.WriteLine("============================================================\n");
}
private KromosomDouble Mutacija(KromosomDouble pt)
{
double vjv = GenerirajSelekcija(1, _rand);
if (vjv <= _vjvMut)
{
vjv = GenerirajSelekcija(1, _rand);
if (vjv <= _vjvOdabiraMut1)
{
pt = Mutacija1(pt);
}
else
{
pt = Mutacija2(pt);
}
}
return(pt);
}
private KromosomDouble SimpleArithmeticRecombination(KromosomDouble kromosom1, KromosomDouble kromosom2)
{
int position = (int)GenerirajSelekcija(_dimenzionalnost, _rand);
KromosomDouble dijete1 = new KromosomDouble();
KromosomDouble dijete2 = new KromosomDouble();
for (int i = 0; i < position; i++)
{
dijete1.PostaviRjesenje(i, kromosom1.Rjesenje(i));
}
for (int i = position; i < _dimenzionalnost; i++)
{
double val = (kromosom1.Rjesenje(i) + kromosom2.Rjesenje(i)) / 2;
dijete1.PostaviRjesenje(i, val);
}
return(dijete1);
}
internal void InspectOutput(KromosomDouble param, Dataset dataset)
{
Console.WriteLine("\nIsprobavanje mreze:");
while (true)
{
Console.WriteLine("Unesite x [0, 63]:");
var broj = int.Parse(Console.ReadLine(), CultureInfo.InvariantCulture);
var output = CalculateOutput(param.PoljeRjesenja, dataset.ExampleAtIndex(broj));
if (broj == -1)
{
break;
}
Console.WriteLine("Izlaz mreze: {0} {1} {2}", output[0], output[1], output[2]);
Console.WriteLine("Stvarni iznos: {0} {1} {2}", dataset.ExampleAtIndex(broj)[2], dataset.ExampleAtIndex(broj)[3], dataset.ExampleAtIndex(broj)[4]);
}
}
internal void InspectClassification(KromosomDouble param, Dataset dataset)
{
Console.WriteLine("\nIspitivanje mreze:");
int N = dataset.DatasetLength;
int korektno = 0;
int pogresno = 0;
for (int broj = 0; broj < N; broj++)
{
var output = CalculateOutput(param.PoljeRjesenja, dataset.ExampleAtIndex(broj));
Console.Write(">Uzorak {0} {1}:", dataset.ExampleAtIndex(broj)[0], dataset.ExampleAtIndex(broj)[1]);
Console.Write("Izlaz: {0} {1} {2}: ", dataset.ExampleAtIndex(broj)[2], dataset.ExampleAtIndex(broj)[3], dataset.ExampleAtIndex(broj)[4]);
for (int j = 0; j < 3; j++)
{
if (output[j] > 0.5)
{
output[j] = 1;
}
else
{
output[j] = 0;
}
}
Console.Write("Izlaz mreze: {0} {1} {2}: ", output[0], output[1], output[2]);
if (output[0] == dataset.ExampleAtIndex(broj)[2] && output[1] == dataset.ExampleAtIndex(broj)[3] && output[2] == dataset.ExampleAtIndex(broj)[4])
{
korektno++;
Console.Write("Korektno klas.\n");
}
else
{
pogresno++;
Console.Write("Pogresno klas.\n");
}
}
Console.WriteLine(">> Broj korektno klasificiranih: {0}", korektno);
Console.WriteLine(">> Broj pogresno klasificiranih: {0}", pogresno);
}
private void InitialWorstBest(KromosomDouble[] p)
{
_best = p[0];
_worstPop = p[1];
for (int k = 0; k < _velicinaPop; k++) //nadji best
{
if (_nn.CalculateError(p[k].PoljeRjesenja, _data) < _nn.CalculateError(_best.PoljeRjesenja, _data))
{
_best = p[k]; //najbolja jedinka
}
if (_nn.CalculateError(p[k].PoljeRjesenja, _data) > _nn.CalculateError(_worstPop.PoljeRjesenja, _data))
{
_worstPop = p[k]; //najbolja jedinka
}
}
//sad kad znamo koji je best, koji worst, svima spremi dobrote
for (int k = 0; k < _velicinaPop; k++)
{
p[k]._dobrota = Dobrota(p[k]);
}
}
internal void WriteParamsToFile(KromosomDouble param, string filenameN1, string filenameN2)
{
int paramIndex = 0;
using (FileStream fs = File.Open(filenameN1, FileMode.Create))
using (StreamWriter sw = new StreamWriter(fs))
{
for (int i = 2; i < _architecture[1] + 2; i++) //od 2 do architecture[1] + 2
{
// w1 s1 w2 s2 w1/s1 w2/s2
sw.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}\t{5}", param.PoljeRjesenja[paramIndex].ToString(CultureInfo.InvariantCulture), param.PoljeRjesenja[paramIndex + 1].ToString(CultureInfo.InvariantCulture),
param.PoljeRjesenja[paramIndex + 2].ToString(CultureInfo.InvariantCulture), param.PoljeRjesenja[paramIndex + 3].ToString(CultureInfo.InvariantCulture),
(param.PoljeRjesenja[paramIndex] / param.PoljeRjesenja[paramIndex + 1]).ToString(CultureInfo.InvariantCulture),
(param.PoljeRjesenja[paramIndex + 2] / param.PoljeRjesenja[paramIndex + 3]).ToString(CultureInfo.InvariantCulture));
paramIndex += 4;
}
}
using (FileStream fs = File.Open(filenameN2, FileMode.Create))
using (StreamWriter sw = new StreamWriter(fs))
{
int currentLayer = 2;
int paramNumPerSingleNeuronT2;
for (int j = currentLayer; j < _numberOfLayers; j++) //j == trenutni sloj
{
//ostali slojevi, neuroni tipa 2
paramNumPerSingleNeuronT2 = _architecture[j - 1] + 1; // w-ovi + w0
for (int i = 0; i < _architecture[j]; i++)
{
for (int k = 0; k < paramNumPerSingleNeuronT2; k++)
{
sw.Write("{0}\t", param.PoljeRjesenja[paramIndex + k].ToString(CultureInfo.InvariantCulture));
}
sw.WriteLine();
paramIndex += paramNumPerSingleNeuronT2;
}
}
}
}
public KromosomDouble ZapocniAlgoritam()
{
t = 0;
KromosomDouble[] P0 = GenerirajPocetnu(_velicinaPop); //generiraj početnu populaciju potencijalnih rješenja P(0);
List <KromosomDouble> tournament = new List <KromosomDouble>(3);
KromosomDouble dijete;
InitialWorstBest(P0);
while (UvjetIspunjen() && t < _brojIteracija)
{
t = t + 1;
NadjiBest(P0);
tournament = SelektirajIz(P0);
_worst = NadjiWorst(tournament);
tournament.Remove(_worst);
dijete = Krizanje(tournament);
dijete = Mutacija(dijete);
if (_nn.CalculateError(dijete.PoljeRjesenja, _data) < _nn.CalculateError(_best.PoljeRjesenja, _data))
{
_best = dijete;
_best._dobrota = dijete._dobrota;
}
else if (_nn.CalculateError(dijete.PoljeRjesenja, _data) > _nn.CalculateError(_worstPop.PoljeRjesenja, _data))
{
_worstPop = dijete;
_worstPop._dobrota = dijete._dobrota;
}
dijete._dobrota = Dobrota(dijete); //samo evaluiraj novo dijete
P0 = ZamijeniDijeteZaWorst(P0, dijete, _worst);
}
NadjiBest(P0);
IspisiRjesenje(_best);
return(_best);
}
