def runNN(load):
saveNNFile = 'backup.p'
if (load):
a = loadNN(saveNNFile)
else:
a = nnet.nnet()
for e in range(a.currEpoch, 10):
a.currEpoch = e
a.train()
saveNN(a, saveNNFile)
def dbn2nnet(self,n_out):
if type(n_out) is list:
size=self.size+n_out
else:
n_out=[n_out]
size=self.size+n_out
ann=nnet(layers=size,active_fun='sigm',output_fun='softmax',momentum=0,show=True)
for ii in xrange(1,ann.n-1):
ann.layer[ii].w=self.lrbm[ii].w.T
ann.layer[ii].b=self.lrbm[ii].c.T
for ii in xrange(1,ann.n):
print('w shape=%s',ann.layer[ii].w.shape)
print('b shape=%s',ann.layer[ii].b.shape)
return ann
def dbn2nnet(self, n_out):
if type(n_out) is list:
size = self.size + n_out
else:
n_out = [n_out]
size = self.size + n_out
ann = nnet(layers=size,
active_fun='sigm',
output_fun='softmax',
momentum=0,
show=True)
for ii in xrange(1, ann.n - 1):
ann.layer[ii].w = self.lrbm[ii].w.T
ann.layer[ii].b = self.lrbm[ii].c.T
for ii in xrange(1, ann.n):
print('w shape=%s', ann.layer[ii].w.shape)
print('b shape=%s', ann.layer[ii].b.shape)
return ann
def __init__(self):
self.serialized_parameters_shape = (100, )
self.config = get_config()
self.nnet = nnet.nnet()
def __init__(self):
self.serialized_parameters_shape = (100,)
self.config = get_config()
self.nnet = nnet.nnet()
def build_and_train_nnet(self, X, Y):
y_onehot = self.class_to_onehot(Y)
n_in = X.shape[1]
n_nodes = self.l1_size
n_out = y_onehot.shape[1]
x = T.dmatrix()
y = T.imatrix()
#bias1, bias2, weights1, weights2
template = [(n_nodes,), (n_out,), (n_in,n_nodes),(n_nodes,n_out)]
#initialize nnet
model = nnet(input=x, n_in=n_in, n_nodes=n_nodes, n_out=n_out)
cost = model.neg_log_likelihood(y)
g_b1 = T.grad(cost, model.b1)
g_b2 = T.grad(cost, model.b2)
g_w1 = T.grad(cost, model.w1)
g_w2 = T.grad(cost, model.w2)
g_params = T.concatenate([g_b1.flatten(),g_b2.flatten(),
g_w1.flatten(),g_w2.flatten()])
getcost = theano.function([x,y],outputs=cost)
getdcost = theano.function([x,y],outputs=g_params)
def cost_fcn(params,inputs,targets):
model.set_params(params,template)
x = inputs
y = targets
return getcost(x,y)
def cost_grad(params, inputs, targets):
model.set_params(params,template)
x = inputs
y = targets
return getdcost(x,y)
args = climin.util.iter_minibatches([X,y_onehot],self.batch_size,[0,0])
batch_args = itertools.repeat(([X,y_onehot],{}))
args = ((i,{}) for i in args)
init_params = model.get_params(template)
opt_sgd = climin.GradientDescent(init_params, cost_fcn, cost_grad,
steprate=0.01, momentum=0.99, args=args,
momentum_type="nesterov")
opt_ncg = climin.NonlinearConjugateGradient(init_params,
cost_fcn,
cost_grad, args=batch_args)
opt_lbfgs = climin.Lbfgs(init_params, cost_fcn,
cost_grad, args=batch_args)
#choose the optimizer
if self.optimizer=='sgd':
optimizer = opt_sgd
elif self.optimizer=='ncg':
optimizer = opt_ncg
else: optimizer = opt_lbfgs
#do the actual training.
costs = []
for itr_info in optimizer:
if itr_info['n_iter'] > self.max_iters: break
costs.append(itr_info['loss'])
model.set_params(init_params, template)
return model, costs
# For NN >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Import images for train and test set ----------------------------------------------------------------
n_images_per_class = 100
train_images, train_labels = loadImages(train_set, n_images_per_class)
n_images_per_class = 10
test_images, test_labels = loadImages(test_set, n_images_per_class)
# -----------------------------------------------------------------------------------------------------
# Classification process ------------------------------------------------------------------------------
print('Classification with NN...')
predicted_nn = nnet(train_images, test_images, train_labels, test_labels,
classes_list)
# -----------------------------------------------------------------------------------------------------
# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Showing results images and predictions --------------------------------------------------------------
random.seed()
images_to_print = [
random.randint(0, n_images_per_class * n_classes - 1) for i in range(4)
]
print(
'Predicted by KNN: ', ' '.join('%20s' % classes_list[int(predicted_knn[i])]
for i in images_to_print))
print(
# outName = raw_input("Output Name: ")
# epoch = raw_input("Epoch: ")
# while not epoch.isdigit():
# epoch = raw_input("\tEnter Integer value for Epoch: ")
# epoch = int(epoch)
# rate = float(raw_input("Rate: "))
netLoc = "data/nn.init"
trainLoc = "data/training.csv"
outName = "data/sahearts.trained"
epoch = 500
rate = 0.1
net = nnet(netLoc)
net.train(trainLoc, epoch, rate)
net.writeFile(outName)
elif inPutz == "gen":
genInit()
exit()
elif inPutz == "test":
# netLoc = getFile("Trained net location: ")
# testLoc = getFile("Testing Set: ")
# outName = raw_input("Output Filename: ")
netLoc = "data/sahearts.trained"
testLoc = "data/test.csv"
outName = "data/sahearts.res"
net = nnet(netLoc)
def build_and_train_nnet(self, X, Y):
y_onehot = self.class_to_onehot(Y)
n_in = X.shape[1]
n_nodes = self.l1_size
n_out = y_onehot.shape[1]
x = T.dmatrix()
y = T.imatrix()
#bias1, bias2, weights1, weights2
template = [(n_nodes, ), (n_out, ), (n_in, n_nodes), (n_nodes, n_out)]
#initialize nnet
model = nnet(input=x, n_in=n_in, n_nodes=n_nodes, n_out=n_out)
cost = model.neg_log_likelihood(y)
g_b1 = T.grad(cost, model.b1)
g_b2 = T.grad(cost, model.b2)
g_w1 = T.grad(cost, model.w1)
g_w2 = T.grad(cost, model.w2)
g_params = T.concatenate(
[g_b1.flatten(),
g_b2.flatten(),
g_w1.flatten(),
g_w2.flatten()])
getcost = theano.function([x, y], outputs=cost)
getdcost = theano.function([x, y], outputs=g_params)
def cost_fcn(params, inputs, targets):
model.set_params(params, template)
x = inputs
y = targets
return getcost(x, y)
def cost_grad(params, inputs, targets):
model.set_params(params, template)
x = inputs
y = targets
return getdcost(x, y)
args = climin.util.iter_minibatches([X, y_onehot], self.batch_size,
[0, 0])
batch_args = itertools.repeat(([X, y_onehot], {}))
args = ((i, {}) for i in args)
init_params = model.get_params(template)
opt_sgd = climin.GradientDescent(init_params,
cost_fcn,
cost_grad,
steprate=0.01,
momentum=0.99,
args=args,
momentum_type="nesterov")
opt_ncg = climin.NonlinearConjugateGradient(init_params,
cost_fcn,
cost_grad,
args=batch_args)
opt_lbfgs = climin.Lbfgs(init_params,
cost_fcn,
cost_grad,
args=batch_args)
#choose the optimizer
if self.optimizer == 'sgd':
optimizer = opt_sgd
elif self.optimizer == 'ncg':
optimizer = opt_ncg
else:
optimizer = opt_lbfgs
#do the actual training.
costs = []
for itr_info in optimizer:
if itr_info['n_iter'] > self.max_iters: break
costs.append(itr_info['loss'])
model.set_params(init_params, template)
return model, costs
#!/usr/bin/env python
import numpy as np
import nnet
import preprocessing
x = preprocessing.X
y = preprocessing.Y
model = nnet.nnet(x.shape[1:])
model.compile(
optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'],
)
model.fit(
x,
y,
batch_size=32,
epochs=10,
validation_split=0.1,
)
