def load_dataset(filename=""): if filename == "": raise Exception("No dataset loaded because no network name provided") ds = SequenceClassificationDataSet.loadFromFile(filename + '.data') print("dataset loaded from " + filename + '.data') testds = SequenceClassificationDataSet.loadFromFile(filename + '_test.data') print("testdataset loaded from " + filename + '_test.data') return ds, testds
def load_dataset(filename=""): if filename == "": raise Exception("No dataset loaded because no network name provided") ds = SequenceClassificationDataSet.loadFromFile(filename + '.data') print("dataset loaded from " + filename + '.data') testds = SequenceClassificationDataSet.loadFromFile(filename + '_test.data') print("testdataset loaded from " + filename + '_test.data') return ds, testds
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 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 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 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 __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 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 generalization_error(net, length, inp_len, med, numb, punct): sentence_tuples = get_nice_sentences_as_tuples(MIN=length, MAX=length, include_numbers=numb, include_punctuation=punct) exper_data = SequenceClassificationDataSet(inp=inp_len, target=2) sentence_matrices = construct_sentence_matrices(sentence_tuples, medium=med) for s in sentence_matrices: insert_grammatical_sequence(exper_data, s) insert_randomized_sequence(exper_data, s) return 1 - testOnSequenceData(net, exper_data)
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 __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)
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()
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")
correct += 1.0 train_accuracy2 = correct / float(len(Y_train)) print "training accuracy is ", train_accuracy2 test_out = net.activateOnDataset(test_ds) Y_pred = convert_output(test_out) correct = 0.0 for i in range(len(Y_test)): if compare_list(Y_test[i], Y_pred[i]): correct += 1.0 test_accuracy2 = correct / float(len(Y_test)) print "test accuracy is ", test_accuracy2 """ x_dimension = len(X_train[0]) y_dimension = len(Y_train[0]) DS = SequenceClassificationDataSet(x_dimension, y_dimension, nb_classes=3) ds = SupervisedDataSet(x_dimension, y_dimension) for i in range(len(X_train)): ds.addSample(X_train[i], Y_train[i]) # construct LSTM network - note the missing output bias rnn = buildNetwork(x_dimension, x_dimension, y_dimension, hiddenclass=LSTMLayer, outclass=SoftmaxLayer, outputbias=False, recurrent=True) # define a training method trainer = RPropMinusTrainer(rnn, dataset=ds, verbose=True)
plt.xticks(tick_marks, behavior_names) plt.yticks(tick_marks, behavior_names) plt.xlabel("Predicted Class") plt.ylabel("True Class") plt.tight_layout() # 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%100==0: trndata.newSequence() trndata.appendLinked(BallLiftJoint[i,:], [0]) for i in range(6000): if i%100==0: trndata.newSequence() trndata.appendLinked(BallRollJoint[i,:], [1]) for i in range(6000): if i%100==0: trndata.newSequence() trndata.appendLinked(BellRingLJoint[i,:], [2]) for i in range(6000):
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) jointRemap = interp1d([-2.2,2.2],[-1,1]) BallLiftJoint = jointRemap(BallLiftJoint) BallRollJoint = jointRemap(BallRollJoint) BellRingLJoint = jointRemap(BellRingLJoint) BellRingRJoint = jointRemap(BellRingRJoint) BallRollPlateJoint = jointRemap(BallRollPlateJoint) RopewayJoint = jointRemap(RopewayJoint) trndata = SequenceClassificationDataSet(10,1, nb_classes=6) tstdata = SequenceClassificationDataSet(10,1, nb_classes=6) for i in range(6000): if i%200==0: trndata.newSequence() trndata.appendLinked(BallLiftJoint[i,:], [4]) for i in range(6000): if i%200==0: trndata.newSequence() trndata.appendLinked(BallRollJoint[i,:], [5]) for i in range(6000,8000): if i%200==0: tstdata.newSequence() tstdata.appendLinked(BallLiftJoint[i,:], [4])
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) jointRemap = interp1d([-2.2,2.2],[-1,1]) BallLiftJoint = jointRemap(BallLiftJoint) BallRollJoint = jointRemap(BallRollJoint) BellRingLJoint = jointRemap(BellRingLJoint) BellRingRJoint = jointRemap(BellRingRJoint) BallRollPlateJoint = jointRemap(BallRollPlateJoint) RopewayJoint = jointRemap(RopewayJoint) 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%100==0: trndata.newSequence() trndata.appendLinked(BallLiftJoint[i,:], [0]) for i in range(6000): if i%100==0: trndata.newSequence() trndata.appendLinked(BallRollJoint[i,:], [1]) for i in range(6000): if i%100==0: trndata.newSequence() trndata.appendLinked(BellRingLJoint[i,:], [2]) for i in range(6000):
for _ in range(nseq): DS.newSequence() buf = rand(npoints) * noise + y1 + (rand(1) - 0.5) * noise for i in range(npoints): DS.addSample([buf[i]], [0]) DS.newSequence() buf = rand(npoints) * noise + y2 + (rand(1) - 0.5) * noise for i in range(npoints): DS.addSample([buf[i]], [1]) return DS DS = SequenceClassificationDataSet # create training and test data trndata = SequenceClassificationDataSet(X_train, Y_train) tstdata = SequenceClassificationDataSet(X_test, Y_test) # construct LSTM network - note the missing output bias rnn = buildNetwork(trndata.indim, (), trndata.outdim, hiddenclass=LSTMLayer, outclass=SoftmaxLayer, outclass=SoftmaxLayer) #buildNetwork( MultiDimensionalLSTM #rnn.addInputModule(LinearLayer(3, name='in')) #rnn.addModule(MDLSTMLayer(5,2, name='hidden')) #rnn.addOutputModule(SoftmaxLayer(1, name='out')) #
high_prices = np.asarray([n['high'] for n in data]) close_prices = np.asarray([n['adj_close'] for n in data]) volumes = np.asarray([n['vol'] for n in data]) 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"))
for x in train_index: X_train.append(X[x]) y_train.append(y[x]) for x in test_index: X_test.append(X[x]) y_test.append(y[x]) # X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.3) # SequenceClassificationDataset(inp,target, nb_classes) # inp = input dimension # target = number of targets # nb_classes = number of classes trndata = SequenceClassificationDataSet(100,1, nb_classes=2) tstdata = SequenceClassificationDataSet(100,1, nb_classes=2) for index in range(len(y_train)): trndata.addSample(X_train[index], y_train[index]) for index in range(len(y_test)): tstdata.addSample(X_test[index], y_test[index]) trndata._convertToOneOfMany( bounds=[0.,1.] ) tstdata._convertToOneOfMany( bounds=[0.,1.] ) if exists("params.xml"): rnn = NetworkReader.readFrom('params.xml') else: # construct LSTM network - note the missing output bias
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()
for i in range(100,10000,100): LRopeway = np.vstack((LRopeway, BellRingLJoint[i:i+100], RopewayJoint[i:i+100])) for i in range(100,10000,100): RRopeway = np.vstack((RRopeway, BellRingRJoint[i:i+100], RopewayJoint[i:i+100])) 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):
for i in range(100,10000,100): LRopeway = np.vstack((LRopeway, BellRingLJoint[i:i+100], RopewayJoint[i:i+100])) for i in range(100,10000,100): RRopeway = np.vstack((RRopeway, BellRingRJoint[i:i+100], RopewayJoint[i:i+100])) 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):
secList.append(sectors[i]['day_price_change']) data.append(secList) #print data #dataset = SequentialDataSet(inputs, outputs) #(data1, data2) = np.array_split(data,2) #print data2 #for x in itertools.izip(data): # dataset.newSequence() # dataset.addSample(x) # create training and test data #datatrn = data1 + data2 #trndata = generateNoisySines(50, 40) #the data is now 2 d array - need to determine the dimensions of the data sets trndata = SequenceClassificationDataSet(numSectors,1) for i in xrange( 1, len(data[0]) ): trndata.newSequence() trndata.appendLinked(data[i - 1], (data[i] )) tstdata = SequenceClassificationDataSet(numSectors,1) for i in xrange( 1, len(data[0]) ): tstdata.newSequence() tstdata.appendLinked(data[i - 1], (data[i] )) #trndata._convertToOneOfMany( bounds=[0.,1.] ) #tstdata = SequenceClassificationDataSet(1,1) #for i in xrange(len(data2) -1): # tstdata.newSequence() # tstdata.addSample(data2[i], data2[i+1]) #tstdata._convertToOneOfMany( bounds=[0.,1.] )