[bmx] Artificial Neural Network Library by AntonyWells [ 1+ years ago ]

[BlitzBot]

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...