//Runs the algoritm for number of iterations
public override void Run(Configuration config)
{
log = new RandomLogSpecification(data.DataFileName, config.RandomSeed, config.NumberOfRuns, config.PenaltyCoefficient);
solution = new SolutionSpecification();
BitArray routerswitches = new BitArray((int)data.RouterCount);
double highestfitness = 0.0;
BitArray best = new BitArray((int)data.RouterCount);
for(int i = 0; i < config.NumberOfRuns; i++)
{
routerswitches = new BitArray((int)data.RouterCount);
int numbertoswitch = randomgenerator.Next((int)data.RouterCount);
for(int j = 0; j < numbertoswitch; j++)
{
int switching;
while(routerswitches.Get(switching = randomgenerator.Next((int)data.RouterCount)) == true);
routerswitches.Set(switching, true);
}
double fitness = FitnessEvaluation(data.NetworkPaths, routerswitches, numbertoswitch, config.PenaltyCoefficient);
if(fitness > highestfitness)
{
((RandomLogSpecification)log).AddEvaluation(i, fitness);
highestfitness = fitness;
best = (BitArray)routerswitches.Clone();
}
}
solution.RoutersTurnedOff = ExtensionMethods.ConvertBitArrayToOffRouterNumbers(best, data.HostCount);
}
public static void Main(string[] args)
{
string filename;
if(args.Length == 0)
filename = "default.cfg";
else
filename = args[0];
Configuration config = new Configuration();
try
{
config.loadFromFile(filename);
}
catch(Exception e)
{
Console.WriteLine("Main Exception: " + e.Message);
return;
}
Console.WriteLine(config);
//Do some reflection on types that can be used as an evolutionary algorithm.
var types = Assembly.GetExecutingAssembly().GetTypes();
EvolutionaryAlgorithm algorithm = null;
//I know there is a better way to do this.
foreach(Type t in types)
{
foreach(Attribute a in t.GetCustomAttributes(typeof(AlgorithmAttribute), true))
{
if(((AlgorithmAttribute)a).AlgorithmType == config.AlgorithmType)
algorithm = (EvolutionaryAlgorithm)Activator.CreateInstance(t);
}
}
//Get a random number generator with a set seed, or a time seed.
Random randomgenerator;
if(config.RandomSeed < 0)
randomgenerator = new Random();
else
randomgenerator = new Random(config.RandomSeed);
algorithm.RandomGenerator = randomgenerator;
algorithm.Data = config.getDataFile();
algorithm.Run(config);
//Output stuff to files
algorithm.Log.writeToFile(config.LogFilePath);
algorithm.Solution.writeToFile(config.SolutionFilePath);
}
public abstract void Run(Configuration config);
//Runs the algoritm for number of iterations
public override void Run(Configuration config)
{
Stopwatch totaltimer = Stopwatch.StartNew();
//Local population average and best fitness
double localaveragefitness = 0.0;
double localbestfitness = 0.0;
//Best solution per run
Individual bestsolution = null;
//Best solution overall
Individual bestbestsolution = null;
log = new MuLambdaLogSpecification(config);
solution = new SolutionSpecification();
this.config = config;
for(int run = 0; run < config.NumberOfRuns; run++)
{
Stopwatch runtimer = Stopwatch.StartNew();
Console.WriteLine("Run: " + run);
bestsolution = null;
fitnessevaluations = 0;
int samefitnessiterations = 0;
//Initialize our population
Stopwatch inittimer = Stopwatch.StartNew();
List<Individual> population = InitUniformRandomPopulation(config.PopulationSize, (int)data.RouterCount);
inittimer.Stop();
Console.WriteLine("Init time(ms): " + inittimer.Elapsed.TotalMilliseconds);
List<Individual> children = new List<Individual>();
//Forever, until broken out of
for(;;)
{
//Generation of children (lambda)
Stopwatch generationtimer = Stopwatch.StartNew();
for(int k = 0; k < config.NumberOfChildren; k++)
{
Individual parenta;
Individual parentb;
if(config.UseKTournamentForParent)
{
//Choose parents by K Tournament selection with replacement.
parenta = KTournamentSelection(config.ParentTournamentSize, population, true);
parentb = KTournamentSelection(config.ParentTournamentSize, population, true);
}
else // if(config.UseFitnessProportionForParent)
{
//Choose parents by fitness proportional selection
parenta = FitnessProportionalSelection(population);
parentb = FitnessProportionalSelection(population);
}
if(config.UseNCrossover)
{
//Generate child by using n point crossover
Individual child = GenerateChildNPoint(new Individual[2] { parenta, parentb }, config.NumberOfCrossoverPoints);
children.Add(child);
}
else // if(config.UseUniformCrossover)
{
//Generate child by using uniform crossover
Individual child = GenerateChildUniform(parenta, parentb);
children.Add(child);
}
}
//Mutation of children by bit flip
//This also adds the childs to the population
for(int a = 0; a < children.Count; a++)
{
children[a] = MutateByBitFlip(children[a], config.BitsToFlip);
population.Add(children[a]);
}
List<Individual> newpopulation = new List<Individual>();
localaveragefitness = 0.0;
localbestfitness = 0.0;
if(config.UseKTournamentForSurvivor)
{
//Finding the survivors for the new population
for(int i = 0; i < config.PopulationSize; i++)
{
//Use K Tournament without replacement
Individual survivor = KTournamentSelection(config.SurvivorTournamentSize, population, false);
newpopulation.Add(survivor);
//Adjust average and best fitnesses
localaveragefitness += survivor.Fitness;
if(survivor.Fitness > localbestfitness)
localbestfitness = survivor.Fitness;
}
localaveragefitness /= (double)config.PopulationSize;
}
else // if(config.UseTruncationForSurvivor)
{
//Find survivors using truncation. This also adjusts best and average fitnesses.
newpopulation = Truncate(population, config.PopulationSize, out localbestfitness, out localaveragefitness);
}
population = newpopulation;
//If it is the first iteration, or we found a new best solution.
if(bestsolution == null || newpopulation[0].Fitness > bestsolution.Fitness)
{
samefitnessiterations = 0;
bestsolution = newpopulation[0];
}
//Otherwise no new best found.
else
{
samefitnessiterations++;
}
generationtimer.Stop();
Console.WriteLine("Generation time(s): " + generationtimer.Elapsed.TotalMilliseconds / 1000);
Console.WriteLine(fitnessevaluations + " " + localaveragefitness + " " + localbestfitness);
//Add generation to log
((MuLambdaLogSpecification)log).AddEvalListing(run, fitnessevaluations, localaveragefitness, localbestfitness);
//If we hit the termination number of same best fitness (t) or the number of fitness evals is >= the max.
if(samefitnessiterations >= config.TerminationConvergence || fitnessevaluations >= config.NumberOfEvals )
break;
}
//Grab the possible global best solution
if(bestbestsolution == null || bestsolution.Fitness > bestbestsolution.Fitness)
{
bestbestsolution = bestsolution;
}
runtimer.Stop();
Console.WriteLine("Run time(s): " + runtimer.Elapsed.TotalMilliseconds / 1000);
}
totaltimer.Stop();
Console.WriteLine("Total time(s): " + totaltimer.Elapsed.TotalMilliseconds / 1000);
//Give the router numbers that were turned off to the solution.
solution.RoutersTurnedOff = ExtensionMethods.ConvertBitArrayToOffRouterNumbers(bestbestsolution.Chromosome, data.HostCount);
}
//Runs the algoritm for number of iterations
public override void Run(Configuration config)
{
this.config = config;
//Prepare solution and log files
log = new MuLambdaLogSpecification(config);
solution = new NsgaIISolutionSpecification();
//For finding global best pareto front
double bestaverage = 0.0;
List<Individual> bestpopulation = new List<Individual>();
for(int run = 0; run < config.NumberOfRuns; run++)
{
//Reset fitness evals every run
fitnessevaluations = 0;
Console.WriteLine("Run: " + (run + 1));
//Randomly initialize
List<Individual> population = InitUniformRandomPopulation(config.PopulationSize, (int)data.RouterCount);
//Sort that population into pareto fronts
population = FastNonDominatedSort(population);
//Forever (until broken out of)
for(;;)
{
List<Individual> childrens = new List<Individual>();
//Create children by selecting parents with binary tournament selection
//And recombinating with N Point crossover
for(int i = 0; i < config.NumberOfChildren; i++)
{
Individual parenta = BinaryTournamentSelection(population);
Individual parentb = BinaryTournamentSelection(population);
childrens.Add(GenerateChildNPoint(new Individual[] { parenta, parentb }, config.NumberOfCrossoverPoints));
}
//Mutate the childrens
for(int j = 0; j < childrens.Count; j++)
{
population.Add(MutateByBitFlip(childrens[j], config.BitsToFlip));
}
//For holding the local best and local average
double localbestfitness = 0.0;
double localaveragefitness = 0.0;
//Sort the population
population = FastNonDominatedSort(population);
//Get rid of the worst pareto fronts
population = Truncate(population, config.PopulationSize, out localbestfitness, out localaveragefitness);
//Output to log file
((MuLambdaLogSpecification)log).AddEvalListing(run, fitnessevaluations, localaveragefitness, localbestfitness);
Console.WriteLine(fitnessevaluations + " " + localaveragefitness + " " + localbestfitness);
//If we have run over the max of fitness evaluations
if(fitnessevaluations > config.NumberOfEvals)
{
//See if the new average is the best average.
if(localaveragefitness > bestaverage)
{
bestaverage = localaveragefitness;
bestpopulation = population;
}
break;
}
}
}
//Get the best pareto front
((NsgaIISolutionSpecification)solution).BestParetoFront = bestpopulation.GetRange(0, bestpopulation.FindIndex(delegate(Individual i) { return i.ParetoFrontRank == 2; }) - 1);
((NsgaIISolutionSpecification)solution).HostOffset = (uint)data.HostCount;
}
public MuLambdaLogSpecification(Configuration config)
: base(config.DataFilePath, config.RandomSeed, config.NumberOfRuns, config.PenaltyCoefficient)
{
this.config = config;
runlisting = new Dictionary<int, List<EvalInfo>>();
}