Python ClassificationDataSet._convertToOneOfMany方法代码示例

# 需要导入模块: from pybrain.datasets import ClassificationDataSet [as 别名]
# 或者: from pybrain.datasets.ClassificationDataSet import _convertToOneOfMany [as 别名]
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

# 需要导入模块: from pybrain.datasets import ClassificationDataSet [as 别名]
# 或者: from pybrain.datasets.ClassificationDataSet import _convertToOneOfMany [as 别名]
def ann(training_filename , testing_filename,itr,epoch,model_type):
    training_start_time = "The generation of data set and training started at :%s" % datetime.datetime.now()
    training_dataset            = np.genfromtxt(training_filename, skip_header=0,dtype="int", delimiter='\t' )
    data = ClassificationDataSet(len(training_dataset[0])-1, 2, nb_classes=2)
    for aSample in training_dataset:
        data.addSample(aSample[0:len(aSample)-1],[aSample[len(aSample)-1]] );
        
    #  
    data._convertToOneOfMany( )

    fann = buildNetwork(314,2,outclass=SoftmaxLayer);
    trainer = BackpropTrainer( fann, dataset=data, momentum=0.1, verbose=False, weightdecay=0.01)
    counter = 0;
    print training_start_time
    while(counter < itr):
        trainer.trainEpochs( epoch );
        counter = counter + 1;
    
    trnresult = percentError( trainer.testOnClassData(),data['class'] )
    trained_result_log = "epoch: %4d" % trainer.totalepochs, \
          "  train error: %5.2f%%" % trnresult;
    
    
    training_time_end = "The training and result logging ended at %s :" % datetime.datetime.now()
    
    filename = working_dir + "\models\\"+model_type + ".obj"
    save_trained_model(fann, filename)
    
    log_file.write("\n" + training_start_time+"\n")
    log_file.write(str(trained_result_log)+"\n")
    log_file.write(training_time_end+"\n")

# 需要导入模块: from pybrain.datasets import ClassificationDataSet [as 别名]
# 或者: from pybrain.datasets.ClassificationDataSet import _convertToOneOfMany [as 别名]
def classify(Xtrain, Ytrain, n_hidden=5):
    """ Use entirety of provided X, Y to predict

    Arguments
    Xtrain -- Training data
    Ytrain -- Training prediction

    Returns
    classifier -- a classifier fitted to Xtrain and Ytrain
    """

    # PyBrain expects data in its DataSet format
    trndata = ClassificationDataSet(Xtrain.shape[1], nb_classes=2)
    trndata.setField('input', Xtrain)
    # Apprently, arrays don't work here as they try to access second dimension size...
    trndata.setField('target', mat(Ytrain).transpose())

    trndata._convertToOneOfMany() # one output neuron per class

    # build neural net and train it
    net = buildNetwork(trndata.indim, n_hidden, trndata.outdim, outclass=SoftmaxLayer)
    trainer = BackpropTrainer(net, dataset=trndata, momentum=0.1, verbose=True, weightdecay=0.01)

    trainer.trainUntilConvergence()
    #trainer.trainEpochs(5)

    print "trained"
    #trainer.trainEpochs(5)

    # Return a functor that wraps calling predict
    return NeuralNetworkClassifier(trainer)

# 需要导入模块: from pybrain.datasets import ClassificationDataSet [as 别名]
# 或者: from pybrain.datasets.ClassificationDataSet import _convertToOneOfMany [as 别名]
def run_nn_fold(training_data, test_data):
    test_features, ignore, featureMap, labels, labelMap = fs.mutualinfo(training_data)

    input_len = len(test_features[0])
    num_classes = len(labelMap.keys())
    train_ds = ClassificationDataSet(input_len, 1,nb_classes=num_classes)
    for i in range(len(test_features)):
        train_ds.addSample(tuple(test_features[i]), (labels[i]))
    train_ds._convertToOneOfMany()
    net = buildNetwork(train_ds.indim, 2, train_ds.outdim, bias=True, hiddenclass=TanhLayer, outclass=SoftmaxLayer)
    trainer = BackpropTrainer(net, train_ds, verbose=True)
    print "training until convergence..."
    trainer.trainUntilConvergence(maxEpochs=100)
    print "done. testing..."


    test_ds = ClassificationDataSet(input_len, 1,nb_classes=num_classes)  

    labels = []
    for tweetinfo in test_data:
        featuresFound = tweetinfo["Features"]
        label = tweetinfo["Answer"]
        labels.append(label)
        features = [0]*len(featureMap.keys())
        for feat in featuresFound:
            if feat in featureMap:
                features[ featureMap[feat] ] = 1
        test_ds.addSample(tuple(features), (labelMap[label]))

    test_ds._convertToOneOfMany()
    tstresult = percentError( trainer.testOnClassData(
            dataset=test_ds ), test_ds['class'] )
    print tstresult

