def fx(func, i, nodes, debug):
if func is "sigm":
res = nnlib.sigmoid(nodes[i])
elif func is "tanh":
res = nnlib.hyper_tan(nodes[i])
log.d(debug, log.hl("f(%d) \t(%.2f)\t---> %s \t---> (%.2f) " %(i, nodes[i], func, res),2))
nodes[i] = res
def _do_with_retry(raw):
# NOTE in list mode, will ignore all Errors
retry_max = etc['list_retry']
retry_count = 0
def check_should_retry():
if retry_max < 0: # -1 means retry forever
return True
if retry_count <= retry_max:
return True
while check_should_retry():
retry_info = str(retry_count) + '/' + str(retry_max)
# print retry info
if retry_count > 0:
log.i('[list] start retry ' + retry_info)
# count info
count = len(raw)
count_ok = 0
count_err = 0
# do each task
log.i('[list] start ' + str(count) + ' task ')
for i in range(count):
task_info = str(i + 1) + ' / ' + str(count)
item = raw[i]
log.p('') # NOTE for better print
log.i('[list] (ok ' + str(count_ok) + ', err ' + str(count_err) + ') start task ' + task_info + ', ' + item + ' ')
try:
_do_one_task(item)
except Exception as e:
log.e('[list] task ' + task_info + ' failed, ' + str(e) + ' \n')
# NOTE check feature list_ignore_task_err
if not conf.FEATURES['list_ignore_task_err']:
log.d('disabled feature list_ignore_task_err')
raise # not ignore Error here
# ignore Error here
count_err += 1
else:
log.o('[list] task ' + task_info + ' finished \n')
count_ok += 1
# check retry
retry_text = ''
if retry_count > 0:
retry_text = ', retry ' + retry_info
if count_err == 0: # no Error, not retry
log.o('[list] all task finished ' + str(count_ok) + ' / ' + str(count) + retry_text + ' ')
break # not retry
# should retry
log.e('[list] task failed ' + str(count_err) + ' / ' + str(count) + retry_text + ' ')
# update retry count
retry_count += 1
# check should retry
if check_should_retry():
log.i('[list] before next retry wait ' + str(conf.list_retry_wait_s) + ' seconds ')
time.sleep(conf.list_retry_wait_s)
else:
log.e('[list] task retry failed' + retry_text + ' ')
def propagate(msg, i, nodes, debug, con):
log.d(debug, msg)
for c in con[i]:
c.propagate(nodes)
log.d(debug, c)
log.d(debug, "")
def main():
"""
eta and alpha are parameters that can be tweaked.
"""
eta = 0.90
alpha = 0.24
"""
maxIter represents the limit of how many times the data can be
rerun and the weights can be adjusted before giving up.
"""
maxIter = 500000
"""
stop_err represents the acceptable value for giving up
and will kick in if the error value becomes smaller and
maxIter still has not stopped the script.
"""
stop_err = 0.001
"""
The data set is splitted into:
[[input],[output]]
"""
dataset = input("Name of dataset: ")
data = io.readDataset("data/%s.data" % dataset)
inodes = 1 # This must match the number of input fields in the data set
hnodes = 4
onodes = 1 # This must match the number of output fields in the data set
"""
The bias node will be placed at the end of the node-array
and will have connections to all nodes in the hidden layer
and the output layer
"""
b = inodes + hnodes + onodes
wtot = inodes*hnodes+hnodes+hnodes*onodes+onodes
"""
The initial weight values for each connection will
be set randomly and later changed by the backpropagation.
"""
weights = [random.random() for r in range(wtot)]
"""
The following is index ranges for the different layers.
Do not change!
"""
ilayer = range(0,inodes)
hlayer = range(inodes,inodes+hnodes)
olayer = range(inodes+hnodes,b)
"""
Debug is turned on during the last iteration if turned off.
Otherwise, the debug information will be printed for each
entry in the data set every time.
"""
debug = False
con = [[],[]]
"""
Add connections between the nodes in the hidden layer and the nodes in
the input layer.
"""
net.connect_nodes(0, hlayer, ilayer, con, weights, b)
net.connect_nodes(1, olayer, hlayer, con, weights, b)
lastIter = False
err = 0
minNErr = 1
idata = False
for times in range(maxIter):
###########################
# Propagating
###########################
if err != 0 and err < stop_err:
lastIter = True
#debug = True
idata = []
random.shuffle(data)
"""
Testing all rows of the data set
"""
(err, t, nodes) = net.testData(data, False, lastIter, idata, b, ilayer, hlayer, olayer, debug, con, inodes, hnodes)
if err < minNErr:
minNErr = err
print(log.hl("%i \t> Error = %.8f\n" % (times, err),1))
if lastIter:
for ida in idata:
print(ida)
log.d(debug, " Stopped after %s iterations.\n\n" % log.hl(times+1, 1))
break
###########################
# backpropagating
###########################
"""
inserting gradient.
"""
hGrad = net.mkarr(b)
for i in olayer:
hGrad[i] = nnlib.tanh_grad(t[i-(inodes+hnodes)], nodes[i])
for c in con[1]:
c.backpropagate(hGrad)
for i in hlayer:
hGrad[i] = nnlib.sig_grad(hGrad[i], nodes[i])
#log.d(debug, " hGrad[%d] = %.2f" % (i, hGrad[i]))
for c in con[0]:
c.backpropagate(hGrad)
net.adjust_weights(1, eta, hGrad, nodes, alpha, con)
net.adjust_weights(0, eta, hGrad, nodes, alpha, con)
try:
testdata = io.readDataset("data/%s.test" % dataset)
(err, t, nodes) = net.testData(testdata, True, False, [], b, ilayer, hlayer, olayer, con. inodes, hnodes)
print(log.hl("\nRunning Testdata...",2))
print("--------------------------------")
print("MAE: %.8f\n" % (err))
while True:
inrow = io.splitTestData(input("Manual input:"));
for new_data in inrow:
print("In: %.4f" % new_data)
nodes = net.propagateData(inrow, b, ilayer, hlayer, olayer, debug, con)
for i in olayer:
print("Out: %.4f" % nodes[i])
except KeyboardInterrupt:
print("Quitting...")
