def generateUpDown( npoints, nseq , balance = 0.5):
""" construct a 2-class dataset out of noisy sines """
lmin = 2
lmax = 6
DS = SequenceClassificationDataSet(1,1, nb_classes=2)
for _ in xrange(nseq):
slen = randint(lmin,lmax)
if rand() < balance:
num = 10
DS.newSequence()
for _ in xrange(slen):
label = 0;
num = num + rand()
seq = num
DS.appendLinked([seq], [label])
else:
num = 10
DS.newSequence()
for _ in xrange(slen):
label = 1;
num = num - rand()
seq = num
DS.appendLinked([seq], [label])
return DS
def create_training_data(training_set,timesteps):
DS = SequenceClassificationDataSet(28*28 , 1 , nb_classes=10)
length = training_set[0].shape[0]
for l in xrange(length):
DS.newSequence()
img = training_set[0][l]
targ = training_set[1][l]
for j in xrange(timesteps):
DS.addSample(img , targ)
return DS
def create_test_data(test_set):
DS = SequenceClassificationDataSet(28*28,1,nb_classes=10)
length = test_set[0].shape[0]
for i in xrange(length):
DS.newSequence()
img = test_set[0][i]
targ = test_set[1][i]
DS.addSample(img , targ)
return DS
def __createDataset(data):
ds = SequenceClassificationDataSet(inputs, 1, nb_classes=nClasses, class_labels=labels.values())
for target in classes:
tupt = np.asarray([target])
# print("Target " + str(tupt))
for x in data[target]:
ds.newSequence()
for y in x:
tup = tuple(y)
ds.appendLinked(tup, tupt)
print(ds.calculateStatistics())
# ds._convertToOneOfMany(bounds=[0, 1])
# print ds.getField('target')
print("DS entries " + str(ds.getNumSequences()))
return ds
def generateNoisySines( npoints, nseq, noise=0.3 ):
""" construct a 2-class dataset out of noisy sines """
x = np.arange(npoints)/float(npoints) * 20.
y1 = np.sin(x+rand(1)*3.)
y2 = np.sin(x/2.+rand(1)*3.)
DS = SequenceClassificationDataSet(1,1, nb_classes=2)
for _ in xrange(nseq):
DS.newSequence()
buf = rand(npoints)*noise + y1 + (rand(1)-0.5)*noise
for i in xrange(npoints):
DS.addSample([buf[i]],[0])
DS.newSequence()
buf = rand(npoints)*noise + y2 + (rand(1)-0.5)*noise
for i in xrange(npoints):
DS.addSample([buf[i]],[1])
return DS
def generateNoisySines(npoints, nseq, noise=0.3):
""" construct a 2-class dataset out of noisy sines """
x = np.arange(npoints) / float(npoints) * 20.
y1 = np.sin(x + rand(1) * 3.)
y2 = np.sin(x / 2. + rand(1) * 3.)
DS = SequenceClassificationDataSet(1, 1, nb_classes=2)
for _ in xrange(nseq):
DS.newSequence()
buf = rand(npoints) * noise + y1 + (rand(1) - 0.5) * noise
for i in xrange(npoints):
DS.addSample([buf[i]], [0])
DS.newSequence()
buf = rand(npoints) * noise + y2 + (rand(1) - 0.5) * noise
for i in xrange(npoints):
DS.addSample([buf[i]], [1])
return DS
def __createDataset(data):
ds = SequenceClassificationDataSet(inputs,
1,
nb_classes=nClasses,
class_labels=labels.values())
for target in classes:
tupt = np.asarray([target])
# print("Target " + str(tupt))
for x in data[target]:
ds.newSequence()
for y in x:
tup = tuple(y)
ds.appendLinked(tup, tupt)
print(ds.calculateStatistics())
# ds._convertToOneOfMany(bounds=[0, 1])
# print ds.getField('target')
print("DS entries " + str(ds.getNumSequences()))
return ds
def sequenceClassificationDataSet(subject='a1', db=None): """Don't know if this is set up right or how to use it""" if not db: db = gyroWalkingData() raw = db.data[subject][:,2:] segs = db.segments[subject] DS = SequenceClassificationDataSet(21, 1) for i in range(0,len(raw),10): DS.newSequence() isSeg = 0 for j in range(10): if i+j in segs: isSeg = 1 else: isSeg = 0 DS.appendLinked(raw[i+j],[isSeg]) DS._convertToOneOfMany() return DS
def Train(self, dataset, error_observer, logger, dump_file):
gradientCheck(self.m_net)
net_dataset = SequenceClassificationDataSet(4, 2)
for record in dataset:
net_dataset.newSequence()
gl_raises = record.GetGlRises()
gl_min = record.GetNocturnalMinimum()
if DayFeatureExpert.IsHypoglycemia(record):
out_class = [1, 0]
else:
out_class = [0, 1]
for gl_raise in gl_raises:
net_dataset.addSample([gl_raise[0][0].total_seconds() / (24*3600), gl_raise[0][1] / 300, gl_raise[1][0].total_seconds() / (24*3600), gl_raise[1][1] / 300] , out_class)
train_dataset, test_dataset = net_dataset.splitWithProportion(0.8)
trainer = RPropMinusTrainer(self.m_net, dataset=train_dataset, momentum=0.8, learningrate=0.3, lrdecay=0.9, weightdecay=0.01, verbose=True)
validator = ModuleValidator()
train_error = []
test_error = []
for i in range(0, 80):
trainer.trainEpochs(1)
train_error.append(validator.MSE(self.m_net, train_dataset)) # here is validate func, think it may be parametrised by custom core function
test_error.append(validator.MSE(self.m_net, test_dataset))
print train_error
print test_error
error_observer(train_error, test_error)
gradientCheck(self.m_net)
dump_file = open(dump_file, 'wb')
pickle.dump(self.m_net, dump_file)
print LBallLift.shape
print RBallLift.shape
print LBallRoll.shape
print RBallRoll.shape
print LBallRollPlate.shape
print RBallRollPlate.shape
print LRopeway.shape
print RRopeway.shape
trndata = SequenceClassificationDataSet(10,1, nb_classes=8)
tstdata = SequenceClassificationDataSet(10,1, nb_classes=8)
for i in range(12000):
if i%200==0:
trndata.newSequence()
trndata.appendLinked(LBallLift[i,:], [0])
for i in range(12000):
if i%200==0:
trndata.newSequence()
trndata.appendLinked(RBallLift[i,:], [1])
for i in range(12000):
if i%200==0:
trndata.newSequence()
trndata.appendLinked(LBallRoll[i,:], [2])
for i in range(12000):
if i%200==0:
trndata.newSequence()
trndata.appendLinked(RBallRoll[i,:], [3])
for i in range(12000):
if i%200==0:
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()
def network_predict(options_file_location,prediction_data_location,output_location,network_location):
prediction_data_file_handle = open(prediction_data_location,"r")
prediction_data_reader = csv.reader(prediction_data_file_handle)
stdout_file = output_location+'prediction_console_output.txt'
stderr_file = output_location+'prediction_console_errput.txt'
sys.stdout = open(stdout_file,"w")
sys.stderr = open(stderr_file,"w")
prediction_results_file_location = output_location+'prediction_results.csv'
prediction_results_file_handle = open(prediction_results_file_location,"w")
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']))
prediction_dataset = SequenceClassificationDataSet(num_predictors, 1,num_classes)
previous_sequence_number = 1
# frame_number_debug = 0
print 'reading in prediction data...'
for row in prediction_data_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 '+str(sequence_number)
# print 'previous_sequence_number '+str(previous_sequence_number)
# frame_number_debug = 0;
prediction_dataset.newSequence()
previous_sequence_number = sequence_number
#add to dataset
prediction_dataset.appendLinked(predictors, outputs)
# frame_number_debug += 1
# print 'frame_number_debug '+str(frame_number_debug)
prediction_dataset._convertToOneOfMany();
network = NetworkReader.readFrom(network_location)
results, targets, accuracy = evalRNN.evalRNNOnSeqClassificationDataset(network,prediction_dataset)
print 'Accuracy: '+str(accuracy)
results_length = results.shape
np.savetxt(prediction_results_file_location,results,delimiter=" ",fmt='%5.5f')
done_file_handle = open(output_location+'predicting_done.txt',"w")
done_file_handle.write('%s' % 'done!')
done_file_handle.close()
################
# Original Joint data
BallLiftJoint = np.loadtxt("../../20fpsFullBehaviorSampling/BallLift/JointData.txt").astype(np.float32)
BallRollJoint = np.loadtxt("../../20fpsFullBehaviorSampling/BallRoll/JointData.txt").astype(np.float32)
BellRingLJoint = np.loadtxt("../../20fpsFullBehaviorSampling/BellRingL/JointData.txt").astype(np.float32)
BellRingRJoint = np.loadtxt("../../20fpsFullBehaviorSampling/BellRingR/JointData.txt").astype(np.float32)
BallRollPlateJoint = np.loadtxt("../../20fpsFullBehaviorSampling/BallRollPlate/JointData.txt").astype(np.float32)
RopewayJoint = np.loadtxt("../../20fpsFullBehaviorSampling/Ropeway/JointData.txt").astype(np.float32)
trndata = SequenceClassificationDataSet(10, 1, nb_classes=6, class_labels=["BL", "BR", "BRL", "BRR", "BRP", "RW"])
tstdata = SequenceClassificationDataSet(10, 1, nb_classes=6, class_labels=["BL", "BR", "BRL", "BRR", "BRP", "RW"])
for i in range(6000):
if i % 200 == 0:
trndata.newSequence()
trndata.appendLinked(BallLiftJoint[i, :], [0])
for i in range(6000):
if i % 200 == 0:
trndata.newSequence()
trndata.appendLinked(BallRollJoint[i, :], [1])
for i in range(6000):
if i % 200 == 0:
trndata.newSequence()
trndata.appendLinked(BellRingLJoint[i, :], [2])
for i in range(6000):
if i % 200 == 0:
trndata.newSequence()
trndata.appendLinked(BellRingRJoint[i, :], [3])
for i in range(6000):
if i % 200 == 0:
features = Features(open_prices, low_prices, high_prices, close_prices, volumes) f_input = features.getInput() f_output = features.getOutput() training_input = f_input[200:-test_n] training_output = f_output[200:-test_n] testing_input = f_input[-test_n:-20] testing_output = f_output[-test_n:-20] testing_label = date[-test_n:-20] n_input = len(f_input[0]) n_output = 1 # build sequential dataset training_dataset = SequenceClassificationDataSet(n_input, n_output, nb_classes=3, class_labels=["UP", "DOWN", "NOWHERE"]) for x, y in zip(training_input, training_output): training_dataset.appendLinked(x, [y]) training_dataset.newSequence() testing_dataset = SequenceClassificationDataSet(n_input, n_output, nb_classes=3, class_labels=["UP", "DOWN", "NOWHERE"]) for x, y in zip(testing_input, testing_output): testing_dataset.appendLinked(x, [y]) testing_dataset.newSequence() training_dataset._convertToOneOfMany() testing_dataset._convertToOneOfMany() # build network net = RecurrentNetwork() net.addInputModule(LinearLayer(training_dataset.indim, name="input")) net.addModule(LSTMLayer(100, name="hidden1")) net.addModule(SigmoidLayer(training_dataset.outdim * 3, name="hidden2")) net.addOutputModule(LinearLayer(training_dataset.outdim, name="output"))
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")
