def train(X, y): """ Trains and predicts dataset with a Neural Network classifier """ ds = ClassificationDataSet(len(X.columns), 1, nb_classes=2) for k in xrange(len(X)): ds.addSample(X.iloc[k], np.array(y[k])) tstdata, trndata = ds.splitWithProportion(0.20) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() input_size = len(X.columns) target_size = 1 hidden_size = 5 fnn = None if os.path.isfile('fnn.xml'): fnn = NetworkReader.readFrom('fnn.xml') else: fnn = buildNetwork(trndata.indim, hidden_size, trndata.outdim, outclass=SoftmaxLayer) trainer = BackpropTrainer(fnn, dataset=trndata, momentum=0.05, learningrate=0.1, verbose=False, weightdecay=0.01) trainer.trainUntilConvergence(verbose=False, validationProportion=0.15, maxEpochs=100, continueEpochs=10) NetworkWriter.writeToFile(fnn, 'oliv.xml') predictions = trainer.testOnClassData(dataset=tstdata) return tstdata['class'], predictions
def main(): images, labels = load_labeled_training(flatten=True) images = standardize(images) # images, labels = load_pca_proj(K=100) shuffle_in_unison(images, labels) ds = ClassificationDataSet(images.shape[1], 1, nb_classes=7) for i, l in zip(images, labels): ds.addSample(i, [l - 1]) # ds._convertToOneOfMany() test, train = ds.splitWithProportion(0.2) test._convertToOneOfMany() train._convertToOneOfMany() net = shortcuts.buildNetwork(train.indim, 1000, train.outdim, outclass=SoftmaxLayer) trainer = BackpropTrainer(net, dataset=train, momentum=0.1, learningrate=0.01, weightdecay=0.05) # trainer = RPropMinusTrainer(net, dataset=train) # cv = validation.CrossValidator(trainer, ds) # print cv.validate() net.randomize() tr_labels_2 = net.activateOnDataset(train).argmax(axis=1) trnres = percentError(tr_labels_2, train["class"]) # trnres = percentError(trainer.testOnClassData(dataset=train), train['class']) testres = percentError(trainer.testOnClassData(dataset=test), test["class"]) print "Training error: %.10f, Test error: %.10f" % (trnres, testres) print "Iters: %d" % trainer.totalepochs for i in range(100): trainer.trainEpochs(10) trnres = percentError(trainer.testOnClassData(dataset=train), train["class"]) testres = percentError(trainer.testOnClassData(dataset=test), test["class"]) trnmse = trainer.testOnData(dataset=train) testmse = trainer.testOnData(dataset=test) print "Iteration: %d, Training error: %.5f, Test error: %.5f" % (trainer.totalepochs, trnres, testres) print "Training MSE: %.5f, Test MSE: %.5f" % (trnmse, testmse)
def consturt_train_data(self): # print len(self.output_train) # print len(self.eigenvector) ds = ClassificationDataSet(self.vct_len, 1, nb_classes=2) for i in range(len(self.output_train)): ds.appendLinked(self.eigenvector[i], self.output_train[i]) # print ds # print ds ds.calculateStatistics() # split training, testing, validation data set (proportion 4:1) tstdata_temp, trndata_temp = ds.splitWithProportion(0.25) tstdata = ClassificationDataSet(self.vct_len, 1, nb_classes=2) for n in range(0, tstdata_temp.getLength()): tstdata.appendLinked( tstdata_temp.getSample(n)[0], tstdata_temp.getSample(n)[1]) trndata = ClassificationDataSet(self.vct_len, 1, nb_classes=2) for n in range(0, trndata_temp.getLength()): trndata.appendLinked( trndata_temp.getSample(n)[0], trndata_temp.getSample(n)[1]) # one hot encoding # print trndata testdata = ClassificationDataSet(self.vct_len, 1, nb_classes=2) test_data_temp = self.test_data for n in range(len(test_data_temp)): testdata.addSample(test_data_temp[n], [0]) # print testdata trndata._convertToOneOfMany() tstdata._convertToOneOfMany() testdata._convertToOneOfMany() return trndata, tstdata, testdata, ds
class NeuralNetwork(BaseWorkflow): def __init__(self, purpose='train', num_inputs=None, num_ouputs=None, classes=None, class_lables=None): super(NeuralNetwork, self).__init__() self.purpose = purpose self.data_path = self.config.neural_net.get(self.purpose, None) self.file_name = 'neural_net' self.all_data = ClassificationDataSet(num_inputs, num_ouputs, nb_classes=classes, class_labels=class_lables) self.train = None self.test = None self.neural_network = None self.train_result = None self.test_result = None self.cross_validation_result = None def process(self): self.prepare_train_test() self.build_network() trainer = self.train_network(dataset=self.train) self.score_train_test(trainer=trainer) self.cross_validate(dataset=self.all_data) def add_sample(self, correlogram_matrix=None, target=None, sample_path=None): self.all_data.addSample(correlogram_matrix, target) logger.info('sample added from {sample_path}'.format(sample_path=sample_path)) def prepare_train_test(self): self.test, self.train = self.all_data.splitWithProportion(0.25) def build_network(self): self.neural_network = buildNetwork(self.train.indim, 7, self.train.outdim, outclass=SoftmaxLayer) # feed forward network def train_network(self, dataset=None): starter_trainer = BackpropTrainer(self.neural_network, dataset=dataset, momentum=0.1, verbose=True, weightdecay=0.01) starter_trainer.trainUntilConvergence(validationProportion=0.25, maxEpochs=100) return starter_trainer def score_train_test(self, trainer=None): self.test_result = percentError(trainer.testOnClassData(dataset=self.test), self.test['class']) logger.info('test error result: {result}'.format(result=self.test_result)) self.train_result = percentError(trainer.testOnClassData(dataset=self.train), self.train['class'] ) logger.info('train error result: {result}'.format(result=self.train_result)) def cross_validate(self, dataset=None): trainer = BackpropTrainer(self.neural_network, dataset=dataset, momentum=0.1, verbose=True, weightdecay=0.01) validator = CrossValidator(trainer=trainer, dataset=dataset, n_folds=10) mean_validation_result = validator.validate() self.cross_validation_result = mean_validation_result logger.info('cross val result: {result}'.format(result=self.cross_validation_result)) @staticmethod def save_network_to_xml(net=None, file_name=None): NetworkWriter.writeToFile(net, file_name) @staticmethod def read_network_from_xml(file_name=None): return NetworkReader.readFrom(file_name)
def prepare_datasets(inp,out,dataframe, ratio): '''conversion from pandas dataframe to ClassificationDataSet of numpy parameters: inp: list of names of input features out: list of names of output features(target value) ratio: ratio of dimension of test to train dataset ''' inp_dim = len(inp) out_dim = len(out) no_classes = 2 alldata = ClassificationDataSet(inp_dim,out_dim,no_classes) inp = dataframe[inp] out = dataframe[out] #for [a,b,c],d in zip(inp.values,out.values): for i in range(len(inp.values)): d = out.values[i] if d=='up': d = 0 elif d == 'down': d = 1 else: d =2 alldata.addSample(inp.values[i],d) tstdata_temp, trndata_temp = alldata.splitWithProportion( ratio ) # to convert supervised datasets to classification datasets tstdata = trndata = ClassificationDataSet(inp_dim, out_dim, no_classes) for n in range(0, tstdata_temp.getLength()): tstdata.addSample( tstdata_temp.getSample(n)[0], tstdata_temp.getSample(n)[1] ) for n in range(0, trndata_temp.getLength()): trndata.addSample( trndata_temp.getSample(n)[0], trndata_temp.getSample(n)[1]) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() return alldata, trndata, tstdata
def conductGeneration(generation, corpus): ''' Conducts a generation of learning and testing on the input data generation (int) --- the number of the generation corpus (object) --- corpus object containing info needed ''' # Set up the dataset skeleton alldata = ClassificationDataSet(2, 1, nb_classes=3, class_labels=['a', 'b', 'c']) # means = [(-1,0),(2,4),(3,1)] # cov = [diag([1,1]), diag([0.5,1.2]), diag([1.5,0.7])] # alldata = ClassificationDataSet(2, 1, nb_classes=3) # for n in xrange(400): # for klass in range(3): # input = multivariate_normal(means[klass],cov[klass]) # print type(input) # alldata.addSample(input, [klass]) alldata.addSample((0, 1), (1)) alldata.addSample((1, 0), (0)) alldata.addSample((0, 0), (2)) alldata.addSample((1, 1), (0)) trndata, partdata = alldata.splitWithProportion(0.5) return alldata
def build_sample_nn(): means = [(-1,0),(2,4),(3,1)] cov = [diag([1,1]), diag([0.5,1.2]), diag([1.5,0.7])] alldata = ClassificationDataSet(2, 1, nb_classes=3) for n in xrange(400): for klass in range(3): input = multivariate_normal(means[klass],cov[klass]) alldata.addSample(input, [klass]) tstdata_temp, trndata_temp = alldata.splitWithProportion(0.25) tstdata = ClassificationDataSet(2, 1, nb_classes=3) for n in xrange(0, tstdata_temp.getLength()): tstdata.addSample( tstdata_temp.getSample(n)[0], tstdata_temp.getSample(n)[1] ) trndata = ClassificationDataSet(2, 1, nb_classes=3) for n in xrange(0, trndata_temp.getLength()): trndata.addSample( trndata_temp.getSample(n)[0], trndata_temp.getSample(n)[1] ) trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) fnn = buildNetwork( trndata.indim, 5, trndata.outdim, outclass=SoftmaxLayer ) trainer = BackpropTrainer( fnn, dataset=trndata, momentum=0.1, verbose=True, weightdecay=0.01) return trainer, fnn, tstdata
class NeuralNetLearner: def __init__(self): self.bunch = load_digits() self.X = np.asarray(self.bunch.data, 'float32') self.Y = np.asarray(self.bunch.target, 'float32') #self.X, self.Y = nudge_dataset(self.X, self.bunch.target) self.X = (self.X - np.min(self.X, 0)) / (np.max(self.X, 0) + 0.0001) # 0-1 scaling self.ds = ClassificationDataSet(64, nb_classes=10, class_labels=self.bunch.target_names) for (x, y) in zip(self.X, self.Y): self.ds.addSample(x, y) self.test_data, self.train_data = self.ds.splitWithProportion(0.3) self.network = buildNetwork(64, 10, 1) def get_datasets(self): return self.train_data, self.test_data def activate(self, x): self.network.activate(x.tolist()) def fitness_func(self, x): if not (x.size == 64): print("Bad input vector: ", x) return sum_of_squared_error = 0 for (input, target) in self.ds: sum_of_squared_error += (target - self.activate(input.tolist())) return (sum_of_squared_error / self.ds.length) def get_weights(self): return
def createnetwork(n_hoglist,n_classlist,n_classnum,n_hiddensize=100): n_inputdim=len(n_hoglist[0]) n_alldata = ClassificationDataSet(n_inputdim,1, nb_classes=n_classnum) for i in range(len(n_hoglist)): n_input = n_hoglist[i] n_class = n_classlist[i] n_alldata.addSample(n_input, [n_class]) n_tstdata, n_trndata = n_alldata.splitWithProportion( 0.25 ) n_trndata._convertToOneOfMany( ) n_tstdata._convertToOneOfMany( ) print "Number of training patterns: ", len(n_trndata) print "Input and output dimensions: ", n_trndata.indim, n_trndata.outdim print "First sample (input, target, class):" print n_trndata['input'][0], n_trndata['target'][0], n_trndata['class'][0] n_fnn = buildNetwork(n_trndata.indim,n_hiddensize, n_trndata.outdim, outclass=SoftmaxLayer) n_trainer = BackpropTrainer(n_fnn, dataset=n_trndata, momentum=0.1, verbose=True, weightdecay=0.01) n_result = 1 while n_result > 0.1: print n_result n_trainer.trainEpochs(1) n_trnresult = percentError(n_trainer.testOnClassData(), n_trndata['class']) n_tstresult = percentError(n_trainer.testOnClassData( dataset=n_tstdata), n_tstdata['class']) print "epoch: %4d" % n_trainer.totalepochs, \ " train error: %5.2f%%" % n_trnresult, \ " test error: %5.2f%%" % n_tstresult n_result = n_tstresult
def trainModel(self): self.finalDataSet = np.c_[self.flattenNumericalData, self.flattenCategoryData, self.flattenTargetDataConverted] self.finalHeaderSet = self.flattenNumericalHeader + self.flattenCategoryHeader + self.flattenTargetHeader self.nattributes = self.flattenNumericalData.shape[1] + self.flattenCategoryData.shape[1] ds = ClassificationDataSet(self.nattributes, 1, nb_classes=self.nbClasses) for rowData in self.finalDataSet: target = rowData[-1] variables = rowData[0:-1] ds.addSample(variables, target) self.testDataSet, self.trainDataSet = ds.splitWithProportion(0.25) self.testDataSet._convertToOneOfMany() self.trainDataSet._convertToOneOfMany() print self.testDataSet print self.trainDataSet self.net = buildNetwork(self.nattributes, self.nhiddenNerons, self.noutput, hiddenclass=TanhLayer, outclass=SigmoidLayer, bias=True) self.trainer = BackpropTrainer(self.net, self.trainDataSet, learningrate=0.001, momentum=0.99) begin0 = time.time() # self.trainer.trainUntilConvergence(verbose=True, dataset=ds, validationProportion=0.25, maxEpochs=10) for i in xrange(10): begin = time.time() self.trainer.trainEpochs(10) end = time.time() print 'iteration ', i, ' takes ', end-begin, 'seconds' end0 = time.time() print 'total time consumed: ', end0 - begin0
class NNetwork: def __init__(self): self.ds = ClassificationDataSet(7, 1, nb_classes=8) #8 since we have 8 gestures, 7 since we have 7 features def add_data(self, training_data): for gesture in training_data: self.ds.addSample(gesture[1], gesture[0]) #a method to add all the training data we have def newData(self, training_data): #a method for replacing the data already existing and adding data from scratch self.ds = ClassificationDataSet(7, 1, nb_classes=8) for gesture in training_data: self.ds.addSample(gesture[1], gesture[0]) def train(self, shouldPrint): tstdata, trndata = self.ds.splitWithProportion(0.2) #splits the data into training and verification data trndata._convertToOneOfMany() tstdata._convertToOneOfMany() self.fnn = buildNetwork(trndata.indim, 64, trndata.outdim, outclass=SoftmaxLayer) #builds a network with 64 hidden neurons self.trainer = BackpropTrainer(self.fnn, dataset=trndata, momentum=0.1, learningrate=0.01, verbose=True, weightdecay=0.1) #uses the backpropagation algorithm self.trainer.trainUntilConvergence(dataset=trndata, maxEpochs=100, verbose=True, continueEpochs=10, validationProportion=0.20) #early stopping with 20% as testing data trnresult = percentError( self.trainer.testOnClassData(), trndata['class'] ) tstresult = percentError( self.trainer.testOnClassData(dataset=tstdata ), tstdata['class'] ) if shouldPrint: print "epoch: %4d" % self.trainer.totalepochs, " train error: %5.2f%%" % trnresult, " test error: %5.2f%%" % tstresult def activate(self, data): #tests a particular data point (feature vector) return self.fnn.activate(data)
def train(self, inputData, verbose=True): # Set of data to classify: # - IMG_SIZE input dimensions per data point # - 1 dimensional output # - 4 clusters of classification all_faces = ClassificationDataSet(IMG_SIZE, 1, nb_classes=4) for entry in inputData: (emotion, data) = entry all_faces.addSample(data, [emotion]) # Generate a test and a train set from our data test_faces, train_faces = all_faces.splitWithProportion(0.25) # Hack to convert a 1-dimensional output into 4 output neurons test_faces._convertToOneOfMany() train_faces._convertToOneOfMany() # Set up the actual network. These are the tunable params self.fnn = buildNetwork( train_faces.indim, 20, train_faces.outdim, outclass=SoftmaxLayer ) # Set up the network trainer. Also nice tunable params trainer = BackpropTrainer( self.fnn, dataset=train_faces, momentum=0.1, verbose=False, weightdecay=0.01 ) tabledata = [] # Train this bitch. if verbose: # Report after every epoch if verbose for i in range(EPOCHS): trainer.trainEpochs(1) trnresult = percentError( trainer.testOnClassData(), train_faces['class'] ) tstresult = percentError( trainer.testOnClassData( dataset=test_faces ), test_faces['class'] ) tabledata.append((trainer.totalepochs,trnresult,tstresult)) else: trainer.trainEpochs(EPOCHS) if verbose: print "Epoch\tTrain Error\tTest Error" for line in tabledata: print "%4d\t" % line[0], \ "%5.2f%%\t\t" % line[1], \ "%5.2f%%" % line[2]
def nn(): DS = ClassificationDataSet(28, 1, nb_classes=4) train = pickle.load(open('train_extracted_df.pkl', 'r')) y = train["median_relevance"] kfold_train_test = pickle.load(open('kfold_train_test.pkl', 'r')) features = ['query_tokens_in_title', 'query_tokens_in_description', 'percent_query_tokens_in_description', 'percent_query_tokens_in_title', 'query_length', 'description_length', 'title_length', 'two_grams_in_q_and_t', 'two_grams_in_q_and_d', 'q_mean_of_training_relevance', 'q_median_of_training_relevance', 'avg_relevance_variance', 'average_title_1gram_similarity_1', 'average_title_2gram_similarity_1', 'average_title_1gram_similarity_2', 'average_title_2gram_similarity_2', 'average_title_1gram_similarity_3', 'average_title_2gram_similarity_3', 'average_title_1gram_similarity_4', 'average_title_2gram_similarity_4', 'average_description_1gram_similarity_1', 'average_description_2gram_similarity_1', 'average_description_2gram_similarity_2', 'average_description_1gram_similarity_2', 'average_description_1gram_similarity_3', 'average_description_2gram_similarity_3', 'average_description_1gram_similarity_4', 'average_description_2gram_similarity_4'] train = train[features] for i in range(len(y)): DS.addSample(train.values[i],y[i]) X = DS['input'] Y = DS['target'] dataTrain, dataTest = DS.splitWithProportion(0.8) xTrain, yTrain = dataTrain['input'], dataTrain['target'] xTest, yTest = dataTest['input'], dataTest['target'] #fnn = RecurrentNetwork() fnn = FeedForwardNetwork() #fnn=buildNetwork(1,40,1,hiddenclass=TanhLayer, bias=True, outclass=SoftmaxLayer) #fnn=buildNetwork(1,40,1,hiddenclass=LSTMLayer, bias=True, outclass=SoftmaxLayer) inLayer = LinearLayer(28, name='inLayer') hiddenLayer = SigmoidLayer(40, name='hiddenLayer0') outLayer =LinearLayer(4, name='outLayer') fnn.addInputModule(inLayer) fnn.addModule(hiddenLayer) fnn.addOutputModule(outLayer) in_to_hidden = FullConnection(inLayer, hiddenLayer) hidden_to_out = FullConnection(hiddenLayer, outLayer) fnn.addConnection(in_to_hidden) fnn.addConnection(hidden_to_out) fnn.sortModules() trainer = BackpropTrainer(fnn, DS, verbose = True, learningrate=0.01) #trainer.trainUntilConvergence(maxEpochs=1000) trainer.trainEpochs(epochs=5) prediction = fnn.activateOnDataset(dataTest) out=[] total_score = 0 for i in prediction: class_index = max(xrange(len(i)), key=i.__getitem__) out.append(class_index+1) print str((class_index+1-yTest[class_index+1])/yTest[class_index+1]) df=pd.DataFrame(out,columns=['predict']) df['real']=dataTest['target'] coun = 0 for i,row in df.iterrows(): if row[0]== row[1]: coun+=1 print coun print "df['real']", df['real'],type(df['real'][0]) print "df['predict']",df['predict'],type(df['predict'][0]) print df v=Validator() #v.MSE(out,dataTest['target']) print "out",out print "dataTest['target']",dataTest['target']
def prepare_datasets(inp, out, dataframe, ratio): '''conversion from pandas dataframe to ClassificationDataSet of numpy Parameters: inp: list of names of input features out: list of names of output features(target value) dataframe: dataframe of the stock data ratio: ratio of dimension of test to train dataset Returns: alldata: dataset for supervised classification trndata: training dataset tstdata: testing dataset ''' inp_dim = len(inp) out_dim = len(out) no_classes = 2 alldata = ClassificationDataSet(inp_dim, out_dim, no_classes) inp = dataframe[inp] out = dataframe[out] # for [a,b,c],d in zip(inp.values,out.values): for i in range(len(inp.values)): d = out.values[i] if d == 'up': d = 0 else: # d == 'down': d = 1 # else: # d = 2 alldata.addSample(inp.values[i], d) alldata._convertToOneOfMany(bounds=[0, 1]) tstdata, trndata = alldata.splitWithProportion(ratio) tstdata_temp, trndata_temp = alldata.splitWithProportion(ratio) # to convert supervised datasets to classification datasets # tstdata = trndata = ClassificationDataSet(inp_dim, out_dim, no_classes) # for n in range(0, tstdata_temp.getLength()): # tstdata.addSample( # tstdata_temp.getSample(n)[0], # tstdata_temp.getSample(n)[1]) # for n in range(0, trndata_temp.getLength()): # trndata.addSample( # trndata_temp.getSample(n)[0], # trndata_temp.getSample(n)[1]) # trndata._convertToOneOfMany() # tstdata._convertToOneOfMany() return alldata, trndata, tstdata
def main(): # Get Data dataSets = genfromtxt('normalizedData.csv', delimiter=',') alldata = ClassificationDataSet(13, 1, nb_classes=3) for dataSet in dataSets: alldata.addSample(dataSet[1:14], int(dataSet[0]) - 1) # Split the data tstdata_temp, trndata_temp = alldata.splitWithProportion(0.25) tstdata = ClassificationDataSet(13, 1, nb_classes=3) for n in range(0, tstdata_temp.getLength()): tstdata.addSample( tstdata_temp.getSample(n)[0], tstdata_temp.getSample(n)[1]) trndata = ClassificationDataSet(13, 1, nb_classes=3) for n in range(0, trndata_temp.getLength()): trndata.addSample( trndata_temp.getSample(n)[0], trndata_temp.getSample(n)[1]) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() # Build Network fnn = buildNetwork(trndata.indim, 4, 4, 4, trndata.outdim) # Construct Trainer trainer = BackpropTrainer(fnn, trndata, learningrate=0.1) # Train while True: trainer.trainEpochs(1) trnresult = percentError(trainer.testOnClassData(), trndata['class']) print("Training Test Error: %5.2f%%" % trnresult) if trnresult < 1: break tstresult = percentError(trainer.testOnClassData(dataset=tstdata), tstdata['class']) print("test error: %5.2f%%" % tstresult) out1 = fnn.activate([ 0.70789474, 0.13636364, 0.60962567, 0.31443299, 0.41304348, 0.83448276, 0.70253165, 0.11320755, 0.51419558, 0.47098976, 0.33333333, 0.58608059, 0.71825963 ]) out2 = fnn.activate([ 0.26578947, 0.70355731, 0.54545455, 0.58762887, 0.10869565, 0.3862069, 0.29746835, 0.54716981, 0.29652997, 0.11262799, 0.25203252, 0.47619048, 0.21540656 ]) out3 = fnn.activate([ 0.81578947, 0.66403162, 0.73796791, 0.71649485, 0.2826087, 0.36896552, 0.08860759, 0.81132075, 0.29652997, 0.67576792, 0.10569106, 0.12087912, 0.20114123 ]) print(out1, out2, out3)
def main(): means = [(-1,0),(2,4),(3,1)] cov = [diag([1,1]), diag([0.5,1.2]), diag([1.5,0.7])] alldata = ClassificationDataSet(2, 1, nb_classes=3) for n in xrange(400): for klass in range(3): input = multivariate_normal(means[klass],cov[klass]) alldata.addSample(input, [klass]) tstdata, trndata = alldata.splitWithProportion( 0.25 ) trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) print "Number of training patterns: ", len(trndata) print "Input and output dimensions: ", trndata.indim, trndata.outdim print "First sample (input, target, class):" print trndata['input'][0], trndata['target'][0], trndata['class'][0] fnn = buildNetwork( trndata.indim, 5, trndata.outdim, outclass=SoftmaxLayer ) trainer = BackpropTrainer( fnn, dataset=trndata, momentum=0.1, verbose=True, weightdecay=0.01) ticks = arange(-3.,6.,0.2) X, Y = meshgrid(ticks, ticks) # need column vectors in dataset, not arrays griddata = ClassificationDataSet(2,1, nb_classes=3) for i in xrange(X.size): griddata.addSample([X.ravel()[i],Y.ravel()[i]], [0]) griddata._convertToOneOfMany() # this is still needed to make the fnn feel comfy for i in range(20): trainer.trainEpochs(1) trnresult = percentError( trainer.testOnClassData(), trndata['class'] ) tstresult = percentError( trainer.testOnClassData( dataset=tstdata ), tstdata['class'] ) print "epoch: %4d" % trainer.totalepochs, \ " train error: %5.2f%%" % trnresult, \ " test error: %5.2f%%" % tstresult out = fnn.activateOnDataset(griddata) out = out.argmax(axis=1) # the highest output activation gives the class out = out.reshape(X.shape) figure(1) ioff() # interactive graphics off clf() # clear the plot hold(True) # overplot on for c in [0,1,2]: here, _ = where(tstdata['class']==c) plot(tstdata['input'][here,0],tstdata['input'][here,1],'o') if out.max()!=out.min(): # safety check against flat field contourf(X, Y, out) # plot the contour ion() # interactive graphics on draw() # update the plot ioff() show()
def makeIrisDatasets(): # taken from iris data set at machine learning repository alldata = ClassificationDataSet(4, 1, nb_classes=3, \ class_labels=['set','vers','virg']) for p in pat: t = p[2] alldata.addSample(p[0], t) tstdata, trndata = alldata.splitWithProportion(0.33) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() return trndata, tstdata
def createDS(): pat = [[[5.1, 3.5, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.9, 3.0, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.7, 3.2, 1.3, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.6, 3.1, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.6, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.9, 1.7, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[4.6, 3.4, 1.4, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.4, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.4, 2.9, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.9, 3.1, 1.5, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.7, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.4, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.0, 1.4, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[4.3, 3.0, 1.1, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[5.8, 4.0, 1.2, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.7, 4.4, 1.5, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.9, 1.3, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.5, 1.4, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.7, 3.8, 1.7, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.8, 1.5, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.4, 1.7, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.7, 1.5, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[4.6, 3.6, 1.0, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.3, 1.7, 0.5], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.4, 1.9, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.0, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.4, 1.6, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[5.2, 3.5, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.2, 3.4, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.7, 3.2, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.1, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.4, 1.5, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[5.2, 4.1, 1.5, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[5.5, 4.2, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.9, 3.1, 1.5, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.2, 1.2, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.5, 3.5, 1.3, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.9, 3.1, 1.5, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[4.4, 3.0, 1.3, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.4, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.5, 1.3, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[4.5, 2.3, 1.3, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[4.4, 3.2, 1.3, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.5, 1.6, 0.6], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.8, 1.9, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.0, 1.4, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.8, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.6, 3.2, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.3, 3.7, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.3, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[7.0, 3.2, 4.7, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[6.4, 3.2, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.9, 3.1, 4.9, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.3, 4.0, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.5, 2.8, 4.6, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 2.8, 4.5, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.3, 3.3, 4.7, 1.6], [0, 1, 0], [1], ['Iris-versicolor']], [[4.9, 2.4, 3.3, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[6.6, 2.9, 4.6, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.2, 2.7, 3.9, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[5.0, 2.0, 3.5, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[5.9, 3.0, 4.2, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.0, 2.2, 4.0, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[6.1, 2.9, 4.7, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 2.9, 3.6, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.7, 3.1, 4.4, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 3.0, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.8, 2.7, 4.1, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[6.2, 2.2, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 2.5, 3.9, 1.1], [0, 1, 0], [1], ['Iris-versicolor']], [[5.9, 3.2, 4.8, 1.8], [0, 1, 0], [1], ['Iris-versicolor']], [[6.1, 2.8, 4.0, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.3, 2.5, 4.9, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.1, 2.8, 4.7, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[6.4, 2.9, 4.3, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.6, 3.0, 4.4, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[6.8, 2.8, 4.8, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[6.7, 3.0, 5.0, 1.7], [0, 1, 0], [1], ['Iris-versicolor']], [[6.0, 2.9, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 2.6, 3.5, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.4, 3.8, 1.1], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.4, 3.7, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[5.8, 2.7, 3.9, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[6.0, 2.7, 5.1, 1.6], [0, 1, 0], [1], ['Iris-versicolor']], [[5.4, 3.0, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.0, 3.4, 4.5, 1.6], [0, 1, 0], [1], ['Iris-versicolor']], [[6.7, 3.1, 4.7, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.3, 2.3, 4.4, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 3.0, 4.1, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.5, 4.0, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.6, 4.4, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[6.1, 3.0, 4.6, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[5.8, 2.6, 4.0, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[5.0, 2.3, 3.3, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 2.7, 4.2, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 3.0, 4.2, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 2.9, 4.2, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.2, 2.9, 4.3, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.1, 2.5, 3.0, 1.1], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 2.8, 4.1, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.3, 3.3, 6.0, 2.5], [0, 0, 1], [2], ['Iris-virginica']], [[5.8, 2.7, 5.1, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[7.1, 3.0, 5.9, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 2.9, 5.6, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.5, 3.0, 5.8, 2.2], [0, 0, 1], [2], ['Iris-virginica']], [[7.6, 3.0, 6.6, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[4.9, 2.5, 4.5, 1.7], [0, 0, 1], [2], ['Iris-virginica']], [[7.3, 2.9, 6.3, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 2.5, 5.8, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[7.2, 3.6, 6.1, 2.5], [0, 0, 1], [2], ['Iris-virginica']], [[6.5, 3.2, 5.1, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 2.7, 5.3, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[6.8, 3.0, 5.5, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[5.7, 2.5, 5.0, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[5.8, 2.8, 5.1, 2.4], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 3.2, 5.3, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.5, 3.0, 5.5, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[7.7, 3.8, 6.7, 2.2], [0, 0, 1], [2], ['Iris-virginica']], [[7.7, 2.6, 6.9, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.0, 2.2, 5.0, 1.5], [0, 0, 1], [2], ['Iris-virginica']], [[6.9, 3.2, 5.7, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[5.6, 2.8, 4.9, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[7.7, 2.8, 6.7, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 2.7, 4.9, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 3.3, 5.7, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[7.2, 3.2, 6.0, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.2, 2.8, 4.8, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.1, 3.0, 4.9, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 2.8, 5.6, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[7.2, 3.0, 5.8, 1.6], [0, 0, 1], [2], ['Iris-virginica']], [[7.4, 2.8, 6.1, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[7.9, 3.8, 6.4, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 2.8, 5.6, 2.2], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 2.8, 5.1, 1.5], [0, 0, 1], [2], ['Iris-virginica']], [[6.1, 2.6, 5.6, 1.4], [0, 0, 1], [2], ['Iris-virginica']], [[7.7, 3.0, 6.1, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 3.4, 5.6, 2.4], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 3.1, 5.5, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.0, 3.0, 4.8, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.9, 3.1, 5.4, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 3.1, 5.6, 2.4], [0, 0, 1], [2], ['Iris-virginica']], [[6.9, 3.1, 5.1, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[5.8, 2.7, 5.1, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[6.8, 3.2, 5.9, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 3.3, 5.7, 2.5], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 3.0, 5.2, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 2.5, 5.0, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[6.5, 3.0, 5.2, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[6.2, 3.4, 5.4, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[5.9, 3.0, 5.1, 1.8], [0, 0, 1], [2], ['Iris-virginica']]] alldata = ClassificationDataSet(4, 1, nb_classes=3, \ class_labels=['set','vers','virg']) for p in pat: t = p[2] alldata.addSample(p[0],t) tstdata, trndata = alldata.splitWithProportion( 0.33 ) trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) return trndata, tstdata
def EvaluateArtificialNeuralNetwork(training_data, Input_features, Output_feature, NUMBER_CLASSES, HIDDEN_NEURONS, NUMBER_LAYERS, dataset_name, ParameterVal): X = training_data[Input_features] Y = training_data[Output_feature] ds = ClassificationDataSet(X.shape[1], nb_classes=NUMBER_CLASSES) for k in xrange(len(X)): ds.addSample((X.ix[k,:]), Y.ix[k,:]) tstdata_temp, trndata_temp = ds.splitWithProportion(.25) tstdata = ClassificationDataSet(X.shape[1], nb_classes=NUMBER_CLASSES) for n in xrange(0, tstdata_temp.getLength()): tstdata.addSample( tstdata_temp.getSample(n)[0], tstdata_temp.getSample(n)[1] ) trndata = ClassificationDataSet(X.shape[1], nb_classes=NUMBER_CLASSES) for n in xrange(0, trndata_temp.getLength()): trndata.addSample( trndata_temp.getSample(n)[0], trndata_temp.getSample(n)[1] ) if NUMBER_CLASSES > 1: trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) '''*****Actual computation with one layer and HIDDEN_NEURONS number of neurons********''' fnn = buildNetwork( trndata.indim, HIDDEN_NEURONS , trndata.outdim, outclass=SoftmaxLayer ) trainer = BackpropTrainer( fnn, dataset=trndata, momentum=0.1, verbose=False, weightdecay=0.01) trainer.trainUntilConvergence(maxEpochs=3) trnresult = percentError( trainer.testOnClassData(), trndata['class'] ) tstresult = percentError( trainer.testOnClassData(dataset=tstdata ), tstdata['class'] ) print ("Accuracy with Artificial Neural Network: epoch: " + str(trainer.totalepochs) + " TrainingSet:" + str(1-trnresult/100) + " TestSet:" + str(1-tstresult/100)) '''****** Graphical Representation*****''' '''tot_hidden_tests, X_train, X_test, Y_train, Y_test, training_error, test_error = InitiateErrorCalcData(ParameterVal, training_data[Input_features], training_data[Output_feature]) for hidden_unit in tot_hidden_tests: print ("Computing hidden unit :" + str(hidden_unit)) model = buildNetwork( trndata.indim, hidden_unit , trndata.outdim, outclass=SoftmaxLayer ) temp_trainer = BackpropTrainer( model, dataset=trndata, momentum=0.1, verbose=True, weightdecay=0.01) temp_trainer.trainUntilConvergence(maxEpochs=3) training_error.append(MSE( temp_trainer.testOnClassData(), trndata['class'] )) test_error.append(MSE( temp_trainer.testOnClassData(dataset=tstdata ), tstdata['class'] )) PlotErrors(tot_hidden_tests, training_error, test_error, dataset_name, "Number of Hidden Units for single layer ANN", "MSE")''' '''*****Graphical representation with multiple layers and HIDDEN_NEURONS number of neurons********''' '''ffn = FeedForwardNetwork()
def makeIrisDatasets(): # taken from iris data set at machine learning repository alldata = ClassificationDataSet(4, 1, nb_classes=3, \ class_labels=['set','vers','virg']) for p in pat: t = p[2] alldata.addSample(p[0],t) tstdata, trndata = alldata.splitWithProportion( 0.33 ) trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) return trndata, tstdata
def createDS(): # taken from iris data set at machine learning repository pat = [[[5.1, 3.5, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.9, 3.0, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.7, 3.2, 1.3, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.6, 3.1, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.6, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.9, 1.7, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[4.6, 3.4, 1.4, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.4, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.4, 2.9, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.9, 3.1, 1.5, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.7, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.4, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.0, 1.4, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[4.3, 3.0, 1.1, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[5.8, 4.0, 1.2, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.7, 4.4, 1.5, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.9, 1.3, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.5, 1.4, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.7, 3.8, 1.7, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.8, 1.5, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.4, 1.7, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.7, 1.5, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[4.6, 3.6, 1.0, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.3, 1.7, 0.5], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.4, 1.9, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.0, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.4, 1.6, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[5.2, 3.5, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.2, 3.4, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.7, 3.2, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.1, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.4, 3.4, 1.5, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[5.2, 4.1, 1.5, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[5.5, 4.2, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.9, 3.1, 1.5, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.2, 1.2, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.5, 3.5, 1.3, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.9, 3.1, 1.5, 0.1], [1, 0, 0], [0], ['Iris-setosa']], [[4.4, 3.0, 1.3, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.4, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.5, 1.3, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[4.5, 2.3, 1.3, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[4.4, 3.2, 1.3, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.5, 1.6, 0.6], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.8, 1.9, 0.4], [1, 0, 0], [0], ['Iris-setosa']], [[4.8, 3.0, 1.4, 0.3], [1, 0, 0], [0], ['Iris-setosa']], [[5.1, 3.8, 1.6, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[4.6, 3.2, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.3, 3.7, 1.5, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[5.0, 3.3, 1.4, 0.2], [1, 0, 0], [0], ['Iris-setosa']], [[7.0, 3.2, 4.7, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[6.4, 3.2, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.9, 3.1, 4.9, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.3, 4.0, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.5, 2.8, 4.6, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 2.8, 4.5, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.3, 3.3, 4.7, 1.6], [0, 1, 0], [1], ['Iris-versicolor']], [[4.9, 2.4, 3.3, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[6.6, 2.9, 4.6, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.2, 2.7, 3.9, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[5.0, 2.0, 3.5, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[5.9, 3.0, 4.2, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.0, 2.2, 4.0, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[6.1, 2.9, 4.7, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 2.9, 3.6, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.7, 3.1, 4.4, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 3.0, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.8, 2.7, 4.1, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[6.2, 2.2, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 2.5, 3.9, 1.1], [0, 1, 0], [1], ['Iris-versicolor']], [[5.9, 3.2, 4.8, 1.8], [0, 1, 0], [1], ['Iris-versicolor']], [[6.1, 2.8, 4.0, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.3, 2.5, 4.9, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.1, 2.8, 4.7, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[6.4, 2.9, 4.3, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.6, 3.0, 4.4, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[6.8, 2.8, 4.8, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[6.7, 3.0, 5.0, 1.7], [0, 1, 0], [1], ['Iris-versicolor']], [[6.0, 2.9, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 2.6, 3.5, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.4, 3.8, 1.1], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.4, 3.7, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[5.8, 2.7, 3.9, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[6.0, 2.7, 5.1, 1.6], [0, 1, 0], [1], ['Iris-versicolor']], [[5.4, 3.0, 4.5, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.0, 3.4, 4.5, 1.6], [0, 1, 0], [1], ['Iris-versicolor']], [[6.7, 3.1, 4.7, 1.5], [0, 1, 0], [1], ['Iris-versicolor']], [[6.3, 2.3, 4.4, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 3.0, 4.1, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.5, 4.0, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.5, 2.6, 4.4, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[6.1, 3.0, 4.6, 1.4], [0, 1, 0], [1], ['Iris-versicolor']], [[5.8, 2.6, 4.0, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[5.0, 2.3, 3.3, 1.0], [0, 1, 0], [1], ['Iris-versicolor']], [[5.6, 2.7, 4.2, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 3.0, 4.2, 1.2], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 2.9, 4.2, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.2, 2.9, 4.3, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[5.1, 2.5, 3.0, 1.1], [0, 1, 0], [1], ['Iris-versicolor']], [[5.7, 2.8, 4.1, 1.3], [0, 1, 0], [1], ['Iris-versicolor']], [[6.3, 3.3, 6.0, 2.5], [0, 0, 1], [2], ['Iris-virginica']], [[5.8, 2.7, 5.1, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[7.1, 3.0, 5.9, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 2.9, 5.6, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.5, 3.0, 5.8, 2.2], [0, 0, 1], [2], ['Iris-virginica']], [[7.6, 3.0, 6.6, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[4.9, 2.5, 4.5, 1.7], [0, 0, 1], [2], ['Iris-virginica']], [[7.3, 2.9, 6.3, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 2.5, 5.8, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[7.2, 3.6, 6.1, 2.5], [0, 0, 1], [2], ['Iris-virginica']], [[6.5, 3.2, 5.1, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 2.7, 5.3, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[6.8, 3.0, 5.5, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[5.7, 2.5, 5.0, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[5.8, 2.8, 5.1, 2.4], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 3.2, 5.3, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.5, 3.0, 5.5, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[7.7, 3.8, 6.7, 2.2], [0, 0, 1], [2], ['Iris-virginica']], [[7.7, 2.6, 6.9, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.0, 2.2, 5.0, 1.5], [0, 0, 1], [2], ['Iris-virginica']], [[6.9, 3.2, 5.7, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[5.6, 2.8, 4.9, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[7.7, 2.8, 6.7, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 2.7, 4.9, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 3.3, 5.7, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[7.2, 3.2, 6.0, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.2, 2.8, 4.8, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.1, 3.0, 4.9, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 2.8, 5.6, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[7.2, 3.0, 5.8, 1.6], [0, 0, 1], [2], ['Iris-virginica']], [[7.4, 2.8, 6.1, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[7.9, 3.8, 6.4, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 2.8, 5.6, 2.2], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 2.8, 5.1, 1.5], [0, 0, 1], [2], ['Iris-virginica']], [[6.1, 2.6, 5.6, 1.4], [0, 0, 1], [2], ['Iris-virginica']], [[7.7, 3.0, 6.1, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 3.4, 5.6, 2.4], [0, 0, 1], [2], ['Iris-virginica']], [[6.4, 3.1, 5.5, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.0, 3.0, 4.8, 1.8], [0, 0, 1], [2], ['Iris-virginica']], [[6.9, 3.1, 5.4, 2.1], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 3.1, 5.6, 2.4], [0, 0, 1], [2], ['Iris-virginica']], [[6.9, 3.1, 5.1, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[5.8, 2.7, 5.1, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[6.8, 3.2, 5.9, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 3.3, 5.7, 2.5], [0, 0, 1], [2], ['Iris-virginica']], [[6.7, 3.0, 5.2, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[6.3, 2.5, 5.0, 1.9], [0, 0, 1], [2], ['Iris-virginica']], [[6.5, 3.0, 5.2, 2.0], [0, 0, 1], [2], ['Iris-virginica']], [[6.2, 3.4, 5.4, 2.3], [0, 0, 1], [2], ['Iris-virginica']], [[5.9, 3.0, 5.1, 1.8], [0, 0, 1], [2], ['Iris-virginica']]] alldata = ClassificationDataSet(4, 1, nb_classes=3, \ class_labels=['set','vers','virg']) for p in pat: t = p[2] alldata.addSample(p[0],t) tstdata, trndata = alldata.splitWithProportion( 0.33 ) trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) return trndata, tstdata
def run_neural_network(xn, xt, yl, epochs, hidden_neurons): f = open('total_list_probe_mac_all.txt', 'rb') role_list = pickle.load(f) teacher_list = [a for a in role_list if a[0] == 1] student_list = [a for a in role_list if a[0] == 0] print 'len st: ', len(student_list), 'len te: ', len(teacher_list) student_list = random.sample(student_list, len(teacher_list)) total_list = student_list + teacher_list shuffle(total_list) alldata = ClassificationDataSet(72, 1, nb_classes=2) for (o, i) in total_list: alldata.addSample(i, o) tstdata, trndata = alldata.splitWithProportion(0.25) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() print "Number of training patterns: ", len(trndata) print "Input and output dimensions: ", trndata.indim, trndata.outdim print "First sample (input, target, class):" print trndata['input'][0], trndata['target'][0], trndata['class'][0] fnn = buildNetwork(trndata.indim, hidden_neurons, trndata.outdim, outclass=SoftmaxLayer) trainer = BackpropTrainer(fnn, trndata, momentum=0.1, verbose=True, weightdecay=0.01) for i in range(epochs): trnresult = percentError(trainer.testOnClassData(), trndata['class']) tstresult = percentError(trainer.testOnClassData(dataset=tstdata), tstdata['class']) trainer.trainEpochs(1) xn.append(trnresult) xt.append(tstresult) yl.append(i) print "epoch: %4d" % trainer.totalepochs, \ " train error: %5.2f%%" % trnresult, \ " test error: %5.2f%%" % tstresult
def neuralNetworksTrain(self): alldata = ClassificationDataSet( 23, 1, nb_classes=2) train_input_data = self.loadData(self.train_file) test_input_data = self.loadData(self.test_file) target = [x[1] for x in train_input_data] target = target[1:] features = [x[2:] for x in train_input_data] features = features[1:] for i in range(0,len(features)): alldata.addSample(features[i], target[i]) tstdata, trndata = alldata.splitWithProportion(0.25) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() INPUT_FEATURES = 23 CLASSES = 2 HIDDEN_NEURONS = 200 WEIGHTDECAY = 0.1 MOMENTUM = 0.1 EPOCH = 2 fnn = buildNetwork(trndata.indim, HIDDEN_NEURONS, trndata.outdim,outclass=LinearLayer) trainer = BackpropTrainer(fnn, dataset=trndata, momentum=MOMENTUM,verbose=True, weightdecay=WEIGHTDECAY) trainer.trainEpochs(EPOCH) pred = trainer.testOnClassData(dataset=tstdata) actual = tstdata['class'] self.computeAccuracy(actual,pred) #trnresult = percentError(trainer.testOnClassData(), # trndata['class']) #tstresult = percentError(trainer.testOnClassData( # dataset=tstdata), tstdata['class']) # print("epoch: %4d" % trainer.totalepochs, # " train error: %5.2f%%" % trnresult, # " test error: %5.2f%%" % tstresult) #out = fnn.activateOnDataset(griddata) # the highest output activation gives the class #out = out.argmax(axis=1) #out = out.reshape(X.shape) testFeatures = [x[2:] for x in test_input_data] testFeatures = testFeatures[1:] prediction = [fnn.activate(x) for x in testFeatures] i=0 print "Neural Network Architecture:" print "Layers: Input layer, Hidden Layer and Output Layers" print "Epoch = "+str(EPOCH) print "Neurons in the hidden layer:"+str(HIDDEN_NEURONS) print "Precision recall F score support metrics for Neural Networks " print precision_recall_fscore_support(actual,pred) print "confusion matrix" print confusion_matrix(actual,pred)
def create_dataset(): '''Create a random dataset to train and test the network on ''' means = [(-1,0),(2,4),(3,1)] cov = [diag([1,1]), diag([0.5,1.2]), diag([1.5,0.7])] alldata=ClassificationDataSet(2,1,nb_classes=3) for n in xrange(400): for klass in range(3): input=multivariate_normal(means[klass],cov[klass]) alldata.addSample(input,[klass]) tstdata,trndata=alldata.splitWithProportion(0.25) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() return (trndata,tstdata)
def classif(): means = [(-1, 0), (2, 4), (3, 1)] cov = [diag([1, 1]), diag([0.5, 1.2]), diag([1.5, 0.7])] alldata = ClassificationDataSet(2, 1, nb_classes=3) for n in xrange(400): for klass in range(3): input = multivariate_normal(means[klass], cov[klass]) alldata.addSample(input, [klass]) tstdata, trndata = alldata.splitWithProportion(0.25) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() print "Number of training patterns: ", len(trndata) print "Input and output dimensions: ", trndata.indim, trndata.outdim print "First sample (input, target, class):" print trndata['input'][0], trndata['target'][0], trndata['class'][0] fnn = buildNetwork(trndata.indim, 5, trndata.outdim, outclass=SoftmaxLayer) trainer = BackpropTrainer(fnn, dataset=trndata, momentum=0.1, verbose=True, weightdecay=0.01) ticks = arange(-3., 6., 0.2) X, Y = meshgrid(ticks, ticks) # need column vectors in dataset, not arrays griddata = ClassificationDataSet(2, 1, nb_classes=3) for i in xrange(X.size): griddata.addSample([X.ravel()[i], Y.ravel()[i]], [0]) griddata._convertToOneOfMany( ) # this is still needed to make the fnn feel comfy for i in range(20): trainer.trainEpochs(5) trnresult = percentError(trainer.testOnClassData(), trndata['class']) tstresult = percentError(trainer.testOnClassData(dataset=tstdata), tstdata['class']) print "epoch: %4d" % trainer.totalepochs, \ " train error: %5.2f%%" % trnresult, \ " test error: %5.2f%%" % tstresult out = fnn.activateOnDataset(griddata) out = out.argmax( axis=1) # the highest output activation gives the class out = out.reshape(X.shape) print out
def main(): ds = ClassificationDataSet(30, class_labels=POSITIONS) data = data_set() for name, positions in data.iteritems(): for position, state in positions.iteritems(): if position == 'fetalalt': position = 'fetal' ds.addSample(state, [POSITIONS.index(position)]) testing_ds, training_ds = ds.splitWithProportion( 0.25 ) testing_ds._convertToOneOfMany() training_ds._convertToOneOfMany() ds._convertToOneOfMany() hidden = HIDDEN_NEURONS net = buildNetwork(ds.indim, hidden, ds.outdim, hiddenclass=SoftmaxLayer) trainer = BackpropTrainer(net, ds, verbose=True, learningrate=0.01, momentum=0.1) trainer.trainUntilConvergence(maxEpochs=ITERATIONS, validationProportion=0.1) wrong = 0 for name, positions in data.iteritems(): for position, state in positions.iteritems(): if position == 'fetalalt': position = 'fetal' guess = POSITIONS[net.activate(state).argmax()] if guess != position: wrong += 1 print "%10s actual: %10s guess: %10s" % (name, position, guess) print 'wrong: ', wrong, '/', len(data) * 4 out_name = 'network-wrong-%02d-hidden-%d.pickle' % (wrong, hidden) print "will save to '%s'" % out_name print "Do you want to use this? (y/n): ", answer = sys.stdin.readline().strip() while answer not in ('y', 'n'): print "Enter (y/n): ", answer = sys.stdin.readline().strip() if answer == 'y': with open(out_name, 'w') as f: pickle.dump(net, f) subprocess.call(['rm', 'network-good.pickle']) subprocess.call(['ln', '-s', out_name, 'network-good.pickle']) subprocess.call(['touch', os.path.join('..', 'server', 'app.py')])
def init_classifier(self, hidden_units = 20): data = ClassificationDataSet(len(self.channels), nb_classes=5) # Prepare the dataset for i in range(len(self.classification_proc)): data.appendLinked(self.y_proc[i], self.classification_proc[i]) # Make global for test purposes self.data = data # Prepare training and test data, 75% - 25% proportion self.testdata, self.traindata = data.splitWithProportion(0.25) #self.traindata._convertToOneOfMany() #self.testdata._convertToOneOfMany() # CHECK the number of hidden units fnn = buildNetwork(self.traindata.indim, hidden_units, self.traindata.outdim) # CHECK meaning of the parameters trainer = BackpropTrainer(fnn, dataset=self.traindata, momentum=0, verbose=True, weightdecay=0.01) return fnn, trainer, data
def fnn(): data = orange.ExampleTable("D:\\Back-up-THICK_on_Vista\\Orange\\W1BIN.tab")#input_dict['data']) addMetaID(data) n_attrs = len(data.domain.attributes) classes = list(data.domain.classVar.values) pbdata = ClassificationDataSet(n_attrs, class_labels=classes) for ex in data: pbdata.appendLinked([x.value for x in list(ex)[:n_attrs]], [classes.index(ex.getclass().value)]) tstdata, trndata = pbdata.splitWithProportion( 0.25 ) trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) print "Number of training patterns: ", len(trndata) print "Input and output dimensions: ", trndata.indim, trndata.outdim print "First sample (input, target, class):" print trndata['input'][0], trndata['target'][0], trndata['class'][0]
def run_neural_network(xn, xt, yl, epochs, hidden_neurons): f = open('total_list_probe_mac_all.txt', 'rb') role_list = pickle.load(f) teacher_list = [a for a in role_list if a[0] == 1] student_list = [a for a in role_list if a[0] == 0] print 'len st: ', len(student_list), 'len te: ', len(teacher_list) student_list = random.sample(student_list, len(teacher_list)) total_list = student_list + teacher_list shuffle(total_list) alldata = ClassificationDataSet(72, 1, nb_classes=2) for (o, i) in total_list: alldata.addSample(i, o) tstdata, trndata = alldata.splitWithProportion(0.25) trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) print "Number of training patterns: ", len(trndata) print "Input and output dimensions: ", trndata.indim, trndata.outdim print "First sample (input, target, class):" print trndata['input'][0], trndata['target'][0], trndata['class'][0] fnn = buildNetwork(trndata.indim, hidden_neurons, trndata.outdim, outclass=SoftmaxLayer) trainer = BackpropTrainer( fnn, trndata, momentum=0.1, verbose=True, weightdecay=0.01) for i in range(epochs): trnresult = percentError( trainer.testOnClassData(), trndata['class'] ) tstresult = percentError( trainer.testOnClassData( dataset=tstdata ), tstdata['class'] ) trainer.trainEpochs(1) xn.append(trnresult) xt.append(tstresult) yl.append(i) print "epoch: %4d" % trainer.totalepochs, \ " train error: %5.2f%%" % trnresult, \ " test error: %5.2f%%" % tstresult
def main(): images, labels = load_labeled_training(flatten=True) images = standardize(images) #images, labels = load_pca_proj(K=100) shuffle_in_unison(images, labels) ds = ClassificationDataSet(images.shape[1], 1, nb_classes=7) for i, l in zip(images, labels): ds.addSample(i, [l - 1]) #ds._convertToOneOfMany() test, train = ds.splitWithProportion(0.2) test._convertToOneOfMany() train._convertToOneOfMany() net = shortcuts.buildNetwork(train.indim, 1000, train.outdim, outclass=SoftmaxLayer) trainer = BackpropTrainer(net, dataset=train, momentum=0.1, learningrate=0.01, weightdecay=0.05) #trainer = RPropMinusTrainer(net, dataset=train) #cv = validation.CrossValidator(trainer, ds) #print cv.validate() net.randomize() tr_labels_2 = net.activateOnDataset(train).argmax(axis=1) trnres = percentError(tr_labels_2, train['class']) #trnres = percentError(trainer.testOnClassData(dataset=train), train['class']) testres = percentError(trainer.testOnClassData(dataset=test), test['class']) print "Training error: %.10f, Test error: %.10f" % (trnres, testres) print "Iters: %d" % trainer.totalepochs for i in range(100): trainer.trainEpochs(10) trnres = percentError(trainer.testOnClassData(dataset=train), train['class']) testres = percentError(trainer.testOnClassData(dataset=test), test['class']) trnmse = trainer.testOnData(dataset=train) testmse = trainer.testOnData(dataset=test) print "Iteration: %d, Training error: %.5f, Test error: %.5f" % ( trainer.totalepochs, trnres, testres) print "Training MSE: %.5f, Test MSE: %.5f" % (trnmse, testmse)
def split_samples(ratio): samples = {} for sound in SOUNDS: samples[sound] = glob.glob(os.path.join('.', sound, '*')) print len(samples[sound]), " x ", sound ds = ClassificationDataSet(FEATURES, 1, nb_classes=3) #TODO: what's the 2nd parameter? for sound in samples: for f in samples[sound]: # if f.lower() != ".\\kick\\XR10bd01.WAV".lower(): # continue print f features = process_sample(*load_sample(f)) ds.addSample(features, [SOUND_INDICES[sound]]) #why put this in an array? training_set, test_set = ds.splitWithProportion( ratio ) training_set._convertToOneOfMany( ) test_set._convertToOneOfMany( ) return training_set, test_set
def fnn(): data = orange.ExampleTable( "D:\\Back-up-THICK_on_Vista\\Orange\\W1BIN.tab") #input_dict['data']) addMetaID(data) n_attrs = len(data.domain.attributes) classes = list(data.domain.classVar.values) pbdata = ClassificationDataSet(n_attrs, class_labels=classes) for ex in data: pbdata.appendLinked([x.value for x in list(ex)[:n_attrs]], [classes.index(ex.getclass().value)]) tstdata, trndata = pbdata.splitWithProportion(0.25) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() print "Number of training patterns: ", len(trndata) print "Input and output dimensions: ", trndata.indim, trndata.outdim print "First sample (input, target, class):" print trndata['input'][0], trndata['target'][0], trndata['class'][0]
def main(): (X, Y, Ynames) = load_magic_data() X = StandardScaler().fit_transform(X) X, Y = shuffle(X, Y, n_samples=None, random_state=None) N = len(Y) alldata = ClassificationDataSet(inp=10, target=1, nb_classes=2) for i in range(N): alldata.addSample(X[i], Y[i]) tstdata, trndata = alldata.splitWithProportion(0.25) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() print "Number of training patterns: ", len(trndata) print "Input and output dimensions: ", trndata.indim, trndata.outdim print "First sample (input, target, class):" print trndata['input'][0], trndata['target'][0], trndata['class'][0] fnn = buildNetwork(trndata.indim, 15, trndata.outdim, bias=True) trainer = BackpropTrainer(fnn, dataset=trndata, momentum=0, learningrate=0.005, verbose=True) trainer.trainUntilConvergence(maxEpochs=100) trnresult = 100 - percentError(trainer.testOnClassData(), trndata['class']) tstresult = 100 - percentError(trainer.testOnClassData(dataset=tstdata), tstdata['class']) print "Epoch:%4d" % trainer.totalepochs, \ " train accuracy: %5.2f%%" % trnresult, \ " test accuracy: %5.2f%%" % tstresult plt.figure(figsize=(8, 8)) plt.plot(trainer.trainingErrors) plt.xlabel('Training Steps') plt.ylabel('Training Error') plt.show()
def generateDS(input_, out, num, xtrain, ytrain): alldata = ClassificationDataSet(input_, out, nb_classes=num) for x, y in zip(xtrain, ytrain): alldata.addSample(x, y) tstdata_temp, trndata_temp = alldata.splitWithProportion(.3) tstdata = ClassificationDataSet(input_, out, nb_classes=num) for n in xrange(tstdata_temp.getLength()): tstdata.addSample(*[tstdata_temp.getSample(n)[i] for i in range(2)]) trndata = ClassificationDataSet(input_, out, nb_classes=num) for n in xrange(trndata_temp.getLength()): trndata.addSample(*[trndata_temp.getSample(n)[i] for i in range(2)]) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() return trndata, tstdata
def split_dataset(data_path, ratio): dataset = ClassificationDataSet(256, 10) with open("../data/semeion.data") as data: for record in data: line = record[:1812] line = line.replace(' ', ', ') data = line[:2046] dataList = data.split(',') dataList = map(float, dataList) ans = line[2048:-2] ansList = ans.split(',') ansList = map(int, ansList) dataset.appendLinked(dataList, ansList) train_data, test_data = dataset.splitWithProportion(ratio) return train_data, test_data
def initializeDatasets(nCount, klassCount): means = [(-1, 0), (2, 4), (3, 1)] cov = [diag([1.0, 1]), diag([0.5, 1.2]), diag([1.5, 0.7])] alldata = ClassificationDataSet(2, 1, nb_classes=3) for n in xrange(nCount): for klass in range(klassCount): input = multivariate_normal(means[klass], cov[klass]) alldata.addSample(input, [klass]) tstdata, trndata = alldata.splitWithProportion(0.25) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() print "Number of training patterns: ", len(trndata) print "Input and output dimensions: ", trndata.indim, trndata.outdim print "First sample (input, target, class):" print trndata["input"][0], trndata["target"][0], trndata["class"][0] return tstdata, trndata
def init_classifier(self, hidden_units=20): data = ClassificationDataSet(len(self.channels), nb_classes=5) # Prepare the dataset for i in range(len(self.classification_proc)): data.appendLinked(self.y_proc[i], self.classification_proc[i]) # Make global for test purposes self.data = data # Prepare training and test data, 75% - 25% proportion self.testdata, self.traindata = data.splitWithProportion(0.25) #self.traindata._convertToOneOfMany() #self.testdata._convertToOneOfMany() # CHECK the number of hidden units fnn = buildNetwork(self.traindata.indim, hidden_units, self.traindata.outdim) # CHECK meaning of the parameters trainer = BackpropTrainer(fnn, dataset=self.traindata, momentum=0, verbose=True, weightdecay=0.01) return fnn, trainer, data
def neuralNetworksTrain(self): alldata = ClassificationDataSet( 23, 1, nb_classes=2) train_input_data = self.loadData(self.train_file) test_input_data = self.loadData(self.test_file) target = [x[1] for x in train_input_data] target = target[1:] features = [x[2:] for x in train_input_data] features = features[1:] for i in range(0,len(features)): alldata.addSample(features[i], target[i]) tstdata, trndata = alldata.splitWithProportion(0.25) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() INPUT_FEATURES = 23 CLASSES = 2 HIDDEN_NEURONS = 200 WEIGHTDECAY = 0.1 MOMENTUM = 0.1 EPOCH = 2 fnn = buildNetwork(trndata.indim, HIDDEN_NEURONS, trndata.outdim,outclass=LinearLayer) trainer = BackpropTrainer(fnn, dataset=trndata, momentum=MOMENTUM,verbose=True, weightdecay=WEIGHTDECAY) trainer.trainEpochs(EPOCH) pred = trainer.testOnClassData(dataset=tstdata) actual = tstdata['class'] self.computeAccuracy(actual,pred) testFeatures = [x[2:] for x in test_input_data] testFeatures = testFeatures[1:] prediction = [fnn.activate(x) for x in testFeatures] i=0 print "Neural Network Architecture:" print "Layers: Input layer, Hidden Layer and Output Layers" print "Epoch = "+str(EPOCH) print "Neurons in the hidden layer:"+str(HIDDEN_NEURONS) print "Precision recall F score support metrics for Neural Networks " print precision_recall_fscore_support(actual,pred) print "confusion matrix" print confusion_matrix(actual,pred)
def hello_classify(): from pybrain.datasets import ClassificationDataSet from pybrain.utilities import percentError from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised.trainers import BackpropTrainer from pybrain.structure.modules import SoftmaxLayer from pylab import ion, ioff, figure, draw, contourf, clf, show, hold, plot from scipy import diag, arange, meshgrid, where from numpy.random import multivariate_normal means = [(-1,0),(2,4),(3,1)] cov = [diag([1,1]), diag([0.5,1.2]), diag([1.5,0.7])] alldata = ClassificationDataSet(2, 1, nb_classes=3) for n in xrange(400): for klass in range(3): input = multivariate_normal(means[klass],cov[klass]) alldata.addSample(input, [klass]) tstdata, trndata = alldata.splitWithProportion( 0.25 ) trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) print "Number of training patterns: ", len(trndata) print "Input and output dimensions: ", trndata.indim, trndata.outdim print "First sample (input, target, class):" print trndata['input'][0], trndata['target'][0], trndata['class'][0] fnn = buildNetwork( trndata.indim, 5, trndata.outdim, outclass=SoftmaxLayer ) trainer = BackpropTrainer( fnn, dataset=trndata, momentum=0.1, verbose=True, weightdecay=0.01) ticks = arange(-3.,6.,0.2) X, Y = meshgrid(ticks, ticks) # need column vectors in dataset, not arrays griddata = ClassificationDataSet(2,1, nb_classes=3) for i in xrange(X.size): griddata.addSample([X.ravel()[i],Y.ravel()[i]], [0]) griddata._convertToOneOfMany() # this is still needed to make the fnn feel comfy
def split_into_train_and_test_dataset(raw_dataset, split_ratio=0.75): """ :param raw_dataset: :param split_ratio: :return: """ # for each test point:input(x1, x2), output(class) classification_dataset = ClassificationDataSet(2, 1, nb_classes=2) # add data element to the dataset for i in range(len(raw_dataset)): x1, x2, class_for_each_point = raw_dataset[i] classification_dataset.addSample([x1, x2], [class_for_each_point]) train_dataset, test_dataset = classification_dataset.splitWithProportion(split_ratio) # small technique:train_dataset's out dimension change from 1 to 2, and class info in train_dataset['class'] train_dataset._convertToOneOfMany() test_dataset._convertToOneOfMany() return train_dataset, test_dataset
def main(): # Get Data dataSets = genfromtxt('normalizedData.csv', delimiter=',') alldata = ClassificationDataSet(13, 1, nb_classes=3) for dataSet in dataSets: alldata.addSample(dataSet[1:14], int(dataSet[0]) - 1) # Split the data tstdata_temp, trndata_temp = alldata.splitWithProportion(0.25) tstdata = ClassificationDataSet(13, 1, nb_classes=3) for n in range(0, tstdata_temp.getLength()): tstdata.addSample( tstdata_temp.getSample(n)[0], tstdata_temp.getSample(n)[1]) trndata = ClassificationDataSet(13, 1, nb_classes=3) for n in range(0, trndata_temp.getLength()): trndata.addSample( trndata_temp.getSample(n)[0], trndata_temp.getSample(n)[1]) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() # Build Network fnn = buildNetwork(trndata.indim, 4, 4, 4, trndata.outdim) # Construct Trainer trainer = BackpropTrainer(fnn, trndata, learningrate=0.1) # Train while True: trainer.trainEpochs(1) trnresult = percentError(trainer.testOnClassData(), trndata['class']) print("Training Test Error: %5.2f%%" % trnresult) if trnresult < 1: break tstresult = percentError(trainer.testOnClassData(dataset=tstdata), tstdata['class']) print("test error: %5.2f%%" % tstresult)
def trainNeuralNetwork(): """ Trains a neural network with the current dataset """ print("Generating training and testing data....") statements, labels = generateBalancedDataset() """ Vectorize the statements """ vect = TfidfVectorizer(analyzer="word", ngram_range=(1, 2), stop_words="english", max_df=0.70, min_df=3) print("Vectorizing the statements and labels...") statements = vect.fit_transform(statements) n_input_neurons = len(vect.vocabulary_) """ vectorize the labels """ v_labels = [] for label in labels: if label == "left": v_labels.append(np.array([1, 0])) elif label == "right": v_labels.append(np.array([0, 1])) labels = v_labels """ Build the dataset """ print("building the dataset...") ds = ClassificationDataSet(n_input_neurons, 2, nb_classes=2, class_labels=["left", "right"]) for k, statement in enumerate(statements): ds.addSample(statement.toarray()[0], labels[k]) """ Split training and testing data """ training_data, testing_data = ds.splitWithProportion(0.1) """ Build the neural network accordingly """ nn = buildNetwork(n_input_neurons, int(float(n_input_neurons) / 2), 2) """ Build the nn trainer """ trainer = BackpropTrainer(nn, dataset=ds, verbose=True) return (trainer, vect, nn, testing_data)
def main(): (X, Y, Ynames) = load_magic_data() X = StandardScaler().fit_transform(X) X,Y = shuffle(X, Y, n_samples=None, random_state=None) N = len(Y) alldata = ClassificationDataSet(inp = 10, target = 1, nb_classes=2) for i in range(N): alldata.addSample(X[i],Y[i]) tstdata, trndata = alldata.splitWithProportion(0.25) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() print "Number of training patterns: ", len(trndata) print "Input and output dimensions: ", trndata.indim, trndata.outdim print "First sample (input, target, class):" print trndata['input'][0], trndata['target'][0], trndata['class'][0] fnn = buildNetwork(trndata.indim, 15, trndata.outdim, bias=True) trainer = BackpropTrainer(fnn, dataset=trndata, momentum=0, learningrate = 0.005, verbose=True) trainer.trainUntilConvergence(maxEpochs=100) trnresult = 100 - percentError(trainer.testOnClassData(), trndata['class']) tstresult = 100 - percentError(trainer.testOnClassData(dataset=tstdata), tstdata['class']) print "Epoch:%4d" % trainer.totalepochs, \ " train accuracy: %5.2f%%" % trnresult, \ " test accuracy: %5.2f%%" % tstresult plt.figure(figsize=(8,8)) plt.plot(trainer.trainingErrors) plt.xlabel('Training Steps') plt.ylabel('Training Error') plt.show()
def Neural_Network(X, y, tst_size, col_size, n_epochs): ## Load the dataset into the neural network. ds = ClassificationDataSet(3*col_size, 1) for i in range(len(X)): ds.addSample(X[i], y[i]) ## Split the data into training and testing. tstdata_tmp, trndata_tmp = ds.splitWithProportion(tst_size) tstdata = ClassificationDataSet(3*col_size, 1, nb_classes = 2) for n in xrange(0, tstdata_tmp.getLength()): tstdata.addSample( tstdata_tmp.getSample(n)[0], tstdata_tmp.getSample(n)[1] ) trndata = ClassificationDataSet(3*col_size, 1, nb_classes = 2) for n in xrange(0, trndata_tmp.getLength()): trndata.addSample( trndata_tmp.getSample(n)[0], trndata_tmp.getSample(n)[1] ) ## And this code converts 1 output to 40 binary outputs, to encode classes with one output neuron per class. trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) ## Training. fnn = buildNetwork(trndata.indim, col_size , trndata.outdim, outclass=SoftmaxLayer) trainer = BackpropTrainer(fnn, dataset=trndata) ## Compute percentage error. trainer.trainEpochs (n_epochs) score = (100 - percentError( trainer.testOnClassData (dataset=tstdata ), tstdata['class']))/100 return score
def Neural_Network(X, y, tst_size, col_size, n_epochs): ## Load the dataset into the neural network. ds = ClassificationDataSet(3*col_size, 1) for i in range(len(X)): ds.addSample(X[i], y[i]) ## Split the data into training and testing. tstdata_tmp, trndata_tmp = ds.splitWithProportion(tst_size) tstdata = ClassificationDataSet(3*col_size, 1, nb_classes = 2) for n in range(0, tstdata_tmp.getLength()): tstdata.addSample( tstdata_tmp.getSample(n)[0], tstdata_tmp.getSample(n)[1] ) trndata = ClassificationDataSet(3*col_size, 1, nb_classes = 2) for n in range(0, trndata_tmp.getLength()): trndata.addSample( trndata_tmp.getSample(n)[0], trndata_tmp.getSample(n)[1] ) ## And this code converts 1 output to 40 binary outputs, to encode classes with one output neuron per class. trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) ## Training. fnn = buildNetwork(trndata.indim, col_size , trndata.outdim, outclass=SoftmaxLayer) trainer = BackpropTrainer(fnn, dataset=trndata) ## Compute percentage error. trainer.trainEpochs (n_epochs) score = (100 - percentError( trainer.testOnClassData (dataset=tstdata ), tstdata['class']))/100 return score
def train_readout_nn(net_file, net_key, readout_window=np.arange(0, 1), num_hidden=2): (samps, all_stim_classes, Ninternal) = get_samples(net_file, net_key, readout_window) alldata = ClassificationDataSet(Ninternal, 1, nb_classes=len(all_stim_classes)) for readout_state,stim_class in samps: alldata.addSample(readout_state, [stim_class]) tstdata, trndata = alldata.splitWithProportion( 0.25 ) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() fnn = buildNetwork( trndata.indim, num_hidden, trndata.outdim, hiddenclass=TanhLayer, outclass=SoftmaxLayer) trainer = BackpropTrainer(fnn, dataset=trndata, momentum=0.1, verbose=False, weightdecay=0.01) test_errors = [] num_slope_samps = 10 slope = 0.0 while True: if len(test_errors) >= num_slope_samps: coef = np.polyfit(np.arange(num_slope_samps), test_errors[-num_slope_samps:], 1) slope = coef[0] if slope > 0.0: print 'Test error slope > 0.0, stopping' break trainer.train() train_err = percentError( trainer.testOnClassData(), trndata['class']) test_err = percentError( trainer.testOnClassData(dataset=tstdata), tstdata['class']) print "Iteration: %d, train_err=%0.4f, test_err=%0.4f, slope=%0.4f" % (trainer.totalepochs, train_err, test_err, slope) test_errors.append(test_err) return (train_err, test_err, fnn, trainer)
# Now initialize the neural network, use width*height*3 for the size of the data because all of the images need to # be resized and then flattened print "Loading image files..." ds = ClassificationDataSet(width * height * 3) for k in xrange(len(allFiles)): img = Image.open(allFiles[k]) img = img.resize([width, height], PIL.Image.ANTIALIAS) imgArray = numpy.asarray(img.getdata()) ds.addSample(ravel(imgArray), supportedFruits.index(allTargets[k])) # Split the data set into 75/25, the 75% being the data that is used to train, the 25% will be used to test # the quality of the neural network training # train until convergence does an automatic split if numEpochs == 0: tstdata, trndata = ds.splitWithProportion(0.00) else: tstdata, trndata = ds.splitWithProportion(0.25) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() # Build a new neural network print "Building the neural network, in-dimension: " + str( trndata.indim) + ", out-dimension: " + str(trndata.outdim) # fnn = buildNetwork(trndata.indim, 25, trndata.outdim, outclass=SoftmaxLayer) #25 worked ok fnn = buildNetwork(trndata.indim, 100, trndata.outdim, outclass=SoftmaxLayer) # Create a new backpropagation trainer print "Creating backpropagation trainer..." #trainer = BackpropTrainer(fnn, dataset=trndata, momentum=0.1, learningrate=0.01 , verbose=True, weightdecay=0.01)
print 'time taken: ', time.clock() # in seconds # can probably merge the upper 2? counter = 0 ds = ClassificationDataSet(unique_ingreds_length, unique_cuisine_length , nb_classes=unique_cuisine_length) for k in xrange(recipes_length): ds.addSample(big_data_matrix[k],cuisine_matrix[k]) counter += 1 print "added into dataset... ", counter, " / ", recipes_length # No memory error when using a desktop with 16g ram print 'classification dataset done!' print 'time taken: ', time.clock() tstdata, trndata = ds.splitWithProportion( 0.25 ) tstdata_temp, trndata_temp = ds.splitWithProportion(0.25) tstdata = ClassificationDataSet(unique_ingreds_length, unique_cuisine_length , nb_classes=unique_cuisine_length) for n in xrange(0, tstdata_temp.getLength()): tstdata.addSample( tstdata_temp.getSample(n)[0], tstdata_temp.getSample(n)[1] ) trndata = ClassificationDataSet(unique_ingreds_length, unique_cuisine_length , nb_classes=unique_cuisine_length) for n in xrange(0, trndata_temp.getLength()): trndata.addSample( trndata_temp.getSample(n)[0], trndata_temp.getSample(n)[1] ) trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) print 'split = ok'
from pybrain.datasets import ClassificationDataSet from pybrain.utilities import percentError from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised.trainers import BackpropTrainer from pybrain.structure.modules import SoftmaxLayer from numpy import ravel # pybrain has its own data sample class that we must add # our training and test set to ds = ClassificationDataSet(4096, 1 , nb_classes=40) for k in xrange(len(X)): ds.addSample(ravel(X[k]),y[k]) # their equivalent of train test split test_data, training_data = ds.splitWithProportion( 0.25 ) len(training_data.data['input'][0]) test_data # pybrain's version of dummy variables test_data._convertToOneOfMany( ) training_data._convertToOneOfMany( ) training_data['input'] training_data['target'] test_data.indim
olivettiData = datasets.fetch_olivetti_faces() dataFeatures = olivettiData.data dataTargets = olivettiData.target #plt.matshow(olivettiData.images[11], cmap=cm.Greys_r) #plt.show() #print dataTargets[11] #print dataFeatures.shape dataSet = ClassificationDataSet(4096, 1, nb_classes=40) for i in xrange(len(dataFeatures)): dataSet.addSample(np.ravel(dataFeatures[i]), dataTargets[i]) testData, trainingData = dataSet.splitWithProportion(0.25) trainingData._convertToOneOfMany() testData._convertToOneOfMany() neuralNetwork = buildNetwork(trainingData.indim, 64, trainingData.outdim, outclass=SoftmaxLayer) trainer = BackpropTrainer(neuralNetwork, dataset=trainingData, momentum=0.2, learningrate=0.01, verbose=True, weightdecay=0.02)
raw_inputs = raw_data[:, 0:-1] raw_target = raw_data[:, 9:] assert (raw_inputs.shape[0] == raw_target.shape[0] ), "Inputs count and target count do not match" all_data = ClassificationDataSet(9, 1, nb_classes=2, class_labels=['Benign', 'Malignant']) all_data.setField('input', raw_inputs) all_data.setField('target', raw_target) all_data.setField('class', raw_target) test_data_temp, training_data_temp = all_data.splitWithProportion(0.33) test_data = ClassificationDataSet(9, 1, nb_classes=2, class_labels=['Benign', 'Malignant']) for n in xrange(0, test_data_temp.getLength()): test_data.addSample( test_data_temp.getSample(n)[0], test_data_temp.getSample(n)[1]) training_data = ClassificationDataSet(9, 1, nb_classes=2, class_labels=['Benign', 'Malignant']) for n in xrange(0, training_data_temp.getLength()):
image = Image.open("8x8.png") image = image.convert('LA') image.thumbnail((8, 8), Image.ANTIALIAS) image.save("numberOut.png") #set y as target X, y = digits.data, digits.target #add the contents of digits to a dataset daSet = ClassificationDataSet(64, 1) for k in xrange(len(X)): daSet.addSample(X.ravel()[k], y.ravel()[k]) #split the dataset into training and testing testData, trainData = daSet.splitWithProportion(0.40) #convert the data into 10 separate digits trainData._convertToOneOfMany() testData._convertToOneOfMany() #check for the save file and load if os.path.isfile('dig.xml'): net = NetworkReader.readFrom('dig.xml') net.sorted = False net.sortModules() else: # net = FeedForwardNetwork() net = buildNetwork(64, 37, 10,
def exec_algo(xml_file, output_location): rootObj=ml.parse(xml_file) #Getting the root element so that we get the subclasses and its members and member function file=open(rootObj.MachineLearning.classification.datafile) var_inp=rootObj.MachineLearning.classification.input var_out=rootObj.MachineLearning.classification.output classes=rootObj.MachineLearning.classification.classes DS=ClassificationDataSet(var_inp,var_out,nb_classes=classes) for line in file.readlines(): data=[float(x) for x in line.strip().split(',') if x != ''] inp=tuple(data[:var_inp]) output=tuple(data[var_inp:]) DS.addSample(inp,output) split=rootObj.MachineLearning.classification.split tstdata,trndata=DS.splitWithProportion(split) trdata=ClassificationDataSet(trndata.indim,var_out,nb_classes=classes) tsdata=ClassificationDataSet(tstdata.indim,var_out,nb_classes=classes) for i in xrange(trndata.getLength()): trdata.addSample(trndata.getSample(i)[0],trndata.getSample(i)[1]) for i in xrange(tstdata.getLength()): tsdata.addSample(tstdata.getSample(i)[0],tstdata.getSample(i)[1]) trdata._convertToOneOfMany() tsdata._convertToOneOfMany() hiddenNeurons=rootObj.MachineLearning.classification.algorithm.RadialBasisFunctionNetwork.hiddenNeurons fnn=FeedForwardNetwork() inputLayer=LinearLayer(trdata.indim) hiddenLayer=GaussianLayer(hiddenNeurons) outputLayer=LinearLayer(trdata.outdim) fnn.addInputModule(inputLayer) fnn.addModule(hiddenLayer) fnn.addOutputModule(outputLayer) in_to_hidden=FullConnection(inputLayer,hiddenLayer) hidden_to_outputLayer=FullConnection(hiddenLayer,outputLayer) fnn.addConnection(in_to_hidden) fnn.addConnection(hidden_to_outputLayer) fnn.sortModules() learningrate=rootObj.MachineLearning.classification.algorithm.RadialBasisFunctionNetwork.learningRate momentum=rootObj.MachineLearning.classification.algorithm.RadialBasisFunctionNetwork.momentum epochs=rootObj.MachineLearning.classification.algorithm.RadialBasisFunctionNetwork.epochs trainer=BackpropTrainer(fnn,dataset=trdata, verbose=True, learningrate=learningrate, momentum=momentum) trainer.trainEpochs(epochs=epochs) #trainer.train() #trainer.trainUntilConvergence(dataset=trdata, maxEpochs=500, verbose=True, continueEpochs=10, validationProportion=0.25) trresult=percentError(trainer.testOnClassData(),trdata['class']) #testingResult=percentError(trainer.testOnClassData(dataset=tsdata),tsdata['class']) #print "Training accuracy : %f , Testing Accuracy: %f" % (100-trresult,100-testingResult) print "Training accuracy : %f " % (100-trresult) ts=time.time() directory = output_location + sep + str(int(ts)) ; makedirs(directory) fileObject=open(output_location + sep + str(int(ts)) + sep + 'pybrain_RBF','w') pickle.dump(trainer,fileObject) pickle.dump(fnn,fileObject) fileObject.close()
class2vec1=np.reshape(class2im1,np.size(class2im1)) class2vec2=np.reshape(class2im2,np.size(class2im1)) class2vec3=np.reshape(class2im3,np.size(class2im1)) class2vec4=np.reshape(class2im4,np.size(class2im1)) class2vec5=np.reshape(class2im5,np.size(class2im1)) trainData1=np.array([class1vec1,class1vec2,class1vec3,class1vec4,class1vec5,class2vec1,class2vec2,clas s2vec3,class2vec4,class2vec5]) ncomponents=9 pca = PCA(n_components=ncomponents) pca.fit(trainData1) trainData=pca.transform(trainData1) trainLabels=np.array([1,1,1,1,1,2,2,2,2,2]) trnData = ClassificationDataSet(ncomponents, 1, nb_classes=2) for i in range(len(trainLabels)): trnData.addSample(trainData[i,:], trainLabels[i]-1) tstdata, trndata = trnData.splitWithProportion( 0.40 ) trnData._convertToOneOfMany( ) fnn = buildNetwork( trnData.indim, 20, trnData.outdim, outclass=SoftmaxLayer ) trainer = BackpropTrainer( fnn, dataset=trnData, momentum=0.1, verbose=True, weightdecay=0.01) for i in range(20): trainer.trainEpochs(5) trnresult=percentError(trainer.testOnClassData(),trnData['class']) print "epoch: %4d" % trainer.totalepochs, \ " train error: %5.2f%%" % trnresult, \ outTrain=fnn.activateOnDataset(trnData) outTrainLabels=outTrain.argmax(axis=1)+1 numErrTrain=numErr=sum(abs(outTrainLabels!=trainLabels)) accTrain=1-numErrTrain/len(trainLabels) from __future__ import division import numpy as np from pybrain.datasets import ClassificationDataSet
from pybrain.supervised.trainers import BackpropTrainer from pybrain.structure.modules import SoftmaxLayer from pylab import ion, ioff, figure, draw, contourf, clf, show, hold, plot from scipy import diag, arange, meshgrid, where from numpy.random import multivariate_normal means = [(-1, 0), (2, 4), (3, 1)] cov = [diag([1, 1]), diag([0.5, 1.2]), diag([1.5, 0.7])] alldata = ClassificationDataSet(2, 1, nb_classes=3) for n in xrange(400): for klass in range(3): input = multivariate_normal(means[klass], cov[klass]) alldata.addSample(input, [klass]) tstdata_temp, trndata_temp = alldata.splitWithProportion(0.25) tstdata = ClassificationDataSet(2, 1, nb_classes=3) for n in xrange(0, tstdata_temp.getLength()): tstdata.addSample( tstdata_temp.getSample(n)[0], tstdata_temp.getSample(n)[1]) trndata = ClassificationDataSet(2, 1, nb_classes=3) for n in xrange(0, trndata_temp.getLength()): trndata.addSample( trndata_temp.getSample(n)[0], trndata_temp.getSample(n)[1]) trndata._convertToOneOfMany() tstdata._convertToOneOfMany()
from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised.trainers import BackpropTrainer from pybrain.structure.modules import SoftmaxLayer from pylab import ion, ioff, figure, draw, contourf, clf, show, hold, plot from scipy import diag, arange, meshgrid, where from numpy.random import multivariate_normal means = [(-1, 0), (2, 4), (3, 1)] cov = [diag([1, 1]), diag([0.5, 1.2]), diag([1.5, 0.7])] alldata = ClassificationDataSet(2, 1, nb_classes=3) for n in xrange(400): for klass in range(3): input = multivariate_normal(means[klass], cov[klass]) alldata.addSample(input, [klass]) tstdata, trndata = alldata.splitWithProportion(0.25) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() print "Number of training patterns: ", len(trndata) print "Input and output dimensions: ", trndata.indim, trndata.outdim print "First sample (input, target, class):" print trndata['input'][0], trndata['target'][0], trndata['class'][0] fnn = buildNetwork(trndata.indim, 5, trndata.outdim, outclass=SoftmaxLayer) trainer = BackpropTrainer(fnn, dataset=trndata, momentum=0.1, verbose=True, weightdecay=0.01)