# 需要导入模块: from pybrain.datasets import ClassificationDataSet [as 别名]
# 或者: from pybrain.datasets.ClassificationDataSet import _convertToOneOfMany [as 别名]
def simpleNeuralNetworkTrain(fileName, numFeatures, numClasses, possibleOutputs, numHiddenNodes, numTrainingEpochs):

    data = np.genfromtxt(fileName)
    trnIn = data[:, 0:5]
    trnOut = data[:, 6]
    trnOut = [int(val) for val in trnOut]

    normalizeData(trnIn, numFeatures)
    trndata = ClassificationDataSet(numFeatures, possibleOutputs, nb_classes=numClasses)
    for row in range(0, len(trnIn)):
        tempListOut = []
        tempListIn = []
        tempListOut.append(int(trnOut[row]))
        for i in range(0, numFeatures):
            tempListIn.append(trnIn[row][i])
        trndata.addSample(tempListIn, tempListOut)

    trndata._convertToOneOfMany()

    #  When running for the first time
    myNetwork = buildNetwork(numFeatures, numHiddenNodes, numClasses, outclass=SoftmaxLayer, bias=True, recurrent=False)

    # Read from file after the first try.
    #  myNetwork = NetworkReader.readFrom('firstTime.xml')    # Use saved results.
    trainer = BackpropTrainer(myNetwork, dataset=trndata, momentum=0.0, verbose=True, weightdecay=0.0)
    for i in range(numTrainingEpochs):
        trainer.trainOnDataset(dataset=trndata)

# 需要导入模块: from pybrain.datasets import ClassificationDataSet [as 别名]
# 或者: from pybrain.datasets.ClassificationDataSet import _convertToOneOfMany [as 别名]
class neuralNetwork():

	def __init__( self, n_classes ):
		self.n_classes = n_classes

	def fit( self, X, Y ):
		n_features = X.shape[1]
		self.train_ds = ClassificationDataSet( n_features, 1, nb_classes = self.n_classes )
		for train, target in zip( X, Y ):
			self.train_ds.addSample( train, [target] )

		self.train_ds._convertToOneOfMany( )

		self.net = buildNetwork( self.train_ds.indim, 2*n_features, self.train_ds.outdim, outclass = SoftmaxLayer )
		self.trainer = BackpropTrainer( self.net, self.train_ds )

	def predict( self, X ):
		n_features = X.shape[1]
		self.test_ds = ClassificationDataSet( n_features, 1, nb_classes = self.n_classes )
		for test in X:
			self.test_ds.addSample( test, [1] )

		self.test_ds._convertToOneOfMany( )

		for i in range( 100 ):
			self.trainer.trainEpochs( 5 )
			self.labels = self.net.activateOnDataset( self.test_ds )
			self.labels = self.labels.argmax(axis=1)
		return self.labels

