def generate_and_test_nn():
d = load_training_set()
n = buildNetwork(d.indim, 13, d.outdim, hiddenclass=LSTMLayer, outclass=SoftmaxLayer, outputbias=False, recurrent=True)
t = BackpropTrainer(n, learningrate=0.01, momentum=0.99, verbose=True)
t.trainOnDataset(d, 1000)
t.testOnData(verbose=True)
return (n, d)
def testOldTraining(hidden=15, n=None):
d = XORDataSet()
if n is None:
n = buildNetwork(d.indim, hidden, d.outdim, recurrent=False)
t = BackpropTrainer(n, learningrate=0.01, momentum=0., verbose=False)
t.trainOnDataset(d, 250)
t.testOnData(verbose=True)
def initializeNetwork(self):
can1 = NNTrainData.NNTrainData(cv2.imread('NNTrain/can1.png'), self.encodingDict["can"])
can2 = NNTrainData.NNTrainData(cv2.imread('NNTrain/can2.png'), self.encodingDict["can"])
can3 = NNTrainData.NNTrainData(cv2.imread('NNTrain/can3.png'), self.encodingDict["can"])
stain1 = NNTrainData.NNTrainData(cv2.imread('NNTrain/stain1.png'), self.encodingDict["stain"])
stain2 = NNTrainData.NNTrainData(cv2.imread('NNTrain/stain2.png'), self.encodingDict["stain"])
stain3 = NNTrainData.NNTrainData(cv2.imread('NNTrain/stain3.png'), self.encodingDict["stain"])
dirt1 = NNTrainData.NNTrainData(cv2.imread('NNTrain/dirt1.png'), self.encodingDict["dirt"])
dirt2 = NNTrainData.NNTrainData(cv2.imread('NNTrain/dirt2.png'), self.encodingDict["dirt"])
dirt3 = NNTrainData.NNTrainData(cv2.imread('NNTrain/dirt3.png'), self.encodingDict["dirt"])
self.trainData.append(can1)
self.trainData.append(can2)
self.trainData.append(can3)
self.trainData.append(stain1)
self.trainData.append(stain2)
self.trainData.append(stain3)
self.trainData.append(dirt1)
self.trainData.append(dirt2)
self.trainData.append(dirt3)
for x in self.trainData:
x.prepareTrainData()
self.net = buildNetwork(4, 3, 3, hiddenclass=TanhLayer, outclass=SoftmaxLayer)
ds = SupervisedDataSet(4, 3)
for x in self.trainData:
ds.addSample((x.contours/100.0, x.color[0]/1000.0, x.color[1]/1000.0, x.color[2]/1000.0), x.output)
trainer = BackpropTrainer(self.net, momentum=0.1, verbose=True, weightdecay=0.01)
trainer.trainOnDataset(ds, 1000)
trainer.testOnData(verbose=True)
print "\nSiec nauczona\n"
def trainedANN():
n = FeedForwardNetwork()
n.addInputModule(LinearLayer(4, name='in'))
n.addModule(SigmoidLayer(6, name='hidden'))
n.addOutputModule(LinearLayer(2, name='out'))
n.addConnection(FullConnection(n['in'], n['hidden'], name='c1'))
n.addConnection(FullConnection(n['hidden'], n['out'], name='c2'))
n.sortModules()
draw_connections(n)
# d = generateTrainingData()
d = getDatasetFromFile(root.path()+"/res/dataSet")
t = BackpropTrainer(n, d, learningrate=0.001, momentum=0.75)
t.trainOnDataset(d)
# FIXME: I'm not sure the recurrent ANN is going to converge
# so just training for fixed number of epochs
count = 0
while True:
globErr = t.train()
print globErr
if globErr < 0.01:
break
count += 1
if count == 20:
return trainedANN()
exportANN(n)
draw_connections(n)
return n
def trainedRNN():
n = RecurrentNetwork()
n.addInputModule(LinearLayer(4, name='in'))
n.addModule(SigmoidLayer(6, name='hidden'))
n.addOutputModule(LinearLayer(2, name='out'))
n.addConnection(FullConnection(n['in'], n['hidden'], name='c1'))
n.addConnection(FullConnection(n['hidden'], n['out'], name='c2'))
n.addRecurrentConnection(NMConnection(n['out'], n['out'], name='nmc'))
# n.addRecurrentConnection(FullConnection(n['out'], n['hidden'], inSliceFrom = 0, inSliceTo = 1, outSliceFrom = 0, outSliceTo = 3))
n.sortModules()
draw_connections(n)
d = getDatasetFromFile(root.path() + "/res/dataSet")
t = BackpropTrainer(n, d, learningrate=0.001, momentum=0.75)
t.trainOnDataset(d)
count = 0
while True:
globErr = t.train()
print globErr
if globErr < 0.01:
break
count += 1
if count == 50:
return trainedRNN()
# exportRNN(n)
draw_connections(n)
return n
def testOldTraining(hidden=15, n=None):
d = XORDataSet()
if n is None:
n = buildNetwork(d.indim, hidden, d.outdim, recurrent=False)
t = BackpropTrainer(n, learningrate=0.01, momentum=0., verbose=False)
t.trainOnDataset(d, 250)
t.testOnData(verbose=True)
def trainedRNN():
n = RecurrentNetwork()
n.addInputModule(LinearLayer(4, name='in'))
n.addModule(SigmoidLayer(6, name='hidden'))
n.addOutputModule(LinearLayer(2, name='out'))
n.addConnection(FullConnection(n['in'], n['hidden'], name='c1'))
n.addConnection(FullConnection(n['hidden'], n['out'], name='c2'))
n.addRecurrentConnection(NMConnection(n['out'], n['out'], name='nmc'))
# n.addRecurrentConnection(FullConnection(n['out'], n['hidden'], inSliceFrom = 0, inSliceTo = 1, outSliceFrom = 0, outSliceTo = 3))
n.sortModules()
draw_connections(n)
d = getDatasetFromFile(root.path()+"/res/dataSet")
t = BackpropTrainer(n, d, learningrate=0.001, momentum=0.75)
t.trainOnDataset(d)
count = 0
while True:
globErr = t.train()
print globErr
if globErr < 0.01:
break
count += 1
if count == 50:
return trainedRNN()
# exportRNN(n)
draw_connections(n)
return n
def trainedANN():
n = FeedForwardNetwork()
n.addInputModule(LinearLayer(4, name='in'))
n.addModule(SigmoidLayer(6, name='hidden'))
n.addOutputModule(LinearLayer(2, name='out'))
n.addConnection(FullConnection(n['in'], n['hidden'], name='c1'))
n.addConnection(FullConnection(n['hidden'], n['out'], name='c2'))
n.sortModules()
draw_connections(n)
# d = generateTrainingData()
d = getDatasetFromFile(root.path() + "/res/dataSet")
t = BackpropTrainer(n, d, learningrate=0.001, momentum=0.75)
t.trainOnDataset(d)
# FIXME: I'm not sure the recurrent ANN is going to converge
# so just training for fixed number of epochs
count = 0
while True:
globErr = t.train()
print globErr
if globErr < 0.01:
break
count += 1
if count == 20:
return trainedANN()
exportANN(n)
draw_connections(n)
return n
def main():
print '----- loading train/test datasets -----'
train_ds, test_ds = create_datasets()
print '----- building the network -----'
net = ann_network()
trainer = BackpropTrainer(net, learningrate=0.1, momentum=0.1, verbose=True)
print '----- training the model -----'
trainer.trainOnDataset(train_ds)
def execute(self):
network = self.networkFactoryMethod()
trainer = BackpropTrainer(network, learningrate = self.learningrate, momentum = self.momentum)
trainer.trainOnDataset(self.datasetForTraining, self.epochs)
averageError = trainer.testOnData(self.datasetForTest)
self.collectedErrors.append(averageError)
return averageError
def testTraining():
d = PrimesDataSet()
d._convertToOneOfMany()
n = buildNetwork(d.indim, 8, d.outdim, recurrent=True)
t = BackpropTrainer(n, learningrate = 0.01, momentum = 0.99, verbose = True)
t.trainOnDataset(d, 1000)
t.testOnData(verbose=True)
for i in range(15):
print "Guess: %s || Real: %s" % (str(n.activate(i)), str(i in d.generatePrimes(10)))
print d
def testTraining():
ds = WebsiteFeaturesDataSet()
net = buildNetwork(ds.indim, 4, ds.outdim, recurrent=True)
trainer = BackpropTrainer(net,
learningrate=0.001,
momentum=0.99,
verbose=True)
trainer.trainOnDataset(ds, 1000)
trainer.testOnData(verbose=True)
import pdb
pdb.set_trace()
def testTraining():
print "Reading data"
d = XORDataSet()
traind,testd = d.splitWithProportion(0.8)
print "Building network"
n = buildNetwork(traind.indim, 4, traind.outdim, recurrent=True)
print "Training"
t = BackpropTrainer(n, learningrate = 0.01, momentum = 0.99, verbose = True)
t.trainOnDataset(traind,100)
testd = XORDataSet(begin=60000,end=80000)
print t.module.params
t.testOnData(testd,verbose= True)
def generate_and_test_nn():
d = load_training_set()
n = buildNetwork(d.indim,
13,
d.outdim,
hiddenclass=LSTMLayer,
outclass=SoftmaxLayer,
outputbias=False,
recurrent=True)
t = BackpropTrainer(n, learningrate=0.01, momentum=0.99, verbose=True)
t.trainOnDataset(d, 1000)
t.testOnData(verbose=True)
return (n, d)
def __init__(self, stock_to_predict, days_of_prediction = 10, days_of_training = 450):
self.number_of_days_before = 8
self.days_of_prediction = days_of_prediction
self.downloader = StockDownloader()
stock_training_data = self.downloader.download_stock(stock_to_predict, days_of_training, days_of_prediction)
self.stock_prediction_data = self.downloader.download_stock(stock_to_predict, days_of_prediction)
self.starting_price = self.stock_prediction_data[0]
self.dataset = StockSupervisedDataSet(self.number_of_days_before, stock_training_data)
self.network = buildNetwork(self.dataset.indim, 10, self.dataset.outdim, recurrent=True)
t = BackpropTrainer(self.network, learningrate = 0.00005, momentum=0., verbose = True)
t.trainOnDataset(self.dataset, 200)
t.testOnData(verbose= True)
self.starting_prices = self.dataset['input'][-1]
def __init__(self):
self.code = {
'cat': [1, 0, 0],
'dust': [0, 1, 0],
'water': [0, 0, 1]
}
pack = 'media.images_train'
train_data = [
(Neuron(load(file_path(pack, 'cat1.png'))), self.code['cat']),
(Neuron(load(file_path(pack, 'cat2.png'))), self.code['cat']),
(Neuron(load(file_path(pack, 'cat3.png'))), self.code['cat']),
(Neuron(load(file_path(pack, 'dust1.png'))), self.code['dust']),
(Neuron(load(file_path(pack, 'dust2.png'))), self.code['dust']),
(Neuron(load(file_path(pack, 'dust3.png'))), self.code['dust']),
(Neuron(load(file_path(pack, 'water1.png'))), self.code['water']),
(Neuron(load(file_path(pack, 'water2.png'))), self.code['water']),
(Neuron(load(file_path(pack, 'water3.png'))), self.code['water']),
]
for x, output in train_data:
x.prepare()
self.net = buildNetwork(
4, 3, 3, hiddenclass=TanhLayer, outclass=SoftmaxLayer
)
data = SupervisedDataSet(4, 3)
for x, output in train_data:
data.addSample(
(
x.contours / 100.0, x.color[0] / 1000.0,
x.color[1] / 1000.0, x.color[2] / 1000.0,
),
output
)
trainer = BackpropTrainer(
self.net, momentum=0.1, verbose=True, weightdecay=0.01
)
trainer.trainOnDataset(data, 1000) # 1000 iterations
trainer.testOnData(verbose=True)
def testTraining():
# the AnBnCn dataset (sequential)
d = AnBnCnDataSet()
# build a recurrent network to be trained
hsize = 2
n = RecurrentNetwork()
n.addModule(TanhLayer(hsize, name = 'h'))
n.addModule(BiasUnit(name = 'bias'))
n.addOutputModule(LinearLayer(1, name = 'out'))
n.addConnection(FullConnection(n['bias'], n['h']))
n.addConnection(FullConnection(n['h'], n['out']))
n.addRecurrentConnection(FullConnection(n['h'], n['h']))
n.sortModules()
# initialize the backprop trainer and train
t = BackpropTrainer(n, learningrate = 0.1, momentum = 0.0, verbose = True)
t.trainOnDataset(d, 200)
# the resulting weights are in the network:
print 'Final weights:', n.params
def testTraining():
# the AnBnCn dataset (sequential)
d = AnBnCnDataSet()
# build a recurrent network to be trained
hsize = 2
n = RecurrentNetwork()
n.addModule(TanhLayer(hsize, name='h'))
n.addModule(BiasUnit(name='bias'))
n.addOutputModule(LinearLayer(1, name='out'))
n.addConnection(FullConnection(n['bias'], n['h']))
n.addConnection(FullConnection(n['h'], n['out']))
n.addRecurrentConnection(FullConnection(n['h'], n['h']))
n.sortModules()
# initialize the backprop trainer and train
t = BackpropTrainer(n, learningrate=0.1, momentum=0.0, verbose=True)
t.trainOnDataset(d, 200)
# the resulting weights are in the network:
print('Final weights:', n.params)
def __init__(self):
self.code = {'cat': [1, 0, 0], 'dust': [0, 1, 0], 'water': [0, 0, 1]}
pack = 'media.images_train'
train_data = [
(Neuron(load(file_path(pack, 'cat1.png'))), self.code['cat']),
(Neuron(load(file_path(pack, 'cat2.png'))), self.code['cat']),
(Neuron(load(file_path(pack, 'cat3.png'))), self.code['cat']),
(Neuron(load(file_path(pack, 'dust1.png'))), self.code['dust']),
(Neuron(load(file_path(pack, 'dust2.png'))), self.code['dust']),
(Neuron(load(file_path(pack, 'dust3.png'))), self.code['dust']),
(Neuron(load(file_path(pack, 'water1.png'))), self.code['water']),
(Neuron(load(file_path(pack, 'water2.png'))), self.code['water']),
(Neuron(load(file_path(pack, 'water3.png'))), self.code['water']),
]
for x, output in train_data:
x.prepare()
self.net = buildNetwork(4,
3,
3,
hiddenclass=TanhLayer,
outclass=SoftmaxLayer)
data = SupervisedDataSet(4, 3)
for x, output in train_data:
data.addSample((
x.contours / 100.0,
x.color[0] / 1000.0,
x.color[1] / 1000.0,
x.color[2] / 1000.0,
), output)
trainer = BackpropTrainer(self.net,
momentum=0.1,
verbose=True,
weightdecay=0.01)
trainer.trainOnDataset(data, 1000) # 1000 iterations
trainer.testOnData(verbose=True)
cpi.append(data[1])
# third feature is unemployment
une.append(data[2])
fund.append(data[3])
indata = tuple(data[:features])
outdata = tuple(data[features:])
ds.addSample(indata,outdata)
# this builds a network that has the number of features as input,
# a *SINGLE* defined hidden layer and a single output neuron.
n = buildNetwork(ds.indim,hidden,hidden,ds.outdim)
t = BackpropTrainer(n,learningrate=0.01,momentum=0.8,verbose=True)
t.trainOnDataset(ds,steps)
t.testOnData(verbose=True)
# let's plot what we have
import matplotlib.pyplot as plt
# lets ask for a prediction: GDP,CPI, Unemployment
#print n.activate([.02,.02,-.002])
x = []
y = []
#print range(len(time))
for i in range(len(time)):
#print n.activate([gdp(i),cpi(i),une(i)])
x.append(.25*time[i]+1954.5)
y.append(n.activate([gdp[i],cpi[i],une[i]]))
((0.1, 0.8), 1.0),
((0.3, 1.0), 1.0),
((1.0, 0.6), 0.0),
((0.7, 0.6), 0.0),
((0.7, 0.1), 1.0),
)
testData = (
((0.8, 0.0), 1.0),
((0.9, 0.7), 0.0),
((0.1, 0.1), 0.0),
((0.2, 0.8), 1.0),
((0.6, 0.6), 0.0),
((0.6, 1.0), 0.0),
((1.0, 0.3), 1.0),
((0.1, 0.1), 0.0),
)
datasetForTraining = SupervisedDataSet(ENTRY_DIMENSION, RESULT_DIMENSION)
for entry, expectedResult in trainingData:
datasetForTraining.addSample(entry, [expectedResult])
datasetForTest = SupervisedDataSet(ENTRY_DIMENSION, RESULT_DIMENSION)
for entry, expectedResult in testData:
datasetForTest.addSample(entry, [expectedResult])
HIDDEN_LAYER_DIMENSION = 4
network = buildNetwork(ENTRY_DIMENSION, HIDDEN_LAYER_DIMENSION, RESULT_DIMENSION, recurrent=True)
trainer = BackpropTrainer(network, learningrate=0.01, momentum=0.99, verbose=True)
trainer.trainOnDataset(datasetForTraining, 1)
trainer.testOnData(datasetForTest, verbose=True)
trainIn = []
for x in row[:numberOfInputs]:
trainIn.append(x)
trainOut = []
for x in row[numberOfInputs:]:
trainOut.append(x)
d.appendLinked(trainIn, trainOut)
# build a neural network with the second parameter being the number of hidden layers
n = buildNetwork(d.indim, 3, d.outdim, recurrent=True)
# configure the trainer
t = BackpropTrainer(n, learningrate=0.01, momentum=0.99, verbose=True)
# split the data randomly into 75% training - 25% testing
train, test = d.splitWithProportion(0.75)
print "{} - {}".format(len(train), len(test))
# train the data with n number of epochs
t.trainOnDataset(train, 10)
# test the data with the remaining data
t.testOnData(test, verbose=True)
# try the same test but with a different method
net = buildNetwork(d.indim, 3, d.outdim, bias=True, hiddenclass=TanhLayer)
trainer = BackpropTrainer(net, d)
trainer.trainUntilConvergence(verbose=True)
def testTraining():
d = SequentialXORDataSet()
n = buildNetwork(d.indim, 4, d.outdim, recurrent=True)
t = BackpropTrainer(n, learningrate=0.01, momentum=0.99, verbose=True)
t.trainOnDataset(d, 1000)
t.testOnData(verbose=True)
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised import BackpropTrainer
from pybrain.datasets import SupervisedDataSet, ImportanceDataSet
class SequentialXORDataSet(ImportanceDataSet):
""" same thing, but sequential, and having no importance on a second output"""
def __init__(self):
ImportanceDataSet.__init__(self, 2, 2)
self.addSample([0,0],[0, 1], [1,0])
self.addSample([0,1],[1, 10], [1,0])
self.addSample([1,0],[1, -1], [1,0])
self.addSample([1,1],[0, 0], [1,0])
d = SequentialXORDataSet()
n = buildNetwork(d.indim, 4, d.outdim, recurrent=True)
t = BackpropTrainer(n, learningrate = 0.01, momentum = 0.99, verbose = True)
t.trainOnDataset(d, 1000)
t.testOnData(verbose= True)
class Classifier:
def __init__(self,Xtrain,Ytrain):
self._Xtrain=Xtrain
self._Ytrain=Ytrain
self.features=Xtrain.keys()
def Train(self,feat_list=None,type='logreg',gamma=0.0,domeanstd=True,special_bias=None,add_bias=True, weight=None, class_instance=None, method='sigmoid',factor=10.0,arch=[10],
cv_feats=None, cv_special_bias=None,cv_class_instance=None):
if feat_list==None:
feat_list=self.features
self.feat_list=feat_list
self._gamma=gamma
self._type=type
self._special_bias = special_bias
self._add_bias = add_bias
Xtrain_feats = np.ascontiguousarray(np.hstack((self._Xtrain[feat] for feat in feat_list)))
self.m, self.std = classifier.feature_meanstd(Xtrain_feats)
if domeanstd==False: #hacky, overwrite the things we computed
self.m[:] = 0
self.std[:] = 1
Xtrain_feats -= self.m
Xtrain_feats /= self.std
if special_bias != None:
Xtrain_feats = np.ascontiguousarray(np.hstack((Xtrain_feats, special_bias)))
#CV
if cv_feats!=None:
cv_feats = np.ascontiguousarray(np.hstack((cv_feats[feat] for feat in feat_list)))
cv_feats -= self.m
cv_feats /= self.std
if special_bias != None:
cv_feats = np.ascontiguousarray(np.hstack((cv_feats, cv_special_bias)))
'''Classifier stage'''
if type=='linsvm':
self.w, self.b = classifier.svm_onevsall(Xtrain_feats, self._Ytrain, self._gamma, weight = weight, special_bias=special_bias, add_bias=add_bias)
return (self.w,self.b)
elif type=='logreg':
self.w, self.b = l2logreg_onevsall(Xtrain_feats, self._Ytrain, self._gamma, weight = weight, special_bias=special_bias, add_bias=add_bias)
return (self.w,self.b)
elif type=='logreg_atwv':
self.w, self.b = Train_atwv(Xtrain_feats,class_instance=class_instance,weight=weight,special_bias=special_bias, add_bias=add_bias, method=method,
factor=factor, gamma=self._gamma, cv_class_instance=cv_class_instance, cv_feats=cv_feats)
elif type=='nn_atwv':
self._arch = arch
self._weights_nn = Train_atwv_nn(Xtrain_feats,class_instance=class_instance,weight=weight,special_bias=special_bias, add_bias=add_bias,
arch=self._arch, method=method, factor=factor, gamma=self._gamma, cv_class_instance=cv_class_instance, cv_feats=cv_feats)
#self._weights_nn = Train_atwv_nn(Xtrain_feats,class_instance=class_instance,weight=self._weights_nn,special_bias=special_bias, add_bias=add_bias,
# arch=self._arch, method=method, factor=factor*10.0)
elif type=='nn_debug':
if mpi.COMM.Get_size() > 1:
print 'Warning!!! Running NN training with MPI with more than one Node!'
#FIXME: Collect X and Y at root to avoid this
# prob = mpi.COMM.gather(prob)
# if mpi.is_root():
# np.vstack(prob)
# #Train
# mpi.COMM.Bcast(self._nn)
# mpi.distribute(prob)
DS = ClassificationDataSet( Xtrain_feats.shape[1], 1, nb_classes=2 )
#for i in range(Xtrain_feats.shape[0]):
# DS.addSample( Xtrain_feats[i,:], [self._Ytrain[i]] )
DS.setField('input', Xtrain_feats)
DS.setField('target', self._Ytrain[:,np.newaxis])
DS._convertToOneOfMany()
self._nn = buildNetwork(DS.indim, 10, DS.outdim, outclass=SoftmaxLayer, fast=True)
self._nn_trainer = BackpropTrainer( self._nn, dataset=DS, momentum=0.1, verbose=True, weightdecay=gamma, learningrate=0.01, lrdecay=1.0)
self._nn_trainer.trainOnDataset(DS,epochs=8)
self._nn_trainer = BackpropTrainer( self._nn, dataset=DS, momentum=0.1, verbose=True, weightdecay=gamma, learningrate=0.001, lrdecay=1.0)
self._nn_trainer.trainOnDataset(DS,epochs=8)
self._nn_trainer = BackpropTrainer( self._nn, dataset=DS, momentum=0.1, verbose=True, weightdecay=gamma, learningrate=0.0001, lrdecay=1.0)
self._nn_trainer.trainOnDataset(DS,epochs=5)
return self._nn
def Accuracy(self, X, Y, special_bias = None):
X_feats = np.ascontiguousarray(np.hstack((X[self.feat_list[i]] for i in range(len(self.feat_list)))))
X_feats -= self.m
X_feats /= self.std
if special_bias != None:
X_feats = np.ascontiguousarray(np.hstack((X_feats, special_bias)))
if self._type=='linsvm' or self._type=='logreg' or self._type=='logreg_atwv':
self.test_accu = classifier.Evaluator.accuracy(Y, np.dot(X_feats,self.w)+self.b)
elif self._type=='nn_atwv':
pred = get_predictions_nn(X_feats, self._weights_nn, arch=[10])[0]
pred[:,0] = 0.5
self.test_accu = classifier.Evaluator.accuracy(Y, pred)
else:
DS = ClassificationDataSet( X_feats.shape[1], 1, nb_classes=2 )
#for i in range(X_feats.shape[0]):
# DS.addSample( X_feats[i,:], [Y[i]] )
DS.setField('input', X_feats)
DS.setField('target', Y[:,np.newaxis])
DS._convertToOneOfMany()
predict,targts = self._nn_trainer.testOnClassData(DS, verbose=True,return_targets=True)
self.test_accu = np.sum(np.array(predict)==np.array(targts))/float(len(targts))
return self.test_accu
def loss_multiclass_logreg(self, X, Y, special_bias=None):
X_feats=np.hstack((X[self.feat_list[i]] for i in range(len(self.feat_list))))
X_feats -= self.m
X_feats /= self.std
if special_bias != None:
X_feats = np.ascontiguousarray(np.hstack((X_feats, special_bias)))
return loss_multiclass_logreg(Y, X_feats, (self.w,self.b))
def loss_multiclass_nn(self, X, Y, special_bias=None):
X_feats = np.ascontiguousarray(np.hstack((X[self.feat_list[i]] for i in range(len(self.feat_list)))))
X_feats -= self.m
X_feats /= self.std
if special_bias != None:
X_feats = np.ascontiguousarray(np.hstack((X_feats, special_bias)))
return loss_multiclass_nn(X_feats, Y, self._weights_nn, self._arch)
def get_predictions_logreg(self, X, special_bias=None):
X_feats=np.hstack((X[self.feat_list[i]] for i in range(len(self.feat_list))))
X_feats -= self.m
X_feats /= self.std
if special_bias != None:
X_feats = np.ascontiguousarray(np.hstack((X_feats, special_bias)))
return get_predictions_logreg(X_feats, (self.w,self.b))
def get_predictions_nn_old(self, X, special_bias=None):
X_feats = np.ascontiguousarray(np.hstack((X[self.feat_list[i]] for i in range(len(self.feat_list)))))
X_feats -= self.m
X_feats /= self.std
if special_bias != None:
X_feats = np.ascontiguousarray(np.hstack((X_feats, special_bias)))
DS = ClassificationDataSet( X_feats.shape[1], 1, nb_classes=2 )
#for i in range(X_feats.shape[0]):
# DS.addSample( X_feats[i,:], [0.0] )
DS.setField('input', X_feats)
DS.setField('target', np.zeros((X_feats.shape[0],1)))
DS._convertToOneOfMany()
prob = self._nn.activateOnDataset(DS)
prob = mpi.COMM.gather(prob)
if mpi.is_root():
return np.vstack(prob)
else:
return np.zeros((0))
def get_predictions_nn(self, X, special_bias=None):
X_feats = np.ascontiguousarray(np.hstack((X[self.feat_list[i]] for i in range(len(self.feat_list)))))
X_feats -= self.m
X_feats /= self.std
if special_bias != None:
X_feats = np.ascontiguousarray(np.hstack((X_feats, special_bias)))
prob = get_predictions_nn(X_feats, self._weights_nn, self._arch)[0]
prob = mpi.COMM.gather(prob)
if mpi.is_root():
return np.vstack(prob)
else:
return np.zeros((0))
