private void RunAlgorithmGenetic(object sender, RoutedEventArgs e)
{
var a = int.Parse(A.Text);
var b = int.Parse(B.Text);
var d = decimal.Parse(D.Text, CultureInfo.InvariantCulture);
var n = int.Parse(N.Text);
var t = int.Parse(T.Text);
var pk = decimal.Parse(Pk.Text, CultureInfo.InvariantCulture);
var pm = decimal.Parse(Pm.Text, CultureInfo.InvariantCulture);
var eliteSize = int.Parse(EliteSize.Text);
GeneticAlgorithm = new GeneticAlgorithm(a, b, d, pk, pm, n, t, eliteSize);
GeneticAlgorithm.Run();
GeneticAlgorithmRun = GeneticAlgorithmRun.MapFrom(GeneticAlgorithm);
GeneticAlgorithmResult = GeneticAlgorithmResult.MapFrom(GeneticAlgorithm);
GeneticAlgorithmSummary = GeneticAlgorithmSummary.MapFrom(GeneticAlgorithm);
TabControl.Visibility = Visibility.Visible;
GenerationSlider.Minimum = 1;
GenerationSlider.Maximum = t;
GenerationSlider.Value = 1;
DisplayGenerationInRunDataGrid(1);
DisplaySummaryInSummaryDataGrid();
GeneratePlot();
}
/// <summary>
/// Executes a single Round of Genetic Algorithm optimization
/// </summary>
private void ExecuteGeneticAlgorithmRound()
{
//initialize range
if (_ranges == null)
{
InitializeRangeArray();
}
//Initialize Required parameters
if (InitializeOptimizationParameters())
{
int index;
// Start Optimization
if ((index = StartOptimizationProcess()) >= 0)
{
// Get Optimized parameters info
Dictionary <int, double> optimizedParameters = ProvideOptimizedParameterInfo(index);
// Create result to be displayed on UI
var result = new GeneticAlgorithmResult();
foreach (KeyValuePair <int, double> keyValuePair in optimizedParameters)
{
OptimizationParameterDetail optimizationParameter;
if (_optimizationParameters.TryGetValue(keyValuePair.Key, out optimizationParameter))
{
// Initialize new value
OptimizationParameterDetail optimizationDetail = new OptimizationParameterDetail();
// Set optimized value
optimizationDetail.OptimizedValue = keyValuePair.Value;
// Save general information
optimizationDetail.Description = optimizationParameter.Description;
// Add to result
result.ParameterList.Add(optimizationDetail);
}
}
// Update Fitness
var risk = Math.Round(_populationArray[index].FitnessMax, 5);
var tempParameterDetail = new OptimizationParameterDetail();
tempParameterDetail.OptimizedValue = risk;
tempParameterDetail.Description = "Risk";
// Add to result
result.ParameterList.Add(tempParameterDetail);
// Publish event to UI
EventSystem.Publish <GeneticAlgorithmResult>(result);
////Dispose();
}
}
}
/// <summary>
/// Displays GA Optimization Result on UI
/// </summary>
/// <param name="optimizationResult">Contains optimized parameters information</param>
private void DisplayResult(GeneticAlgorithmResult optimizationResult)
{
_currentDispatcher.Invoke(DispatcherPriority.Normal, (Action)(() =>
{
RoundsCompleted++;
foreach (OptimizationParameterDetail optimizationParameterDetail in optimizationResult.ParameterList)
{
OptimizedParameters.Add(optimizationParameterDetail);
}
if (RoundsCompleted == Rounds)
{
Status = OptimizationStatus.Completed;
}
}));
}
public static async Task Main(string[] args)
{
UnweightedDirectedGraph = await GraphService.GetUnweightedDirectedGraphAsync();
WeightedDirectedGraph = await GraphService.GetWeightedDirectedGraphAsync();
if (args != null && args.Contains("debug", OrdinalIgnoreCase))
{
DoDebug();
}
CreateDirectory($"{AppDomain.CurrentDomain.BaseDirectory}Outputs");
var settings = new JsonSerializerSettings {
Formatting = Indented
};
var serializer = Create(settings);
string path;
#region Weighted Sum Algorithm
Write("Weighted Sum Algorithm? (Y/N) ");
if (ReadLine() == "Y")
{
var allSimplePaths = WeightedDirectedGraph.AllSimplePaths(
"HARROW & WEALDSTONE",
"ELEPHANT & CASTLE",
EdgeAdder,
25
).ToList();
var weights = new Dictionary <ObjectiveType, double>
{
{ ObjectiveType.Comfortability, 100 },
{ ObjectiveType.Reliability, 50 }
};
var weightedSumAlgorithmResults = new List <WeightedSumAlgorithmResult>();
for (var noOfPaths = 100; noOfPaths < allSimplePaths.Count; noOfPaths += 100)
{
var times = new List <double>();
for (var i = 0; i < 100; i++)
{
Stopwatch.Restart();
allSimplePaths
.Take(noOfPaths)
.WeightedSumShortestPath(weights, WeightedSumShortestPathObjectiveSelector);
Stopwatch.Stop();
times.Add(Stopwatch.Elapsed.TotalMilliseconds);
}
var weightedSumAlgorithmResult = new WeightedSumAlgorithmResult(
times.Average(),
noOfPaths
);
weightedSumAlgorithmResults.Add(weightedSumAlgorithmResult);
}
path = $@"{AppDomain.CurrentDomain.BaseDirectory}Outputs\WeightedSumAlgorithmResults.json";
using (var file = File.CreateText(path))
{
serializer.Serialize(file, weightedSumAlgorithmResults);
}
}
#endregion
#region Dijkstra's Algorithm
Write("Dijkstra's Algorithm? (Y/N) ");
if (ReadLine() == "Y")
{
var dijkstraAlgorithm = new DijkstraShortestWeightedDirectedPathAlgorithm <string, Edge>(
WeightedDirectedGraph,
EdgeAdder,
EdgeComparer
);
var dijkstraAlgorithmResults = new List <DijkstraAlgorithmResult>();
foreach (var destination in WeightedDirectedGraph.Vertices.TakeLast(200))
{
var times = new List <double>();
var pathDistances = new List <double>();
var pathTimes = new List <double>();
for (var i = 0; i < 10000; i++)
{
EdgeComparer.NoOfTotalComparisons = 0;
EdgeComparer.NoOfInteractiveComparisons = 0;
Stopwatch.Restart();
var weightedDirectedPath = dijkstraAlgorithm.Path("HARROW & WEALDSTONE", destination);
Stopwatch.Stop();
times.Add(Stopwatch.Elapsed.TotalMilliseconds);
pathDistances.Add(weightedDirectedPath.Weight.Distance);
pathTimes.Add(weightedDirectedPath.Weight.Time.TotalMinutes);
}
var dijkstraAlgorithmResult = new DijkstraAlgorithmResult(
times.Average(),
EdgeComparer.NoOfInteractiveComparisons,
EdgeComparer.NoOfTotalComparisons,
pathDistances.Average(),
pathTimes.Average()
);
dijkstraAlgorithmResults.Add(dijkstraAlgorithmResult);
}
path = $@"{AppDomain.CurrentDomain.BaseDirectory}Outputs\DijkstraAlgorithmResults.json";
using (var file = File.CreateText(path))
{
serializer.Serialize(file, dijkstraAlgorithmResults);
}
}
#endregion
#region Genetic Algorithm
Write("Genetic Algorithm? (Y/N) ");
if (ReadLine() == "Y")
{
var exactSolution = new DijkstraShortestWeightedDirectedPathAlgorithm <string, Edge>(
WeightedDirectedGraph,
EdgeAdder,
EdgeComparer
).Path("HARROW & WEALDSTONE", "ELEPHANT & CASTLE").Weight;
var geneticAlgorithmResults = new List <GeneticAlgorithmResult>();
for (var noOfGenerations = 50; noOfGenerations < 550; noOfGenerations += 50)
{
for (var mutationProbability = 0; mutationProbability < 110; mutationProbability += 10)
{
var accuracies = new List <double>();
var times = new List <double>();
for (var i = 0; i < 10; i++)
{
EdgeComparer.NoOfTotalComparisons = 0;
EdgeComparer.NoOfInteractiveComparisons = 0;
var geneticAlgorithm = new PathGeneticAlgorithm <string, Edge>(
noOfGenerations,
50,
100,
mutationProbability / 100d,
WeightedDirectedGraph,
"HARROW & WEALDSTONE",
"ELEPHANT & CASTLE",
EdgeAdder,
EdgeComparer
);
geneticAlgorithm.Evolve();
var approximateSolution = geneticAlgorithm.FittestChromosome.Weight;
accuracies.Add(
1 - (
Abs((exactSolution.Distance - approximateSolution.Distance) / exactSolution.Distance) +
Abs((exactSolution.Time - approximateSolution.Time) / exactSolution.Time) +
Abs((exactSolution.Comfortability - approximateSolution.Comfortability) /
exactSolution.Comfortability) +
Abs((exactSolution.Reliability - approximateSolution.Reliability) /
exactSolution.Reliability)
)
);
times.Add(geneticAlgorithm.Time.TotalSeconds);
}
var geneticAlgorithmResult = new GeneticAlgorithmResult(
times.Average(),
noOfGenerations,
mutationProbability / 100d,
accuracies.Average()
);
geneticAlgorithmResults.Add(geneticAlgorithmResult);
}
}
path = $@"{AppDomain.CurrentDomain.BaseDirectory}Outputs\GeneticAlgorithmResults.json";
using (var file = File.CreateText(path))
{
serializer.Serialize(file, geneticAlgorithmResults);
}
}
#endregion
}
