Neural Networks

Egy ilyen szorzat-készítő hálózatnak milyen aktivációs függvényt érdemes megadni?
Illetve elvárhatom-e a hálózattól, hogy a 2 inputon beadott számból az 1 outputon kijöjjön a pontos szorzat?
tehát ha
input1:=5
input2:=4
akkor
output:=20
??

Na találtam egy howtoszeráséget:
http://www.codeproject.com/useritems/brainnet.asp#4.1.%20Training%20Pha…

Ez lett belőle ccc-ben, de hibás:

static TRAIN:=10000
static LEARNING_RATE:=0.5

static ipl:={}
static hl:={}
static ol:={}
static test_pat:={}

static NUM
static MAX_INP:=2
static MAX_HID:=3
static MAX_OUT:=1

******************************************************

class neuron(object)
method initialize
attrib weight
attrib a
attrib threshold
attrib E
attrib change
attrib t_change

******************************************************

function neuron.initialize(this,NUM)
local i
this:weight:=array(NUM)
this:change:=array(NUM)
this:E:=0
this:t_change:=0
this:a:=0

for i:=1 to len(this:weight)
this:weight[i]:=(random()%399+1)/1000
this:change[i]:=0
next

this:threshold:=(random()%399+1)/1000

return this

******************************************************

function sigmoid(x)
return 1/(1+exp(-x))

******************************************************
function populate_arrays()
local i

for i:=1 to len(ipl)
ipl[i]:=neuronNew(MAX_INP)
next

for i:=1 to len(hl)
hl[i]:=neuronNew(len(ipl))
next

for i:=1 to len(ol)
ol[i]:=neuronNew(len(hl))
next
return NIL

******************************************************

function output_error(expout)
local i

for i:=1 to MAX_OUT
ol[i]:E:=expout-ol[i]:a
ol[i]:t_change:=ol[i]:a*(1-ol[i]:a)*ol[i]:E
next

return NIL

******************************************************

function hidden_error()
local i,sum,j

for i:=1 to MAX_HID
sum:=0
for j:=1 to MAX_OUT
sum+=(ol[j]:t_change*hl[i]:weight[j])
next
hl[i]:E:=sum
hl[i]:t_change:=hl[i]:a*(1-hl[i]:a)*hl[i]:E
next
return NIL

******************************************************

function update_params()
local i,j

for i:=1 to MAX_HID
hl[i]:threshold:=hl[i]:threshold + LEARNING_RATE * 1 * hl[i]:t_change
for j:=1 to len(hl[i]:weight)
hl[i]:weight[j]:=hl[i]:weight[j] + LEARNING_RATE * 1 * ipl[j]:a * hl[i]:t_change
next
next

for i:=1 to MAX_OUT
ol[i]:threshold:=ol[i]:threshold + LEARNING_RATE * 1 * ol[i]:t_change
for j:=1 to len(ol[i]:weight)
ol[i]:weight[j]:=ol[i]:weight[j] + LEARNING_RATE * 1 * hl[j]:a * ol[i]:t_change
next
next

return NIL

****************************************************************************
****************************************************************************
****************************************************************************
function teach()
local in1,in2
local i,j
local tab:={{0,0,0},{0,1,0},{1,0,0},{1,1,1}}

for i:=1 to TRAIN
for j:=1 to len(tab)
test_pat:={}
aadd(test_pat,tab[j][1])
aadd(test_pat,tab[j][2])

run_network()
output_error(tab[j][3])
hidden_error()
update_params()
next
next

return NIL

******************************************************

function run_network()
local i,j
local sum

for i:=1 to MAX_INP
sum:=0
for j:=1 to NUM
sum:=sum+ipl[i]:weight[j]*test_pat[j]
next
ipl[i]:a:=sigmoid(sum+ipl[i]:threshold)
next

for i:=1 to MAX_HID
sum:=0
for j:=1 to MAX_INP
sum:=sum+hl[i]:weight[j]*ipl[j]:a
next
hl[i]:a:=sigmoid(sum+hl[i]:threshold)
next

for i:=1 to MAX_OUT
sum:=0
for j:=1 to MAX_HID
sum:=sum+ol[i]:weight[j] * hl[j]:a
next
ol[i]:a:=sigmoid(sum+ol[i]:threshold)
next

return NIL

******************************************************

function main(in1,in2)
local i
NUM:=2
ipl:=array(MAX_INP)
hl:=array(MAX_HID)
ol:=array(MAX_OUT)

populate_arrays()

teach()

aadd(test_pat,val(in1))
aadd(test_pat,val(in2))

run_network()

for i:=1 to MAX_OUT
? "Output preceptron value #"+tostrtrim(i)+"= "+tostrtrim(ol[i]:a)
next

xquit()

return NIL

Nu.
odáig eljutottam, hogy látszólag működik. De csak az utolsó tanítási eredményt jeyzi meg. Mit lehet ezzel kezdeni?