def train(self, epoch):
self.ds._convertToOneOfMany()
trainer = RPropMinusTrainer(self.net,
dataset=self.ds,
momentum=0.1,
verbose=True,
weightdecay=0.01)
trainer.trainEpochs(epoch)
def train(self, params, verbose=False):
if params['reset_every_training']:
if verbose:
print 'create lstm network'
random.seed(6)
if params['output_encoding'] == None:
self.net = buildNetwork(self.nDimInput,
params['num_cells'],
self.nDimOutput,
hiddenclass=LSTMLayer,
bias=True,
outputbias=True,
recurrent=True)
elif params['output_encoding'] == 'likelihood':
self.net = buildNetwork(self.nDimInput,
params['num_cells'],
self.nDimOutput,
hiddenclass=LSTMLayer,
bias=True,
outclass=SigmoidLayer,
recurrent=True)
self.net.reset()
ds = SequentialDataSet(self.nDimInput, self.nDimOutput)
networkInput = self.window(self.networkInput, params)
targetPrediction = self.window(self.targetPrediction, params)
# prepare a training data-set using the history
for i in xrange(len(networkInput)):
ds.addSample(self.inputEncoder.encode(networkInput[i]),
self.outputEncoder.encode(targetPrediction[i]))
mycount = 0
if params['num_epochs'] > 1:
trainer = RPropMinusTrainer(self.net, dataset=ds, verbose=verbose)
if verbose:
print " train LSTM on ", len(
ds), " records for ", params['num_epochs'], " epochs "
if len(networkInput) > 1:
trainer.trainEpochs(params['num_epochs'])
else:
self.trainer.setData(ds)
self.trainer.train()
# run through the training dataset to get the lstm network state right
self.net.reset()
for i in xrange(len(networkInput)):
self.net.activate(ds.getSample(i)[0])
def partial_fit(self, X, y):
"""
Additional training of the estimator
:param pandas.DataFrame X: data shape [n_samples, n_features]
:param y: labels of events - array-like of shape [n_samples]
:return: self
"""
dataset = self._prepare_dataset(X, y, self._model_type)
if not self.is_fitted():
self._prepare_net(dataset=dataset, model_type=self._model_type)
if self.use_rprop:
trainer = RPropMinusTrainer(self.net,
etaminus=self.etaminus,
etaplus=self.etaplus,
deltamin=self.deltamin,
deltamax=self.deltamax,
delta0=self.delta0,
dataset=dataset,
learningrate=self.learningrate,
lrdecay=self.lrdecay,
momentum=self.momentum,
verbose=self.verbose,
batchlearning=self.batchlearning,
weightdecay=self.weightdecay)
else:
trainer = BackpropTrainer(self.net,
dataset,
learningrate=self.learningrate,
lrdecay=self.lrdecay,
momentum=self.momentum,
verbose=self.verbose,
batchlearning=self.batchlearning,
weightdecay=self.weightdecay)
if self.epochs < 0:
trainer.trainUntilConvergence(
maxEpochs=self.max_epochs,
continueEpochs=self.continue_epochs,
verbose=self.verbose,
validationProportion=self.validation_proportion)
else:
trainer.trainEpochs(epochs=self.epochs, )
return self
def partial_fit(self, X, y):
"""
Additional training of the estimator
:param pandas.DataFrame X: data shape [n_samples, n_features]
:param y: labels of events - array-like of shape [n_samples]
:return: self
"""
dataset = self._prepare_dataset(X, y, self._model_type)
if not self.is_fitted():
self._prepare_net(dataset=dataset, model_type=self._model_type)
if self.use_rprop:
trainer = RPropMinusTrainer(self.net,
etaminus=self.etaminus,
etaplus=self.etaplus,
deltamin=self.deltamin,
deltamax=self.deltamax,
delta0=self.delta0,
dataset=dataset,
learningrate=self.learningrate,
lrdecay=self.lrdecay,
momentum=self.momentum,
verbose=self.verbose,
batchlearning=self.batchlearning,
weightdecay=self.weightdecay)
else:
trainer = BackpropTrainer(self.net,
dataset,
learningrate=self.learningrate,
lrdecay=self.lrdecay,
momentum=self.momentum,
verbose=self.verbose,
batchlearning=self.batchlearning,
weightdecay=self.weightdecay)
if self.epochs < 0:
trainer.trainUntilConvergence(maxEpochs=self.max_epochs,
continueEpochs=self.continue_epochs,
verbose=self.verbose,
validationProportion=self.validation_proportion)
else:
trainer.trainEpochs(epochs=self.epochs, )
return self
def train_net():
fnn = buildNetwork(len(input_args), 3, 2)
ds = ClassificationDataSet(len(input_args),2,nb_classes=2)
ds = generate_data(ds , hour_to_use_app = 10)
trainer = RPropMinusTrainer( fnn, dataset= ds, verbose=True)
trainer.train()
trainer.trainEpochs(15)
test = ClassificationDataSet(4,2)
test.addSample((12,6,10,6),[1,0])
test.addSample((12,1,7,2),[0,1])
test.addSample((12,3,11,1),[0,1])
fnn.activateOnDataset(test)
return fnn,trainer,ds,test
training_dataset._convertToOneOfMany( bounds=[0,1] )
# same for the independent test data set
testing_dataset = generate_data(test=True)
testing_dataset._convertToOneOfMany( bounds=[0,1] )
# build a feed-forward network with 20 hidden units, plus
# a corresponding trainer
# fnn = buildNetwork( training_dataset.indim, 15,15, training_dataset.outdim, outclass=SoftmaxLayer )
fnn = buildNetwork( training_dataset.indim, 15, training_dataset.outdim, hiddenclass=LSTMLayer, outclass=SoftmaxLayer, outputbias=False, recurrent=True)
trainer = RPropMinusTrainer( fnn, dataset=training_dataset, verbose=True )
#trainer = BackpropTrainer( fnn, dataset=training_dataset,verbose=True)
for i in range(500):
# train the network for 1 epoch
trainer.trainEpochs( 15 )
# evaluate the result on the training and test data
trnresult = percentError( trainer.testOnClassData(),
training_dataset['class'] )
tstresult = percentError( trainer.testOnClassData(
dataset=testing_dataset ), testing_dataset['class'] )
# print the result
print "epoch: %4d" % trainer.totalepochs, \
" train error: %5.2f%%" % trnresult, \
" test error: %5.2f%%" % tstresult
if tstresult <= 0.5 :
print 'Bingo !!!!!!!!!!!!!!!!!!!!!!'
break
# clock
snd_20043 = load_snd(20043)
append2DS(DS, snd_20043, 2, nClasses)
# fnn = buildNetwork(1, 15, 5, hiddenclass = LSTMLayer, outclass = SoftmaxLayer, outputbias = False, recurrent = True)
fnn = buildNetwork(1, 1, nClasses, hiddenclass=LSTMLayer, outclass=TanhLayer, outputbias=False, recurrent=True)
# Create a trainer for backprop and train the net.
# trainer = BackpropTrainer(fnn, DStrain, learningrate = 0.005)
trainer = RPropMinusTrainer(fnn, dataset=DS, verbose=True)
for i in range(4):
# train the network for 1 epoch
trainer.trainEpochs(1)
print trainer.train()
fnn.reset()
summed = numpy.zeros(nClasses)
for sample in snd_18768:
summed += fnn.activate([sample])
print summed / len(snd_18768)
fnn.reset()
summed = numpy.zeros(nClasses)
for sample in snd_21649:
summed += fnn.activate([sample])
print summed / len(snd_21649)
fnn.reset()
def BnTNN(ds, hiddensize, epoches):
net = buildNetwork(ds.indim, hiddensize, ds.outdim, outclass=SoftmaxLayer)
st = time()
trainer = RPropMinusTrainer(net, dataset=ds, momentum=0.1, verbose=True, weightdecay=0.01)#
trainer.trainEpochs( epoches )
return net
def train(self, epoch):
self.ds._convertToOneOfMany( )
trainer = RPropMinusTrainer(self.net, dataset=self.ds, momentum=0.1, verbose=True, weightdecay=0.01)
trainer.trainEpochs( epoch )
nHidden,
segments,
hiddenclass=LSTMLayer,
outclass=TanhLayer,
outputbias=True,
recurrent=True,
peepholes=False,
fast=False,
)
trainer = RPropMinusTrainer(fnn, dataset=DS, verbose=True)
print "Begin training..."
# Train the network
trainer.trainEpochs(nEpoch)
# Store the encoder
file = open("autoencoder-%i.xml" % (nHidden), "w")
pickle.dump(fnn, file)
file.close()
# Show an example
id = 86464
cochleogram = data.load_cochleogram(id)
fnn.reset()
haha = numpy.zeros(cochleogram.shape, dtype=numpy.float32)
for i in range(cochleogram.shape[1]):
output = fnn.activate(cochleogram[:, i].T.tolist()[0])
haha[:, i] = output
def train_network(options_file_location,training_data_location,output_location):
training_file_handle = open(training_data_location,"r")
training_reader = csv.reader(training_file_handle)
stdout_file = output_location+'training_console_output.txt'
stderr_file = output_location+'training_console_errput.txt'
sys.stdout = open(stdout_file,"w")
sys.stderr = open(stderr_file,"w")
options_file_location = options_file_location
options_file_handle = open(options_file_location,'r')
options_dictionary = {}
for option in options_file_handle.readlines():
key,val = option.split('=')
print key
print val
options_dictionary[key] = val;
num_predictors = int(options_dictionary['num_predictors'])
num_outputs = int(options_dictionary['num_outputs'])
num_training_epochs = int(options_dictionary['num_training_epochs'])
num_hidden_neurons = int(options_dictionary['num_hidden_neurons'])
num_classes = int((options_dictionary['num_classes']))
hidden_neuron_type_str = options_dictionary['hidden_neuron_type']
output_neuron_type_str = options_dictionary['output_neuron_type']
hidden_layer_type,output_layer_type = net_topol.get_layer_types(options_dictionary)
training_dataset = SequenceClassificationDataSet(num_predictors, 1,num_classes)
previous_sequence_number = 1
#read data into dataset objects
print 'reading in training data...'
for row in training_reader:
#convert list of strings to list of floats
list = [float(s) for s in row]
#split input line
predictors = list[0:num_predictors]
#+1 is to skip over the sequence column
outputs = list[num_predictors+1:num_predictors+1+num_outputs]
#convert from python list to numpy array
predictors = np.array(predictors)
outputs = np.array(outputs)
sequence_number = math.trunc(list[num_predictors])
if not sequence_number==previous_sequence_number:
# print sequence_number
# print previous_sequence_number
training_dataset.newSequence()
previous_sequence_number = sequence_number
#add to dataset
training_dataset.appendLinked(predictors, outputs)
network = shortcuts.buildNetwork(num_predictors, num_hidden_neurons, num_outputs, hiddenclass=LSTMLayer, outclass=SoftmaxLayer)
network.sortModules();
training_dataset._convertToOneOfMany();
print str(network)
print str(training_dataset)
trainer = RPropMinusTrainer(module=network, dataset=training_dataset)
for i in range(num_training_epochs):
print 'Starting training epoch: '+str(i)
trainer.trainEpochs(1)
sys.stdout.flush()
network_file_location = output_location+'trained_network.xml'
NetworkWriter.writeToFile(network, network_file_location)
done_file_handle = open(output_location+'training_done.txt',"w")
done_file_handle.write('%s' % 'done!')
done_file_handle.close()
img = Image.open("img/" + files[i])
data = np.array(img)
data = data.reshape(-1)
ds.addSample((data), (files[i][0:6]))
img1 = Image.open("test_img/152830.png")
data1 = np.array(img1)
data1 = data1.reshape(-1)
net = buildNetwork(200 * 60 * 3, 1)
trainer = RPropMinusTrainer(net)
trainer.setData(ds)
trainer.trainEpochs(100)
def calculation(a, b):
i = 0
if ((int(a) // 100000) % 10 == (int(b) // 100000) % 10):
i = i + 1
if ((int(a) // 10000) % 10 == (int(b) // 10000) % 10):
i = i + 1
if ((int(a) // 1000) % 10 == (int(b) // 1000) % 10):
i = i + 1
if ((int(a) // 100) % 10 == (int(b) // 100) % 10):
i = i + 1
if ((int(a) // 10) % 10 == (int(b) // 10) % 10):
i = i + 1
if ((int(a) // 1) % 10 == (int(b) // 1) % 10):
testing_dataset = generate_data(test=True)
testing_dataset._convertToOneOfMany(bounds=[0, 1])
# build a feed-forward network with 20 hidden units, plus
# a corresponding trainer
fnn = buildNetwork(training_dataset.indim,
15,
15,
training_dataset.outdim,
outclass=SoftmaxLayer)
#trainer = BackpropTrainer( fnn, dataset=training_dataset,verbose=True)
trainer = RPropMinusTrainer(fnn, dataset=training_dataset, verbose=True)
for i in range(500):
# train the network for 1 epoch
trainer.trainEpochs(15)
# evaluate the result on the training and test data
trnresult = percentError(trainer.testOnClassData(),
training_dataset['class'])
tstresult = percentError(trainer.testOnClassData(dataset=testing_dataset),
testing_dataset['class'])
# print the result
print "epoch: %4d" % trainer.totalepochs, \
" train error: %5.2f%%" % trnresult, \
" test error: %5.2f%%" % tstresult
if tstresult <= 0.5:
print 'Bingo !!!!!!!!!!!!!!!!!!!!!!'
break
f = open('___learned3', 'r')
net = pickle.load(f)
f.close()
print 'loaded from file', time() - st
except:
'''
#exit()
if True:
st = time()
trainer = RPropMinusTrainer(net, dataset=ds, momentum=0.1, verbose=True, weightdecay=0.01)#
#trainer = BackpropTrainer( net, dataset=ds, momentum=0.1, verbose=True, weightdecay=0.01)
#trainer.trainOnDataset(ds, 10)
#trainer.testOnData()
print 'start train'
trainer.trainEpochs( 100 )
#trainer.trainUntilConvergence()
print 'Learning time:', time() - st
f = open('___learned3', 'w')
pickle.dump(net, f)
f.close()
#print net.activate(FeaturesFromFile('pos/5.jpg'))
counter = 0
st = time()
for i in xrange(40000, 50000):
image = cv.LoadImage(posnames[i], cv.CV_LOAD_IMAGE_GRAYSCALE)
res = net.activate(FeaturesFromImg(image, size)).argmax()
#print i, 'pos', res
if res == 1:
class sequence_classifier():
num_time_steps = 5
def __init__(self, ds):
num_inputs = ds.num_features * sequence_classifier.num_time_steps
self.alldata = SequenceClassificationDataSet(num_inputs,
target = 1,
nb_classes = ds.get_num_classes(),
class_labels = ds.get_classes() )
for Idx in range(len(ds.all_moves)):
if not (Idx + sequence_classifier.num_time_steps < len(ds.all_moves)):
continue
class_first = ds.all_moves[Idx].class_
features = []
for i in range(sequence_classifier.num_time_steps):
features = features + ds.all_moves[Idx + i].get_features()
class_last = ds.all_moves[Idx + sequence_classifier.num_time_steps].class_
if class_first == class_last:
self.alldata.appendLinked(features, [ds.get_classes().index(ds.all_moves[Idx].class_)])
self.alldata.newSequence()
self.tstdata, self.trndata = self.alldata.splitWithProportion(0.25)
self.trndata._convertToOneOfMany()
self.tstdata._convertToOneOfMany()
self.seq_rnn = None #buildNetwork(num_inputs, 2, self.trndata.outdim, hiddenclass=LSTMLayer,recurrent=True ,outclass=SoftmaxLayer)
self.create_network(num_inputs)
self.trainer = RPropMinusTrainer(module=self.seq_rnn, dataset=self.trndata)
def create_network(self, num_inputs):
self.seq_rnn = RecurrentNetwork()
in_layer = LinearLayer(num_inputs)
hidden_LSTM_ = LSTMLayer(24)
hidden_layer_0 = LinearLayer(12)
hidden_layer_1 = SigmoidLayer(12)
output_layer = LinearLayer(self.trndata.outdim)
self.seq_rnn.addInputModule(in_layer)
self.seq_rnn.addModule(hidden_layer_0)
self.seq_rnn.addModule(hidden_layer_1)
self.seq_rnn.addOutputModule(output_layer)
#Now add the connections:
in_to_LTSM = FullConnection(in_layer , hidden_LSTM)
LTSM_to_h0 = FullConnection(hidden_LSTM, hidden_layer_0)
in_to_h0 = FullConnection(in_layer , hidden_layer_0)
h0_to_h1 = FullConnection(hidden_layer_0, hidden_layer_1)
h1_to_out = FullConnection(hidden_layer_1, output_layer)
self.seq_rnn.addConnection(in_to_LSTM)
self.seq_rnn.addConnection(LSTM_to_h0)
self.seq_rnn.addConnection(in_to_h0)
self.seq_rnn.addConnection(h0_to_h1)
self.seq_rnn.addConnection(h1_to_out)
self.seq_rnn.sortModules()
def start_training(self):
f = open("./results/seq_rnn_perf.txt", "w");
for i in range(200):
print "training step: " , i
self.trainer.trainEpochs(1)
err = self.evaluate()
f.write(str(err) + ",")
f.flush()
f.close()
def evaluate(self):
print "epoch:" , self.trainer.totalepochs
correct = 0
wrong = 0
self.seq_rnn.sortModules()
for Idx in range (len(self.tstdata)):
out = self.seq_rnn.activate(self.tstdata['input'][Idx])
if argmax(out) == argmax(self.tstdata['target'][Idx]) :
correct += 1
else:
wrong += 1
correct_ratio = correct*1.0/(wrong + correct)
self.correct_perc.append(correct_ratio)
print "Wrong Predictions: " , wrong , "Ratio = ", wrong*100.0/(wrong+correct) , "%"
print "Correct Predictions: ", correct, "Ratio = ", correct*100.0/(wrong+correct) , "%"
if (self.max_ratio < correct_ratio):
print "Found new max, saving network"
self.write_out("best_perfrming_")
self.max_ratio = correct_ratio
return 1 - correct_ratio
def write_out(self, name=""):
NetworkWriter.writeToFile(self.seq_rnn, "./results/" + name + "req_rnn.xml")
def work(self, image):
width = self.pt2[0] - self.pt1[0]
height = self.pt2[1] - self.pt1[1]
currentrect = (self.pt1[0], self.pt1[1], width, height)#self.currentrect
#print currentrect
image_size = cv.GetSize(image)
# create grayscale version
grayscale = cv.CreateImage(image_size, 8, 1)
cv.CvtColor(image, grayscale, cv.CV_BGR2GRAY)
storage = cv.CreateMemStorage(0)
cv.EqualizeHist(grayscale, grayscale)
frame = np.asarray(image[:, :])
frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
mask = np.zeros_like(frame_gray)
mask[self.pt1[1]:self.pt2[1], self.pt1[0]:self.pt2[0]] = 255
st = time.time()
tracks = self.detector.detect(frame_gray, mask)
print 'detect time', time.time() - st
cv.Rectangle (image, self.pt1, self.pt2, (0, 255, 0), 1)
cv.SetImageROI(image, currentrect)
st = time.time()
out = self.ClassifyWindow(grayscale, currentrect)
print out, '|time', time.time() - st
cv.ResetImageROI(image)
if out == 1:
cv.Rectangle (image, (currentrect[0], currentrect[1]), (currentrect[2] + currentrect[0], currentrect[3] + currentrect[1]), (0, 255, 255), 5)
self.pt1, self.pt2 = PatchBoundary(tracks, self.pt1, self.pt2)
tmp = self.ImageFromRect(grayscale, currentrect)
features = FeaturesFromImg(grayscale, self.ninsize)
self.additionslds.addSample(features, [1])
for i in xrange(2):
badwin = self.ImageFromRect(grayscale, RandomRect(currentrect))
features = FeaturesFromImg(badwin, self.ninsize)
self.additionslds.addSample(features, [0])
print 'len of new dataset', len(self.additionslds)
'''
else:
rect = self.SearchObject(grayscale, currentrect)
if rect:
self.pt1, self.pt2 = RectToPoints(rect)
'''
if self.stage > 0:
tmp = self.ImageFromRect(grayscale, currentrect)
features = FeaturesFromImg(grayscale, self.ninsize)
self.additionslds.addSample(features, [1])
for i in xrange(2):
badwin = self.ImageFromRect(grayscale, RandomRect(currentrect))
features = FeaturesFromImg(badwin, self.ninsize)
self.additionslds.addSample(features, [0])
print 'len of new dataset', len(self.additionslds)
if len(self.additionslds) > 20:
self.additionslds._convertToOneOfMany( )
self.additionslds.outdim = self.net.outdim
#net = buildNetwork(self.ninsize[0] * self.ninsize[1], 96, self.additionslds.outdim, outclass=SoftmaxLayer)
trainer = RPropMinusTrainer(
self.net, dataset=self.additionslds,
momentum=0.1, verbose=True, weightdecay=0.01)
'''trainer = BackpropTrainer(
self.net, dataset=self.additionslds,
momentum=0.1, verbose=True, weightdecay=0.01)'''
trainer.trainEpochs( 3 )
self.additionslds.clear()
self.numoflearning += 1
if self.key == 113:
cv.SaveImage('img.bmp', image)
self.key = 255
if self.key == 119:
self.stage = 1
self.key = 255
if self.stage == 1 and self.numoflearning > 2:
self.stage = 2
'''
for item in tracks:
cv.Circle(image, (item[-1][0], item[-1][1]), 2, (0, 255, 0), -1)
'''
return image
