Ooops
November 28, 2020, 02:02:51 PM

Author Topic: [bmx] Artificial Neural Network Library by AntonyWells [ 1+ years ago ]  (Read 749 times)

Offline BlitzBot

  • Jr. Member
  • **
  • Posts: 1
Title : Artificial Neural Network Library
Author : AntonyWells
Posted : 1+ years ago

Description : Weight based networked learning, commonly known as a artificial learning network.

Usage,

1.) Extend the neural network class.
2.) Override the training method, and train the network
3.) Use the network.

Feel free to ask for help.


Code :
Code: BlitzMax
  1. Framework brl.glmax2d
  2. Import brl.jpgloader
  3. Import brl.pngloader
  4. Import brl.retro
  5. Import brl.standardio
  6. Import brl.map
  7. Import brl.linkedlist
  8. Import brl.Random
  9.  
  10. Const MAX_WEIGHTS:Int = 1024 * 100
  11. Const MAX_NEURONS:Int = 1024*100
  12. Const MAX_LAYERS:Int = 32
  13. Const LEARN_RATE:Double = 30
  14.  
  15. Type Neuron
  16.  
  17.         Field Value:Double
  18.         Field Weight:Double[]
  19.         Field Output:Double
  20.         Field Err:Double, Target:Double
  21.  
  22. End Type
  23.  
  24. Type NeuronLayer
  25.  
  26.         Field N:Neuron[]
  27.         Field NC:Int = 0
  28.         Field NMap:TMap = New TMap
  29.        
  30.         Method Add:Neuron(id:String)
  31.        
  32.                 Local nn:Neuron = New Neuron
  33.                
  34.                 N[NC] = nn
  35.                
  36.                 NC:+1
  37.                
  38.                 MapInsert(NMap,id,nn)
  39.                
  40.                 Return nn
  41.        
  42.         End Method
  43.        
  44.         Function Cr:NeuronLayer(count:Int)
  45.        
  46.                 Local r:NeuronLayer = New NeuronLayer
  47.                
  48.                 r.N = New Neuron[count]
  49.                                
  50.                 For i = 0 Until count
  51.                        
  52.                         r.N[i] = New Neuron
  53.                
  54.                 Next
  55.                
  56.                 r.NC = count
  57.                
  58.                 Return r
  59.        
  60.         End Function
  61.  
  62.         Method Get:Neuron(id:String)
  63.        
  64.                 Return Neuron(MapValueForKey(nmap,id))
  65.        
  66.         End Method
  67.        
  68. End Type
  69.  
  70. Type NeuralNetwork
  71.        
  72.         Field Layer:NeuronLayer[MAX_LAYERS]
  73.         Field LC:Int
  74.  
  75.         Function CreateBackProp:NeuralNetwork(hidden, output)
  76.                
  77.                 Local n:NeuralNetwork = New NeuralNetwork
  78.                
  79.                 n.InitNetwork()
  80.                                        
  81.                 Return n
  82.        
  83.         End Function
  84.  
  85.         Method InitNetwork()
  86.        
  87.                 For i = 0 Until MAX_LAYERS
  88.                        
  89.                         If Layer[i] = Null Exit
  90.                        
  91.                         For n = 0 Until Layer[i].NC
  92.                                
  93.                                 If Layer[i + 1] <> Null
  94.                        
  95.                                         Layer[i].N[n].Weight = New Double[Layer[i + 1].NC]
  96.                                
  97.                                         For w = 0 Until Layer[i + 1].NC
  98.                                                
  99.                                                 Layer[i].n[n].Weight[w] = Rnd(0.0, 100.0) / 100.0
  100.                                
  101.                                         Next
  102.                                
  103.                                 End If
  104.                                
  105.                                 Layer[i].N[n].Output = Rnd(0.0, 100.0) / 100.0
  106.                                
  107.                         Next
  108.                
  109.                 Next
  110.                
  111.                 TrainNetwork()
  112.        
  113.         End Method
  114.        
  115.         Method TrainNetwork:Double()
  116.                
  117.        
  118.         End Method
  119.        
  120.         Method Run:Double()
  121.                
  122.                 RunLayer(1)
  123.                 RunLayer(2)
  124.        
  125.                 Return Error(2)
  126.                
  127.         End Method
  128.        
  129.         Method RunLayer(i:Int)
  130.                
  131.                 Local l1:NeuronLayer = Layer[i - 1]
  132.                 Local l2:NeuronLayer = Layer[i]
  133.                
  134.        
  135.                 If i = 1
  136.                
  137.                 For n = 0 Until l2.nc
  138.                        
  139.                         v:Double = 0.0
  140.                         For in = 0 Until l1.nc
  141.                                
  142.                                 v:+l1.N[in].Output * l1.N[in].Weight[n]
  143.                                        
  144.                         Next
  145.                        
  146.                         l2.N[n].Value = v
  147.                         l2.N[n].Output = F(v)
  148.                                
  149.                 Next
  150.                
  151.                 Else If i = 2
  152.                
  153.                         For n = 0 Until l2.nc
  154.                                
  155.                                 Local an:Neuron = l2.N[n]
  156.                        
  157.                                 v:Double = 0.0
  158.                        
  159.                                 For in = 0 Until l1.nc
  160.                                
  161.                                         v:+l1.N[in].Output * l1.N[in].Weight[n]
  162.                                                
  163.                                 Next
  164.                        
  165.                         an.Value = v
  166.                         an.Output = F(v)
  167.                         an.Err = (an.Target - an.Output) * (an.Output) * (1.0 - an.Output)
  168.                                                
  169.                 Next
  170.                
  171.                 End If
  172.        
  173.         End Method
  174.        
  175.         Method Error:Double(l:Int)
  176.                
  177.                 err:Double = 0.0
  178.        
  179.                 For i = 0 Until Layer[l].NC
  180.                
  181.                         err:+((Layer[l].N[i].Target - Layer[l].N[i].Output) ^ 2.0) / 2.0
  182.                        
  183.                 Next
  184.                
  185.                 Return err
  186.        
  187.         End Method
  188.        
  189.         Method Train:Double()
  190.  
  191.         End Method
  192.        
  193. End Type
  194.  
  195. Function F:Double(x:Double)
  196.        
  197.         Return (1 / (1 + Exp(-x)))
  198.  
  199. End Function
  200.  
  201.  
  202. Type NeuralNetworkBackProp Extends NeuralNetwork
  203.        
  204.  
  205.         Method InitBackProp(hc:Int)
  206.                
  207.                 LC = 3
  208.                 Layer[0] = NeuronLayer.Cr(0)
  209.                 Layer[1] = NeuronLayer.Cr(hc)
  210.                 Layer[2] = NeuronLayer.Cr(0)
  211.                
  212.        
  213.                
  214.         End Method
  215.        
  216.         Method LearnBP()
  217.                
  218.                 Local il:NeuronLayer = layer[0]
  219.                 Local hl:NeuronLayer = layer[1]
  220.                 Local ol:NeuronLayer = layer[2]
  221.        
  222.                 For i = 0 Until hl.NC
  223.                
  224.                         v:Double = 0.0
  225.                        
  226.                         For j = 0 Until ol.NC
  227.                                
  228.                                 v:+ hl.N[i].Weight[j] * ol.N[j].Err                    
  229.                        
  230.                         Next
  231.                        
  232.                        
  233.                                
  234.                         hl.N[i].Err = v
  235.                
  236.                 Next
  237.                
  238.                 For i = 0 Until hl.NC
  239.                        
  240.                         For j = 0 Until il.NC
  241.                        
  242.                                 il.N[j].Weight[i]:+LEARN_RATE * hl.n[i].Err * il.N[j].Output
  243.                        
  244.                         Next
  245.                
  246.                 Next
  247.                
  248.                 For i = 0 Until ol.NC
  249.                        
  250.                         For j = 0 Until hl.NC
  251.                        
  252.                                 hl.N[j].Weight[i]:+LEARN_RATE * ol.n[i].Err * hl.N[j].Output
  253.                        
  254.                         Next
  255.                
  256.                 Next
  257.                
  258.        
  259.         End Method
  260.                
  261. End Type


Comments : none...

 

SimplePortal 2.3.6 © 2008-2014, SimplePortal