 |
Das deutsche QBasic- und FreeBASIC-Forum
Für euch erreichbar unter qb-forum.de, fb-forum.de und freebasic-forum.de!
|
| Vorheriges Thema anzeigen :: Nächstes Thema anzeigen |
| Autor |
Nachricht |
Haubitze
Anmeldungsdatum: 14.10.2009
Beiträge: 132
|
 Verfasst am: 20.05.2016, 10:24 Titel: kein plan von neuronale netze backprobagation |
 |
|
hi Leute,
ich hab mich die letzten paar tage mit KNNs beschaeftigt.
nun hab ich auf dieser seite https://wwwmath.uni-muenster.de:16030/Professoren/Lippe/lehre/skripte/wwwnnscript/prin.html
eine matrix darstellung der gewichte gesehen, ich dachte mir
sauber is ja ideal fuer die computerwelt. also angefangen
und schon bekomm ich ein problem.
ich denke das ich noch nicht verstanden hab wie dieses backprobagating
funktioniert. daher waere es nett wenn das mal einer in verstandlichen
worten erklaeren koennte. oder ich hab einfach nur nen denkfehler bei
dem wie ich es machen moechte.
salute
anbei mal der code
| Code: |
#include once "fbgfx.bi"
'#include once "NeuroBrain.bi"
using FB
screenres 1024,600,32
randomize timer,4
type brain_t 'the brain type
num_layers as UInteger 'number of layers
num_neurons as uinteger 'number of neurons in the whole brain
input_offset as UInteger 'is used for the set_input sub
output_offset as uinteger 'is used for the get_output function
weight_matrix as single ptr ptr 'here are all wheights between all neurons (a value of 0 indicates no connection)
neuron_matrix as single ptr 'all the neurons outputs
declare constructor()
declare destructor()
declare sub create_brain cdecl(num_layer as uinteger, ... )
declare sub render_brain()
declare sub process()
declare sub think_forward(in_neuron_nr as uinteger,out_put as single)
declare function think_backward(out_neuron_nr as uinteger,soll as single,lern_faktor as single) as boolean
declare sub set_input(neuron_nr as uinteger,in as single)
declare function get_output(neuron_nr as uinteger) as single
declare function Sigmoid(netinput as single, response as single) as single
End Type
'do nothing
constructor brain_t()
num_layers=0
End Constructor
'delete all from memory
destructor brain_t()
if num_neurons>0 then
For i as uinteger = 0 To num_neurons-1
delete [] weight_matrix[i]
Next
delete [] weight_matrix
delete [] neuron_matrix
weight_matrix=0
neuron_matrix=0
num_neurons=0
EndIf
End Destructor
'create a brain whith num_layer layers and add all the neurons to them
'the neurons are the folowing parameter from the ... parameters
'creates also the weight matrix whith all weight between the neurons
'and initialize it random
'usage bsp. brain->create_brain(3,2,3,1)
sub brain_t.create_brain cdecl(num_layer as uinteger, ... )
Dim arg As Any Ptr
dim sum as uinteger
arg = va_first()
input_offset=va_arg(arg, uinteger)
For i as uinteger = 0 To num_layer-1
sum += va_arg(arg, uinteger)
output_offset=va_arg(arg, uinteger)
arg = va_next(arg, uinteger)
Next
neuron_matrix=new single[sum]
weight_matrix=new single ptr[sum]
for i as uinteger=0 to sum-1
weight_matrix[i]=new single[sum]
Next
this.num_layers=num_layer
this.num_neurons=sum
for i as uinteger=0 to num_neurons-1
for j as uinteger=0 to num_neurons-1
weight_matrix[i][j]=(rnd-0.5)
Next
Next
End Sub
'get the output of a output neuron
function brain_t.get_output(neuron_nr as uinteger) as single
dim out_offs as uinteger=neuron_nr mod this.output_offset
return neuron_matrix[num_neurons-1-out_offs]
End Function
'set the output of a input neuron to a value
sub brain_t.set_input(neuron_nr as uinteger,in as single)
dim in_offs as uinteger=neuron_nr mod this.input_offset
neuron_matrix[in_offs]=in
End Sub
'calculate all the neuron states
sub brain_t.process()
dim net_input as single
for i as uinteger=0 to num_neurons-1
for j as uinteger=0 to num_neurons-1
net_input+=weight_matrix[i][i]*neuron_matrix[j]
Next
neuron_matrix[i]=Sigmoid(net_input,1)
Next
End Sub
'here thinks the brain forward but i have no idea how
sub brain_t.think_forward(in_neuron_nr as uinteger,out_put as single)
End Sub
'here give a soll value and the neuron nr then the brain hopfull learn that soll value on the output neuron
'(lern_faktor are the learn_factor, how fast the brain learns that value)
function brain_t.think_backward(out_neuron_nr as uinteger,soll as single,lern_faktor as single) as boolean
dim out_offs as uinteger=num_neurons-(out_neuron_nr mod this.output_offset)-1
dim delta as single=(soll-get_output(out_neuron_nr))*get_output(out_neuron_nr)/(num_neurons)'*num_neurons)
for i as uinteger=0 to num_neurons-1
for j as uinteger=0 to num_neurons-1
'if weight_matrix[i][j]<>0 then
weight_matrix[i][j]+=(delta*lern_faktor)
'endif
Next
Next
if delta=0 then return TRUE
return FALSE
End function
'this renders the brain on the screen
sub brain_t.render_brain()
for j as uinteger=0 to input_offset-1
if neuron_matrix[j]<0 then
line(50,50+j*4)-(50+(1)*4,50+(j+1)*4),rgb(32+abs(neuron_matrix[j])*(255-32),64,64),BF
elseif neuron_matrix[j]>0 then
line(50,50+j*4)-(50+(1)*4,50+(j+1)*4),rgb(64,32+abs(neuron_matrix[j])*(255-32),64),BF
else
line(50,50+j*4)-(50+(1)*4,50+(j+1)*4),rgb(64,64,64),BF
endif
'layer[i].render()
next
for j as uinteger=input_offset to num_neurons-output_offset-1
if neuron_matrix[j]<0 then
line(50,54+j*4)-(50+(1)*4,54+(j+1)*4),rgb(32+abs(neuron_matrix[j])*(255-32),64,64),BF
elseif neuron_matrix[j]>0 then
line(50,54+j*4)-(50+(1)*4,54+(j+1)*4),rgb(64,32+abs(neuron_matrix[j])*(255-32),64),BF
else
line(50,54+j*4)-(50+(1)*4,54+(j+1)*4),rgb(64,64,64),BF
endif
'layer[i].render()
next
for j as uinteger=0 to num_neurons-1
for i as uinteger=0 to num_neurons-1
if weight_matrix[i][j]<0 then
line(56+i*4,50+j*4)-(56+(i+1)*4,50+(j+1)*4),rgb(32+abs(weight_matrix[i][j])*(255-32),64,64),BF
elseif weight_matrix[i][j]>0 then
line(56+i*4,50+j*4)-(56+(i+1)*4,50+(j+1)*4),rgb(64,32+abs(weight_matrix[i][j])*(255-32),64),BF
else
line(56+i*4,50+j*4)-(56+(i+1)*4,50+(j+1)*4),rgb(64,64,64),BF
endif
'layer[i].render()
Next
Next
for j as uinteger=num_neurons-output_offset to num_neurons-1
if neuron_matrix[j]<0 then
line(56+j*4,56+(num_neurons-1)*4)-(56+(j+1)*4,56+(num_neurons)*4),rgb(32+abs(neuron_matrix[j])*(255-32),64,64),BF
elseif neuron_matrix[j]>0 then
line(56+j*4,56+(num_neurons-1)*4)-(56+(j+1)*4,56+(num_neurons)*4),rgb(64,32+abs(neuron_matrix[j])*(255-32),64),BF
else
line(56+j*4,56+(num_neurons-1)*4)-(56+(j+1)*4,56+(num_neurons)*4),rgb(64,64,64),BF
endif
'layer[i].render()
next
End Sub
'the sigmoid activation function, looks like tanh but whith adjustable flanks
function brain_t.Sigmoid(netinput as single, response as single) as single
return (( 1 / ( 1 + exp(-netinput / response))))
end function
dim brain as brain_t ptr
brain=new brain_t()
brain->create_brain(3,3,5,4)
for j as uinteger=0 to 15
brain->set_input(j,rnd)
Next
dim w as single ptr
while not multikey(SC_ESCAPE)
screenlock
line(0,0)-(1024,600),0
locate 1,1
'brain->set_input(rnd*16,rnd-0.5)
' brain->set_input(0,1)
' brain->set_input(1,0.25)
brain->think_backward(0,0.1,0.1)
brain->think_backward(1,0.75,0.1)
brain->think_backward(2,0.5,0.1)
brain->think_backward(3,1.0,0.1)
brain->render_brain()
brain->process()
print brain->get_output(0) & " "
print brain->get_output(1) & " "
print brain->get_output(2) & " "
print brain->get_output(3) & " "
screenunlock
screensync
sleep 16
wend
sleep
screen 0
delete brain
end
|
|
|
| Nach oben |
|
 |
