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)); }