public void DrawBase(ErrorMatrix matrix)
{
CtlBase.Clear();
int size = 9;
long axisOffset = 12;
for (int y = 0; y < matrix.Output.Length; ++y)
{
for (int x = 0; x < matrix.Input.Length; ++x)
{
CtlBase.DrawRectangle(null, PenSilver, Rects.Get(axisOffset + x * size, axisOffset + y * size, size, size));
}
}
for (int x = 0; x < matrix.Output.Length; ++x)
{
var text = ClassesFmtText[matrix.Classes[x]];
CtlBase.DrawText(text, Points.Get(axisOffset + x * size + (size - text.Width) / 2, 1 + axisOffset + matrix.Input.Length * size));
}
for (int y = 0; y < matrix.Input.Length; ++y)
{
var text = ClassesFmtText[matrix.Classes[y]];
CtlBase.DrawText(text, Points.Get(1 + axisOffset + matrix.Output.Length * size + (size - text.Width) / 2, axisOffset + y * size));
}
CtlBase.DrawText(FmtOutput, Points.Get(axisOffset + (matrix.Output.Length * size - FmtOutput.Width) / 2, axisOffset - FmtOutput.Height - 1));
CtlBase.DrawText(FmtInput, Points.Get(-axisOffset - (matrix.Input.Length * size - FmtInput.Width) / 1, axisOffset - FmtInput.Height - 1), -90);
CtlBase.Update();
}
public NetworkDataModel CreateNetworkDataModel(INetworkTask task, bool isCopy)
{
ErrorMatrix em1 = null;
if (task != null)
{
em1 = new ErrorMatrix(task.GetClasses());
var em2 = new ErrorMatrix(task.GetClasses());
em1.Next = em2;
em2.Next = em1;
}
var model = new NetworkDataModel(Id, GetLayersSize())
{
ErrorMatrix = em1,
Classes = task?.GetClasses(),
IsEnabled = CtlIsNetworkEnabled.IsOn,
Color = CtlColor.Foreground.GetColor(),
RandomizeMode = RandomizeMode,
RandomizerParamA = RandomizerParamA,
LearningRate = LearningRate,
InputInitial0 = ActivationFunction.Helper.GetInstance(InputLayer.ActivationFunc).Do(InputLayer.Initial0, InputLayer.ActivationFuncParamA),
InputInitial1 = ActivationFunction.Helper.GetInstance(InputLayer.ActivationFunc).Do(InputLayer.Initial1, InputLayer.ActivationFuncParamA),
CostFunction = CostFunction.Helper.GetInstance(CtlCostFunction.SelectedValue.ToString()),
IsAdjustFirstLayerWeights = InputLayer.IsAdjustFirstLayerWeights
};
model.ActivateNetwork();
LayerDataModel prevLayer = null;
var layers = GetLayersControls();
for (int ln = 0; ln < layers.Count; ++ln)
{
if (ln > 0)
{
prevLayer = model.Layers[ln - 1];
}
model.Layers[ln].VisualId = layers[ln].Id;
var neurons = layers[ln].GetNeuronsControls();
for (int nn = 0; nn < neurons.Count; ++nn)
{
var neuronModel = model.Layers[ln].Neurons[nn];
neuronModel.VisualId = neurons[nn].Id;
neuronModel.IsBias = neurons[nn].IsBias;
neuronModel.IsBiasConnected = neurons[nn].IsBiasConnected;
neuronModel.ActivationFunction = ActivationFunction.Helper.GetInstance(neurons[nn].ActivationFunc);
neuronModel.ActivationFuncParamA = neurons[nn].ActivationFuncParamA;
if (ln == 0 && !neuronModel.IsBias)
{
neuronModel.WeightsInitializer = InputLayer.WeightsInitializer;
neuronModel.WeightsInitializerParamA = InputLayer.WeightsInitializerParamA;
double initValue = InitializeMode.Helper.Invoke(neuronModel.WeightsInitializer, neuronModel.WeightsInitializerParamA);
if (!InitializeMode.Helper.IsSkipValue(initValue))
{
neuronModel.Weights.ForEach(w => w.Weight = InitializeMode.Helper.Invoke(neuronModel.WeightsInitializer, neuronModel.WeightsInitializerParamA));
}
}
else
{
neuronModel.WeightsInitializer = neurons[nn].WeightsInitializer;
neuronModel.WeightsInitializerParamA = neurons[nn].WeightsInitializerParamA;
double initValue = InitializeMode.Helper.Invoke(neuronModel.WeightsInitializer, neuronModel.WeightsInitializerParamA);
if (!InitializeMode.Helper.IsSkipValue(initValue))
{
neuronModel.Weights.ForEach(w => w.Weight = InitializeMode.Helper.Invoke(neuronModel.WeightsInitializer, neuronModel.WeightsInitializerParamA));
}
}
if (neuronModel.IsBias)
{
neuronModel.ActivationInitializer = neurons[nn].ActivationInitializer;
neuronModel.ActivationInitializerParamA = neurons[nn].ActivationInitializerParamA;
double initValue = InitializeMode.Helper.Invoke(neurons[nn].ActivationInitializer, neurons[nn].ActivationInitializerParamA);
if (!InitializeMode.Helper.IsSkipValue(initValue))
{
neuronModel.Activation = initValue;
}
}
if (!isCopy && prevLayer != null && prevLayer.Height > 0)
{
neuronModel.ForwardHelper = new ListX <ForwardNeuron>(prevLayer.Height);
var prevNeuron = prevLayer.Neurons[0];
while (prevNeuron != null)
{
if (!neuronModel.IsBias || (neuronModel.IsBiasConnected && prevNeuron.IsBias))
{
neuronModel.ForwardHelper.Add(new ForwardNeuron(prevNeuron, prevNeuron.WeightTo(neuronModel)));
}
prevNeuron = prevNeuron.Next;
}
}
}
}
model.Layers.Last().VisualId = Const.OutputLayerId;
{
var neurons = OutputLayer.GetNeuronsControls();
for (int i = 0; i < neurons.Count; ++i)
{
model.Layers.Last().Neurons[i].VisualId = neurons[i].Id;
}
}
if (!isCopy)
{
model.Copy = CreateNetworkDataModel(task, true);
}
return(model);
}
public void Draw(ErrorMatrix matrix)
{
if (!IsLoaded)
{
return;
}
if (IsClassesChanged(matrix.Classes))
{
InitClassesFmtText(matrix.Classes);
DrawBase(matrix);
}
Classes = matrix.Classes;
CtlPresenter.Clear();
int size = 9;
long goodMax = 1;
long badMax = 1;
long axisOffset = 12;
long bound = 30;
for (int y = 0; y < matrix.Output.Length; ++y)
{
for (int x = 0; x < matrix.Input.Length; ++x)
{
if (x == y)
{
goodMax = Math.Max(goodMax, matrix.Matrix[x, y]);
}
else
{
badMax = Math.Max(badMax, matrix.Matrix[x, y]);
}
}
}
for (int y = 0; y < matrix.Output.Length; ++y)
{
for (int x = 0; x < matrix.Input.Length; ++x)
{
if (matrix.Matrix[y, x] > 0)
{
var value = (double)matrix.Matrix[y, x] / (double)(x == y ? goodMax : badMax);
var color = Tools.Draw.GetColorDradient(Colors.LightGray, x == y ? Colors.Green : Colors.Red, 255, value);
var brush = Tools.Draw.GetBrush(color);
CtlPresenter.DrawRectangle(brush, PenSilver, Rects.Get(axisOffset + x * size, axisOffset + y * size, size, size));
}
}
}
long outputMax = Math.Max(matrix.Output.Max(), 1);
for (int x = 0; x < matrix.Output.Length; ++x)
{
var color = Tools.Draw.GetColorDradient(Colors.White, matrix.Output[x] > matrix.Input[x] ? Colors.Red : matrix.Output[x] < matrix.Input[x] ? Colors.Blue : Colors.Green, 100, (double)matrix.Output[x] / (double)outputMax);
var brush = Tools.Draw.GetBrush(color);
CtlPresenter.DrawRectangle(brush, PenSilver, Rects.Get(axisOffset + x * size, 10 + axisOffset + matrix.Input.Length * size, size, (int)(bound * (double)matrix.Output[x] / (double)outputMax)));
}
long inputMax = Math.Max(matrix.Input.Max(), 1);
for (int y = 0; y < matrix.Input.Length; ++y)
{
var color = Tools.Draw.GetColorDradient(Colors.White, Colors.Green, 100, (double)matrix.Input[y] / (double)inputMax);
var brush = Tools.Draw.GetBrush(color);
CtlPresenter.DrawRectangle(brush, PenSilver, Rects.Get(11 + axisOffset + matrix.Output.Length * size, axisOffset + y * size, (int)(bound * (double)matrix.Input[y] / (double)inputMax), size));
}
CtlPresenter.Update();
}