# 需要导入模块: from pybrain.datasets import ClassificationDataSet [as 别名]
# 或者: from pybrain.datasets.ClassificationDataSet import _convertToOneOfMany [as 别名]
def big_training(np_data, num_nets=1, num_epoch=20, net_builder=net_full, train_size=.1, testing=False):
    sss = cross_validation.StratifiedShuffleSplit(np_data[:,:1].ravel(), n_iter=num_nets , test_size=1-train_size, random_state=3476)
    nets=[None for net_ind in range(num_nets)]
    trainaccu=[[0 for i in range(num_epoch)] for net_ind in range(num_nets)]
    testaccu=[[0 for i in range(num_epoch)] for net_ind in range(num_nets)]
    net_ind=0
    for train_index, test_index in sss:
        print ('%s Building %d. network.' %(time.ctime(), net_ind+1))
        #print("TRAIN:", len(train_index), "TEST:", len(test_index))
        trainset = ClassificationDataSet(np_data.shape[1] - 1, 1)
        trainset.setField('input', np_data[train_index,1:]/100-.6)
        trainset.setField('target', np_data[train_index,:1])
        trainset._convertToOneOfMany( )
        trainlabels = trainset['class'].ravel().tolist()
        if testing:
            testset = ClassificationDataSet(np_data.shape[1] - 1, 1)
            testset.setField('input', np_data[test_index,1:]/100-.6)
            testset.setField('target', np_data[test_index,:1])
            testset._convertToOneOfMany( )
            testlabels = testset['class'].ravel().tolist()
        nets[net_ind] = net_builder()
        trainer = BackpropTrainer(nets[net_ind], trainset)
        for i in range(num_epoch):
            for ii in range(3):
                err = trainer.train()
            print ('%s Epoch %d: Network trained with error %f.' %(time.ctime(), i+1, err))
            trainaccu[net_ind][i]=accuracy_score(trainlabels,trainer.testOnClassData())
            print ('%s Epoch %d: Train accuracy is %f' %(time.ctime(), i+1, trainaccu[net_ind][i]))
            print ([sum([trainaccu[y][i]>tres for y in range(net_ind+1)]) for tres in [0,.1,.2,.3,.4,.5,.6]])
            if testing:
                testaccu[net_ind][i]=accuracy_score(testlabels,trainer.testOnClassData(testset))
                print ('%s Epoch %d: Test accuracy is %f' %(time.ctime(), i+1, testaccu[net_ind][i]))
        NetworkWriter.writeToFile(nets[net_ind], 'nets/'+net_builder.__name__+str(net_ind)+'.xml')
        net_ind +=1
    return [nets, trainaccu, testaccu]

# 需要导入模块: from pybrain.datasets import ClassificationDataSet [as 别名]
# 或者: from pybrain.datasets.ClassificationDataSet import _convertToOneOfMany [as 别名]
class EightBitBrain(object):
    
    def __init__(self, dataset, inNodes, outNodes, hiddenNodes, classes):
        self.__dataset = ClassificationDataSet(inNodes, classes-1)
        for element in dataset:
            self.addDatasetSample(self._binaryList(element[0]), element[1])
        self.__dataset._convertToOneOfMany()
        self.__network = buildNetwork(inNodes, hiddenNodes, self.__dataset.outdim, recurrent=True)
        self.__trainer = BackpropTrainer(self.__network, learningrate = 0.01, momentum = 0.99, verbose = True)
        self.__trainer.setData(self.__dataset)

    def _binaryList(self, n):
        return [int(c) for c in "{0:08b}".format(n)]
    
    def addDatasetSample(self, argument, target):
        self.__dataset.addSample(argument, target)

    def train(self, epochs):
        self.__trainer.trainEpochs(epochs)
    
    def activate(self, information):
        result = self.__network.activate(self._binaryList(information))
        highest = (0,0)
        for resultClass in range(len(result)):
            if result[resultClass] > highest[0]:
                highest = (result[resultClass], resultClass)
        return highest[1]

# 需要导入模块: from pybrain.datasets import ClassificationDataSet [as 别名]
# 或者: from pybrain.datasets.ClassificationDataSet import _convertToOneOfMany [as 别名]
	def test(self,filename,classes,trainer,net):
		testLabels = []

		#load test data
		tstdata = ClassificationDataSet(103, 1, nb_classes=classes)
		tstdata = self.loaddata(filename, classes)

		testLabels = tstdata['target'];

		# some sort of mandatory conversion
		tstdata._convertToOneOfMany()
		
		# using numpy array
		output = np.array([net.activate(x) for x, _ in tstdata])
		output = output.argmax(axis=1)
		print(output)
		print("on test data",percentError( output, tstdata['class'] ))

		for i, l in enumerate(output):
			print l, '->', testLabels[i][0]

		# alternate version - using activateOnDataset function
		out = net.activateOnDataset(tstdata).argmax(axis=1)
		print out
		return percentError( out, tstdata['class'])

