def train_nn(self): connection_rate = 1 iterations_between_reports = 100000 ann = libfann.neural_net() if self.num_hidden2 == 0: ann.create_standard_array( (self.num_input, self.num_hidden1, self.num_output)) elif self.num_hidden2 > 0: ann.create_standard_array((self.num_input, self.num_hidden1, self.num_hidden2, self.num_output)) ann.set_learning_rate(self.learning_rate) # ann.set_activation_function_hidden(libfann.SIGMOID) # ann.set_activation_function_hidden(libfann.SIGMOID_SYMMETRIC) ann.set_activation_function_hidden(libfann.SIGMOID_SYMMETRIC_STEPWISE) # ann.set_activation_function_output(libfann.LINEAR) # ann.set_activation_function_output(libfann.ELLIOT_SYMMETRIC) ann.set_activation_function_output(libfann.SIGMOID_SYMMETRIC_STEPWISE) ann.train_on_file(self.train_file, self.max_iterations, iterations_between_reports, self.desired_error) ann.save(self.net_file)
def sumscore_classifier_ann_single(X, Y): #approxFun1 = (np.vectorize(class1)) #approxFun2 = (np.vectorize(class2)) ann = libfann.neural_net() ann.create_from_file("project_data/ann"+str(max(Y))+".net") nr_features = max(X.shape) mat1 = np.array([]) for i in range(nr_features): out_vec = ann.run(X[i,:]) out_vec_rounded = map(int, np.round(out_vec)) out_vec_rounded = np.array(out_vec_rounded) cl = np.where(out_vec_rounded==1)[0] if not len(cl)==1: print 'error in sumscore: more than one or no output unit was 1; there were ',len(cl),' 1-output units.' cl = np.where(out_vec==np.max(out_vec))[0][0] mat1 = np.append(mat1, cl) return sumscore_single(Y[:, 0], mat1)
def train_nn(data_file,net_file): connection_rate = 1 learning_rate = 0.7 num_input = 2 num_hidden = 4 num_output = 1 desired_error = 0.0001 max_iterations = 10000 iterations_between_reports = 10000 ann = libfann.neural_net() ann.create_standard_array((7,10,10,10,10,10,10,10,1)) ann.set_learning_rate(0.7) ann.set_activation_function_output(libfann.SIGMOID_SYMMETRIC_STEPWISE) ann.train_on_file(data_file, max_iterations, iterations_between_reports, desired_error) ann.save(net_file)
def predict_and_print_ann(name, X, nnfilename): ann = libfann.neural_net() ann.create_from_file(nnfilename) Ypred = [0]; nrFeatures = max(X.shape) for i in range(nrFeatures): out_vec = ann.run(X[i,:]) out_vec_rounded = map(int, np.round(out_vec)) out_vec_rounded = np.array(out_vec_rounded) cl = np.where(out_vec_rounded==1)[0] if not len(cl)==1: print 'error in predict&print: more than one or no output unit was 1; there were ',len(cl),' 1-output units.' cl = np.where(out_vec==np.max(out_vec))[0][0] Ypred = np.append(Ypred, [cl], axis=0) Ypred=Ypred[1:] #X = X.tolist() #Ypred =[class1(X), class2(X)] np.savetxt('project_data/' + name + '.txt', Ypred.T, fmt='%i', delimiter=',')
def trainNetwork(dataFilename, netFilename, numInput, numOutput): ann = libfann.neural_net() #ann.create_sparse_array(NNWrapper.connection_rate, (numInput, 6, 4, numOutput)) #TODO: is this what we want? # the one that works in 40 seconds 4, 10, 6, 1. the one that trained in 30 secs was 6,6 ann.create_sparse_array(NNWrapper.connection_rate, (numInput, 200, 80, 40, 20, 10, numOutput)) ann.set_learning_rate(NNWrapper.learning_rate) ann.set_activation_function_output(libfann.SIGMOID_SYMMETRIC_STEPWISE) ann.set_bit_fail_limit(.2) #ann.randomize_weights(0,0) t0 = time.clock() ann.train_on_file(dataFilename, NNWrapper.max_iterations, NNWrapper.iterations_between_reports, NNWrapper.desired_error) t1 = time.clock() seconds = t1-t0 m, s = divmod(seconds, 60) h, m = divmod(m, 60) print "Time to train:" print "%d:%02d:%02d" % (h, m, s) ann.save(netFilename)
def train_nn(self, data_file,net_file): connection_rate = 1 learning_rate = 0.7 num_input = 2 num_hidden = 4 num_output = 1 desired_error = 0.0001 max_iterations = 100000 iterations_between_reports = 100000 ann = libfann.neural_net() ann.create_standard_array((3,25,6,1)) ann.set_learning_rate(0.3) ann.set_activation_function_hidden(libfann.SIGMOID) ann.set_activation_function_output(libfann.LINEAR) ann.train_on_file(data_file, max_iterations, iterations_between_reports, desired_error) ann.save(net_file)
def train_nn(self, data_file, net_file): connection_rate = 1 learning_rate = 0.7 num_input = 2 num_hidden = 4 num_output = 1 desired_error = 0.0001 max_iterations = 100000 iterations_between_reports = 100000 ann = libfann.neural_net() ann.create_standard_array((3, 25, 6, 1)) ann.set_learning_rate(0.3) ann.set_activation_function_hidden(libfann.SIGMOID) ann.set_activation_function_output(libfann.LINEAR) ann.train_on_file(data_file, max_iterations, iterations_between_reports, desired_error) ann.save(net_file)
def testNet(testSet, netFilename, labelHandler): if NNWrapper.numThatActuallyHaveLabel == None: NNWrapper.numThatActuallyHaveLabel = [0]*len(labelHandler.labelIdsToLabels) NNWrapper.numThatActuallyHaveLabelCorrectlyLabeled = [0]*len(labelHandler.labelIdsToLabels) testingSummaryFile = open(NNWrapper.testingSummaryFilename, "a") ann = libfann.neural_net() ann.create_from_file(netFilename) #ann.print_connections() numTested = 0 numLabeledCorrectly = 0 for pair in testSet: featureVec = pair[0] actualLabelId = pair[1].index(1) actualLabel = labelHandler.labelIdsToLabels[actualLabelId] result = ann.run(featureVec) #print result, actualLabel numTested += 1 winningIndex = result.index(max(result)) NNWrapper.numThatActuallyHaveLabel[actualLabelId] += 1 #testingSummaryFile.write(labelHandler.labelIdsToLabels[winningIndex]+","+actualLabel+"\n") testingSummaryFile.write(actualLabel + ";" + str(actualLabelId) + ";" + str(result) + "\n") if winningIndex == actualLabelId: numLabeledCorrectly += 1 NNWrapper.numThatActuallyHaveLabelCorrectlyLabeled[actualLabelId] += 1 print "numTested", numTested print "numLabeledCorrectly", numLabeledCorrectly NNWrapper.totalTested += numTested NNWrapper.totalCorrect += numLabeledCorrectly print "totalTested", NNWrapper.totalTested print "totalCorrect", NNWrapper.totalCorrect print "percentageCorrect", float(NNWrapper.totalCorrect)/NNWrapper.totalTested print "*****************" for i in range(len(NNWrapper.numThatActuallyHaveLabel)): print labelHandler.labelIdsToLabels[i], NNWrapper.numThatActuallyHaveLabel[i], NNWrapper.numThatActuallyHaveLabelCorrectlyLabeled[i], float(NNWrapper.numThatActuallyHaveLabelCorrectlyLabeled[i])/NNWrapper.numThatActuallyHaveLabel[i] testingSummaryFile.close()
def train_nn(self): connection_rate = 1 iterations_between_reports = 100000 ann = libfann.neural_net() if self.num_hidden2 == 0: ann.create_standard_array((self.num_input,self.num_hidden1,self.num_output)) elif self.num_hidden2 > 0: ann.create_standard_array((self.num_input,self.num_hidden1,self.num_hidden2,self.num_output)) ann.set_learning_rate(self.learning_rate) # ann.set_activation_function_hidden(libfann.SIGMOID) # ann.set_activation_function_hidden(libfann.SIGMOID_SYMMETRIC) ann.set_activation_function_hidden(libfann.SIGMOID_SYMMETRIC_STEPWISE) # ann.set_activation_function_output(libfann.LINEAR) # ann.set_activation_function_output(libfann.ELLIOT_SYMMETRIC) ann.set_activation_function_output(libfann.SIGMOID_SYMMETRIC_STEPWISE) ann.train_on_file(self.train_file, self.max_iterations, iterations_between_reports, self.desired_error) ann.save(self.net_file)
def makeANN(training, hidden, error): with open(FILENAME + ".data", "w") as fout: numInOutPairs = str(len(training)) numIns = str(len(training[0][:-1])) numOuts = str(len(training[0][0])) header = " ".join((numInOutPairs, numIns, numOuts)) fout.write(header + "\n") for line in training: secLine = line.pop() line = " ".join(line) secLine = " ".join(secLine) fout.write(line + "\n" + secLine + "\n") #================================================================================== connection_rate = 1 num_input = 4 num_hidden = hidden num_output = 3 desired_error = error max_iterations = 100000 iterations_between_reports = 1000 print "\n\nMaking ANN\n\n" ann = libfann.neural_net() ann.create_sparse_array(connection_rate, (num_input, num_hidden, num_output)) ann.set_activation_function_output(libfann.SIGMOID_SYMMETRIC_STEPWISE) ann.set_activation_function_hidden(libfann.SIGMOID_SYMMETRIC_STEPWISE) ann.train_on_file(FILENAME + ".data", max_iterations, iterations_between_reports, desired_error) ann.save(FILENAME + ".net")
def trainNetwork(dataFilename, netFilename, layerSizes, max_iterations, desired_error): # layerSizes should look something like this: (numInput, 200, 80, 40, 20, 10, numOutput) ann = libfann.neural_net() #ann.create_sparse_array(NNWrapper.connection_rate, (numInput, 6, 4, numOutput)) #TODO: is this what we want? # the one that works in 40 seconds 4, 10, 6, 1. the one that trained in 30 secs was 6,6 ann.create_standard_array(layerSizes) ann.set_learning_rate(NNWrapper.learning_rate) # rprop doesn't use learning rate ann.set_activation_function_output(libfann.SIGMOID_SYMMETRIC_STEPWISE) #ann.set_training_algorithm(libfann.TRAIN_RPROP) ann.set_training_algorithm(libfann.TRAIN_QUICKPROP) ann.set_bit_fail_limit(.3) #ann.randomize_weights(0,0) t0 = time.time() ann.train_on_file(dataFilename, max_iterations, NNWrapper.iterations_between_reports, desired_error) t1 = time.time() seconds = t1-t0 print "Seconds: ", seconds m, s = divmod(seconds, 60) h, m = divmod(m, 60) print "Time to train:" print "%d:%02d:%02d" % (h, m, s) ann.save(netFilename)
def create_and_train_nn(XTrain, YTrain, datafile, nr_its): data_size = max(XTrain.shape) nr_output = len(np.unique(YTrain)) connection_rate = 1 steepness_out = 1.0 #nr_hidden1 = 500 #nr_hidden2 = 75 nr_hidden = 100 desired_error = 0.01 max_iterations = 3*nr_its its_per_round = nr_its ann = libfann.neural_net() ann.create_sparse_array(connection_rate, (min(XTrain.shape), nr_hidden, nr_output)) #create...(rate, (in, hidden1, hidden2, out)) ann.set_training_algorithm(libfann.TRAIN_QUICKPROP) ann.set_activation_function_output(libfann.SIGMOID) #output units are between 1 or 0; for execution, use libfann.THRESHOLD ann.set_activation_steepness_hidden(steepness_out) nndat_all = libfann.training_data() nndat_all.read_train_from_file(datafile) if split_training_data: nndat_all.shuffle_train_data() nndat_train = libfann.training_data(nndat_all) nndat_test = libfann.training_data(nndat_all) nndat_train.subset_train_data(0, int(np.ceil(split_percentage_train*data_size))) nndat_test.subset_train_data(int(np.ceil(split_percentage_train*data_size)), min(int(np.floor(split_percentage_test*data_size)), int(np.floor((1-split_percentage_train)*data_size)))) else: nndat_train = nndat_all #ann.set_input_scaling_params(nndat_train, -1., 1.) #ann.set_input_scaling_params(nndat_test, -1., 1.) testE = 5; # mean square error counter = 0; max_counter = 2; #if more than max_counter times the error on testing data increased, stop overfit = False i = 0 #nr of runs of network updates ## statistics on ann.train_on_data: # # ~2000 input units, 10 output units, output function: sigmoid # - 1 hidden layer of 20 units, 100 epochs: # TRAIN_QUICKPROP: 1 min , error: ~0.06 # TRAIN_RPROP: < 5 sec , error: ~0.09 # TRAIN_RPROP, 2nd run: 1 min , error: ~0.08 # - 1 hidden layer of 20 units, 1000 epochs: # TRAIN_RPROP: stopped it after 3 or 4 mins while i < max_iterations & ~overfit: ann.train_on_data(nndat_train, its_per_round, 0, desired_error) trainE_new = ann.test_data(nndat_train) if split_training_data: testE_new = ann.test_data(nndat_test) if testE_new > testE: counter = counter+1 if counter > max_counter: overfit = True trainE = trainE_new testE = testE_new i = i + its_per_round if i % 10 == 0: print 'nr of epochs so far: %d; error on training set: %f; on test set: %f' % (i, trainE, testE) print 'network has been trained in %d epochs; error on training set: %f; on test set: %f' % (i, trainE, testE) print 'overfitting: '+str(overfit)+" (test data exists: "+str(split_training_data)+")" ann.save("project_data/ann"+str(max(YTrain))+".net") return "project_data/ann"+str(max(YTrain))+".net"
def test_each(self, net_file, test_data): ann = libfann.neural_net() ann.create_from_file(net_file) return ann.run(test_data)[0]
def test_each(net_file, price, ma5, ma10, vol5, vol10, macd, vol): ann = libfann.neural_net() ann.create_from_file(net_file) return ann.run([price, ma5, ma10, vol5, vol10, macd, vol])[0]
import libfann connection_rate = 1 learning_rate = 0.7 num_input = 2 num_hidden = 4 num_output = 1 desired_error = 0.0001 max_iterations = 100000 iterations_between_reports = 1000 ann = libfann.neural_net() ann.create_sparse_array(connection_rate, (num_input, num_hidden, num_output)) ann.set_learning_rate(learning_rate) ann.set_activation_function_output(libfann.SIGMOID_SYMMETRIC_STEPWISE) ann.train_on_file('E:/FANN_workspace/xor.txt', max_iterations, iterations_between_reports, desired_error) ann.save("E:/xor_py.net")
def runANN(L): ann = libfann.neural_net() ann.create_from_file(FILENAME + ".net") return ann.run(L)
def test_each(net_file,price,ma5,ma10,vol5,vol10,macd,vol): ann = libfann.neural_net() ann.create_from_file(net_file) return ann.run([price,ma5,ma10,vol5,vol10,macd,vol])[0]
def testNet(datasetRaw, netFilename, labelHandler): if NNWrapper.numThatActuallyHaveLabel == None: NNWrapper.numThatActuallyHaveLabel = {} NNWrapper.numThatActuallyHaveLabelCorrectlyLabeled = {} try: os.remove(testingSummaryFilename) except: print "already no such file" testingSummaryFile = open(NNWrapper.testingSummaryFilename, "a") ann = libfann.neural_net() ann.create_from_file(netFilename) #ann.print_connections() labelLen = labelHandler.numLabels stats = {} documents = relationToDocuments(datasetRaw, labelHandler) for document in documents: print document boxes = documents[document] boxPairs = itertools.permutations(boxes, 2) for pair in boxPairs: featureVec = pair[0][0]+pair[1][0] actualLabelsBox1 = labelHandler.getLabelsForXInNRep(pair[0][1]) actualLabelsBox2 = labelHandler.getLabelsForXInNRep(pair[1][1]) result = ann.run(featureVec) testingSummaryFile.write(str(pair[0][1])+"\t;"+str(pair[1][1])+"\t;"+str(result)) guessedLabelsBox1 = labelHandler.labelsFromNetAnswer(result[:labelLen]) guessedLabelsBox2 = labelHandler.labelsFromNetAnswer(result[labelLen:]) for actualLabelBox1 in actualLabelsBox1: box1Stats = stats.get(actualLabelBox1, {"left": {}, "right": {}}) for guessedLabelBox1 in guessedLabelsBox1: box1Stats["left"][guessedLabelBox1] = box1Stats["left"].get(guessedLabelBox1, 0) + 1 stats[actualLabelBox1] = box1Stats for actualLabelBox2 in actualLabelsBox2: box2Stats = stats.get(actualLabelBox2, {"left": {}, "right": {}}) for guessedLabelBox2 in guessedLabelsBox2: box2Stats["right"][guessedLabelBox2] = box2Stats["right"].get(guessedLabelBox2, 0) + 1 stats[actualLabelBox2] = box2Stats for key in stats: print key, "left" print "*******************" for label in labelHandler.labelIdsToLabels: count = stats[key]["left"].get(label, 0) print label, "\t\t\t", count print key, "right" print "*******************" for label in labelHandler.labelIdsToLabels: count = stats[key]["right"].get(label, 0) print label, "\t\t\t", count
def test_each(self, net_file,test_data): ann = libfann.neural_net() ann.create_from_file(net_file) return ann.run(test_data)[0]