Как применять веса в нейронной сети?

Question

Я пытаюсь узнать, как реализовать нейронные сети. Единственное, что я не могу найти нигде, это то, как применять и хранить веса. Я получил это для работы в простой сети [2 Input, 4 Output], вручную выполнив все умножения для каждого вывода. Но теперь у меня 4 входа, 4 скрытых в 2 слоях и 4 выхода и хранятся в массиве 4x4x2. Я не могу понять, как применить это использование для циклов. В текущем коде ниже показано, что у меня есть, и части, прокомментированные как нейронные сети, - это то, что я сейчас пытаюсь выяснить.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 
//Import SFML 
using SFML.Graphics; 
using SFML.System; 
using SFML.Window; 
namespace GeneticAlgorithims 
{ 
    class Program 
    { 
     //Neural Network Variables 
     public static int Inputs = 4; 
     public static int Outputs = 4; 
     public static int Hiddens = 2; 
     //End Variables 
     public static Random rand = new Random(); 
     public static List<Organism> organisms = new List<Organism>(); 
     public static RenderWindow window = new RenderWindow(new VideoMode(800,600), "Neural Networks", Styles.Default, new ContextSettings(512, 512, 16)); 
     static void Main(string[] args) 
     { 
      Generate(); 
      while(window.IsOpen) 
      { 
       window.DispatchEvents(); 
       Update(); 
       window.Clear(Color.Cyan); 
       Draw(); 
       window.Display(); 
      } 
     } 

     static void Generate() 
     { 
      for (int x = 0; x < 2; x++) 
      { 
       organisms.Add(new Organism(new Vector2f(rand.Next(0, (int)window.Size.X), rand.Next(0, (int)window.Size.Y)), new Matrix(new double[Inputs, Inputs, Hiddens]))); 
      } 

      foreach (Organism organism in organisms) 
      { 
       organism.color = new Color((byte)rand.Next(0, 255),(byte)rand.Next(0, 255),(byte)rand.Next(0, 255)); 
       organism.rotation = rand.Next(1, 360); 
      } 
     } 

     static void Update() 
     { 
      //Image map = window.Capture(); 
      foreach(Organism organism in organisms) 
      { 
       //Get Near Organism 
       Organism near = new Organism(); 
       foreach (Organism check in organisms) 
       { 
        if (check != organism) 
        { 
         if (Math.Abs(check.position.X - organism.position.X) < 128) 
         { 
          if (Math.Abs(check.position.Y - organism.position.Y) < 128) 
          { 
           near = check; 
          } 
         } 
        } 
       } 
       //Begin Neural Network 
       int CurrentColor = near.color.R; 
       float DistanceX = (near.position != null) ? Math.Abs(near.position.X - organism.position.X) : 0; 
       float DistanceY = (near.position != null) ? Math.Abs(near.position.Y - organism.position.Y) : 0; 
       float Health = organism.Health; 
       Console.WriteLine(CurrentColor); 
       for (int A = 0; A < Inputs; A++) 
       { 
        for (int B = 0; B < Outputs; B += 4) 
        { 
         for (int C = 0; C < Hiddens; C++) 
         { 
          organism.rotation += 
         } 
        } 
       } 
        //End Neural Network 
        organism.Age++; 
       organism.position.X += organism.Speed * (float)Math.Cos(organism.rotation * 0.0174f); 
       organism.position.Y += organism.Speed * (float)Math.Sin(organism.rotation * 0.0174f); 

       float X = organism.position.X; 
       float Y = organism.position.Y; 
       if (organism.position.X > window.Size.X) organism.position.X = 0; 
       if (organism.position.X < 0) organism.position.X = window.Size.X; 
       if (organism.position.Y > window.Size.Y) organism.position.Y = 0; 
       if (organism.position.Y < 0) organism.position.Y = window.Size.Y; 

       if(organism.Age % 2500 == 0) 
       { 
        Organism newOrganism = new Organism(organism.position, organism.brain); 
        newOrganism.rotation = rand.Next(0, 360); 
        newOrganism.color = organism.color; 
        //organisms.Add(newOrganism); 
        //return; 
       } 
       if (organism.Age > 3000) 
       { 
        //organisms.Remove(organism); 
        //return; 
       } 
      } 
     } 

     static void Draw() 
     { 
      Sprite bufferSprite = new Sprite(new Texture("img.png")); 
      foreach (Organism organism in organisms) 
      { 

       Vertex[] line = new Vertex[2]; 
       line[0] = new Vertex(organism.position, Color.Red); 
       line[1] = new Vertex(new Vector2f(organism.position.X + (float)(120 * Math.Cos((organism.rotation - 30) * 0.0174)), organism.position.Y + (float)(120 * Math.Sin((organism.rotation - 30) * 0.0174))), Color.Red); 
       window.Draw(line, PrimitiveType.Lines); 

       line[0] = new Vertex(organism.position, Color.Red); 
       line[1] = new Vertex(new Vector2f(organism.position.X + (float)(120 * Math.Cos((organism.rotation + 30) * 0.0174)), organism.position.Y + (float)(120 * Math.Sin((organism.rotation + 30) * 0.0174))), Color.Red); 
       window.Draw(line, PrimitiveType.Lines); 

       bufferSprite.Origin = new Vector2f(8, 8); 
       bufferSprite.Color = organism.color; 
       bufferSprite.Rotation = organism.rotation; 
       bufferSprite.Position = organism.position; 
       window.Draw(bufferSprite); 

      } 
     } 
    } 
} 

Answer 1

Так как я сказал в комментариях, у вас будет класс уровня с весами и сетевой класс. В большинстве случаев нет необходимости расколоть вещи, которые меньше этого.

Таким образом, для класса слоя, мы имеем N весов плюс смещение:

class Layer 
{ 
    double[] weights; 
    int nOut, nIn; 
    Layer(int inputs, int outputs) 
    { 
     nIn=inputs; nOut=outputs; 
     weights=new double[(inputs+1)*outputs]; //Assume random weights chosen 
    } 

    double[] processInput(double[] in) 
    { 
     double[] out=new double[nOut]; //initialise all to zero 
     for(int i=0; i<nOut; i++) 
     { 
      out[i] = weights[(i+1)*nIn] //bias always present 
      for(int j=0; j<nIn; j++) 
      { 
       out[i] +=in[j]*weights[(i+1)*nIn+j +1] //skips bias 
      } 
      out[i]=activationFunction(out[i]) 
     } 
     return out 
    } 
} 

Тогда для класса сети

class Network 
{ 
    List<Layer> 
    //skipping adding and setting up layers 

    double[] processInput(double[] in) 
    { 
     double[] temp=in; 
     for(Layer l:layers) 
     { 
      temp=layer.processInput(temp); 
      //input for next layer is output from previous 
     } 
     return temp; 
    } 
} 

Надеется, что ясно