private void ReplaceNetworksManagerControl(NetworksManager manager)
{
if (manager == null)
{
CtlNetworkName.Content = "...";
CtlMenuStart.IsEnabled = false;
CtlMenuReset.IsEnabled = false;
CtlMainMenuSaveAs.IsEnabled = false;
CtlMenuNetwork.IsEnabled = false;
CtlNetworkContextMenu.IsEnabled = false;
}
else
{
CtlNetworkName.Content = Path.GetFileNameWithoutExtension(Config.Main.GetString(Const.Param.NetworksManagerName));
CtlMenuStart.IsEnabled = true;
CtlMenuReset.IsEnabled = true;
CtlMainMenuSaveAs.IsEnabled = true;
CtlMenuNetwork.IsEnabled = true;
CtlNetworkContextMenu.IsEnabled = true;
CtlPlotPresenter.Clear();
CtlStatisticsPresenter.Clear();
CtlMatrixPresenter.Clear();
}
OnNetworkUIChanged(Notification.ParameterChanged.Structure);
}
private void RunNetwork()
{
DateTime prevTime = DateTime.Now;
while (!CancellationToken.IsCancellationRequested)
{
lock (ApplyChangesLocker)
{
NetworksManager.PrepareModelsForRound();
foreach (var model in NetworksManager.Models)
{
model.FeedForward();
var output = model.GetMaxActivatedOutputNeuron();
var input = model.GetNumberOfFirstLayerActiveNeurons();
var cost = model.Cost(input);
if (input == output.Id)
{
++model.Statistic.CorrectRounds;
model.Statistic.LastGoodInput = input;
model.Statistic.LastGoodOutput = output.Id;
model.Statistic.LastGoodOutputActivation = output.Activation;
model.Statistic.LastGoodCost = cost;
}
else
{
model.Statistic.LastBadInput = input;
model.Statistic.LastBadOutput = output.Id;
model.Statistic.LastBadOutputActivation = output.Activation;
model.Statistic.LastBadCost = cost;
}
model.ErrorMatrix.AddData(input, output.Id);
++model.Statistic.Rounds;
model.BackPropagation(input);
if (model.Statistic.Rounds == 1)
{
model.Statistic.AverageCost = cost;
}
else
{
model.Statistic.AverageCost = (model.Statistic.AverageCost * (model.Statistic.Rounds - 1) + cost) / model.Statistic.Rounds;
}
}
++Round;
}
if (NetworksManager.Models[0].ErrorMatrix.Count % Settings.SkipRoundsToDrawErrorMatrix == 0)
{
using (var ev = new AutoResetEvent(false))
{
BeginInvoke((Action)(() =>
{
CtlMatrixPresenter.Draw(NetworksManager.Models, NetworksManager.SelectedNetworkModel);
NetworksManager.ResetErrorMatrix();
ev.Set();
}));
ev.WaitOne();
};
}
if (Round % Settings.SkipRoundsToDrawNetworks == 0)// || DateTime.Now.Subtract(startTime).TotalSeconds >= 10)
{
using (var ev = new AutoResetEvent(false))
{
BeginInvoke((Action)(() =>
{
try
{
lock (ApplyChangesLocker)
{
DrawModels(NetworksManager.Models);
}
}
catch (Exception ex)
{
int hha = 1;
}
ev.Set();
}));
ev.WaitOne();
};
}
if ((long)DateTime.Now.Subtract(prevTime).TotalSeconds >= 1)
{
prevTime = DateTime.Now;
BeginInvoke((Action)(() => CtlTime.Text = "Time: " + DateTime.Now.Subtract(StartTime).ToString(@"hh\:mm\:ss")));
}
}
}
unsafe private void RunNetwork(object args)
{
var arr = (object[])args;
var processor = (Processor)arr[0];
SetProcessorAffinity(processor);
SetThreadPriority(ThreadPriorityLevel.Highest);
var forLimit = new List <ForLimit>
{
new ForLimit(Settings.SkipRoundsToDrawErrorMatrix),
new ForLimit(Settings.SkipRoundsToDrawNetworks),
new ForLimit(Settings.SkipRoundsToDrawStatistics)
};
forLimit = forLimit.OrderBy(fl => fl.Current).ToList();
bool IsErrorMatrixRendering = false;
bool IsNetworkRendering = false;
bool IsStatisticsRendering = false;
var currentForLimit = forLimit[0];
var swPureSpeed = new Stopwatch();
var swLock = new Stopwatch();
double k1 = 0.5;
double k2 = 0.5;
while (!CancellationToken.IsCancellationRequested)
{
lock (ApplyChangesLocker)
{
swPureSpeed.Start();
for (int i = 0; i < currentForLimit.Current; ++i)
{
NetworksManager.PrepareModelsForRound();
var model = NetworksManager.Models[0];
while (model != null)
{
if (!model.IsEnabled)
{
continue;
}
model.FeedForward();
var output = model.GetMaxActivatedOutputNeuron();
var outputId = output.Id;
var input = model.TargetOutput;
var cost = model.CostFunction.Do(model);
if (input == outputId)
{
++model.Statistics.CorrectRoundsTotal;
++model.Statistics.CorrectRounds;
model.Statistics.LastGoodInput = model.Classes[input];
model.Statistics.LastGoodOutput = model.Classes[outputId];
model.Statistics.LastGoodOutputActivation = output.Activation;
model.Statistics.LastGoodCost = cost;
}
else
{
model.Statistics.LastBadInput = model.Classes[input];
model.Statistics.LastBadOutput = model.Classes[outputId];
model.Statistics.LastBadOutputActivation = output.Activation;
model.Statistics.LastBadCost = cost;
model.Statistics.LastBadTick = StartTime.Elapsed.Duration().Ticks;
}
model.Statistics.CostSum += cost;
model.ErrorMatrix.AddData(input, outputId);
model.BackPropagation();
model = model.Next;
}
}
swPureSpeed.Stop();
Round += currentForLimit.Current;
if (Round % Settings.SkipRoundsToDrawStatistics == 0)
{
var pureSpeedElapsedSeconds = swPureSpeed.Elapsed.Duration().TotalSeconds;
var totalTicksElapsed = StartTime.Elapsed.Duration().Ticks;
var m = NetworksManager.Models[0];
while (m != null)
{
m.Statistics.Rounds = Round;
m.Statistics.TotalTicksElapsed = totalTicksElapsed;
m.Statistics.CostSumTotal += m.Statistics.CostSum;
m.Statistics.PureRoundsPerSecond = Round / pureSpeedElapsedSeconds;
var percent = 100 * (double)m.Statistics.CorrectRounds / Settings.SkipRoundsToDrawStatistics;
var percentTotal = 100 * (double)m.Statistics.CorrectRoundsTotal / Round;
/*
* k1 = (totalTicksElapsed - m.Statistics.LastBadTick) / m.Statistics.LastBadTick;
* if (k1 > 1)
* {
* k1 = 1;
* }
*
* k2 = 1 - k1;
*/
k1 = 1;
k2 = 0;
m.Statistics.Percent = percent * k1 + percentTotal * k2;
var costAvg = m.Statistics.CostSum / Settings.SkipRoundsToDrawStatistics;
var costAvgTotal = m.Statistics.CostSumTotal / Round;
m.Statistics.CostAvg = costAvg * k1 + costAvgTotal * k2;
m.DynamicStatistics.Add(m.Statistics.Percent, m.Statistics.CostAvg);
m.Statistics.CostSum = 0;
m.Statistics.CorrectRounds = 0;
m = m.Next;
}
}
if (forLimit.Count > 1)
{
for (int i = 1; i < forLimit.Count; ++i)
{
forLimit[i].Current -= currentForLimit.Current;
}
currentForLimit.Current = currentForLimit.Original;
forLimit.RemoveAll(fl => fl.Current == 0);
forLimit = forLimit.OrderBy(fl => fl.Current).ToList();
currentForLimit = forLimit[0];
}
}
var matrixNeeded = !IsErrorMatrixRendering && Round % Settings.SkipRoundsToDrawErrorMatrix == 0;
var networkNeeded = !IsNetworkRendering && Round % Settings.SkipRoundsToDrawNetworks == 0;
var statisticsNeeded = !IsStatisticsRendering && Round % Settings.SkipRoundsToDrawStatistics == 0;
var anyNeeded = matrixNeeded || networkNeeded || statisticsNeeded;
if (anyNeeded)
{
if (matrixNeeded)
{
IsErrorMatrixRendering = true;
}
if (networkNeeded)
{
IsNetworkRendering = true;
}
if (statisticsNeeded)
{
IsStatisticsRendering = true;
}
Dispatcher.BeginInvoke((Action)(() =>
{
if (matrixNeeded)
{
ErrorMatrix errorMatrix;
lock (ApplyChangesLocker)
{
swLock.Restart();
errorMatrix = NetworksManager.SelectedNetworkModel.ErrorMatrix;
NetworksManager.SelectedNetworkModel.ErrorMatrix = errorMatrix.Next;
swLock.Stop();
RenderTime.ErrorMatrix = swLock.Elapsed.Ticks;
}
CtlMatrixPresenter.Draw(errorMatrix);
errorMatrix.ClearData();
IsErrorMatrixRendering = false;
}
if (networkNeeded)
{
NetworkDataModel modelCopy;
lock (ApplyChangesLocker)
{
swLock.Restart();
modelCopy = NetworksManager.SelectedNetworkModel.GetCopyForRender();
CtlInputDataPresenter.SetInputStat(NetworksManager.Models[0]);
swLock.Stop();
RenderTime.Network = swLock.Elapsed.Ticks;
}
DrawNetwork(modelCopy, CtlOnlyWeights.IsOn, CtlOnlyChangedWeights.IsOn, CtlHighlightChangedWeights.IsOn);
IsNetworkRendering = false;
}
if (statisticsNeeded)
{
NetworkDataModel selectedModel;
Statistics statistics;
double learningRate;
lock (ApplyChangesLocker)
{
swLock.Restart();
CtlPlotPresenter.Vanish(NetworksManager.Models);
selectedModel = NetworksManager.SelectedNetworkModel;
statistics = selectedModel?.Statistics.Copy();
learningRate = selectedModel == null ? 0 : selectedModel.LearningRate;
swLock.Stop();
RenderTime.Statistics = swLock.Elapsed.Ticks;
}
CtlPlotPresenter.Draw(NetworksManager.Models, selectedModel);
var lastStats = DrawStatistics(statistics, learningRate);
if (selectedModel != null)
{
selectedModel.LastStatistics = lastStats;
}
IsStatisticsRendering = false;
}
}), DispatcherPriority.Render);// .Send);
}
}
StartTime.Stop();
}
