Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht Das deutsche QBasic- und FreeBASIC-Forum
Für euch erreichbar unter qb-forum.de, fb-forum.de und freebasic-forum.de!
 
FAQFAQ   SuchenSuchen   MitgliederlisteMitgliederliste   BenutzergruppenBenutzergruppen  RegistrierenRegistrieren
ProfilProfil   Einloggen, um private Nachrichten zu lesenEinloggen, um private Nachrichten zu lesen   LoginLogin
Zur Begleitseite des Forums / Chat / Impressum
Aktueller Forenpartner:

kein plan von neuronale netze backprobagation

 
Neues Thema eröffnen   Neue Antwort erstellen    Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht -> Allgemeine Fragen zu FreeBASIC.
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen  
Autor Nachricht
Haubitze



Anmeldungsdatum: 14.10.2009
Beiträge: 93

BeitragVerfasst am: 20.05.2016, 11:24    Titel: kein plan von neuronale netze backprobagation Antworten mit Zitat

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
Benutzer-Profile anzeigen Private Nachricht senden
Affemitwaffel



Anmeldungsdatum: 02.06.2011
Beiträge: 39

BeitragVerfasst am: 20.05.2016, 13:09    Titel: Antworten mit Zitat

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
Benutzer-Profile anzeigen Private Nachricht senden
Haubitze



Anmeldungsdatum: 14.10.2009
Beiträge: 93

BeitragVerfasst am: 21.05.2016, 20:00    Titel: Antworten mit Zitat

danke fuer denn link Affemitwaffel,

leider werd ich, nach 3 maligem anschauen, auch nicht schlauer. traurig
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
Benutzer-Profile anzeigen Private Nachricht senden
Haubitze



Anmeldungsdatum: 14.10.2009
Beiträge: 93

BeitragVerfasst am: 23.05.2016, 02:27    Titel: Antworten mit Zitat

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
Benutzer-Profile anzeigen Private Nachricht senden
Affemitwaffel



Anmeldungsdatum: 02.06.2011
Beiträge: 39

BeitragVerfasst am: 23.05.2016, 16:59    Titel: Antworten mit Zitat

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
Benutzer-Profile anzeigen Private Nachricht senden
Haubitze



Anmeldungsdatum: 14.10.2009
Beiträge: 93

BeitragVerfasst am: 23.05.2016, 22:06    Titel: Antworten mit Zitat

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 zwinkern

salute
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Haubitze



Anmeldungsdatum: 14.10.2009
Beiträge: 93

BeitragVerfasst am: 27.05.2016, 15:10    Titel: Antworten mit Zitat

so auf ein neues grinsen

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 grinsen )


salute
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Beiträge der letzten Zeit anzeigen:   
Neues Thema eröffnen   Neue Antwort erstellen    Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht -> Allgemeine Fragen zu FreeBASIC. Alle Zeiten sind GMT + 1 Stunde
Seite 1 von 1

 
Gehe zu:  
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.

 Impressum :: Datenschutz