Neurales Nummernetzwerk trainieren

  • C#
  • .NET (FX) 4.0

Es gibt 6 Antworten in diesem Thema. Der letzte Beitrag () ist von faxe1008.

    Neurales Nummernetzwerk trainieren

    Hi,

    Ich bin neulich mal auf jenes Video gestoßen:


    Dachte mir, ok scheint jetzt nicht so abartig kompliziert zu werden - kann man ja mal versuchen.
    Das ist mein Ansatz:

    NeuralHelper

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    7. namespace NeuralNumberNetwork {
    8. class NeuralHelper {
    10. public static double SigmoidFunction(double x) {
    11. double eX = Math.Pow(Math.E, x);
    12. return eX / (1 + eX);
    13. }
    15. public static String getRandomName(int length) {
    16. StringBuilder sb = new StringBuilder();
    17. Random rand = new Random();
    18. for (int i = 0; i < length; i++) {
    19. var ch = Convert.ToChar(49+rand.Next(20));
    20. sb.Append(ch);
    21. }
    22. return sb.ToString();
    23. }
    24. }
    25. }


    NerualNetwork

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    7. namespace NeuralNumberNetwork {
    8. abstract class NeuralNetwork {
    10. private List<Neuron> _InputNeurons = new List<Neuron>();
    11. public List<Neuron> InputNeurons { get { return _InputNeurons; } }
    13. private List<Neuron> _ResultNeurons = new List<Neuron>();
    14. public List<Neuron> ResultNeurons { get { return _ResultNeurons; } }
    16. public abstract void InitializeInputNeurons(Object inputData);
    18. public abstract void IntializeHiddenLayers();
    20. public abstract void IntializeResultNeurons();
    22. public Neuron runNetwork() {
    23. Neuron result = new Neuron() {Activation = 0 };
    24. for (int i = 0; i < ResultNeurons.Count; i++) {
    25. double neuronResult = ResultNeurons[i].EvaluateActivation();
    26. if (neuronResult > result.Activation) {
    27. result = ResultNeurons[i];
    28. }
    29. }
    30. return result;
    31. }
    33. public double evaluateFailure(int indexExpectedResult) {
    34. double sqaureSum = 0;
    35. for (int i = 0; i < ResultNeurons.Count; i++) {
    36. if (i == indexExpectedResult) {
    37. sqaureSum += Math.Pow(1 - ResultNeurons[i].Activation, 2);
    38. } else {
    39. sqaureSum += Math.Pow(0 - ResultNeurons[i].Activation, 2);
    40. }
    42. }
    44. return sqaureSum;
    45. }
    47. }
    48. }


    Neuron

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    7. namespace NeuralNumberNetwork {
    8. class Neuron {
    10. public Neuron(String Name) {
    11. this.Name = Name;
    13. }
    15. public Neuron() {
    16. this.Name = NeuralHelper.getRandomName(20);
    17. }
    19. public Neuron(double Activation, bool isBase) {
    20. this.Activation = Activation;
    21. this.Name = NeuralHelper.getRandomName(20);
    22. this._IsBaseNeuron = isBase;
    23. }
    26. /// <summary>
    27. /// Name of the Neuron
    28. /// </summary>
    29. public String Name { get; }
    31. /// <summary>
    32. /// Is the degree of Activation of the Neuron
    33. /// </summary>
    34. private double _Activation = 0 ;
    35. public double Activation {
    36. get {
    37. return _Activation;
    38. }
    39. set {
    40. if (value > 1 || value < 0) {
    41. throw new ArgumentException("Neuron Activation has to be between 0 and 1.");
    42. }
    43. _Activation = value;
    44. }
    45. }
    47. /// <summary>
    48. /// The Bias of the Neuron
    49. /// </summary>
    50. public double Bias { get; set; }
    52. /// <summary>
    53. /// Determines if Neuron is in the starter layer of the network
    54. /// </summary>
    55. private readonly bool _IsBaseNeuron = false;
    56. public bool IsBaseNeuron { get { return _IsBaseNeuron; } }
    58. /// <summary>
    59. /// List of all the Predeccessor Neurons connected to the Neuron
    60. /// </summary>
    61. private List<Neuron> _PredeccessorNeurons = new List<Neuron>();
    62. public List<Neuron> PredeccessorNeurons { get { return _PredeccessorNeurons; } }
    64. /// <summary>
    65. /// List of all the Weights of the Predeccessor Neurons connected to this Neuron
    66. /// </summary>
    67. private List<double> _PredeccessorWeights = new List<double>();
    68. public List<double> PredeccessorWeights { get { return _PredeccessorWeights; } }
    70. /// <summary>
    71. /// Calculation of the Activation using recursion
    72. /// </summary>
    73. /// <returns></returns>
    74. public double EvaluateActivation() {
    75. //Evalutation only on inner Neurons need when they have not been evaluated before
    76. if (!this.IsBaseNeuron) {
    77. double weightedSum = 0;
    78. for (int i = 0; i < this.PredeccessorNeurons.Count; i++) {
    79. weightedSum += this.PredeccessorNeurons[i].EvaluateActivation() * this.PredeccessorWeights[i];
    80. }
    82. //Subtract the Bias
    83. weightedSum = weightedSum - Bias;
    85. //Calculate Sigmoid function (e^x)/(1+e^x), optimization possible
    86. this.Activation = NeuralHelper.SigmoidFunction(weightedSum);
    87. }
    88. return this.Activation;
    89. }
    91. public void randomizeWeights() {
    92. Random rand = new Random();
    93. //Order of weight to Neuron is mixed but does not matter since it is random anyways
    94. for (int i = 0; i < this.PredeccessorNeurons.Count; i++) {
    95. this.PredeccessorWeights.Add(rand.NextDouble());
    96. }
    97. }
    99. public override string ToString() {
    100. return this.Name + " :" + this.Activation;
    101. }
    102. }
    103. }


    Crappy-Implementierung:
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Drawing;
    4. using System.Linq;
    5. using System.Text;
    6. using System.Threading.Tasks;
    8. namespace NeuralNumberNetwork.NumberNeuralNetwork {
    9. class NumberNeuralNetwork : NeuralNetwork {
    11. /// <summary>
    12. /// inputData is an Image
    13. /// </summary>
    14. /// <param name="inputData"></param>
    15. public override void InitializeInputNeurons(object inputData) {
    16. Bitmap bmp = (Bitmap)inputData;
    17. for (int x = 0; x < bmp.Size.Width; x++) {
    18. for (int y = 0; y < bmp.Size.Height; y++) {
    19. var activation = getActivation(bmp.GetPixel(x,y));
    20. this.InputNeurons.Add(new Neuron(activation,true));
    21. }
    22. }
    23. }
    25. public double getActivation(Color c) {
    26. return (c.R + c.B + c.G) / (3 * 255);
    27. }
    29. public override void IntializeResultNeurons() {
    30. for (int i = 0; i < 10; i++) {
    31. ResultNeurons.Add(new Neuron("Number_"+i+"_Neuron"));
    32. }
    33. }
    35. public override void IntializeHiddenLayers() {
    36. List<Neuron> Shapes = new List<Neuron>();
    37. Shapes.Add(new Neuron("TOPLOOP") );
    38. Shapes.Add(new Neuron("BOTTOMLOOP"));
    39. Shapes.Add(new Neuron("TOPLEFTEDGE"));
    40. Shapes.Add(new Neuron("TOPRIGHTEDGE"));
    41. Shapes.Add(new Neuron("BOTTOMLEFTEDGE"));
    42. Shapes.Add(new Neuron("BOTTOMTIGHTEDGE"));
    43. Shapes.Add(new Neuron("MIDDLELINE"));
    45. foreach (var item in ResultNeurons) {
    46. foreach (var middle in Shapes) {
    47. item.PredeccessorNeurons.Add(middle);
    48. }
    49. item.randomizeWeights();
    50. }
    52. foreach (var item in Shapes) {
    53. foreach (var input in InputNeurons) {
    54. item.PredeccessorNeurons.Add(input);
    55. }
    56. item.randomizeWeights();
    57. }
    59. }
    60. }
    61. }


    Idee ist dass ich quasi bei einem ResultNeuron EvaluateActivation aufrufe und dann rekursiv durchgerechnet wird. Das funktioniert alles auch soweit wie es soll.
    Jetzt habe ich allerdings Verständnis Fragen um weiter zu kommen:
    1. Habe mal nur eine Layer eingefügt, die gleiche zusammengesetzte Formen erkennen soll z.B. TOPLOOP als oberer Kringel von einer 8.
    Da es allerdings nahezu unzumutbar ist da von Hand Gewichte ranzubauen - (28*28)<Bildgröße>*(6)<Anzahl der Subformen>*(10)<Anzahl möglicher Ziffern> habe ich eine Methode geschrieben die die Dinger zufällig wählt. Was die Frage bei mir aufwirft, ob man sich über solche Unterteilungsgeschichten überhaupt Gedanken machen muss, oder ob man einfach beliebig viele Neuronen in die Zwischenlayers haut und hofft, dass sie sich halt nach langem Training anpassen?


    2. Wie ziehe ich aufgrund der Fehlerrate (Quadratsumme der Abweichung) Rückschlüsse darauf wie ich die Gewichte nachjustieren muss?

    3. Ist die Vorgehensweise für ein allgemeines Konzept eines Neuralen Netzwerkes annehmbar?

    8-) faxe1008 8-)

    Ich glaube, du hast ein paar grundlegende Sachen noch nicht ganz verstanden:

    faxe1008 schrieb:



    Idee ist dass ich quasi bei einem ResultNeuron EvaluateActivation aufrufe und dann rekursiv durchgerechnet wird


    Man fängt aber beim ersten Layer (Eingabelayer) an und rechnet dann weiter bis zum Ausgabelayer... Für die Ausgabe eines Neurons
    $y_k$
    eines Layers gilt:

    $y_k = o\left( \sum_{i=0}^{N} w_ix_i\right)$


    $o$
    - Aktivierungsfunktion
    $N$
    - Anzahl Gewichte (Eingänge) des Neurons
    $w_i$
    -
    $i$
    tes Gewicht des Neurons
    $x_i$
    -
    $i$
    te Eingabe des Neurons

    Du bestimmst also
    $y_k$
    für jedes Neuron
    $k$
    des Eingabelayers und fährst dann mit dem nächsten Layer fort. Die
    $y_k$
    werden dabei zu den
    $x_i$
    des nachfolgenden Layers.

    Ein separater Bias ist nicht zwingend notwending, wenn man die erste Eingabe
    $x_0 = 1$
    setzt. Dies macht auch die Implementierung der Backpropagation einfacher (siehe unten)

    faxe1008 schrieb:


    2. Wie ziehe ich aufgrund der Fehlerrate (Quadratsumme der Abweichung) Rückschlüsse darauf wie ich die Gewichte nachjustieren muss?


    Mittels Backpropagation des Fehlergradienten (partielle Ableitungen der Fehlerfunktion bezüglich der Gewichte).

    Dieser Beitrag wurde bereits 11 mal editiert, zuletzt von „Quadsoft“ ()

    Quadsoft schrieb:

    Man fängt aber beim ersten Layer (Eingabelayer) an und rechnet dann weiter bis zum Ausgabelayer


    Ist das nicht genau das was die Rekursion beginnend bei den Ergebnis Neuronen tut?


    Wenn ich das ganze so berechne wie in meinem Modell dann würde das ja so aussehen:

    Quellcode

    1. L3_1 = w(L2_1) * L2_1 + w(L2_2) * L2_2
    2. L2_1 = w(L1_1)*L1_1+w(L1_2)*L1_2+w(L1_3)*L1_3
    3. L2_2 = w(L1_1)*L1_1+w(L1_2)*L1_2+w(L1_3)*L1_3


    Wobei w() das Gewicht der Neuroneverbindung ist. Ich hab die Sigmoid Function nicht mit rein genommen, da das ganze sonst nur unübersichtlich wird. Ich bekomme allerdings für jedes Resulat Neuron dieselbe Aktivierung O.o ?

    Quadsoft schrieb:

    Mittels Backpropagation des Fehlergradienten (partielle Ableitungen der Fehlerfunktion bezüglich der Gewichte).


    Danke werde ich mir ansehen sobald das eigentliche Berechnen funktioniert :)

    EDIT:// Habe mal die Projektmappe ohne Executable angehängt, damit man sich es einfacher ansehen kann.
    Dateien

    8-) faxe1008 8-)

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „faxe1008“ ()

    @faxe1008

    Dein Code aus dem Anhang stürzt ab, da die PredecessorWeights nicht gesetzt sind. Der Ansatz, das rekursiv zu berechnen ist zwar denkbar, aber umständlich und bei großen Netzen nicht performant.

    Ich habe das mal geschrieben, wie ich mir das vorstelle:

    Layer.cs

    C#-Quellcode

    1. using System;
    3. namespace NeuralNumberNetwork
    4. {
    5. class Layer
    6. {
    7. int neuronCount;
    8. int inputsPerNeuron;
    10. double[,] weights;
    11. double[] activations;
    13. Activation activation;
    15. public Layer(int neuronCount, int inputsPerNeuron, Activation activation)
    16. {
    17. this.neuronCount = neuronCount;
    18. this.inputsPerNeuron = inputsPerNeuron;
    19. this.activation = activation;
    21. weights = new double[neuronCount, inputsPerNeuron + 1]; // extra Input für Bias
    22. activations = new double[neuronCount];
    23. }
    25. public void ComputeActivations(double[] inputs)
    26. {
    27. if (inputs.Length != inputsPerNeuron)
    28. throw new Exception("Input length does not match this layer");
    30. for (int i = 0; i < neuronCount; i++)
    31. {
    32. double sum = weights[i, inputs.Length]; // Bias
    33. for (int j = 0; j < inputs.Length; j++)
    34. {
    35. sum += inputs[j] * weights[i, j]; // Inputs
    36. }
    37. activations[i] = activation(sum);
    38. }
    39. }
    41. public void InitializeWeights() // Mit Zufallszahlen befüllen
    42. {
    43. Random rand = new Random();
    44. for (int i = 0; i < neuronCount; i++)
    45. {
    46. for (int j = 0; j < inputsPerNeuron + 1; j++)
    47. {
    48. weights[i, j] = rand.NextDouble() * (rand.Next(2) > 1 ? 1.0 : -1.0);
    49. }
    50. }
    51. }
    53. public double[] Activations
    54. {
    55. get { return this.activations; }
    56. }
    57. }
    58. }



    Activation.cs

    C#-Quellcode

    1. using System;
    3. namespace NeuralNumberNetwork
    4. {
    5. delegate double Activation(double x);
    7. static class Activations
    8. {
    9. public static double Sigmoid(double x)
    10. {
    11. return 1.0 / (1 + Math.Exp(-x));
    12. }
    13. }
    14. }



    Program.cs

    C#-Quellcode

    1. using System;
    3. namespace NeuralNumberNetwork {
    4. class Program {
    5. static void Main(string[] args) {
    7. double[] inputs = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
    8. Layer hiddenLayer = new Layer(30, 10, Activations.Sigmoid);
    9. Layer outputLayer = new Layer(10, 30, Activations.Sigmoid);
    11. hiddenLayer.InitializeWeights();
    12. outputLayer.InitializeWeights();
    14. hiddenLayer.ComputeActivations(inputs);
    15. outputLayer.ComputeActivations(hiddenLayer.Activations);
    17. foreach (double d in outputLayer.Activations)
    18. Console.Write("{0} ", d);
    19. Console.ReadLine();
    20. }
    21. }
    22. }


    Der Input in Program.cs ist nur ein Beispiel, natürlich kannst du da auch die Pixelwerte aus deinem Bild nehmen.

    Der nächste Schritt ist jetzt das Hinzufügen der Fehlerfunktion und die Durchführung der Backpropagation.

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „Quadsoft“ ()

    @Quadsoft
    Habe mir deine Implementierung mal angesehen, manchmal kann man echt unnötig irgendwo Rekursion reinfummeln wollen ^^ . *Hust*

    Rückwärtspropagation habe ich diese Seite hier gefunden: codingvision.net/miscellaneous…kpropagation-tutorial-xor
    Habe Theorie verstanden nur bleibt die Frage stehen ob die Formel für die hidden layers die er da verwendet, dann auch für ein Netz mit 2 Hiddenlayers gilt:

    InputH1H2Output
    i1H11H21O1
    i2H12H22O2
    Sprich der Artikel erklärt wie von O1 auf H21 und H22 gerechnet wird. Funktioniert das Rückwärtspropagieren genauso von H21 zu H11 bzw. H12, respektive dann im nächsten Schritt die Input Layer?

    BTW: Habe deine Idee mal in eine abstrakte Klasse überführt:

    C#-Quellcode

    1. ​public abstract class NeuralNetwork {
    3. private List<Layer> _Layers = new List<Layer>();
    4. public List<Layer> layers { get { return _Layers; } }
    6. public NeuralNetwork(int inputLayerCount, int[] hiddenLayerNeurons, int outputLayer, Activation a) {
    7. layers.Add(new Layer(inputLayerCount, 0, a));
    8. layers.Add(new Layer(hiddenLayerNeurons[0], inputLayerCount, a));
    9. for (int i = 1; i < hiddenLayerNeurons.Length; i++) {
    10. layers.Add(new Layer(hiddenLayerNeurons[i], hiddenLayerNeurons[i-1], a));
    11. }
    12. layers.Add(new Layer(outputLayer, hiddenLayerNeurons[hiddenLayerNeurons.Length-1], a));
    14. foreach (var item in layers) {
    15. item.InitializeWeights();
    16. }
    17. }
    19. public void ComputeActivations() {
    20. for (int i = 1; i < layers.Count; i++) {
    21. layers[i].ComputeActivations(layers[i - 1].Activations);
    22. }
    23. }
    25. public abstract void populateInputLayer(Object obj);
    27. }

    8-) faxe1008 8-)

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „faxe1008“ ()

    faxe1008 schrieb:

    Funktioniert das Rückwärtspropagieren genauso von H21 zu H11 bzw. H12, respektive dann im nächsten Schritt die Input Layer?


    Prinzipiell ja, nur ist das Beispiel von der verlinkten Website recht einfach, denn es gibt nur ein einziges Ausgabe-Neuron. Wenn es mehrere Nachfolger-Neuronen gibt, musst du die Summe der gewichteten Fehlerterme betrachten:

    $\text{error}_{i,l} = \begin{cases} (\text{target}_i - \text{output}_{i,l}) f'(\text{output}_{i,l}) & \text {für } l = N \text{ (Ausgabelayer)} \\ \left( \sum_{k} \text{error}_{k, l+1}w_{i,k,l} \right) f'(\text{output}_{i,j}) & \text {sonst} \end{cases} $


    $\text{error}_{i,l}$ - Fehlerterm für das $i$te Neuron im $l$ten Layer

    $\text{output}_{i,l}$ - Ausgabe des $i$ten Neurons im $l$ten Layer

    $\text{target}_{i}$ - Zielausgabe des $i$ten Neurons im Ausgabelayer (das was gelernt werden soll)

    $\text{w}_{i,k,l}$ - Gewicht zwischen dem $i$ten Neuron im Layer $l$ und dem $k$ten Neuron im nachfolgenden Layer


    Das Updaten der Gewichte folgt der Formel aus dem Tutorial. In der Regel macht man aber nicht lediglich

    $w = w + \text{error}\cdot\text{output}$


    sondern fügt eine Lernrate
    $\varepsilon$
    ein, die steuert, wie stark die Anpassung der Gewichte stattfindet:

    $w = w + \text{error}\cdot\text{output}\cdot \varepsilon$


    In der Regel ist
    $\varepsilon$
    eine Zahl betragsmäßig kleiner 1, z.B. 0.05. Dies verbessert die Konvergenz des Gradientenabstiegs.

    @Quadsoft

    Habe die Fehlerfunktion mal implementiert, bin mir allerdings nicht sicher ob ich bei den ganzen Indicies durcheinander gekommen bin:

    C#-Quellcode

    1. ​ private double errorNeuronInLayer(int layerIndex, int NeuronIndex, int expectedNeuronResultIndex) {
    2. //check if its the output layer
    3. if (layerIndex == layers.Count - 1) {
    4. var output_i_l = this.layers[layerIndex].Activations[NeuronIndex];
    5. return ((NeuronIndex == expectedNeuronResultIndex ? 1 : 0) - output_i_l) * this.ActivationFunc.ActivationFunctionDerivative(output_i_l);
    6. } else {
    7. double sum = 0;
    8. for (int k = 0; k < this.layers[layerIndex-1].Activations.Length; k++) {
    9. sum += errorNeuronInLayer(layerIndex - 1, k, 0) * this.layers[layerIndex].Weights[NeuronIndex, k];
    10. }
    11. sum *= this.ActivationFunc.ActivationFunctionDerivative(this.layers[layerIndex].Activations[NeuronIndex]);
    12. return sum;
    13. }
    14. }


    Habe die Aktivierungsfunktion in ein eigenes Interface gepackt, da man ja immer paarweise Archivierungsfunktion und deren Ableitung braucht.

    C#-Quellcode

    1. ​public interface IActivationFunction {
    3. double ActivationFunction(double x);
    5. double ActivationFunctionDerivative(double x);
    7. }



    Layers werden ja nach diesem Schema in die LayerListe gegeben:
    IndexLayer
    0Eingabelayer
    1Hiddenlayer 1
    2Hiddenlayer 2
    3Ausgabelayer

    Ich war verwirrt welcher Richtung mit "nächsten Layer" jetzt gemeint war ^^ , denn eigentlich geht man vom index her zurück (daher ja auch backpropagation)

    8-) faxe1008 8-)

Facebook
Telefonspende