public HillClimber(int NeighbourHoodSize, int gPopSize, int Dim, OptimisationFunctionSet func, IOptimiser optimiser)
{
NeighbourhoodSize = NeighbourHoodSize;
GuessedPopSize = gPopSize;
Dimension = Dim;
Functions = func;
Optimiser = optimiser;
}
public IEnumerable <PerformanceIndicator> Run(OptimisationFunctionSet Functions)
{
List <PerformanceIndicator> performances = new List <PerformanceIndicator>();
foreach (var func in Functions.Functions)
{
double accuracy = double.NaN;
int averageEpochsToConverge = 0;
double averageAccuracy = 0.0;
for (int runNum = 0; runNum < NUMBER_OF_RUNS; runNum++)
{
bool converged = false;
m_thisGeneration = new ArrayList(Generations);
CreateGenomes(func);
for (int generationNum = 0; generationNum < Generations; generationNum++)
{
m_nextGeneration = new ArrayList(Generations);
if (!converged && Math.Abs(((Genome)m_thisGeneration[0]).Fitness - func.KnownGoal) < FITNESS_MARGIN)
{
converged = true;
averageEpochsToConverge += generationNum;
break;
}
RankPopulation(ref m_thisGeneration, func.Function);
CreateNextGeneration(ref m_thisGeneration, ref m_nextGeneration);
RankPopulation(ref m_nextGeneration, func.Function);
ApplyElitism(ref m_thisGeneration, ref m_nextGeneration);
}
if (!converged)
{
averageEpochsToConverge += Generations;
}
if (double.IsNaN(accuracy))
{
accuracy = ((Genome)m_thisGeneration[0]).Fitness;
}
averageAccuracy += ((Genome)m_thisGeneration[0]).Fitness;
if (((Genome)m_thisGeneration[0]).Fitness < accuracy)
{
accuracy = ((Genome)m_thisGeneration[0]).Fitness;
}
//if (runNum % (NUMBER_OF_RUNS / 10) == 0)
// Console.Write("..." + (((double)(runNum) / NUMBER_OF_RUNS * 100.0) + 10.0) + "%");
}
averageEpochsToConverge /= NUMBER_OF_RUNS;
averageAccuracy /= NUMBER_OF_RUNS;
performances.Add(new PerformanceIndicator()
{
Accuracy = accuracy,
Function = func,
AlgorithmName = "GGA",
PopulationNumber = PopulationSize,
Iterations = averageEpochsToConverge
});
}
return(performances);
}
public IEnumerable <PerformanceIndicator> Run(OptimisationFunctionSet Functions)
{
Random r1 = new Random(System.DateTime.Now.Millisecond);
Random r2 = new Random(System.DateTime.Now.Millisecond);
SetUp();
foreach (FunctionWrapper function in Functions.Functions)
{
//initialise swarm
Population = new Particle[PopulationSize];
double[] GlobalBest = new double[Dimensions];
for (int i = 0; i < Dimensions; i++)
{
GlobalBest[i] = function.UpperBound;
}
Random rand = new Random();
for (int i = 0; i < PopulationSize; i++)
{
Population[i] = new Particle()
{
Position = new double[Dimensions],
BestPosition = new double[Dimensions],
Velocity = new double[Dimensions],
Fitness = 0
};
//define Position
for (int j = 0; j < Dimensions; j++)
{
Population[i].Velocity[j] = 0;
Population[i].Position[j] = function.LowerBound + rand.NextDouble() * (function.UpperBound - function.LowerBound);
Population[i].BestPosition[j] = Population[i].Position[j];
}
}
//execute pso algorithm
int iteration = 0;
while (iteration <= MaxIterations)
{
for (int i = 0; i < PopulationSize; i++)
{
//check BestPosition Position
if (function.Function(Population[i].Position) < function.Function(Population[i].BestPosition))
{
Array.Copy(Population[i].Position, Population[i].BestPosition, Dimensions);
}
//check gBest Position
if (function.Function(Population[i].BestPosition) < function.Function(GlobalBest))
{
Array.Copy(Population[i].BestPosition, GlobalBest, GlobalBest.Length);
}
}
//Velocity and Position updates
for (int i = 0; i < PopulationSize; i++)
{
//Velocity
for (int j = 0; j < Dimensions; j++)
{
Population[i].Velocity[j] = W * Population[i].Velocity[j] + C1 * r1.NextDouble() * (Population[i].BestPosition[j] - Population[i].Position[j])
+ C2 * r2.NextDouble() * (GlobalBest[j] - Population[i].Position[j]);
}
//Position
for (int j = 0; j < Dimensions; j++)
{
Population[i].Position[j] = Population[i].Position[j] + Population[i].Velocity[j];
if (Population[i].Position[j] < function.LowerBound)
{
Population[i].Position[j] = function.LowerBound;
}
else if (Population[i].Position[j] > function.UpperBound)
{
Population[i].Position[j] = function.UpperBound;
}
}
}
Console.WriteLine(iteration + ". " + function.Function(GlobalBest));
/*!!!!!!!!!For diversity measure
* if (iteration % 10 == 0)
* {
* //work out average of average distance
* //every particle
* double outerSum = 0;
* for (int i = 0; i < PopulationSize; i++)
* {
* double innerSum = 0;
* for (int j = 0; j < PopulationSize; j++)
* {
* double ksum = 0;
* for (int k = 0; k < Dimensions; k++)
* {
* ksum += Math.Pow(Population[i].Position[k] - Population[j].Position[k], 2);
* }
* innerSum += Math.Sqrt(ksum);
* }
* outerSum += 1.0 / PopulationSize * innerSum;
* }
* outerSum = 1.0 / PopulationSize * outerSum;
* }!!!!!!!!!!!!*/
/*!!!!!!!!!!!!!!for efficiency
* if (Math.Abs(function.optimumGoal - calculateFitness(gBest)) < 0.005 && !solFound)
* {
* solFound = true;
* solutionIteration = iteration;
* }!!!!!!!!!!!!!!!!!!*/
iteration++;
}
}
//accuracy
//double acc = Math.Abs(function.Function(gBest) - function.optimumGoal);
Console.ReadLine();
return(new List <PerformanceIndicator>());
}
public IEnumerable <PerformanceIndicator> Run(OptimisationFunctionSet Functions)
{
foreach (FunctionWrapper function in Functions.Functions)
{
SetUp();
//initialise population
Random rand = new Random();
for (int i = 0; i < PopulationSize; i++)
{
Agent agent = new Agent()
{
Position = new double[Dimensions],
Fitness = 0
};
for (int j = 0; j < Dimensions; j++)
{
agent.Position[j] = function.LowerBound + rand.NextDouble() * (function.UpperBound - function.LowerBound);
}
Population.Add(agent);
}
int generation = 0;
while (generation < MaxGenerations)
{
List <Agent> newPopulation = new List <Agent>();
foreach (Agent parentAgent in Population)
{
//fitness
parentAgent.Fitness = function.Function(parentAgent.Position);
//trial vector (mutation)
Agent trialAgent = new Agent()
{
Position = new double[Dimensions],
Fitness = 0
};
List <Agent> targetAgents = new List <Agent>();
rand = new Random();
while (targetAgents.Count < 3)
{
Agent testAgent = Population.ElementAt(rand.Next(PopulationSize));
if (!testAgent.Equals(parentAgent) && !targetAgents.Contains(testAgent))
{
targetAgents.Add(testAgent);
}
}
Agent a, b, c;
a = targetAgents.ElementAt(0);
b = targetAgents.ElementAt(1);
c = targetAgents.ElementAt(2);
for (int i = 0; i < Dimensions; i++)
{
trialAgent.Position[i] = a.Position[i] + ScalingFactor * (b.Position[i] - c.Position[i]);
if (!(trialAgent.Position[i] > function.LowerBound && trialAgent.Position[i] < function.UpperBound))
{
trialAgent.Position[i] = function.LowerBound + rand.NextDouble() * (function.UpperBound - function.LowerBound);
}
}
//crossover
rand = new Random();
Agent offspringAgent = new Agent()
{
Position = new double[Dimensions],
Fitness = 0
};
int crossoverDefault = rand.Next(Dimensions);
offspringAgent.Position[crossoverDefault] = trialAgent.Position[crossoverDefault];
for (int i = 0; i < Dimensions; i++)
{
if (i != crossoverDefault)
{
if (rand.NextDouble() < CrossoverProbability)
{
offspringAgent.Position[i] = trialAgent.Position[i];
}
else
{
offspringAgent.Position[i] = parentAgent.Position[i];
}
}
}
offspringAgent.Fitness = function.Function(offspringAgent.Position);
//offspring vs parent test
if (offspringAgent.Fitness < parentAgent.Fitness)
{
newPopulation.Add(offspringAgent);
}
else
{
newPopulation.Add(parentAgent);
}
}
Population = newPopulation;
generation++;
double avg = 0;
foreach (Agent agent in Population)
{
avg += agent.Fitness;
}
avg /= PopulationSize;
Console.WriteLine(avg);
}
}
Console.ReadLine();
return(new List <PerformanceIndicator>());
}
