def start(): featuresList=[] labelsList=[] featuresList, labelsList= loadFile("output.txt") print 'Normalizing array...' normalizearray(featuresList) alldata = ClassificationDataSet( len(featuresList[0]), 1, nb_classes=8, class_labels=['ffi_brainmatter','ffi_neuron','ffi_vacuole','ffi_astrocyte', 'wt_brainmatter', 'wt_neuron', 'wt_vacuole', 'wt_astrocyte'] ) for i in range(len(labelsList)): alldata.appendLinked(featuresList[i], labelsList[i]) #print 'All data: ', alldata #print 'Statisticcs: ', alldata.calculateStatistics() newK=fSel.getTreeFeatures(featuresList, labelsList); newK=newK.shape[1] print "K= ", newK reducedFeatures= fSel.getBestK(featuresList,labelsList, 'f_classif', newK) reducedData=ClassificationDataSet( len(reducedFeatures[0]), 1, nb_classes=8, class_labels=['ffi_brainmatter','ffi_neuron','ffi_vacuole','ffi_astrocyte', 'wt_brainmatter', 'wt_neuron', 'wt_vacuole', 'wt_astrocyte'] ) #prep reducedData object with reduced feature list for i in range(len(labelsList)): reducedData.appendLinked(reducedFeatures[i], labelsList[i]) print 'Splitting test and training data...' tstdata, trndata = alldata.splitWithProportion( 0.30 ) reducedTestData, reducedTrainData=reducedData.splitWithProportion(0.3) print 'Number of training and test patterns: ', len(trndata), len(tstdata) trndata._convertToOneOfMany(bounds=[0,1]) tstdata._convertToOneOfMany(bounds=[0,1]) reducedTestData._convertToOneOfMany(bounds=[0,1]) reducedTrainData._convertToOneOfMany(bounds=[0,1]) #print "Number of training patterns: ", len(trndata) print "Input and output dimensions: ", trndata.indim, trndata.outdim #print "Sample (input, target, class):" #print trndata['input'][0], trndata['target'][0], trndata['class'][0] #print trndata['input'][1], trndata['target'][1], trndata['class'][1] buildFNN(tstdata, trndata) print "___________________________________________FEATURE REDUCTION________________________________________________" buildFNN(reducedTestData, reducedTrainData)
def initialize(trainingfeatures,traininglabels,p=0.7): alldata = ClassificationDataSet(trainingfeatures.shape[1], 1, nb_classes=len(set(traininglabels))) for i in xrange(traininglabels[0]): alldata.appendLinked(trainingfeatures[i] , traininglabels[i]) trndata, tstdata = alldata.splitWithProportion( p ) trndata._convertToOneOfMany(bounds=[0, 1]) tstdata._convertToOneOfMany(bounds=[0, 1]) model, accuracy, params = buildANN(trndata, tstdata) print '\nThe best model had '+str(accuracy)+'% accuracy and used the parameters:\n'+params+'\n' return model
def pybrainData(split, data=None): # taken from iris data set at machine learning repository if not data: pat = cat1 + cat2 + cat3 else: pat = data 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(split) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() return trndata, tstdata
fobj = open('02 select_data_num.csv', 'wb') [(fobj.write(item), fobj.write(',')) for item in header] fobj.write('\n') [([(fobj.write(str(it).replace(',', ' ')), fobj.write(',')) for it in item], fobj.write('\n')) for item in numdata] fobj.close() npdata = np.array(numdata, dtype=np.float) npdata[:, 2:] = preprocessing.scale(npdata[:, 2:]) numdata = copy.deepcopy(npdata) net = buildNetwork(14, 14, 1, bias=True, outclass=SoftmaxLayer) ds = ClassificationDataSet(14, 1, nb_classes=2) for item in numdata: ds.addSample(tuple(item[2:]), (item[1])) dsTrain, dsTest = ds.splitWithProportion(0.8) print('Trainging') trainer = BackpropTrainer(net, ds, momentum=0.1, verbose=True, weightdecay=0.01) # trainer.train() trainer.trainUntilConvergence(maxEpochs=20) print('Finish training') Traininp = dsTrain['input'] Traintar = dsTrain['target'] Testinp = dsTest['input'] Testtar = dsTest['target']
from sklearn import datasets from pybrain.datasets.classification import ClassificationDataSet from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised.trainers import BackpropTrainer iris = datasets.load_iris() x, y = iris.data, iris.target print(len(x)) dataset = ClassificationDataSet(4, 1, nb_classes=3) for i in range(len(x)): dataset.addSample(x[i], y[i]) train_data, part_data = dataset.splitWithProportion(0.6) test_data, val_data = part_data.splitWithProportion(0.5) net = buildNetwork(dataset.indim, 3, dataset.outdim) trainer = BackpropTrainer(net, dataset=train_data, learningrate=0.01, momentum=0.1, verbose=True) train_errors, val_errors = trainer.trainUntilConvergence(dataset=train_data, maxEpochs=100) trainer.totalepochs
from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised.trainers import BackpropTrainer import matplotlib.pyplot as plt iris = datasets.load_iris() entrada, saida = iris.data, iris.target dataset = ClassificationDataSet(4, 1, nb_classes=3) #Adicionar as amostras ao dataset for i in range(len(entrada)): dataset.addSample(entrada[i], saida[i]) #Recuperar dados para realizar o treinamento da rede parteTreino, parteDados = dataset.splitWithProportion(0.6) print("Quantidade para treinamento da rede : " + str(len(parteTreino))) #Separando a parte de dados para realização do teste e para a validação da rede teste, validacao = parteDados.splitWithProportion(0.5) print("Quantidade para teste da rede : " + str(len(teste))) print("Quantidade para validação da rede : " + str(len(validacao))) #Criando a rede rede = buildNetwork(dataset.indim, 3, dataset.outdim) #Realizando o treinamento e recuperando os erros treinamento = BackpropTrainer(rede, dataset=parteTreino, learningrate=0.01, momentum=0.1,
import matplotlib.pyplot as plt from sklearn import datasets from pybrain.datasets.classification import ClassificationDataSet from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised import BackpropTrainer iris = datasets.load_iris() X, y = iris.data, iris.target dataset = ClassificationDataSet(4, 1, nb_classes=3) for sample_input, sample_output in zip(X, y): dataset.addSample(sample_input, sample_output) # Partitioning data for training training_data, partitioned_data = dataset.splitWithProportion(0.6) # Spliting data for testing and validation testing_data, validation_data, = partitioned_data.splitWithProportion(0.5) network = buildNetwork(dataset.indim, 2, 2, dataset.outdim) trainer = BackpropTrainer(network, dataset=training_data, learningrate=0.01, momentum=0.1, verbose=True) training_errors, validation_errors = trainer.trainUntilConvergence( dataset=training_data, maxEpochs=200) plt.plot(training_errors, 'b', validation_errors, 'r') plt.legend()
from sklearn import datasets from pybrain.datasets.classification import ClassificationDataSet from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised.trainers import BackpropTrainer iris = datasets.load_iris() x, y = iris.data, iris.target dataset = ClassificationDataSet(4, 1, nb_classes=3) for i in range(len(x)): dataset.addSample(x[i], y[i]) train_data_temp, part_data_temp = dataset.splitWithProportion(0.6) test_data_temp, val_data_temp = part_data_temp.splitWithProportion(0.5) train_data = ClassificationDataSet(4, 1, nb_classes=3) for n in range(train_data_temp.getLength()): train_data.addSample( train_data_temp.getSample(n)[0], train_data_temp.getSample(n)[1]) test_data = ClassificationDataSet(4, 1, nb_classes=3) for n in range(test_data_temp.getLength()): train_data.addSample( test_data_temp.getSample(n)[0], test_data_temp.getSample(n)[1]) val_data = ClassificationDataSet(4, 1, nb_classes=3) for n in range(val_data_temp.getLength()): val_data.addSample( val_data_temp.getSample(n)[0],
X, y = iris.data, iris.target from pybrain.datasets.classification 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 #import numpy as np import matplotlib.pyplot as pl ds = ClassificationDataSet(4, 1, nb_classes=3) for i in range(len(X)): ds.addSample(X[i], y[i]) # splitting data into train,test and valid data in 60/20/20 proportions trndata, partdata = ds.splitWithProportion(0.60) tstdata, validdata = partdata.splitWithProportion(0.50) # to encode classes wwith one output neuron per class trndata._convertToOneOfMany() tstdata._convertToOneOfMany() validdata._convertToOneOfMany() # original target values are stored in class created by function to #preserve the value print trndata['class'] # new values of target after convertion print trndata['target'] # check the dimensions of input(4types) and output(3 categories) print trndata.indim, trndata.outdim, tstdata.indim, tstdata.outdim
n.addConnection(in_to_hidden) n.addConnection(hidden_to_out) n.sortModules() print 'build set' alldata = ClassificationDataSet(dim, 1, nb_classes=2) (data,label,items) = BinReader.readData(ur'F:\AliRecommendHomeworkData\1212新版\train15_17.expand.samp.norm.bin') #(train,label,data) = BinReader.readData(r'C:\data\small\norm\train1217.bin') for i in range(len(data)): alldata.addSample(data[i],label[i]) tstdata, trndata = alldata.splitWithProportion(0.25) trainer = BackpropTrainer(n,trndata,momentum=0.1,verbose=True,weightdecay=0.01) print 'start' #trainer.trainEpochs(1) trainer.trainUntilConvergence(maxEpochs=2) 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 print 'get result'
from pybrain.tools.customxml.networkwriter import NetworkWriter from pybrain.tools.customxml.networkreader import NetworkReader import os # Downloading Dataset olivetti = datasets.fetch_olivetti_faces() oData, oTarget = olivetti.data, olivetti.target # Initializing Dataset dataset = ClassificationDataSet(4096, 1, nb_classes=40) for i in range(len(oData)): dataset.addSample(ravel(oData[i]), oTarget[i]) # Splitting dataset for 75% training data and 25% test data testData, trainingData = dataset.splitWithProportion(0.25) trainingData._convertToOneOfMany() testData._convertToOneOfMany() # Neural Network Construction # Load previous training if it exists if os.path.isfile('oliv.xml'): print('Loading Previous Training Data...') fnn = NetworkReader.readFrom('oliv.xml') print('Training Data Loaded!\n') # Build fresh network if training does not exist else: fnn = buildNetwork(trainingData.indim, 64, trainingData.outdim, outclass=SoftmaxLayer) # Trainer initialization
y = pd.Series.as_matrix(y) #print "datatypes",type(X),type(y) ds = ClassificationDataSet(13, 1, nb_classes=2) for i in range(len(X)): ds.addSample(X[i], y[i]) # since X has 13 columns our nput of nueral network are 13 nodes #ds = pyd.ClassificationDataSet(13, 1 , nb_classes=2) #,class_labels=['yes','no']) #print ds # ravel is used for ordering and joining into 1-D array #for i in range(len(X)): # ds.addSample(X[i],y[i]) # splitting data into test and train tstdata, trndata = ds.splitWithProportion(0.30) # converts one to 2 binary outputs,assign each output to one neuron trndata._convertToOneOfMany() tstdata._convertToOneOfMany() print trndata['input'], trndata['target'], tstdata.indim, tstdata.outdim # original target values are stored in class created by function to #preserve the value print trndata['class'] # new values of target after convertion print trndata['target'] fnn = buildNetwork(trndata.indim, trndata.outdim, outclass=SoftmaxLayer) #The learning rate gives the ratio of which parameters are changed into the direction of the gradient. The learning rate #decreases by lrdecay, which is used to to multiply the learning rate after each training step. The parameters are also adjusted # with respect to momentum, which is the ratio by which the gradient of the last timestep is used.