public virtual void FromStorage(Storage.Storage storage, Storage.Records.Optimizer optimizer, Storage.Records.Solution solution)
{
Data.Clear();
foreach (KeyValuePair <string, string> data in solution.Data)
{
Data[data.Key] = data.Value;
}
Fitness.Reset();
foreach (KeyValuePair <string, double> fit in solution.Fitness)
{
Fitness.Values[fit.Key] = fit.Value;
}
Fitness.Update();
}
public static TSPResult TSP(OptimizationParameters optimizationParameters, CancellationToken ct, int seed = 0)
{
seed = GetSeed(seed);
var random = new Random(seed);
var matrix = Files.ReadArray(optimizationParameters.DataPath);
Distances.Create(matrix);
var tsp = new GeneticTSP(PointsArrayGenerator.GeneratePointsToVisit(matrix.Length), optimizationParameters,
(population) =>
{
double[] fitness = new double[population.Length];
for (int i = 0; i < population.Length; i++)
{
fitness[i] = Fitness.CalculateFitness(population[i]);
}
return(fitness);
}, ct, random);
var result = tsp.Run();
result.Seed = seed;
return(result);
}
public Optimizer()
{
d_fitness = new Fitness();
d_settings = CreateSettings();
d_state = CreateState();
d_population = new List <Solution>();
d_parameters = new List <Parameter>();
d_boundaries = new List <Boundary>();
d_boundaryHash = new Dictionary <string, Boundary>();
d_parameterHash = new Dictionary <string, Parameter>();
d_extensions = new List <Extension>();
d_convergenceThreshold = new Expression();
d_convergenceWindow = new Expression();
d_minIterations = new Expression();
d_lastBest = new LinkedList <Fitness>();
}
private void UpdateConvergence()
{
uint window = (uint)d_convergenceWindow.Evaluate(Biorob.Math.Constants.Context);
while (d_lastBest.Count > window)
{
d_lastBest.RemoveFirst();
}
Fitness fitness = null;
foreach (Solution solution in Population)
{
if (fitness == null || solution.Fitness > fitness)
{
fitness = solution.Fitness;
}
}
if (fitness != null)
{
d_lastBest.AddLast((Fitness)fitness.Clone());
}
}
public virtual void FromStorage(Storage.Storage storage, Storage.Records.Optimizer optimizer)
{
d_storage = storage;
if (optimizer == null)
{
optimizer = d_storage.ReadJob().Optimizer;
}
/* Settings */
d_settings.Clear();
foreach (KeyValuePair <string, string> pair in optimizer.Settings)
{
d_settings[pair.Key] = pair.Value;
}
/* Boundaries */
d_boundaries.Clear();
d_boundaryHash.Clear();
foreach (Storage.Records.Boundary boundary in optimizer.Boundaries)
{
Boundary bound = new Boundary(boundary.Name);
bound.MinSetting.Representation = boundary.Min;
bound.MaxSetting.Representation = boundary.Max;
bound.MinInitialSetting.Representation = boundary.MinInitial;
bound.MaxInitialSetting.Representation = boundary.MaxInitial;
AddBoundary(bound);
}
/* Parameters */
d_parameters.Clear();
foreach (Storage.Records.Parameter parameter in optimizer.Parameters)
{
AddParameter(new Parameter(parameter.Name, 0, Boundary(parameter.Boundary.Name)));
}
/* Fitness */
d_fitness.Clear();
Fitness.Mode mode = Fitness.ModeFromString(optimizer.Fitness.Mode);
if (mode != Fitness.Mode.Invalid)
{
Fitness.CompareMode = mode;
}
else
{
Fitness.CompareMode = Fitness.Mode.Default;
}
d_fitness.Expression.Parse(optimizer.Fitness.Expression);
foreach (KeyValuePair <string, Storage.Records.Fitness.Variable> pair in optimizer.Fitness.Variables)
{
mode = Fitness.CompareMode;
Fitness.Mode parsed = Fitness.ModeFromString(pair.Value.Mode);
if (parsed != Fitness.Mode.Invalid)
{
mode = parsed;
}
d_fitness.AddVariable(pair.Key, pair.Value.Expression, parsed);
}
/* Restore iteration, state */
d_currentIteration = (uint)storage.ReadIterations();
d_state.Settings.Clear();
foreach (KeyValuePair <string, string> pair in optimizer.State.Settings)
{
d_state.Settings[pair.Key] = pair.Value;
}
d_state.Random = optimizer.State.Random;
/* Restore population */
d_population.Clear();
if (d_currentIteration > 0)
{
Storage.Records.Iteration iteration = storage.ReadIteration((int)d_currentIteration - 1);
foreach (Storage.Records.Solution solution in iteration.Solutions)
{
Solution sol = CreateSolution((uint)solution.Index);
FromStorage(storage, optimizer, solution, sol);
Add(sol);
}
// Restore best solution
Storage.Records.Solution best = storage.ReadSolution(-1, -1);
if (best != null)
{
d_best = CreateSolution((uint)best.Index);
FromStorage(storage, optimizer, best, d_best);
}
else
{
d_best = null;
}
}
else
{
InitializePopulation();
d_best = null;
}
foreach (Extension ext in d_extensions)
{
ext.FromStorage(storage, optimizer);
}
Setup();
}
private void LoadFitness(XmlNode root)
{
XmlNode fitness = root.SelectSingleNode("fitness");
Fitness.CompareMode = Fitness.Mode.Default;
if (fitness == null)
{
return;
}
XmlAttribute attr = fitness.Attributes["mode"];
if (attr != null)
{
Fitness.Mode mode = Fitness.ModeFromString(attr.Value);
if (mode == Fitness.Mode.Invalid)
{
throw new Exception(String.Format("Fitness mode is invalid: `{0}'", attr.Value));
}
Fitness.CompareMode = mode;
}
XmlNode expression = root.SelectSingleNode("fitness/expression");
if (expression == null)
{
return;
}
if (!d_fitness.Parse(expression.InnerText))
{
throw new Exception("XML: Could not parse fitness");
}
XmlNodeList nodes = root.SelectNodes("fitness/variable");
foreach (XmlNode node in nodes)
{
XmlAttribute nm = node.Attributes["name"];
if (nm == null)
{
throw new Exception("XML: Fitness variable has no name");
}
XmlAttribute hint = node.Attributes["mode"];
Fitness.Mode mode = Fitness.CompareMode;
if (hint != null)
{
Fitness.Mode parsed = Fitness.ModeFromString(hint.Value);
if (parsed != Fitness.Mode.Invalid)
{
mode = parsed;
}
}
d_fitness.AddVariable(nm.Value, node.InnerText, mode);
}
}
public static int Compare(Fitness a, Fitness b)
{
return(s_comparer(a, b));
}
public double[] Solve(ObjectiveFunction ObjFunc)
{
if (Validation())
{
PopulationsHistory.Clear();
FitnessHistory.Clear();
#region Initial Population and its Fitness
double[][] initilaPopulation = initializePopulation();
PopulationsHistory.Add(initilaPopulation);
Fitness initialFitness = new Fitness(GA_Settings.PopulationSize);
Parallel.For(0, GA_Settings.PopulationSize, i =>
{
initialFitness.FitnessPopulation[i] = ObjFunc(initilaPopulation[i]);
});
initialFitness.SetFitenessData();
initialFitness.BestFeature = (double[])initilaPopulation[initialFitness.MaxFitnessIndex].Clone();;
FitnessHistory.Add(initialFitness);
OPTHistoryResult.Add(new Result
{
Parameters = (double[])initialFitness.BestFeature.Clone(),
target = new double[2] {
initialFitness.MaxFitness, initialFitness.MeanFitness
}
});
#endregion
int gen = 0;
#region While Loop for Genereations
while (gen < GA_Settings.Generations - 1)
{
double[][] currentPopulation = PopulationsHistory.Last();
Fitness currentFitness = FitnessHistory.Last();
double[][] newPopulation = new double[GA_Settings.PopulationSize][];
#region GA
newPopulation = Selection(currentPopulation, currentFitness.FitnessPopulation);
newPopulation[0] = (double[])currentFitness.BestFeature.Clone();
newPopulation = Crossover(newPopulation);
newPopulation = Mutation(newPopulation);
#endregion
Fitness newFitness = new Fitness(GA_Settings.PopulationSize);
Parallel.For(0, GA_Settings.PopulationSize, i =>
{
newFitness.FitnessPopulation[i] = ObjFunc(newPopulation[i]);
});
newFitness.SetFitenessData();
newFitness.BestFeature = (double[])newPopulation[newFitness.MaxFitnessIndex].Clone();
#region Saving Best fearture NEW Vs CURRENT
if (newFitness.MaxFitness <= currentFitness.MaxFitness)
{
newPopulation[0] = (double[])currentFitness.BestFeature.Clone();
newFitness.BestFeature = (double[])currentFitness.BestFeature.Clone();
newFitness.FitnessPopulation[0] = currentFitness.MaxFitness;
newFitness.SetFitenessData();
}
#endregion
PopulationsHistory.Add(newPopulation);
FitnessHistory.Add(newFitness);
OPTHistoryResult.Add(new Result
{
Parameters = (double[])newFitness.BestFeature.Clone(),
target = new double[2] {
newFitness.MaxFitness, newFitness.MeanFitness
}
});
gen++;
}
#endregion
OPTResult.Parameters = OPTHistoryResult.Last().Parameters;
OPTResult.target = OPTHistoryResult.Last().target;
}
return(OPTHistoryResult.Last().Parameters);
}
public bool Progress(Job job)
{
if (!d_client.Connected)
{
return(false);
}
Communication communication = new Communication();
communication.Type = Communication.CommunicationType.Progress;
Progress pgs = new Progress();
pgs.Tick = job.Optimizer.CurrentIteration + 1;
int num = d_unknowns.Count + d_variables.Count + 1;
pgs.Terms = new Progress.Term[num];
FitnessForIndex fitfunc = delegate(Fitness fitness, int i)
{
if (i == 0)
{
return(fitness.Value);
}
else if (i <= d_unknowns.Count)
{
string key = d_unknowns[i - 1];
if (fitness.Values.ContainsKey(key))
{
return(fitness.Values[key]);
}
else
{
return(0);
}
}
else
{
string key = d_variables[i - d_unknowns.Count - 1];
if (fitness.Variables.ContainsKey(key))
{
return(fitness.Variables[key].Expression.Evaluate(Biorob.Math.Constants.Context, fitness.Context));
}
else
{
return(0);
}
}
};
// Compute best here manually because it's not yet updated in the optimizer
Fitness best = null;
// Setup the means
for (int s = 0; s < job.Optimizer.Population.Count; ++s)
{
Solution solution = job.Optimizer.Population[s];
if (best == null || solution.Fitness > best)
{
best = solution.Fitness;
}
for (int i = 0; i < num; ++i)
{
if (s == 0)
{
pgs.Terms[i] = new Progress.Term();
}
pgs.Terms[i].Mean += fitfunc(solution.Fitness, i);
}
}
// Setup the bests
for (int i = 0; i < num; ++i)
{
pgs.Terms[i].Best = fitfunc(best, i);
pgs.Terms[i].Mean /= job.Optimizer.Population.Count;
}
communication.Progress = pgs;
return(Send(communication));
}