Affemitwaffel
Anmeldungsdatum: 02.06.2011
Beiträge: 39
|
| Verfasst am: 20.05.2016, 12:09 Titel: |
|
|
Hallo,
in dem Video https://www.youtube.com/watch?v=59Hbtz7XgjM wird die Backprop relativ gut und anschaulich erklärt. Vom Prinzip her musst du Ableitungen deines gesamten neurnalen Netzes nach jeder Variable bestimmen(einen Gradienten bilden).
Ich habe außerdem noch einen Tipp für dich: Wenn du deine Sigmoid Funktion durch eine ReLU Funktion(f(x) = 0 für x < 0 und f(x) = x für x >= 0) wird es einfacher die Ableitung zu berechnen (f'(x) = 0 für x <0 und f'(x)=1 für x>=0). Außerdem konvergieren Netze mit ReLU Activation Functions meistens schneller wodurch du nicht ganz so lange zum trainieren deines Netzes brauchst. |
|
| Nach oben |
|
|
Haubitze
Anmeldungsdatum: 14.10.2009
Beiträge: 132
|
| Verfasst am: 21.05.2016, 19:00 Titel: |
|
|
danke fuer denn link Affemitwaffel,
leider werd ich, nach 3 maligem anschauen, auch nicht schlauer. 
zb komm ich mit diesen formaln nicht klar (bin kein mathematiker),
ich kann mir zwar vieler herleiten und erklaeren aber manchmal sieht
man den wald vor lauter baeumen nich.
evtl koenntest du das, wenn du dich damit schonmal beschaeftigt hast,
mal mit deinen worten versuchen verstaendlich zu erklaeren.
salute |
|
| Nach oben |
|
|
Haubitze
Anmeldungsdatum: 14.10.2009
Beiträge: 132
|
| Verfasst am: 23.05.2016, 01:27 Titel: |
|
|
okay, also nur mal zum verstaendniss, gegeben sei
1 inputlayer a 3 input neurons
2 hidden layer a 2 neurons
3 output layer a 3 output neurons
nun soll ich den error berechnen was ja noch leicht ist.
ausserdem soll ich den gradienten berechenen.
nun hab ich das so verstanden das ich diesen gradient fuer jedes neuron
berechnen soll.
nun mal meine gedanken:
outputlayer zu hiddenlayer=3*2 weights -> 6 gradienten
hiddenlayer zu inputlayer=2*3 weights -> 6 gradienten
summe= 12 gradienten
jetzt lass ich mal aussen vor das ich immernoch nicht dahinter gekommen
bin, wie man die gradienten berechnet. aber ich hoffe das ich mit meiner annahme von 12 gradienten richtig liege.
wenn dem nicht so ist so solle man mich bitte berichten.
salute |
|
| Nach oben |
|
|
Affemitwaffel
Anmeldungsdatum: 02.06.2011
Beiträge: 39
|
| Verfasst am: 23.05.2016, 15:59 Titel: |
|
|
Hallo,
also um deine Neuronen zu trainieren musst du herausfinden wie stark der aktuelle Output des gesamten Netzes von den einzelnen Gewichtungen der Neuroneninputs abhängt. Ein Gradient ist einfach nur ein Vektor in dem die einzelnen Ableitungen nach den Gewichtungen stehen(blöde Fachbegriffe...).
In deinem Gradienten sollten also 12 verschiedene Ableitungen sein. Diese Ableitungen berechnet man aber normalerweise nicht von Hand, weil neuronale Netze oft sehr groß sind und es gibt entsprechend sehr viele unterschiedliche Gewichte. Die Backpropagation wird benutzt um den aktuellen Einfluss eines Gewichtsvektors auf das Endergebnis zu berechnen, damit man später eine Lernregel anwenden kann.
Ich versuche mal dir die Backpropagation für ein einzelnes Neuron zu erklären:
Ich gehe jetzt mal von einem Neuron aus, dass nur 2 Inputs(i1 und i2) hat. Das Neuron macht ja jetzt nichts anderes als w1*i1 + w2*i2 zu berechnen (w1 und w2 sind die Gewichtungen der Inputs) und das Ergebnis davon kann im nächsten Schritt in eine Aktivierungsfunktion (z.B. Sigmoid) gegeben und das Ergebnis davon ist dann der Output vom Neuron. Die Aktivierungsfunktion lasse ich jetzt erstmal weg, weil es dann ein bisschen einfacher wird:
Jetzt weiß ich z.B., dass i1 = 1 und i2 = 2 ist. Wenn ich jetzt wissen will, wie "stark" der Einfluss von w1 und w2 auf das Ergebnis ist, dann berechne ich die Ableitung von w1*1+w2*2 nach der Variable w1 und eine Ableitung nach w2. Das Ergebnis von der Ableitung nach w1 ist 1(einfach Anwendung von Ableitungsregeln) und die Ableitung nach w2 ergibt 2.
Mit diesen Zahlen weiß ich jetzt: wenn ich w1 um 1 erhöhe, dann wird auch der Output vom Neuron um 1 höher und wenn ich w2 um 1 erhöhe, dann wird der Output vom Neuron um 2 höher. Wenn ich jetzt noch eine Aktivierungsfunktion dazu nehme würde die Formel, die das Neuron berechnet so aussehen: Sigmoid(w1*1 + w2*2). Die Ableitung von Sigmoid(x) ist Sigmoid(x)*(1-Sigmoid(x)). Um die Ableitung nach w1 zu bekommen müssen wir jetzt einfach nur die Ableitung nach w1 ohne die Sigmoid Funktion in das x vom Sigmoid einsetzen: Sigmoid(1)*(1-Sigmoid(1))=0.196. Die Ableitung nach w2 ist dann 0.105.
Zu der genauen Lernregel kann ich dir leider im moment nichts sagen, weil ich die schon länger nicht mehr selber implementiert habe... Falls ich heute oder morgen mal etwas Zeit finde, werde ich mir die Lernregel nochmal kurz angucken und dann versuche ich die mal zu erklären. |
|
| Nach oben |
|
|
Haubitze
Anmeldungsdatum: 14.10.2009
Beiträge: 132
|
| Verfasst am: 23.05.2016, 21:06 Titel: |
|
|
supi danke Affemitwaffel,
ich jab jetzt ma so bissl was zusamm geschustert.
| Code: |
type brain_t 'the brain type
num_layers as UInteger 'number of layers
num_neurons as uinteger 'number of neurons in the whole brain
belohnung as integer
last_weight0 as UInteger
last_weight1 as UInteger
current_weight0 as uinteger
current_weight1 as uinteger
weight_matrix as single ptr ptr 'here are all wheights between all neurons (a value of 0 indicates no connection)
delta_weight_matrix as single ptr ptr 'here are all the delta_weights between all neurons (a value of 0 indicates no connection)
neuron_matrix as single ptr 'all the neurons outputs
prev_delta_matrix as single ptr ptr'all the neurons outputs
layer_matrix as uinteger ptr'holds the offsets of neurons in the layers in the neuron_matrix
declare constructor()
declare destructor()
declare sub create_brain cdecl(num_layer as uinteger, ... )
declare sub render_brain(x as single,y as single)
declare sub process()
declare sub think(good as integer,quality as single)
declare function think_forward(in_neuron_nr as uinteger,out_put as single,soll as single) as single
declare function think_backward(out_neuron_nr as uinteger,soll as single ptr,lern_faktor as single,momentum as single) as boolean
declare sub set_input(neuron_nr as uinteger,in as single)
declare function get_output(neuron_nr as uinteger) as single
declare function Sigmoid(netinput as single, response as single) as single
End Type
'do nothing
constructor brain_t()
num_layers=0
End Constructor
'delete all from memory
destructor brain_t()
if num_neurons>0 then
For i as uinteger = 0 To num_neurons-1
delete [] weight_matrix[i]
delete [] delta_weight_matrix[i]
delete [] prev_delta_matrix[i]
Next
delete [] weight_matrix
delete [] delta_weight_matrix
delete [] neuron_matrix
delete [] prev_delta_matrix
delete [] layer_matrix
weight_matrix=0
delta_weight_matrix=0
neuron_matrix=0
prev_delta_matrix=0
layer_matrix=0
num_neurons=0
num_layers=0
EndIf
End Destructor
'create a brain whith num_layer layers and add all the neurons to them
'the neurons are the folowing parameter from the ... parameters
'creates also the weight matrix whith all weight between the neurons
'and initialize it random
'usage bsp. brain->create_brain(3,2,3,1)
sub brain_t.create_brain cdecl(num_layer as uinteger, ... )
layer_matrix=new uinteger[num_layer+1]
Dim arg As Any Ptr
dim sum as uinteger
arg = va_first()
layer_matrix[0]=0
For i as uinteger = 1 To num_layer
sum += va_arg(arg, uinteger)
layer_matrix[i]=sum
arg = va_next(arg, uinteger)
Next
neuron_matrix=new single[sum]
prev_delta_matrix=new single ptr[sum]
weight_matrix=new single ptr[sum]
delta_weight_matrix=new single ptr[sum]
for i as uinteger=0 to sum-1
weight_matrix[i]=new single[sum]
delta_weight_matrix[i]=new single[sum]
prev_delta_matrix[i]=new single[sum]
Next
this.num_layers=num_layer+1
this.num_neurons=sum
for i as uinteger=0 to num_neurons-1
for j as uinteger=0 to num_neurons-1
'if i<>j then
weight_matrix[i][j]=(rnd-0.5)
'delta_weight_matrix[i][j]=0.0001
'prev_delta_matrix[i][j]=weight_matrix[i][j]
'endif
Next
Next
current_weight0=int(rnd*num_neurons)
current_weight1=int(rnd*num_neurons)
End Sub
'get the output of a output neuron
function brain_t.get_output(neuron_nr as uinteger) as single
dim out_offs as uinteger=neuron_nr mod layer_matrix[num_layers-1]
return neuron_matrix[num_neurons-1-out_offs]
End Function
'set the output of a input neuron to a value
sub brain_t.set_input(neuron_nr as uinteger,in as single)
dim in_offs as uinteger=neuron_nr mod layer_matrix[1]
neuron_matrix[in_offs]=in
End Sub
'calculate all the neuron states
sub brain_t.process()
dim net_input as single
for i as uinteger=0 to num_neurons-1
for j as uinteger=0 to num_neurons-1
net_input+=(weight_matrix[i][j]*neuron_matrix[j])
Next
neuron_matrix[i]=Sigmoid(net_input,1)
Next
End Sub
'here the brain thinks but i have no idea how
sub brain_t.think(good as integer,quality as single)
' if good>0 then
weight_matrix[current_weight0][current_weight1]+=(rnd-0.5)*0.01'(quality)'/num_neurons
if weight_matrix[current_weight0][current_weight1]>1 then weight_matrix[current_weight0][current_weight1]=1
' endif
' if (good<0) then'belohnung) then
'weight_matrix[current_weight0][current_weight1]-=(quality)'/num_neurons
if weight_matrix[current_weight0][current_weight1]<-1 then weight_matrix[current_weight0][current_weight1]=-1
'while (current_weight0=current_weight1)
current_weight0=int(rnd*num_neurons)
current_weight1=int(rnd*num_neurons)
'wend
' endif
belohnung=good
End Sub
'here thinks the brain forward but i have no idea how
function brain_t.think_forward(in_neuron_nr as uinteger,out_put as single,soll as single) as single
return 1.0
End function
'here give a soll value and the neuron nr then the brain hopfull learn that soll value on the output neuron
'(lern_faktor are the learn_factor, how fast the brain learns that value)
function brain_t.think_backward(out_neuron_nr as uinteger,soll as single ptr ,lern_faktor as single,momentum as single) as boolean
'find the delta for the output layer
for i as uinteger=layer_matrix[num_layers-2] to layer_matrix[num_layers-1]-1
for j as uinteger=0 to num_neurons-1
delta_weight_matrix[i][j]=neuron_matrix[i]*(1-neuron_matrix[i])*(soll[i]-neuron_matrix[i])'this is the error?
next
next
'find the delta for the hidden layer
for i as uinteger=0 to num_layers-2
for j as integer=layer_matrix[i] to layer_matrix[i+1]-1
dim sum as single=0.0
for k as integer=0 to num_neurons-1
sum+=delta_weight_matrix[j][k]*weight_matrix[j][k]
delta_weight_matrix[j][k]=neuron_matrix[j]*(1-neuron_matrix[j])*sum
next
next
next
'aplly momentum (0 does nothing)
for j as uinteger=0 to num_neurons-1
for k as uinteger=0 to num_neurons-1
weight_matrix[j][k]+=momentum*prev_delta_matrix[j][k]
next
next
'adjust all the weights
for j as uinteger=0 to num_neurons-1
for k as uinteger=0 to num_neurons-1
prev_delta_matrix[j][k]=lern_faktor*delta_weight_matrix[j][k]*neuron_matrix[k]
weight_matrix[j][k]+=prev_delta_matrix[j][k]
print delta_weight_matrix[j][k],'delta_weight_matrix[j][k],
next
next
return FALSE
End function
'this renders the brain on the screen
sub brain_t.render_brain(x as single,y as single)
for j as uinteger=0 to layer_matrix[num_layers-1]-1
if neuron_matrix[j]<0 then
line(x,y+j*4)-(x+(1)*4,y+(j+1)*4),rgb(32+abs(neuron_matrix[j])*(255-32),64,64),BF
elseif neuron_matrix[j]>0 then
line(x,y+j*4)-(x+(1)*4,y+(j+1)*4),rgb(64,32+abs(neuron_matrix[j])*(255-32),64),BF
else
line(x,y+j*4)-(x+(1)*4,y+(j+1)*4),rgb(0,0,0),BF
endif
'layer[i].render()
next
for j as uinteger=0 to num_neurons-1
for i as uinteger=0 to num_neurons-1
if weight_matrix[i][j]<0 then
line(x+6+i*4,y+j*4)-(x+6+(i+1)*4,y+(j+1)*4),rgb(32+abs(weight_matrix[i][j])*(255-32),64,64),BF
elseif weight_matrix[i][j]>0 then
line(x+6+i*4,y+j*4)-(x+6+(i+1)*4,y+(j+1)*4),rgb(64,32+abs(weight_matrix[i][j])*(255-32),64),BF
else
line(x+6+i*4,y+j*4)-(x+6+(i+1)*4,y+(j+1)*4),rgb(0,0,0),BF
endif
'layer[i].render()
Next
Next
for j as uinteger=0 to layer_matrix[num_layers-1]-1
if neuron_matrix[j]<0 then
line(x+6+j*4,y+6+(num_neurons-1)*4)-(x+6+(j+1)*4,y+6+(num_neurons)*4),rgb(32+abs(neuron_matrix[j])*(255-32),64,64),BF
elseif neuron_matrix[j]>0 then
line(x+6+j*4,y+6+(num_neurons-1)*4)-(x+6+(j+1)*4,y+6+(num_neurons)*4),rgb(64,32+abs(neuron_matrix[j])*(255-32),64),BF
else
line(x+6+j*4,y+6+(num_neurons-1)*4)-(x+6+(j+1)*4,y+6+(num_neurons)*4),rgb(0,0,0),BF
endif
'layer[i].render()
next
End Sub
'the sigmoid activation function, looks like tanh but whith adjustable flanks
function brain_t.Sigmoid(netinput as single, response as single) as single
return (( 1 / ( 1 + exp(-netinput / response))))
end function
|
leider will das immer noch nicht so wie es soll.
ich kann zur zeit naehmlich nur die gewichte vom output layer
zum ersten hidden layer aendern.
aber das scheint mir auch noch nicht so richtig zu sein, da da auch nur
stuss rauskommt.
evtl siehst du ja den fehler und kannst mir ma auf die fuesse tretten 
salute |
|
| Nach oben |
|
|
Haubitze
Anmeldungsdatum: 14.10.2009
Beiträge: 132
|
| Verfasst am: 27.05.2016, 14:10 Titel: |
|
|
so auf ein neues 
alles nochmal geschrottet, nun sieht mein derzeitiger code so aus.
| Code: |
function Sigmoid(netinput as single, response as single) as single
'return (1+exp(netinput)-1+exp(-netinput))/(1+exp(netinput)+1+exp(-netinput))
return (( 1 / ( 1 + exp(-netinput / response))))
end function
type neuron_t
sum as Single
weights as single ptr
inputs as neuron_t ptr ptr
outputs as single
nr_inputs as uinteger
aktive_signal as Single
aktive_derivate as Single
type_m as uinteger
function_m as uinteger
enum type_e
bias
inputs
hidden
outputs
End Enum
enum active_function_e
Sigmoid
tanh
binaer
End Enum
declare function set_type(t as type_e) as boolean
declare function set_active_function(f as active_function_e) as boolean
declare function set_input(in_nr as uinteger,value as single) as boolean
declare function get_type() as type_e
declare function get_active_function() as active_function_e
declare function get_output() as single
declare function get_nr_inputs() as uinteger
declare sub feed_forward()
declare function back_probagate() as boolean
declare function create_connection(neuron_to as neuron_t ptr) as boolean
declare function delete_connection(neuron as neuron_t ptr ptr) as boolean
End Type
function neuron_t.set_type(t as type_e) as boolean
this.type_m=t
return TRUE
End Function
function neuron_t.set_active_function(f as active_function_e) as boolean
this.function_m=f
return TRUE
End Function
function neuron_t.set_input(in_nr as uinteger,value as single) as boolean
if this.nr_inputs=0 then
this.outputs=value
else
' this.inputs[in_nr].get_outputs()
EndIf
return TRUE
End Function
function neuron_t.get_type() as type_e
return this.type_m
End Function
function neuron_t.get_active_function() as active_function_e
return this.function_m
End Function
function neuron_t.get_output() as single
return this.outputs
End Function
function neuron_t.get_nr_inputs() as uinteger
return this.nr_inputs
End Function
sub neuron_t.feed_forward()
if nr_inputs=0 then
else
this.sum=0
for i as uinteger=0 to nr_inputs-1
this.sum+=this.inputs[i]->get_output() * this.weights[i]
Next
this.outputs=Sigmoid(this.sum,0.5)
this.aktive_derivate=Sigmoid(1-Sigmoid(this.outputs,0.5),0.5)
EndIf
End sub
function neuron_t.back_probagate() as boolean
return TRUE
End Function
function neuron_t.create_connection(neuron_to as neuron_t ptr ) as boolean
nr_inputs+=1
dim tmp_i as neuron_t ptr ptr=new neuron_t ptr[nr_inputs]
dim tmp_w as single ptr=new single[nr_inputs]
if nr_inputs>=2 then
for i as uinteger=0 to nr_inputs-1
tmp_i[i]=inputs[i]
tmp_w[i]=weights[i]
Next
endif
swap tmp_i,inputs
swap tmp_w,weights
inputs[nr_inputs-1]=neuron_to
weights[nr_inputs-1]=rnd-0.5
if tmp_i<>0 then
delete [] tmp_i
delete [] tmp_w
tmp_i=0
tmp_w=0
endif
return TRUE
End Function
function neuron_t.delete_connection(neuron as neuron_t ptr ptr) as boolean
return TRUE
End Function
|
nun erstmal eine einfache frage, laut einzelner tutorials und so wie ich
Affemitwaffel verstanden hab, soll man ja ein sogenanntes Derivat
berechnen. dies mach ich jetzt in der feed_forward sub. ist das so richtig
oder hab ich da wieder nen fehler drin?
(ich traeum schon langsam nur noch formeln aber helfen tuts auch
nich )
salute |
|
| Nach oben |
|
|
|
|
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.
|
|
FAQ
Suchen
Mitgliederliste
Benutzergruppen
Registrieren
Profil
Einloggen, um private Nachrichten zu lesen
Login
