public void Init()
{
for (int i = 0; i < _marimePopulatie; i++)
{
var p = new Particula(_dimensiuni);
p.Create(_dimensiuni);
_populatie.Add(p);
}
}
public void AddPozitie(Particula p)
{
_listaPozitii.Add(p);
_listaPozitii = _listaPozitii.OrderBy(x => x.Fitness()).ToList();
}
public void AddVecin(Particula vecin)
{
_vecini.Add(vecin);
_vecini = _vecini.OrderBy(x => x.Fitness()).ToList();
}
public Particula Executar(TextWriter notificador)
{
notificador.WriteLine("Fitness Avaliacoes");
foreach (Particula p in _Particulas)
{
//_Rastringin(p);
_ELM(p);
p.AtualizarMelhorPosicaoParticula(true);
}
do
{
_AtualizarVelocidadeParticulas();
_AtualizarPosicaoParticulas();
_AvaliarParticulas();
if ((double)count / 100.0 > 1)
{
_Particulas.Sort(delegate(Particula i1, Particula i2) { return i1.MelhorFitness.CompareTo(i2.MelhorFitness); });
_GBest = _Particulas[0];
Console.WriteLine(_GBest.MelhorFitness.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("en-US")) + " " + count);
foreach (Particula part in _Particulas)
notificador.WriteLine(part.MelhorFitness.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("en-US")) + " " + count);
}
if (count > _NumeroMaximoAvaliacoesFuncao)
break;
}
while (true);
return _GBest;
}
private void _Rastringin(Particula p)
{
int n = p.PosicaoAtual.Length;
double s = 0;
for (int i = 0; i < n; i++)
{
s = s + (Math.Pow(p.PosicaoAtual[i], 2) - 10 * Math.Cos(2 * Math.PI * p.PosicaoAtual[i]));
}
count++;
p.Fitness = s;
// Variação de C1 e C2
if (_VariarC1C2)
{
if (count % _LimiteVariacaoC1C2 == 0)
{
_C1 = _C1 - _TaxaVariacaoC1C2;
_C2 = _C2 + _TaxaVariacaoC1C2;
}
}
// Variação de W
if (_VariarW)
{
if (count % _LimiteVariacaoW == 0)
_W = _W - _TaxaVariacaoW;
}
}
private RCConfiguration _GetELMConfigurationFromPSOParticle(Particula particle, DataProvider dProv)
{
int inputNodesLengh = particle.GetFlagCountFromSubListValues((int)dProv.InputsN);
if (inputNodesLengh == 0)
{
particle.PosicaoAtual[0] = 1;
inputNodesLengh = particle.GetFlagCountFromSubListValues((int)dProv.InputsN);
}
Data[] dataSet = new Data[dProv.DataSetLines];
int index = 0;
for (int i = 0; i < dProv.DataSetLines; i++)
{
index = 0;
dataSet[i] = new Data(new double[inputNodesLengh], new double[dProv.OutputsN]);
dataSet[i].Output = dProv.DataSet[i].Output;
for (int k = 0; k < dProv.InputsN; k++)
{
if (particle.PosicaoAtual[k] == 1)
{
dataSet[i].Input[index] = dProv.DataSet[i].Input[k];
index++;
}
}
}
DataProvider prov = new DataProvider(dataSet, EExecutionType.Predction, Util.Random);
int hiddenNodes = particle.GetHiddenNodes((int)dProv.InputsN, MaxHiddenNodes);
if (hiddenNodes == 0)
{
particle.PosicaoAtual[(int)dProv.InputsN] = 1;
hiddenNodes = particle.GetHiddenNodes((int)dProv.InputsN, MaxHiddenNodes);
}
prov.MaxClassificationClass = dProv.MaxClassificationClass;
return new RCConfiguration(prov, hiddenNodes, 1, 0.05, 1, EActivationFunctionType.SigmoidLogistic, EExecutionType.Predction);
}
private void _ELM(Particula p)
{
DataProvider prov = new DataProvider(_DataSetPath, EExecutionType.Predction, Util.Random);
RCConfiguration config = _GetELMConfigurationFromPSOParticle(p, prov);
config.Prov.MaxValue = prov.MaxValue.Clone() as double[];
config.Prov.MinValue = prov.MinValue.Clone() as double[];
config.Prov.NormalizeData(inputA, inputB, outputA, outputB);
config.Prov.ShuffleDataSet(1);
config.Prov.SplitData();
RC elm = new RC(config.Prov.TrainSet, config.Prov.ValidationSet, config);
try
{
elm.Run();
}
catch
{ }
RCEvaluator eval = new RCEvaluator(elm, EEvaluationInfo.EMQ | EEvaluationInfo.DEV | EEvaluationInfo.EPMA);
eval.Evaluate();
double fitness = eval.TrainEPMA + (2 * eval.ValidationDEV * p.GetFlagCountFromSubListValues((int)config.Prov.InputsN) / config.Prov.ValidationSetLines) + (config.HidenNodesNumber / MaxHiddenNodes);
p.Eval = eval;
p.Fitness = fitness;
p.Config = config;
count++;
// Variação de C1 e C2
if (_VariarC1C2)
{
if (count % _LimiteVariacaoC1C2 == 0)
{
_C1 = _C1 - _TaxaVariacaoC1C2;
_C2 = _C2 + _TaxaVariacaoC1C2;
}
}
// Variação de W
if (_VariarW)
{
if (count % _LimiteVariacaoW == 0)
_W = _W - _TaxaVariacaoW;
}
}
private void _AtualizarVelocidadeParticulas()
{
#region Se for focal
if (_TipoTopologia == ETipoTopologia.Focal)
{
// Seleção da partícula focal (a seleção é aleatória).
Random randomParticulaFocal = Util.Random;
int indiceParticulaFocal = randomParticulaFocal.Next(_Particulas.Count - 1);
_ParticulaFocal = _Particulas[indiceParticulaFocal];
// Seleção da melhor partícula. A partícula focal sem movimentará de acordo com ela.
_Particulas.Sort(delegate(Particula i1, Particula i2) { return i1.Fitness.CompareTo(i2.Fitness); });
_GBest = _Particulas[0];
// Movimentação da partícula focal de acordo com a melhor partícula encontrada.
for (int i = 0; i < _ParticulaFocal.Velocidade.Length; i++)
{
switch (_TipoVel)
{
case ETipoAtualizacaoVelocidade.Classica:
_ParticulaFocal.Velocidade[i] = _W * _ParticulaFocal.Velocidade[i] +
_C1 * Util.Random.NextDouble() * (_ParticulaFocal.MelhorPosicao[i] - _ParticulaFocal.PosicaoAtual[i]) +
_C2 * Util.Random.NextDouble() * (_GBest.MelhorPosicao[i] - _ParticulaFocal.PosicaoAtual[i]);
break;
case ETipoAtualizacaoVelocidade.Clerc:
_ParticulaFocal.Velocidade[i] = _W * (_ParticulaFocal.Velocidade[i] +
_C1 * Util.Random.NextDouble() * (_ParticulaFocal.MelhorPosicao[i] - _ParticulaFocal.PosicaoAtual[i]) +
_C2 * Util.Random.NextDouble() * (_GBest.MelhorPosicao[i] - _ParticulaFocal.PosicaoAtual[i]));
break;
}
if (_ParticulaFocal.Velocidade[i] > VMax)
_ParticulaFocal.Velocidade[i] = VMax;
else if (_ParticulaFocal.Velocidade[i] < -VMax)
_ParticulaFocal.Velocidade[i] = -VMax;
}
// Movimentação de demais partículas baseando-se em _GBest porque precisam se movimentar de acordo com o que a focal fez.
foreach (Particula particula in _Particulas)
{
for (int i = 0; i < particula.Velocidade.Length; i++)
{
particula.Velocidade[i] = _W * particula.Velocidade[i] +
_C1 * Util.Random.NextDouble() * (particula.MelhorPosicao[i] - particula.PosicaoAtual[i]) +
_C2 * Util.Random.NextDouble() * (_GBest.MelhorPosicao[i] - particula.PosicaoAtual[i]);
if (particula.Velocidade[i] > VMax)
particula.Velocidade[i] = VMax;
else if (particula.Velocidade[i] < -VMax)
particula.Velocidade[i] = -VMax;
}
}
}
#endregion
#region Global ou Local
else
{
foreach (Particula particula in _Particulas)
{
// _GBest será atualizando a cada movimento de partícula
if (_TipoTopologia == ETipoTopologia.Global)
{
_Particulas.Sort(delegate(Particula i1, Particula i2) { return i1.Fitness.CompareTo(i2.Fitness); });
_GBest = _Particulas[0];
}
for (int i = 0; i < particula.Velocidade.Length; i++)
{
particula.Velocidade[i] = _W * particula.Velocidade[i] +
_C1 * Util.Random.NextDouble() * (particula.MelhorPosicao[i] - particula.PosicaoAtual[i]) +
_C2 * Util.Random.NextDouble() * (_GetMelhorPosicaoGlobal(particula.Indice, i) - particula.PosicaoAtual[i]);
if (particula.Velocidade[i] > VMax)
particula.Velocidade[i] = VMax;
else if (particula.Velocidade[i] < -VMax)
particula.Velocidade[i] = -VMax;
}
}
}
#endregion
}
public Particula Rezolva(Parametrii param)
{
var rand = new Random();
var roi = new Particula[param.NumarParticule];
for (var i = 0; i < roi.Length; i++)
{
roi[i] = new Particula();
var pozitie = new double[param.DimensiuneProblema];
var viteza = new double[param.DimensiuneProblema]; //initialize with 0
for (var j = 0; j < pozitie.Length; j++)
{
pozitie[j] = (param.Max - param.Min) * rand.NextDouble() + param.Min;
}
// viteza[j] = rand.NextDouble();
roi[i].OptimPersonal = new Particula();
roi[i].OptimPersonal.Pozitie = new double[param.DimensiuneProblema];
pozitie.CopyTo(roi[i].OptimPersonal.Pozitie, 0);
roi[i].Pozitie = pozitie;
roi[i].Viteza = viteza;
roi[i].OptimPersonal.Cost = roi[i].Cost = Functie(roi[i].Pozitie);
} //sfarsit initializare
var aux = roi.OrderBy(part => part.Cost).First();
var optimSocial = new Particula();
optimSocial.Pozitie = new double[param.DimensiuneProblema];
aux.Pozitie.CopyTo(optimSocial.Pozitie, 0);
optimSocial.Cost = aux.Cost;
for (var i = 0; i < param.NumarIteratii; i++)
{
for (var k = 0; k < roi.Length; k++)
{
var particula = roi[k];
var r1 = rand.NextDouble();
var r2 = rand.NextDouble();
for (var j = 0; j < param.DimensiuneProblema; j++)
{
particula.Viteza[j] =
param.W * particula.Viteza[j] +
param.C1 * r1 * (particula.OptimPersonal.Pozitie[j] - particula.Pozitie[j]) +
param.C2 * r2 * (optimSocial.Pozitie[j] - particula.Pozitie[j]);
if (particula.Viteza[j] > param.VitezaMaxima)
{
particula.Viteza[j] = param.VitezaMaxima;
}
}
for (var j = 0; j < param.DimensiuneProblema; j++)
{
particula.Pozitie[j] += particula.Viteza[j];
if (particula.Pozitie[j] > param.Max)
{
particula.Pozitie[j] = param.Max;
}
if (particula.Pozitie[j] < param.Min)
{
particula.Pozitie[j] = param.Min;
}
}
particula.Cost = Functie(particula.Pozitie);
if (particula.Cost < particula.OptimPersonal.Cost)
{
particula.OptimPersonal = new Particula();
particula.OptimPersonal.Pozitie = new double[param.DimensiuneProblema];
particula.Pozitie.CopyTo(particula.OptimPersonal.Pozitie, 0);
particula.OptimPersonal.Cost = Functie(particula.OptimPersonal.Pozitie);
}
if (particula.Cost < optimSocial.Cost)
{
particula.Pozitie.CopyTo(optimSocial.Pozitie, 0);
optimSocial.Cost = particula.Cost;
}
}
}
return(optimSocial);
}