private static Model BuildDiscriminator(Optimiser optimiser)
{
var discriminator = new Model(optimiser, new BinaryCrossEntropyCost());
discriminator.Add(new DenseLayer(28 * 28, 512, new LeakyReLUActivation(0.2)));
discriminator.Add(new DenseLayer(512, 256, new LeakyReLUActivation(0.2)));
discriminator.Add(new DenseLayer(256, 1, new SigmoidActivation()));
return(discriminator);
}
private static Model BuildGenerator(Optimiser optimiser)
{
var generator = new Model(optimiser, new BinaryCrossEntropyCost());
generator.Add(new DenseLayer(NOISE_DIM, 256, new LeakyReLUActivation(0.2)));
generator.Add(new DenseLayer(256, 512, new LeakyReLUActivation(0.2)));
generator.Add(new DenseLayer(512, 1024, new LeakyReLUActivation(0.2)));
generator.Add(new DenseLayer(1024, 28 * 28, new TanhActivation())); // Centred around 0 like our data
return(generator);
}
public void Show(Optimiser optimiser)
{
optimiser.IterationComplete += HandleIterationComplete;
optimiser.Complete += HandleComplete;
_optimiser = optimiser;
Show();
_startTime = DateTime.Now;
}
public int Find_optimal_routes_to_intersection(string route1, string route2)
{
var plotter = new Plotter();
var mapper = new Mapper(plotter);
mapper.MapRoute(1, route1);
mapper.MapRoute(2, route2);
var optimiser = new Optimiser();
var leastPointsToAnIntersection = optimiser.LeastDistanceToIntersection(mapper);
return(leastPointsToAnIntersection);
}
/// <summary>
/// Runs the optimiser
/// </summary>
public override void Optimize()
{
var chromosomeTypes = new StrategyChromosomeTypeFactory(Strategy).GetChromosomeTypes();
var optimiserParameters = GetParameters(chromosomeTypes);
_startDateTime = DateTime.Now;
_iterationNumber = 0;
try
{
using (
_parameterWriter =
new ParameterWriter(Strategy.Instrument.FullName, optimiserParameters.ExportGenes))
{
Strategy.Print(
string.Format(
"{0}: Start time: {1} Parameters: {2} Population {3} MaximumGenerations: {4} Log results: {5} Screen threshold: {6}",
Strategy.Instrument.FullName, _startDateTime, Strategy.Parameters.Count,
optimiserParameters.PopulationSize, optimiserParameters.MaximumGenerations,
optimiserParameters.ExportGenes, optimiserParameters.ScreeningThreshold));
_parameterWriter.WriteParameterNames(chromosomeTypes);
var optimiser = new Optimiser(new FitnessEvaluator(Strategy, chromosomeTypes));
optimiser.IterationComplete += HandleIterationComplete;
optimiser.GenerationComplete += HandleGenerationComplete;
optimiser.ReportNoProgress += HandleNoProgress;
var progressForm = new ProgressForm();
progressForm.Show(optimiser);
optimiser.Run(chromosomeTypes, optimiserParameters);
var endDateTime = DateTime.Now;
Strategy.Print(Strategy.Instrument.FullName + ": completed: " + endDateTime + ", total iterations: " +
(_iterationNumber + 1) + ", total time (minutes): " +
(endDateTime - _startDateTime).TotalMinutes.ToString("N1") + ", best result:");
if (_bestResult != null)
{
Strategy.Print(_bestResult.Gene.ToString(chromosomeTypes));
}
}
}
finally
{
_parametersForm.Close();
}
}
/// <summary>
/// Завершаем оптимизацию извне оптимизатора
/// </summary>
public void StopOptimisation()
{
StopOptimisationTougle = true;
LoadingOptimisationTougle = true;
Optimiser.Stop();
var processes = System.Diagnostics.Process.GetProcesses().Where(x => x.ProcessName == "metatester64");
foreach (var item in processes)
{
item.Kill();
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="optimiser">The optimiser.</param>
/// <param name="model">The model.</param>
/// <param name="timeOutManager">The timeout manager.</param>
/// <param name="convergenceCheckers">Checks for early termination.</param>
/// <param name="reportingFrequency">Number of reinsertions between reports on progress.</param>
/// <param name="numberOfNewIndividualsPerGeneration">Number of new individuals to generate whenever an individual is evaluated.</param>
public ReinsertionAgent(
Optimiser optimiser,
IModel model,
TimeOutManager timeOutManager,
Func <Population, bool> convergenceCheckers,
int reportingFrequency,
int numberOfNewIndividualsPerGeneration)
{
CancellationSource = new CancellationTokenSource();
this.timeOutManager = timeOutManager;
this.convergenceCheckers = convergenceCheckers;
NumberGenerated = 0;
NumberReinserted = 0;
AllEvaluated = new List <Individual>();
ReportingFrequency = reportingFrequency;
this.optimiser = optimiser;
this.model = model;
this.numberOfNewIndividualsPerGeneration = numberOfNewIndividualsPerGeneration;
IndividualsForReinsertion = new TransformManyBlock <Individual, Individual>(
(Func <Individual, IEnumerable <Individual> >)Process,
new ExecutionDataflowBlockOptions
{
CancellationToken = CancellationSource.Token,
MaxDegreeOfParallelism = 1
});
NewIndividuals = new BufferBlock <Individual>(
new DataflowBlockOptions
{
CancellationToken = CancellationSource.Token
});
Reports = new BroadcastBlock <Population>(i => i);
//Set up link so that new individuals created
// are pushed to the output buffer
IndividualsForReinsertion.LinkTo(
NewIndividuals,
new DataflowLinkOptions()
{
PropagateCompletion = true
});
}
public void Puzzle3_part2()
{
var plotter = new Plotter();
var mapper = new Mapper(plotter);
var routes = File.ReadLines("C:\\Code\\github\\AdventOfCode2019\\Puzzle3\\input.txt");
int routeId = 1;
foreach (var route in routes)
{
mapper.MapRoute(routeId++, route);
}
var optimiser = new Optimiser();
var leastPointsToAnIntersection = optimiser.LeastDistanceToIntersection(mapper);
Console.WriteLine($"Least points to an intersection = {leastPointsToAnIntersection}");
Assert.AreEqual(15612, leastPointsToAnIntersection);
}
/// <summary>
/// Метод смены оптимизатора
/// </summary>
/// <param name="optimiserName">Имя выбранного оптимизатора</param>
/// <returns>true в слечае успеха</returns>
public bool ChangeOptimiser(string optimiserName, string terminalName)
{
// Еслизапущен процесс оптимизации или же запущен терминалл - то не чего не делаем
if (Optimiser != null &&
(Optimiser.IsOptimisationInProcess || Optimiser.TerminalManager.IsActive))
{
return(false);
}
// Если текущий оптимизатор не пуст
if (Optimiser != null)
{
// Отписываемся от событий прошлого оптимизатора
Optimiser.ProcessStatus -= Optimiser_ProcessStatus;
Optimiser.OptimisationProcessFinished -= Optimiser_OptimisationProcessFinished;
Optimiser.ClearOptimiser();
Optimiser.CloseSettingsWindow();
// Создаем новый оптимизатор и копируем старый менеджер терминалла
Optimiser = optimiserCreators.First(x => x.Name == optimiserName).Create(Optimiser.TerminalManager);
}
else
{
try
{
// Создаем новый оптимизатор и создаем менеджер терминалла
Optimiser = optimiserCreators.First(x => x.Name == optimiserName)
.Create(new TerminalManager(terminalDirectory.Terminals.First(x => x.Name == terminalName)));
}
catch (Exception e)
{
// В случае ошибки - переадресоввываем её текст в графический интерфейс
ThrowException(e.Message);
return(false);
}
}
// Подписываемся на события нового оптимизатора
Optimiser.ProcessStatus += Optimiser_ProcessStatus;
Optimiser.OptimisationProcessFinished += Optimiser_OptimisationProcessFinished;
return(true);
}
private double TrainBatches(Matrix trainingData, Matrix labels, int batchSize, int epoch)
{
int currentIndex = 0;
int currentBatch = 1;
List <double> batchLosses = new List <double>();;
//Loop untill the data is exhauted for every batch selected
while (trainingData.CanSliceRows(currentIndex, batchSize))
{
//Get the batch data based on the specified batch size
var xtrain = trainingData.SliceRows(currentIndex, batchSize);
var ytrain = labels.SliceRows(currentIndex, batchSize);
//Run forward for all the layers to predict the value for the training set
var ypred = Forward(xtrain);
//Find the loss/cost value for the prediction wrt expected result
var costVal = Cost.Forward(ypred, ytrain);
batchLosses.Add(costVal.Data[0]);
//Get the gradient of the cost function which is then passed to the layers during back-propagation
var grad = Cost.Backward(ypred, ytrain);
//Run back-propagation accross all the layers
Backward(grad);
//Now time to update the neural network weights using the specified optimizer function
foreach (var layer in Layers)
{
Optimiser.Update(layer);
}
currentIndex = currentIndex + batchSize;
double batchLossAvg = Math.Round(costVal.Data[0], 3);
BatchEndEventArgs eventArgs1 = new BatchEndEventArgs(epoch, currentBatch, batchLossAvg);
BatchEnd?.Invoke(epoch, eventArgs1);
currentBatch += 1;
}
return(Math.Round(batchLosses.Average(), 3));
}
/// <summary>
/// Коллбек окончания процеса оптимизации
/// </summary>
/// <param name="obj">Оптимизатор</param>
private void Optimiser_OptimisationProcessFinished(IOptimiser optimiser)
{
DirectoryInfo cachDir = optimiser.TerminalManager.TerminalChangeableDirectory
.GetDirectory("Tester")
.GetDirectory("cache", true);
workingDirectory.Tester.GetDirectory("cache", true).GetFiles().ToList()
.ForEach(x =>
{
string path = Path.Combine(cachDir.FullName, x.Name);
if (!File.Exists(path))
{
x.MoveTo(path);
}
});
SaveOptimisations(optimiser);
if (LoadingOptimisationTougle)
{
LoadSavedOptimisation(optimiser.OptimiserWorkingDirectory);
}
OptimisationStoped();
Optimiser.ClearOptimiser();
}
void runThread(object o)
{
stopWatch = new Stopwatch();
iteration = 0;
updateCount = 0;
results = new float[2000000];
// Thread.CurrentThread.Name = o.ToString();
while (Thread.CurrentThread.IsAlive)
{
//Thread.CurrentThread.Name = o.ToString();
Job job = null;
lock (jobs)
{
if (jobs.Count > 0)
{
job = jobs.Dequeue();
}
}
if (job == null)
{
changeThreadProgress(Int32.Parse(Thread.CurrentThread.Name), -1, -1, "No more jobs!");
return;
}
currentJob = job;
iteration = 0;
if (stopWatch.IsRunning)
stopWatch.Stop();
stopWatch.Reset();
Optimiser optimiser = new Optimiser(job.Filename);
optimiser.Network.EndEpochEvent += new NeuronDotNet.Core.TrainingEpochEventHandler(Network_EndEpochEvent);
//BackgroundWorker worker = (BackgroundWorker)sender;
double mes = 1;
stopWatch.Start();
DateTime startTime = DateTime.Now;
mes = optimiser.Optimise();
changeThreadProgress(Int32.Parse(Thread.CurrentThread.Name), optimiser.Network.MeanSquaredError, optimiser.MaxIterations,"Writing results...");
DateTime endTime = DateTime.Now;
DataAccess dataAccess = new DataAccess(job.Filename);
dataAccess.SaveResult(job.ID,optimiser.Network, iteration, results, startTime,endTime);
//worker.ReportProgress((int)e.Argument, mes);
}
}
public override void Compute_rank(Optimiser.node.Node n)
{
}
private void StartOptimisation(OptimiserInputData optimiserInputData, bool isAppend, string dirPrefix)
{
if ((optimiserInputData.HistoryBorders.Count == 0 && optimiserInputData.ForwardBorders.Count == 0))
{
ThrowException("Fill in date borders");
OnPropertyChanged("ResumeEnablingTogle");
return;
}
if (Optimiser.TerminalManager.IsActive)
{
ThrowException("Terminal already running");
return;
}
if (optimiserInputData.OptimisationMode == ENUM_OptimisationMode.Disabled)
{
StartTest(optimiserInputData);
return;
}
if (!isAppend)
{
var dir = workingDirectory.GetOptimisationDirectory(optimiserInputData.Symb,
Path.GetFileNameWithoutExtension(optimiserInputData.RelativePathToBot),
dirPrefix, Optimiser.Name);
List <FileInfo> data = dir.GetFiles().ToList();
data.ForEach(x => x.Delete());
List <DirectoryInfo> dirData = dir.GetDirectories().ToList();
dirData.ForEach(x => x.Delete());
}
Optimiser.CloseSettingsWindow();
try
{
DirectoryInfo cachDir = Optimiser.TerminalManager.TerminalChangeableDirectory
.GetDirectory("Tester")
.GetDirectory("cache", true);
DirectoryInfo cacheCopy = workingDirectory.Tester.GetDirectory("cache", true);
cacheCopy.GetFiles().ToList().ForEach(x => x.Delete());
cachDir.GetFiles().ToList()
.ForEach(x => x.MoveTo(Path.Combine(cacheCopy.FullName, x.Name)));
ClearResults();
Optimiser.ClearOptimiser();
int ind = optimiserInputData.BotParams.FindIndex(x => x.Variable == Fixed_Input_Settings.Params[InputParamName.CloseTerminalFromBot]);
if (ind > -1)
{
var item = optimiserInputData.BotParams[ind];
item.Value = "true";
item.IsOptimize = false;
optimiserInputData.BotParams[ind] = item;
}
var botParams = optimiserInputData.BotParams.ToList(); // Copy expert settings
Optimiser.Start(optimiserInputData,
Path.Combine(terminalDirectory.Common.FullName,
$"{Path.GetFileNameWithoutExtension(optimiserInputData.RelativePathToBot)}_Report.xml"), dirPrefix);
SetFileManager fileManager = new SetFileManager(
Path.Combine(workingDirectory.GetOptimisationDirectory(optimiserInputData.Symb,
Path.GetFileNameWithoutExtension(optimiserInputData.RelativePathToBot),
dirPrefix, Optimiser.Name).FullName, "OptimisationSettings.set"), true)
{
Params = botParams
};
fileManager.SaveParams();
Optimiser.TerminalManager.WaitForStop();
}
catch (Exception e)
{
Optimiser.Stop();
throw e;
}
}
public abstract void Compute_rank(Optimiser.node.Node n);
public override void Compute_rank(Optimiser.node.Node n)
{
throw new NotImplementedException();
}
public Model(Optimiser optimiser, Cost cost)
{
Layers = new List <Layer>();
Optimiser = optimiser;
Cost = cost;
}
public OptimiserTests()
{
builder = new ObjectCreators.OptimiserBuilderMock();
optimiserMock = builder.CreateOptimiser();
}
/// <summary>
/// Instantiates <see cref="Compiler" /> .
/// </summary>
public Compiler()
{
_parser = new Parser();
_optimiser = new Optimiser();
_generator = new Generator();
}
