private static bool IsSuccess(BulldozerAlgorithm<double> algorithm, double threshold, out Chromosome chromosome)
{
var chromosomes = algorithm.ChromosomePool
.Union(algorithm.ChromosomeBank)
.OfType<TreeChromosome>()
.ToList();
var maxValue = chromosomes.Max(c => c.Metrics[2]);
chromosome = chromosomes.FirstOrDefault(c => c.Metrics[2] == maxValue);
return maxValue >= threshold;
}
private static RunInfo RunOnce(BulldozerAlgorithm<double> algorithm, Properties properties, string evolutionLogName)
{
var success = false;
Chromosome chromosome = null;
var simplificationRules = AlgebraicRules.Get()
.Where(z => z.Tags.Contains(StdTags.SafeResection))
.ToList();
var stopwatch = new Stopwatch();
stopwatch.Start();
for (var i = 0; i < properties.IterationCount; ++i)
{
algorithm.MakeIteration();
if (OnlineSimplification(algorithm, properties))
{
if (Balancer.TraceEvolution) WriteEvolutionLog(algorithm, evolutionLogName);
algorithm.SimplifyPool(simplificationRules);
}
if (Balancer.ShowTrace) Trace(algorithm);
if (Balancer.TraceEvolution) WriteEvolutionLog(algorithm, evolutionLogName);
success = IsSuccess(algorithm, properties.Threshold, out chromosome);
if(success)
{
break;
}
}
stopwatch.Stop();
var treeChromosome = (TreeChromosome)chromosome;
return new RunInfo
{
Success = success,
ElapsedSeconds = stopwatch.Elapsed.TotalSeconds,
ElapsedIterations = algorithm.CurrentIteration,
ID = chromosome != null ? treeChromosome.ID : -1,
ResultRepresentation = chromosome != null
? treeChromosome.Tree.ToPrefixForm()
: null
};
}
private static bool OnlineSimplification(BulldozerAlgorithm<double> algorithm, Properties properties)
{
return properties.OnlineSimplification
&& algorithm.CurrentIteration % properties.OnlineSimplificationRate == 0;
}
private static void WriteEvolutionLog(BulldozerAlgorithm<double> algorithm, string logName)
{
using (var file = File.Open(logName, FileMode.Append))
{
var text = new StreamWriter(file) {AutoFlush = true};
text.WriteLine("[{0}]", algorithm.CurrentIteration);
var tags = algorithm.Pool.Select(GetTag);
tags.ForEach(text.WriteLine);
}
}
private static void Trace(BulldozerAlgorithm<double> algorithm)
{
if(algorithm.CurrentIteration % 100 != 0) return;
Console.Clear();
Console.SetCursorPosition(0,0);
Console.WriteLine("===============================");
algorithm.ChromosomePool.Union(algorithm.ChromosomeBank)
.OfType<TreeChromosome>()
.OrderByDescending(c => c.Value)
.Take(5)
.Select(c => Tuple.Create(c.Tree.ToPrefixForm(), c.Value))
.ForEach(p => Console.WriteLine("{0} {1}", p.Item1, p.Item2));
Console.WriteLine("===============================");
Console.WriteLine();
}
public static BulldozerAlgorithm<double> AssembleAlgorithm(TaskDataSet dataSet, Dictionary<string, double> weights, Dictionary<string, double> merics, bool onlineSimplification)
{
_dataSet = dataSet;
_alg = new BulldozerAlgorithm<double>();
AlgebraicRules.RandomMin = -10;
AlgebraicRules.RandomMax = 10;
var mutationSet = new List<RuleSet>
{
new RuleSet
{
Name = StdTags.SafeResection,
Weight = weights[StdTags.SafeResection],
Rules = AlgebraicRules.Get()
.Where(r => r.Tags.Contains(StdTags.SafeResection))
.ToList()
},
new RuleSet
{
Name = StdTags.UnsafeResection,
Weight = weights[StdTags.UnsafeResection],
Rules = new List<Rule>(BasicRules.MutationRules())
},
new RuleSet
{
Name = StdTags.SafeBlowing,
Weight = weights[StdTags.SafeBlowing],
Rules = AlgebraicRules.Get()
.Where(r => r.Tags.Contains(StdTags.SafeBlowing))
.ToList()
},
new RuleSet
{
Name = StdTags.UnsafeBlowing,
Weight = weights[StdTags.UnsafeBlowing],
Rules = AlgebraicRules.Get()
.Where(r => r.Tags.Contains(StdTags.UnsafeBlowing))
.Union(BasicRules.VariableRules(_dataSet.Args.First().Length))
.ToList()
},
new RuleSet
{
Name = StdTags.Tunning,
Weight = weights[StdTags.Tunning],
Rules = AlgebraicRules.Get()
.Where(r => r.Tags.Contains(StdTags.Tunning))
.ToList()
}
};
var inductiveSet = mutationSet.Where(s => s.Name != StdTags.SafeResection
&& s.Name != StdTags.UnsafeResection)
.ToList();
_alg.MutationRules.AddRange(!onlineSimplification ? mutationSet : inductiveSet);
_alg.CrossoverRules.Add(new RuleSet
{
Name = "Crossing",
Rules = BasicRules.CrossingRules().ToList()
});
_alg.Metrics.Add(new Metric(tc => GetReciprocalError(tc, _dataSet.Learn), "Eval", 1));
_alg.Metrics.Add(new Metric(tc => -tc.Tree.GetOperationCount(), "Length", merics["Length"]));
_alg.Metrics.Add(new Metric(tc => GetReciprocalError(tc, _dataSet.Control), "CheatEval", 0));
if (Environment.OSVersion.Platform != PlatformID.Unix)
_alg.IterationCallBack += Print;
_alg.PerformBanking = () => _alg.Bank.AddRange(_alg.Pool.Where(z => z.Age > 20 && z.Metrics[0] < EvalThreshold));
_alg.PerformSelection = GASolutions.PerformSelection(ExceptCondition, 30);
return _alg;
}