# 需要导入模块: from pybrain.datasets import ClassificationDataSet [as 别名]
# 或者: from pybrain.datasets.ClassificationDataSet import _convertToOneOfMany [as 别名]
def prepare_dataset():
    # Prepare output coding. "-" is 1 "." is 0
    d_morse_array = '100' # ( 1, 0, 0 ) # D -.. - 100
    g_morse_array = '110' # ( 1, 1, 0 ) # G --. - 110
    k_morse_array = '101' # ( 1, 0, 1 ) # K -.- - 101
    o_morse_array = '111' # ( 1, 1, 1 ) # O --- - 111
    r_morse_array = '010' # ( 0, 1, 0 ) # R .-. - 010
    s_morse_array = '000' # ( 0, 0, 0 ) # S ... - 000
    u_morse_array = '001' # ( 0, 0, 1 ) # U ..- - 001
    w_morse_array = '011' # ( 0, 1, 1 ) # W .-- - 011
    # Load learning data
    d_array = read_array( "d" )
    g_array = read_array( "g" )
    k_array = read_array( "k" )
    o_array = read_array( "o" )
    r_array = read_array( "r" )
    s_array = read_array( "s" )
    u_array = read_array( "u" )
    w_array = read_array( "w" )
    # Create dataset
    dataset = ClassificationDataSet( 1600, nb_classes=8, class_labels=[d_morse_array,g_morse_array,k_morse_array,o_morse_array,r_morse_array,s_morse_array,u_morse_array,w_morse_array] )
    # add all samples to dataset
    dataset.addSample( d_array, [0] )
    dataset.addSample( g_array, [1] )
    dataset.addSample( k_array, [2] )
    dataset.addSample( o_array, [3] )
    dataset.addSample( r_array, [4] )
    dataset.addSample( s_array, [5] )
    dataset.addSample( u_array, [6] )
    dataset.addSample( w_array, [7] )
    dataset._convertToOneOfMany( )
    return dataset

# 需要导入模块: from pybrain.datasets import ClassificationDataSet [as 别名]
# 或者: from pybrain.datasets.ClassificationDataSet import _convertToOneOfMany [as 别名]
def get_ds_for_pybrain(X,y):
	ds = ClassificationDataSet(2127,nb_classes=5)
	tuples_X = [tuple(map(float,tuple(x))) for x in X.values]
	tuples_y = [tuple(map(float,(y,))) for y in y.values]
	for X,y in zip(tuples_X,tuples_y):
		ds.addSample(X,y)
	ds._convertToOneOfMany()
	return ds

