/// <summary>
/// Gets information about learning neural network process
/// </summary>
/// <returns>List of string array</returns>
public List <String[]> GetInformation()
{
List <String[]> list = new List <String[]>();
list.Add(new String[] { "Liczba wejść", Info.ni.ToString() });
list.Add(new String[] { "Liczba wyjść", Info.no.ToString() });
list.Add(new String[] { "Liczba neuronów", Info.nn.ToString() });
list.Add(new String[] { "Liczba wzorców", Info.np.ToString() });
list.Add(new String[] { "Liczba wag", Info.nw.ToString() });
list.Add(new String[] { "MU - wielkość o jaką mogą się zmieniać wagi", Settings.MU.ToString() });
list.Add(new String[] { "Dolna granica MU", Settings.MUL.ToString() });
list.Add(new String[] { "Górna granica MU", Settings.MUH.ToString() });
list.Add(new String[] { "Skala", Settings.Scale.ToString() });
list.Add(new String[] { "Maksymalna liczba iteracji", Settings.MaxIterations.ToString() });
list.Add(new String[] { "Maksymalny błąd uczenia", Settings.MaxError.ToString() });
String tmp = "";
foreach (var t in Topo)
{
tmp += t.ToString() + ", ";
}
tmp = tmp.TrimEnd(new char[] { ' ', ',' });
list.Add(new String[] { "Topografia sieci", tmp });
tmp = "";
foreach (var t in TopoIndex)
{
tmp += t.ToString() + ", ";
}
tmp = tmp.TrimEnd(new char[] { ' ', ',' });
list.Add(new String[] { "Indeksy topografii sieci", tmp });
tmp = "";
FunctionChoice fc = (FunctionChoice)ActivationFunction[0];
switch (fc)
{
case FunctionChoice.BipolarElliotNeuron: tmp = "dwubiegunowa Elliota"; break;
case FunctionChoice.BipolarNeuron: tmp = "dwubiegunowa"; break;
case FunctionChoice.LinearNeuron: tmp = "liniowa"; break;
case FunctionChoice.UnipolarElliotNeuron: tmp = "jednobiegunowa Elliota"; break;
case FunctionChoice.UnipolarNeuron: tmp = "jednobiegunowa"; break;
default: tmp = ""; break;
}
list.Add(new String[] { "Funkcja aktywacji", tmp });
list.Add(new String[] { "Liczba prób uczenia/testowania", Trials.ToString() });
list.Add(new String[] { "Średnia błędów uczenia (RMSE)", FinalRMSE.ToString() });
list.Add(new String[] { "Średnia błędów testowania (RMSE)", TestRMSE.ToString() });
list.Add(new String[] { "Średni czas uczenia", AverageLearnTime });
list.Add(new String[] { "Średni czas testowania", AverageTestTime });
return(list);
}
/// <summary>
/// Computes activation function and its derivative
/// </summary>
/// <param name="n">int</param>
/// <param name="net">double - net</param>
/// <param name="acct">VectorHorizontal - activation matrix</param>
/// <param name="gain">VectorHorizontal - gain matrix</param>
/// <returns>FunctionRD - function result</returns>
/// <remarks>Remember that values are passed by ref to speed up</remarks>
public static FunctionRD computeFunctionDervative(ref int n, ref double net, ref Activation acct, ref Gain gain)
{
FunctionChoice function = (FunctionChoice)(int)acct.Data[0][n];
FunctionRD rd = new FunctionRD();
switch (function)
{
case FunctionChoice.LinearNeuron: //for output layer
{
rd.FunctionResult = gain.Data[0][n] * net;
rd.FunctionDerivative = gain.Data[0][n];
} break;
case FunctionChoice.UnipolarNeuron:
{
rd.FunctionResult = 1 / (1 + System.Math.Exp(-gain.Data[0][n] * net));
rd.FunctionDerivative = gain.Data[0][n] * (1 - rd.FunctionResult) * rd.FunctionResult;
} break;
case FunctionChoice.BipolarNeuron: //for hidden layer
{
rd.FunctionResult = System.Math.Tanh(gain.Data[0][n] * net);
rd.FunctionDerivative = gain.Data[0][n] * (1 - System.Math.Pow(rd.FunctionResult, 2));
} break;
case FunctionChoice.BipolarElliotNeuron:
{
rd.FunctionResult = gain.Data[0][n] * net / (1 + gain.Data[0][n] * System.Math.Abs(net));
rd.FunctionDerivative = 1 / System.Math.Pow((gain.Data[0][n] * System.Math.Abs(net) + 1), 2);
} break;
case FunctionChoice.UnipolarElliotNeuron:
{
rd.FunctionResult = 2 * gain.Data[0][n] * net / (1 + gain.Data[0][n] * System.Math.Abs(net)) - 1;
rd.FunctionDerivative = 2 * gain.Data[0][n] / System.Math.Pow((gain.Data[0][n] * System.Math.Abs(net) + 1), 2);
} break;
default:
{
throw new NeuralNetworkError(Properties.Settings.Default.FE1);
}
}
return(rd);
}
/// <summary>
/// Computes activation function
/// </summary>
/// <param name="n">int</param>
/// <param name="net">double - net</param>
/// <param name="acct">VectorHorizontal - activation matrix</param>
/// <param name="gain">VectorHorizontal - gain matrix</param>
/// <returns>double - function result</returns>
/// <remarks>Remember that values are passed by ref to speed up</remarks>
public static double computeFunction(ref int n, ref double net, ref Activation acct, ref Gain gain)
{
try
{
FunctionChoice function = (FunctionChoice)(int)acct.Data[0][n];
switch (function)
{
case FunctionChoice.LinearNeuron:
{
return(gain.Data[0][n] * net);
}
case FunctionChoice.UnipolarNeuron:
{
return(1 / (1 + System.Math.Exp(-gain.Data[0][n] * net)));
}
case FunctionChoice.BipolarNeuron:
{
return(System.Math.Tanh(gain.Data[0][n] * net));
}
case FunctionChoice.BipolarElliotNeuron:
{
return(gain.Data[0][n] * net / (1 + gain.Data[0][n] * System.Math.Abs(net)));
}
case FunctionChoice.UnipolarElliotNeuron:
{
return(2 * gain.Data[0][n] * net / (1 + gain.Data[0][n] * System.Math.Abs(net)) - 1);
}
default:
{
throw new System.Exception(Properties.Settings.Default.FE1);
}
}
}
catch (System.Exception ex)
{
throw new NeuralNetworkError("Błąd obliczania funkcji aktywacji.", ex);
}
}