# 需要导入模块: from pybrain.datasets import ClassificationDataSet [as 别名]
# 或者: from pybrain.datasets.ClassificationDataSet import _convertToOneOfMany [as 别名]
    def __init__(self, data, targets, cv_data, cv_targets, extra, layers, epochs=1, smoothing=1, new=True, filename_in=False):
        
        if len(cv_data) != len(cv_targets): raise Exception("Number of CV data and CV targets must be equal")
        if len(data) != len(targets): raise Exception("Number of data and targets must be equal")

        if new:
            class_tr_targets = [str(int(t[0]) - 1) for t in targets] # for pybrain's classification datset
            print "...training the DNNRegressor"
            if len(layers) > 2: # TODO testing only
                net = DNNRegressor(data, extra, class_tr_targets, layers, hidden_layer="TanhLayer", final_layer="SoftmaxLayer", compression_epochs=epochs, bias=True, autoencoding_only=False)
                print "...running net.fit()"
                net = net.fit()
            elif len(layers) == 2:
                net = buildNetwork(layers[0], layers[-1], outclass=SoftmaxLayer, bias=True)

            ds = ClassificationDataSet(len(data[0]), 1, nb_classes=9)
            bag = 1
            noisy, _ = self.dropout(data, noise=0.0, bag=bag, debug=True)
            bagged_targets = []
            for t in class_tr_targets:
                for b in range(bag):
                    bagged_targets.append(t)
            for i,d in enumerate(noisy):
                t = bagged_targets[i]
                ds.addSample(d, t)
            ds._convertToOneOfMany()

            print "...smoothing for epochs: ", smoothing
            self.model = net
            preds = [self.predict(d) for d in cv_data]
            cv = score(preds, cv_targets, debug=False)
            preds = [self.predict(d) for d in data]
            tr = score(preds, targets, debug=False)
            trainer = BackpropTrainer(net, ds, verbose=True, learningrate=0.0008, momentum=0.04, weightdecay=0.05) # best score 0.398 after 50 compression epochs and 200 epochs with lr=0.0008, weightdecay=0.05, momentum=0.04. Used dropout of 0.2 in compression, 0.5 in softmax pretraining, and no dropout in smoothing.
            print "Train score before training: ", tr
            print "CV score before training: ", cv
            for i in range(smoothing):
                trainer.train()
                self.model = net
                preds = [self.predict(d) for d in cv_data]
                cv = score(preds, cv_targets, debug=False)
                preds = [self.predict(d) for d in data]
                tr = score(preds, targets, debug=False)
                print "Train/CV score at epoch ", (i+1), ': ', tr, '/', cv
                #if i == 1:
                    #print "...saving the model"
                    #save("data/1000_ex_4_hidden/net_epoch_1.txt", net)
                #elif i == 3:
                    #print "...saving the model"
                    #save("data/1000_ex_4_hidden/net_epoch_3.txt", net)
                #elif i == 5:
                    #print "...saving the model"
                    #save("data/1000_ex_4_hidden/net_epoch_5.txt", net)
            print "...saving the model"
            #save("data/1000_ex_4_hidden/net_epoch_10.txt", net)
        else:
            model = load(filename_in)
            self.model = model

# 需要导入模块: from pybrain.datasets import ClassificationDataSet [as 别名]
# 或者: from pybrain.datasets.ClassificationDataSet import _convertToOneOfMany [as 别名]
def nn_classify():
    # train_X,Y = load_svmlight_file('data/train_metrix')
    # rows = pd.read_csv('data/log_test2.csv',index_col=0).sort_index().index.unique()
    # train_X = pd.read_csv('data/train_tfidf.csv',index_col=0)
    # test_X = pd.read_csv('data/test_tfidf.csv',index_col=0)
    # select = SelectPercentile(f_classif, percentile=50)
    # select.fit(train_X,Y)
    # train_X = select.transform(train_X)
    # test_X = select.transform(test_X)
    # print 'dump train...'
    # dump_svmlight_file(train_X,Y,'data/train_last')
    # test_Y = [0]*(test_X.shape[0])
    # print 'dump test...'
    # dump_svmlight_file(test_X,test_Y,'data/test_last')

    train_X,Y = load_svmlight_file('data/train_last')
    test_X,test_Y = load_svmlight_file('data/test_last')
    train_X = train_X.toarray()
    test_X = test_X.toarray()
    Y = [int(y)-1 for y in Y]
    print 'Y:',len(Y)
    rows = pd.read_csv('data/log_test2.csv',index_col=0).sort_index().index.unique()
    train_n = train_X.shape[0]
    m = train_X.shape[1]
    test_n = test_X.shape[0]
    print train_n,m,#test_n
    train_data = ClassificationDataSet(m,1,nb_classes=12)
    test_data = ClassificationDataSet(m,1,nb_classes=12)
    # test_data = ClassificationDataSet(test_n,m,nb_classes=12)
    for i in range(train_n):
        train_data.addSample(np.ravel(train_X[i]),Y[i])
    for i in range(test_n):
        test_data.addSample(test_X[i],Y[i])
    trndata = train_data
    # tstdata = train_data

    trndata._convertToOneOfMany()
    # tstdata._convertToOneOfMany()
    test_data._convertToOneOfMany()

     # 先用训练集训练出所有的分类器
    print 'train classify...'
    fnn = buildNetwork( trndata.indim, 400 , trndata.outdim, outclass=SoftmaxLayer )
    trainer = BackpropTrainer( fnn, dataset=trndata, momentum=0.1, learningrate=0.01 , verbose=True, weightdecay=0.01)
    trainer.trainEpochs(3)
    # print 'Percent Error on Test dataset: ' , percentError( trainer.testOnClassData (
    #            dataset=tstdata )
    #            , )
    print 'end train classify'
    pre_y = trainer.testOnClassData(dataset=trndata)
    print metrics.classification_report(Y,pre_y)
    pre_y = trainer.testOnClassData(dataset=test_data)
    print 'write result...'
    print 'before:',pre_y[:100]
    pre_y = [int(y)+1 for y in pre_y]
    print 'after:',pre_y[:100]
    DataFrame(pre_y,index=rows).to_csv('data/info_test2.csv', header=False)
    print 'end...'

# 需要导入模块: from pybrain.datasets import ClassificationDataSet [as 别名]
# 或者: from pybrain.datasets.ClassificationDataSet import _convertToOneOfMany [as 别名]
def main():
    random.seed(50)
    data, digit = read_data(DATAFILE)
    
#     ds = ClassificationDataSet(64, 1, nb_classes=10)
#     
#     
#     for i in xrange(len(data)):
#         ds.addSample(data[i], [digit[i]])
#     ds._convertToOneOfMany()
#     
#     simple_network(data, digit, ds)
#     one_hidden_layer(data, digit, ds)
    n_folds = 5
    perms = np.array_split(np.arange(len(data)), n_folds)
    simple_results = []
    one_hl_results = []
    creative_results = []
    for i in xrange(n_folds):
        train_ds = ClassificationDataSet(64, 1, nb_classes = 10)
        test_ds = ClassificationDataSet(64, 1, nb_classes = 10)
        
        train_perms_idxs = range(n_folds)
        train_perms_idxs.pop(i)
        temp_list = []
        for train_perms_idx in train_perms_idxs:
            temp_list.append(perms[ train_perms_idx ])
        train_idxs = np.concatenate(temp_list)
        
        for idx in train_idxs:
            train_ds.addSample(data[idx], [digit[idx]])
        train_ds._convertToOneOfMany()

        # determine test indices
        test_idxs = perms[i]
        for idx in test_idxs:
            test_ds.addSample(data[idx], [digit[idx]])
        test_ds._convertToOneOfMany()
        
        simple_results.append(simple_network(data, digit, train_ds, test_ds))
        one_hl_results.append(one_hidden_layer(data, digit, train_ds, test_ds))
        creative_results.append(creative_network(data, digit, train_ds, test_ds))
        
    for i in xrange(len(simple_results)):
        print 'Simple %f : Hidden %f : Creative %f' % (simple_results[i],
                                                    one_hl_results[i],
                                                    creative_results[i])
    print 'Simple mean: %f' % np.mean(simple_results)
    print 'One hidden layer mean: %f' % np.mean(one_hl_results)
    print 'Creative mean : %f' % np.mean(creative_results)
    
     
    print "Simple vs onehl"
    paired_t_test(simple_results, one_hl_results)
    print "simple vs creative"
    paired_t_test(simple_results, creative_results)
    print "onehl vs creative"
    paired_t_test(one_hl_results, creative_results)

# 需要导入模块: from pybrain.datasets import ClassificationDataSet [as 别名]
# 或者: from pybrain.datasets.ClassificationDataSet import _convertToOneOfMany [as 别名]
 def createDataset(self, inputData):
     data = ClassificationDataSet(100,nb_classes=len(inputData.keys()), class_labels=inputData.keys())
     allTheLetters = string.uppercase
     for i in range(300):
         for letter in inputData.keys():
             data.addSample(inputData[letter], allTheLetters.index(letter)) 
     
     data._convertToOneOfMany([0,1])
     return data