def fit(self, X, y):
"""
Train the regressor model.
:param X: pandas.DataFrame of shape [n_samples, n_features]
:param y: values - array-like of shape [n_samples]
:return: self
"""
dataset = self._prepare_net_and_dataset(X, y, 'regression')
trainer = BackpropTrainer(self.net,
dataset,
learningrate=self.learningrate,
lrdecay=self.lrdecay,
momentum=self.momentum,
verbose=self.verbose,
batchlearning=self.batchlearning,
weightdecay=self.weightdecay)
if self.epochs < 0:
trainer.trainUntilConvergence(maxEpochs=self.max_epochs,
continueEpochs=self.continue_epochs,
verbose=self.verbose,
validationProportion=self.validation_proportion)
else:
for i in range(self.epochs):
trainer.train()
self.__fitted = True
return self
def main():
inputs = ReadCSV('./data/input.csv')
outputs = ReadCSV('./data/output.csv')
test_set = test.keys()
train_set = []
for k in inputs.keys():
if k not in test_set:
train_set.append(k)
print "Number of training samples", len(train_set)
print "Number of testing samples", len(test_set)
net = buildNetwork(178, 6, 5)
ds=SupervisedDataSet(178,5)
for id in train_set:
ds.addSample(inputs[id],outputs[id])
trainer = BackpropTrainer(net, ds, learningrate=0.001, momentum = 0.001)
trainer.trainUntilConvergence(maxEpochs=1000, validationProportion = 0.5)
for id in test_set:
predicted = net.activate(inputs[id])
actual = outputs[id]
print '-----------------------------'
print test[id]
print '-----------------------------'
print 'Trait\t\tPredicted\tActual\tError'
for i in range(0,5):
error = abs(predicted[i] - actual[i])*100/4.0
print traits[i], '\t', predicted[i], '\t', actual[i], '\t', error,"%"
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 main():
a = 0
for i in range(0,100):
inLayer = SigmoidLayer(2)
hiddenLayer = SigmoidLayer(3)
outLayer = SigmoidLayer(1)
net = FeedForwardNetwork()
net.addInputModule(inLayer)
net.addModule(hiddenLayer)
net.addOutputModule(outLayer)
in_to_hidden = FullConnection(inLayer,hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer,outLayer)
net.addConnection(in_to_hidden)
net.addConnection(hidden_to_out)
net.sortModules()
ds = SupervisedDataSet(2,1)
ds.addSample((1,1), (0))
ds.addSample((1,0), (1))
ds.addSample((0,1), (1))
ds.addSample((0,0), (0))
trainer = BackpropTrainer(net,ds)
trainer.trainUntilConvergence()
out = net.activate((1,1))
if (out < 0.5):
a = a + 1
print(str(a) + "/100")
def training_nerual_network(self):
dataTrain,dataTest = self.DS.splitWithProportion(0.7)
xTrain, yTrain = dataTrain['input'], dataTrain['target']
xTest, yTest = dataTest['input'], dataTest['target']
trainer = BackpropTrainer(self.fnn, dataTrain,verbose = True, learningrate=0.03, momentum=0.1)
trainer.trainUntilConvergence(maxEpochs=20)
output = self.fnn.activateOnDataset(dataTest)
count = 0
countRight = 0
error = 0
for i in range(len(output)):
posReal = yTest[i].argmax()
posPredict = output[i].argmax()
#print('o',output[i],posPredict)
#print('r',yTest[i],posReal)
error += abs(posReal-posPredict)
if posReal == posPredict:
countRight+=1
count +=1
error/=count
print('Correct rate:{:.2f} Average error:{:.2f}'.format(countRight/count,error))
def neuralNetwork_eval_func(self, chromosome):
node_num, learning_rate, window_size = self.decode_chromosome(chromosome)
if self.check_log(node_num, learning_rate, window_size):
return self.get_means_from_log(node_num, learning_rate, window_size)[0]
folded_dataset = self.create_folded_dataset(window_size)
indim = 21 * (2 * window_size + 1)
mean_AUC = 0
mean_decision_value = 0
mean_mcc = 0
sample_size_over_thousand_flag = False
for test_fold in xrange(self.fold):
test_labels, test_dataset, train_labels, train_dataset = folded_dataset.get_test_and_training_dataset(test_fold)
if len(test_labels) + len(train_labels) > 1000:
sample_size_over_thousand_flag = True
ds = SupervisedDataSet(indim, 1)
for i in xrange(len(train_labels)):
ds.appendLinked(train_dataset[i], [train_labels[i]])
net = buildNetwork(indim, node_num, 1, outclass=SigmoidLayer, bias=True)
trainer = BackpropTrainer(net, ds, learningrate=learning_rate)
trainer.trainUntilConvergence(maxEpochs=self.maxEpochs_for_trainer)
decision_values = [net.activate(test_dataset[i]) for i in xrange(len(test_labels))]
decision_values = map(lambda x: x[0], decision_values)
AUC, decision_value_and_max_mcc = validate_performance.calculate_AUC(decision_values, test_labels)
mean_AUC += AUC
mean_decision_value += decision_value_and_max_mcc[0]
mean_mcc += decision_value_and_max_mcc[1]
if sample_size_over_thousand_flag:
break
if not sample_size_over_thousand_flag:
mean_AUC /= self.fold
mean_decision_value /= self.fold
mean_mcc /= self.fold
self.write_log(node_num, learning_rate, window_size, mean_AUC, mean_decision_value, mean_mcc)
self.add_log(node_num, learning_rate, window_size, mean_AUC, mean_decision_value, mean_mcc)
return mean_AUC
def NeuralNetwork(tRiver, qRiver, pRiver, TRiver, qnewRiver, pnewRiver, TnewRiver):
# build neural network with 20 neurons for historic data on flux, 3 for last 3 temp data, 3 for last precipitation,
# hidden layer with more than input neurons (hinder specification)
# and 3 output neurons (flux for next day, first derivative, second derivative
Ndim = 10+3+3
Nout = 3
net = buildNetwork(Ndim, Ndim, Nout, hiddenclass=TanhLayer)
ds = SupervisedDataSet(Ndim, Nout)
# next big job: find data values to build up library of training set
for t in range(len(tRiver)-3):
input_flow = qRiver[t-20:2:t]
input_prec = pRiver[t-3:t]
input_temp = TRiver[t-3:t]
input_vec = np.hstack([input_flow, input_prec, input_temp])
output_flow = np.hstack([qRiver[t:t+3]]) # first approx, split later for long predictions
ds.addSample(input_vec, output_flow)
trainer = BackpropTrainer(net, ds)
#trainer.train()
trainer.trainUntilConvergence()
# now call it repeatedly on the second set
prediction = net.activate(np.hstack([qnewRiver[:20], pnewRiver[:3], TnewRiver[:3]]))
return prediction
def train(data): """ See http://www.pybrain.org/docs/tutorial/fnn.html Returns a neural network trained on the test data. Parameters: data - A ClassificationDataSet for training. Should not include the test data. """ network = buildNetwork( # This is where we specify the architecture of # the network. We can play around with different # parameters here. # http://www.pybrain.org/docs/api/tools.html data.indim, 5, data.outdim, hiddenclass=SigmoidLayer, outclass=SoftmaxLayer ) # We can fiddle around with this guy's options as well. # http://www.pybrain.org/docs/api/supervised/trainers.html trainer = BackpropTrainer(network, dataset=data) trainer.trainUntilConvergence(maxEpochs=20) return network
def trainNetwork(inData, numOfSamples, numOfPoints, epochs):
# Build the dataset
alldata = createRGBdataSet(inData, numOfSamples, numOfPoints)
# Split into test and training data
trndata, tstdata = splitData(alldata)
# Report stats
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]
# Build and train the network
fnn = buildNetwork( trndata.indim, 256, trndata.outdim, outclass=SoftmaxLayer )
trainer = BackpropTrainer( fnn, dataset=trndata, momentum=0.001, verbose=True, weightdecay=0.001)
#trainer.trainEpochs( epochs )
trainer.trainUntilConvergence(maxEpochs=epochs)
# Report results
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
# Report results of final network
checkNeuralNet(trainer, alldata, numOfSamples)
return fnn
def getModel(inputSize,hiddenSize1,hiddenSize2,trainData,target): fnn = FeedForwardNetwork() inLayer = LinearLayer(inputSize,name = 'inLayer') hiddenLayer0 = SigmoidLayer(hiddenSize1,name='hiddenLayer0') hiddenLayer1 = SigmoidLayer(hiddenSize2,name='hiddenLayer1') outLayer = LinearLayer(1,name = 'outLayer') fnn.addInputModule(inLayer) fnn.addModule(hiddenLayer0) fnn.addModule(hiddenLayer1) fnn.addOutputModule(outLayer) inToHidden0 = FullConnection(inLayer,hiddenLayer0) hidden0ToHidden1 = FullConnection(hiddenLayer0,hiddenLayer1) hidden1ToHiddenOutput = FullConnection(hiddenLayer1,outLayer) fnn.addConnection(inToHidden0) fnn.addConnection(hidden0ToHidden1) fnn.addConnection(hidden1ToHiddenOutput) fnn.sortModules() Ds = SupervisedDataSet(inputSize,1) scaler = preprocessing.StandardScaler().fit(trainData) x = scaler.transform(trainData) # print(len(target)) # print(len(x)) for i in range(len(target)): Ds.addSample(x[i],[target[i]]) trainer = BackpropTrainer(fnn,Ds,learningrate=0.01,verbose=False) trainer.trainUntilConvergence(maxEpochs=1000) return fnn
def createNet(): """Create and seed the intial neural network""" #CONSTANTS nn_input_dim = 6 #[x_enemy1, y_enemy1, x_enemy2, y_enemy2, x_enemy3, y_enemy3] nn_output_dim = 6 #[x_ally1, y_ally1, x_ally2, y_ally2, x_ally3, y_ally3] allyTrainingPos, enemyTrainingPos = runExperiments.makeTrainingDataset() ds = SupervisedDataSet(nn_input_dim, nn_output_dim) #normalizes and adds it to the dataset for i in range(0, len(allyTrainingPos)): x = normalize(enemyTrainingPos[i]) y = normalize(allyTrainingPos[i]) x = [val for pair in x for val in pair] y = [val for pair in y for val in pair] ds.addSample(x, y) for inpt, target in ds: print inpt, target net = buildNetwork(nn_input_dim, 30, nn_output_dim, bias=True, hiddenclass=TanhLayer) trainer = BackpropTrainer(net, ds) trainer.trainUntilConvergence() NetworkWriter.writeToFile(net, "net.xml") enemyTestPos = runExperiments.makeTestDataset() print(net.activate([val for pair in normalize(enemyTestPos) for val in pair])) return ds
def train(self): print "Enter the number of times to train, -1 means train until convergence:" t = int(raw_input()) print "Training the Neural Net" print "self.net.indim = "+str(self.net.indim) print "self.train_data.indim = "+str(self.train_data.indim) trainer = BackpropTrainer(self.net, dataset=self.train_data, momentum=0.1, verbose=True, weightdecay=0.01) if t == -1: trainer.trainUntilConvergence() else: for i in range(t): trainer.trainEpochs(1) trnresult = percentError( trainer.testOnClassData(), self.train_data['class']) # print self.test_data tstresult = percentError( trainer.testOnClassData(dataset=self.test_data), self.test_data['class'] ) print "epoch: %4d" % trainer.totalepochs, \ " train error: %5.2f%%" % trnresult, \ " test error: %5.2f%%" % tstresult if i % 10 == 0 and i > 1: print "Saving Progress... Writing to a file" NetworkWriter.writeToFile(self.net, self.path) print "Done training... Writing to a file" NetworkWriter.writeToFile(self.net, self.path) return trainer
def train(self):
#self.init_iri()
self.init_image()
self.ds = ClassificationDataSet(self.IN, 1, nb_classes=128)
#classifier.init_image()
self.load_data()
print "Number of trianing patterns: ", len(self.trndata)
print "Input and output dimensions: ", self.trndata.indim, self.trndata.outdim
print "First sample (input, target, class):"
print self.trndata['input'][0], self.trndata['target'][0], self.trndata['class'][0]
print self.trndata.indim, self.trndata.outdim
self.net = buildNetwork(self.trndata.indim, 7, self.trndata.outdim)
trainer = BackpropTrainer(self.net, dataset=self.trndata, momentum=0.1, verbose=True, weightdecay=0.01)
"""
for i in range(200):
trainer.trainEpochs(1)
trnresult = percentError(trainer.testOnClassData(), self.trndata['class'])
tstresult = percentError(trainer.testOnClassData(dataset = self.tstdata), self.tstdata["class"])
print "epch: %4d" % trainer.totalepochs, \
" train error: %5.2f%%" % trnresult, \
" test error: %5.2f%%" % tstresult
"""
trainer.trainUntilConvergence()
trnresult = percentError(trainer.testOnClassData(), self.trndata['class'])
tstresult = percentError(trainer.testOnClassData(dataset = self.tstdata), self.tstdata["class"])
print "epch: %4d" % trainer.totalepochs, \
" train error: %5.2f%%" % trnresult, \
" test error: %5.2f%%" % tstresult
def train(self):
trainer = BackpropTrainer(self.network, self.data_set)
trainer.trainUntilConvergence(
verbose=False, validationProportion=0.15, maxEpochs=1000, continueEpochs=10)
return trainer
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
def run(self, ds_train, ds_test):
"""
This function both trains the ANN and evaluates the ANN using a specified training and testing set
Args:
:param ds_train (TweetClassificationDatasetFactory): the training dataset the neural network is trained with.
:param ds_test (TweetClassificationDatasetFactory): the test dataset evaluated.
:returns: error (float): the percent error of the test dataset, tested on the neural network.
"""
ds_train._convertToOneOfMany()
ds_test._convertToOneOfMany()
trainer = BackpropTrainer(
self.network,
dataset=ds_train,
momentum=0.1,
verbose=True,
weightdecay=0.01)
trainer.trainUntilConvergence(
dataset=ds_train,
maxEpochs=self.max_epochs,
continueEpochs=self.con_epochs)
result = trainer.testOnClassData(dataset=ds_test)
error = percentError(result, ds_test['class'])
return error
def neural_network(data, target, network):
DS = SupervisedDataSet(len(data[0]), 1)
nn = buildNetwork(len(data[0]), 7, 1, bias = True)
kf = KFold(len(target), 10, shuffle = True);
RMSE_NN = []
for train_index, test_index in kf:
data_train, data_test = data[train_index], data[test_index]
target_train, target_test = target[train_index], target[test_index]
for d,t in zip(data_train, target_train):
DS.addSample(d, t)
bpTrain = BackpropTrainer(nn,DS, verbose = True)
#bpTrain.train()
bpTrain.trainUntilConvergence(maxEpochs = 10)
p = []
for d_test in data_test:
p.append(nn.activate(d_test))
rmse_nn = sqrt(np.mean((p - target_test)**2))
RMSE_NN.append(rmse_nn)
DS.clear()
time = range(1,11)
plt.figure()
plt.plot(time, RMSE_NN)
plt.xlabel('cross-validation time')
plt.ylabel('RMSE')
plt.show()
print(np.mean(RMSE_NN))
def entrenarSomnolencia(red):
#Se inicializa el dataset
ds = SupervisedDataSet(4096,1)
"""Se crea el dataset, para ello procesamos cada una de las imagenes obteniendo los rostros,
luego se le asignan los valores deseados del resultado la red neuronal."""
print "Somnolencia - cara"
for i,c in enumerate(os.listdir(os.path.dirname('/home/taberu/Imágenes/img_tesis/somnoliento/'))):
try:
im = cv2.imread('/home/taberu/Imágenes/img_tesis/somnoliento/'+c)
pim = pi.procesarImagen(im)
cara = d.deteccionFacial(pim)
if cara == None:
print "No hay cara"
else:
print i
ds.appendLinked(cara.flatten(),10)
except:
pass
trainer = BackpropTrainer(red, ds)
print "Entrenando hasta converger"
trainer.trainUntilConvergence()
NetworkWriter.writeToFile(red, 'rna_somnolencia.xml')
def dynamic_data_network(slept, study):
train_set = SupervisedDataSet(2, 1)
for r1 in range(0, 15):
slept = random.randint(0,10)
study = random.randint(0,10)
score = random.randint(60,100)
train_set.addSample((slept, study), score)
#print train_set['input']
print 'build net'
net = buildNetwork(2, 3, 1, bias=True)
print 'initial guess'
print net.activate((slept,study))
print 'trainer'
trainer = BackpropTrainer(net, train_set)
print 'training'
trainer.trainUntilConvergence()
print 'final guess'
print net.activate((slept,study))
while True:
slept = int(raw_input('hours slept: '))
if slept < 0:
break
study = raw_input('hours studied: ')
print 'new guess :'
print net.activate((slept,study))
def bayesian_net(train, train_label, layers):
inputs = 0
targets = 0
print train_label[0]
if type(train[0]) is list:
inputs = len(train[0])
else:
inputs = 1
if type(train_label[0]) is list:
targets = len(train_label[0])
else: targets = 1
ds = SupervisedDataSet(inputs,targets)
for i in range(len(train)):
ds.addSample(train[i], train_label[i])
net = buildNetwork(inputs, layers, targets, bias=True, hiddenclass=SigmoidLayer)
trainer = BackpropTrainer(net, ds)
trainer.trainUntilConvergence()
return trainer
def makeAndTrainANN(ls_x, ls_y, window_size, hiddenSize=5, epochs=1): # Build Pybrain dataset ds = SupervisedDataSet(window_size, 1) for i, sample in enumerate(ls_x): ds.addSample(sample, ls_y[i]) inLayer = LinearLayer(window_size) hiddenLayer = SigmoidLayer(hiddenSize) outLayer = LinearLayer(1) constant = BiasUnit() n = FeedForwardNetwork() n.addInputModule(inLayer) n.addModule(hiddenLayer) n.addOutputModule(outLayer) n.addModule(constant) n.addConnection(FullConnection(inLayer, hiddenLayer)) n.addConnection(FullConnection(hiddenLayer, outLayer)) n.addConnection(FullConnection(constant, inLayer)) n.addConnection(FullConnection(constant, hiddenLayer)) n.addConnection(FullConnection(constant, outLayer)) n.sortModules() n.reset() #trainer = BackpropTrainer(n, dataset=ds) trainer = BackpropTrainer(n, dataset=ds, momentum=0.2) #trainer.trainEpochs(epochs) trainer.trainUntilConvergence(maxEpochs=epochs) return n
def trainprediction(self, data=None, biased=False, maxEpochs = 10000):
"""Trains the neural network with the provided trainings data and returns true, if the training was successful"""
if not data:
out.writeDebug('No training data! The net stays initialized with random weights!')
return False
#create supervised data set from the training nodes
ds = SupervisedDataSet(len(self.features), 2)
reduced_dataset = [set([]),set([])]
for node, target in data:
featuresValue = []
for feature in self.features:
featuresValue.append(feature(self, node, None, node.querySequence))
if target:
reduced_dataset[0].add(tuple(featuresValue+[ACCEPTED, NOTACCEPTED]))
else:
reduced_dataset[1].add(tuple(featuresValue+[NOTACCEPTED, ACCEPTED]))
for posInstance, negInstance in zip(reduced_dataset[0],reduced_dataset[1]):
ds.addSample(posInstance[:-2],posInstance[-2:])
ds.addSample(negInstance[:-2],negInstance[-2:])
if biased:
ds = SupervisedDataSet(len(self.features), 2)
for instance in reduced_dataset[0]:
ds.addSample(instance[:-2],instance[-2:])
for instance in reduced_dataset[1]:
ds.addSample(instance[:-2],instance[-2:])
out.writeDebug('Start training neural net with %s training examples. Dataset bias is set to %s'%(len(ds), biased ))
trainer = BackpropTrainer(self.net, ds)
trainer.trainUntilConvergence(maxEpochs = maxEpochs)
return True
def train(self, x, y):
''' Trains on the given inputs and labels for either a fixed number of epochs or until convergence.
Normalizes the input with a z-transform'''
print "training..."
# normalize input
m = x.mean()
s = x.std()
x = self.z_transform(x, m, s)
ds = SupervisedDataSet(x.shape[1], 1)
ds.setField('input', x)
ds.setField('target', y)
trainer = BackpropTrainer(self.n,ds, learningrate=self.learning_rate, momentum=self.momentum, verbose=True)
if (self.epochs == 0):
trainer.trainUntilConvergence()
else:
for i in range(0, self.epochs):
start_time = time.time()
trainer.train()
print "epoch: ", i
print "time: ", time.time() - start_time, " seconds"
print "finished"
def startTrials(ds, maxTrials = 2, maxExperiments = 2):
"""start and run the trials"""
hpCount = []
for i in range(0, maxExperiments):
for j in range(0, maxTrials):
enemyTestPos = runExperiments.makeTestDataset()
net = NetworkReader.readFrom("net.xml")
netResults = net.activate([val for pair in normalize(enemyTestPos) for val in pair])
netIter = iter(netResults)
allyTestPos = zip(netIter, netIter)
#undo normalization
allyTestPos = map(lambda p: (abs(p[0]*640), abs(p[1]*720)), allyTestPos)
print(allyTestPos)
runExperiments.writeTestData(allyTestPos)
runExperiments.run()
with open("exp_results_raw.txt", "r") as resultsFile:
lines = resultsFile.readlines()
if "Zerg_Zergling" in lines[1]:
x = normalize(enemyTestPos)
y = normalize(allyTestPos)
x = [val for pair in x for val in pair]
y = [val for pair in y for val in pair]
ds.addSample(x, y)
lineSplit = lines[1].split("Zerg_Zergling")[-1]
hpCount.append(lineSplit.split(" ")[2])
trainer = BackpropTrainer(net, ds)
trainer.trainUntilConvergence()
return hpCount
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)
def main():
for stock in STOCK_TICKS:
# Download Data
get_data(stock)
# Import Data
days = extract_data(stock)
today = days.pop(0)
# Make DataSet
data_set = ClassificationDataSet(INPUT_NUM, 1, nb_classes=2)
for day in days:
target = 0
if day.change > 0:
target = 1
data_set.addSample(day.return_metrics(), [target])
# Make Network
network = buildNetwork(INPUT_NUM, MIDDLE_NUM, MIDDLE_NUM, OUTPUT_NUM)
# Train Network
trainer = BackpropTrainer(network)
trainer.setData(data_set)
trainer.trainUntilConvergence(maxEpochs=EPOCHS_MAX)
# Activate Network
prediction = network.activate(today.return_metrics())
print prediction
def encoderdecoder(outersize,innersize,indata,
fname):
# create network
n = FeedForwardNetwork()
inLayer = LinearLayer(outersize)
hiddenLayer = SigmoidLayer(innersize)
outLayer = LinearLayer(outersize)
n.addInputModule(inLayer)
n.addModule(hiddenLayer)
n.addOutputModule(outLayer)
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer, outLayer)
n.addConnection(in_to_hidden)
n.addConnection(hidden_to_out)
n.sortModules()
# create dataset
ds = SupervisedDataSet(outersize,outersize)
for x,y in indata,indata:
ds.addSample(x,y)
# train network
trainer = BackpropTrainer(n,ds)
trainer.trainUntilConvergence()
n.saveNetwork(fname)
return [[in_to_hidden,hidden_to_out],
[inLayer,hiddenLayer,outLayer],
n]
def main():
#read in pre-processed features
print('reading preprocessed data')
bag = read_bag_of_word('features')
#read in sentimental dictionary
print('reading dictionary')
[word_vector, sentiments] = read_dictionary("positive.txt", "negative.txt")
features,target,features_dict=create_feature_matrix(bag, sentiments)
# Sort dates in order
dates=dow_jones_labels.keys()
dates = [datetime.datetime.strptime(ts, "%Y-%m-%d") for ts in dates]
dates.sort()
dates = [datetime.datetime.strftime(ts, "%Y-%m-%d") for ts in dates]
ds = SupervisedDataSet(4, 1)
ds.setField('input', features)
target=np.array(target).reshape( -1, 1 )
ds.setField('target', target)
net = buildNetwork(4, 40, 1, bias=True)
trainer = BackpropTrainer(net, ds)
trainer.trainUntilConvergence(verbose=True, validationProportion=0.15, maxEpochs=10000, continueEpochs=10)
count=0
for i in range(0,len(target)):
print("predict={0},actual={1}".format(net.activate(features[i]),target[i]))
if net.activate(features[i])*target[i]>0:
count+=1
print("accuracy={0}".format(float(count) / len(dow_jones_labels)))
def makeNet(learning_rate):
ds = SupervisedDataSet(20, 20)
with open('data/misspellingssmall.csv', 'rbU') as f:
reader = csv.reader(f)
for row in reader:
ds.addSample(convert(row[0]),convert(row[1]))
#testds, trainds = ds.splitWithProportion(0.2)
net = buildNetwork(20, 20, 20)
#trainer = BackpropTrainer(net, dataset=trainds, learningrate=learning_rate)
trainer = BackpropTrainer(net, dataset=ds, learningrate=learning_rate)
#trainer.train()
#trainer.trainEpochs(5)
trainer.trainUntilConvergence()
score = 0
for x, y in testds:
predict = unconvert(net.activate(x))
score += damerau_levenshtein_distance(predict,unconvert(y))
global lastNet
lastNet = net
global netNum
netNum += 1
print "Network " + str(netNum) + " done with score " + str(score)
return score
def xtest_simple(self):
# Create a network with 2 input nodes, 3 hidden nodes, 1 output node
net = buildNetwork(2, 3, 1)
# Create 2 input, 1 output dataset
ds = SupervisedDataSet(2, 1)
ds.addSample((0, 0), (0,))
ds.addSample((0, 1), (1,))
ds.addSample((1, 0), (1,))
ds.addSample((1, 1), (0,))
ds.addSample((0, 0), (0,))
ds.addSample((0, 1), (1,))
ds.addSample((1, 0), (1,))
ds.addSample((1, 1), (0,))
ds.addSample((1, 1), (0,))
ds.addSample((1, 1), (0,))
ds.addSample((1, 1), (0,))
ds.addSample((1, 1), (0,))
ds.addSample((1, 1), (0,))
ds.addSample((1, 1), (0,))
#print ds['input']
#print ds['target']
#self.assertEqual(len(ds), 8)
#self.show_activation(net, ds)
trainer = BackpropTrainer(net, ds, learningrate=1.0)
trainer.trainUntilConvergence(verbose=True, validationProportion=0.125)
self.show_activation(net, ds)
train = pandas.read_csv("train.csv")
target = train["Survived"]
m = Massager()
train_array = m.transform(train, True)
input_len = train_array.shape[1]
net = buildNetwork(input_len, 4, 1)
ds = ClassificationDataSet(input_len, 1)
for i in xrange(train_array.shape[0]):
ds.addSample(train_array[i, :], target[i])
trainer = BackpropTrainer(net,
ds,
learningrate=0.02,
momentum=0.5,
verbose=True)
trainer.trainUntilConvergence(maxEpochs=150, verbose=True)
test = pandas.read_csv("test.csv")
answers = pandas.DataFrame(test["PassengerId"])
test_array = m.transform(test)
test_ds = ClassificationDataSet(train_array.shape[1], 1)
predictions = []
for i in xrange(test_array.shape[0]):
out = net.activate(test_array[i, :])
survived = 1 if out[0] >= 0.5 else 0
predictions.append(survived)
answers['Survived'] = pandas.Series(predictions)
answers.to_csv("solution_nn.csv", index=False)
from pybrain.structure.modules import SoftmaxLayer
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.utilities import percentError
n_hidden = 500
bp_nn = buildNetwork(trndata.indim,
n_hidden,
trndata.outdim,
outclass=SoftmaxLayer)
trainer = BackpropTrainer(bp_nn,
dataset=trndata,
verbose=True,
momentum=0.5,
learningrate=0.0001,
batchlearning=True)
err_train, err_valid = trainer.trainUntilConvergence(maxEpochs=1000,
validationProportion=0.25)
# 收敛曲线用于累积BP算法的过程
import matplotlib.pyplot as plt
f1 = plt.figure(1)
plt.plot(err_train, 'b', err_valid, 'r')
plt.title('BP network classification')
plt.ylabel('error rate')
plt.xlabel('epochs')
plt.show()
# 测试
tst_result = percentError(trainer.testOnClassData(tstdata), tstdata['class'])
print("epoch: %4d" % trainer.totalepochs, " test error: %5.2f%%" % tst_result)
in_to_hidden0 = FullConnection(inLayer, hiddenLayer0)
hidden0_to_out = FullConnection(hiddenLayer0, outLayer)
# add the links to neural network
fnn.addConnection(in_to_hidden0)
fnn.addConnection(hidden0_to_out)
# make neural network come into effect
fnn.sortModules()
# train the NN
# we use BP Algorithm
# verbose = True means print th total error
trainer = BackpropTrainer(fnn, DS, verbose=True, learningrate=0.01)
# set the epoch times to make the NN fit
trainer.trainUntilConvergence(maxEpochs=10)
NetworkWriter.writeToFile(net, 'srnNet.xml')
for mod in fnn.modules:
print("Module:", mod.name)
if mod.paramdim > 0:
print("--parameters:", mod.params)
for conn in fnn.connections[mod]:
print("-connection to", conn.outmod.name)
if conn.paramdim > 0:
print("- parameters", conn.params)
if hasattr(fnn, "recurrentConns"):
print("Recurrent connections")
for conn in fnn.recurrentConns:
print("-", conn.inmod.name, " to", conn.outmod.name)
net.sortModules()
#net = buildNetwork(ds_train.indim, HIDDEN_NEURONS_NUM, ds_train.outdim, bias=True,outclass=SoftmaxLayer)
# ds.indim -- количество нейронов входного слоя, равне количеству признаков
# ds.outdim -- количество нейронов выходного слоя, равное количеству меток классов
# SoftmaxLayer -- функция активации, пригодная для решения задачи многоклассовой классификации
init_params = np.random.random(
(len(net.params)
)) # Инициализируем веса сети для получения воспроизводимого результата
net._setParameters(init_params)
#%%
np.random.seed(0)
# Модуль настройки параметров pybrain использует модуль random; зафиксируем seed для получения воспроизводимого результата
trainer = BackpropTrainer(
net, dataset=ds_train) # Инициализируем модуль оптимизации
err_train, err_val = trainer.trainUntilConvergence(maxEpochs=MAX_EPOCHS)
line_train = plt.plot(err_train, 'b', err_val, 'r') # Построение графика
xlab = plt.xlabel('Iterations')
ylab = plt.ylabel('Error')
#%%
#ROC - кривые - порог
grance = 0.5
res_train = net.activateOnDataset(
ds_train) # Подсчет результата на обучающей выборке
res_train_bin = []
for i in res_train:
if i > grance:
res_train_bin.append(1)
else:
res_train_bin.append(0)
from pybrain.datasets import SupervisedDataSet
dataModel = [
[(0, 0), (0, )],
[(0, 1), (1, )],
[(1, 0), (1, )],
[(1, 1), (0, )],
]
ds = SupervisedDataSet(2, 1)
for input, target in dataModel:
ds.addSample(input, target)
random.seed()
trainingSet = SupervisedDataSet(2, 1)
for ri in range(0, 1000):
input, target = dataModel[random.getrandbits(2)]
trainingSet.addSample(input, target)
net = buildNetwork(2, 2, 1, bias=True)
trainer = BackpropTrainer(net, ds, learningrate=0.001, momentum=0.99)
trainer.trainUntilConvergence(verbose=True,
trainingData=trainingSet,
validationData=ds,
maxEpochs=10)
print '0,0->', net.activate([0, 0])
print '0,1->', net.activate([0, 1])
print '1,0->', net.activate([1, 0])
print '1,1->', net.activate([1, 1])
validation_samples.append(ts[i:i + 4])
# Normalize
validation_samples = np.array(validation_samples) / float(max_sample)
inputs_validation = validation_samples[:, 0:3]
target_validation = validation_samples[:, 3]
target_validation = target_validation.reshape(-1, 1)
ds = SupervisedDataSet(len(inputs_training), len(target_training))
ds.setField('input', inputs_training)
ds.setField('target', target_training)
trainer = BackpropTrainer(n, ds)
trainer.trainUntilConvergence(verbose=True,
validationProportion=0.15,
maxEpochs=100,
continueEpochs=10)
for i in range(700):
mse = trainer.train()
rmse = np.sqrt(mse)
print "training RSME, epoch {}: {}".format(i + 1, rmse)
#==============================================================================
# trainer = BackpropTrainer(n, ds, learningrate=0.01, momentum=0.1)
#
# for epoch in range(1, 100000000):
# if epoch % 10000000 == 0:
# error = trainer.train()
# print 'Epoch: ', epoch
# print 'Error: ', error
xlu = [
xtu[0], xtu[1], xtu[2], xtu[3], xtu[4], xtu[5], xtu[6], xtu[7], xtu[8],
xtu[9], xtu[10]
]
xvu = [xbu[0], xbu[1]]
ltrain_input.append(xlu)
ltrain_output.append(xvu)
ds.addSample(xlu, xvu)
##for i in x:
## ds.addSample(i,50*math.sin(i))
##print ds
n = buildNetwork(ds.indim, 40, ds.outdim, recurrent=True)
t = BackpropTrainer(n, learningrate=0.05, momentum=0.5, verbose=True)
t.trainUntilConvergence(ds, 10, continueEpochs=10, validationProportion=0.01)
t.testOnData(verbose=True)
fileObject = open('trained_net', 'w')
pickle.dump(n, fileObject)
fileObject.close()
N1 = 3111
L = 10
j = 1
T = 0.24
##N=100
##y=np.empty(100)
x = np.empty(100)
qw = 0
##yn=np.empty(100)
net = buildNetwork(trndata.indim,
500,
tstdata.outdim,
hiddenclass=TanhLayer,
outclass=SoftmaxLayer,
bias=True)
trainer = BackpropTrainer(net,
trndata,
learningrate=0.01,
lrdecay=1,
momentum=0.00,
verbose=False,
batchlearning=False,
weightdecay=0.0)
trainer.setData(trndata)
trainer.trainUntilConvergence(verbose=True, trainingData=data, maxEpochs=1)
net.offset = 0
m = myo.Myo()
e = []
def proc_emg(emg, moving, times=[]):
global e, emg_correctmean, emg_filtered, emg_rectified, low_pass, sfreq, emg_envelope
e = emg
#emg_correctmean = e - np.mean(e)
emg_correctmean = scipy.signal.detrend(e)
high = 20 / (1000 / 2)
low = 450 / (1000 / 2)
def run():
# Parameters used for program
HIDDEN_LAYERS = [ 35, 35 ]
LEARNING_DECAY = 1 # Set in range [0.9, 1]
LEARNING_RATE = 0.096 # Set in range [0, 1]
MOMENTUM = 0.1 # Set in range [0, 0.5]
TRAINING_ITERATIONS = 1500
BATCH_LEARNING = False
VALIDATION_PROPORTION = 0.0
# Import the data for the two spirals Task
dataset, classes = csv.loadCSV(path.abspath('spirals/SpiralOut.txt'))
# Set up the network and trainer
inDimension = dataset.indim
outDimension = dataset.outdim
layers = [inDimension] + HIDDEN_LAYERS + [outDimension]
neuralNet = buildNetwork(*layers)
print neuralNet
trainer = BackpropTrainer(neuralNet, dataset, learningrate=LEARNING_RATE, momentum=MOMENTUM,
lrdecay=LEARNING_DECAY, batchlearning=BATCH_LEARNING)
# Train the network
trainingErrors = []
validationErrors = []
for i in xrange(TRAINING_ITERATIONS):
print "Training iteration: ", i
# Check if VALIDATION_PROPORTION is not 0. This will split the input dataset into
# VALIDATION_PROPORTION % for Validation Data and
# (1 - VALIDATION_PROPORTION) % for Training Data
# e.g. 25% ValidationData and 75% Training Data
if VALIDATION_PROPORTION == 0.0 or VALIDATION_PROPORTION == 0:
# Cannot split the data set into Training and Validation Data. Train the
# Neural Network by standard means. This will not calculate Validatinon Error
# The result of training is the proportional error for the number of epochs run
trainingError = trainer.train()
trainingErrors.append(trainingError)
# Display the result of training for the iteration
print " Training error: ", trainingError
else:
trainingErrors, validationErrors = trainer.trainUntilConvergence(validationProportion=VALIDATION_PROPORTION)
# create path if it doesn't exist
generated_dir = path.abspath(path.join("generated", "TaskA-TrainedNN-{}".format(strftime("%Y-%m-%d_%H-%M-%S"))))
if not path.exists(generated_dir):
makedirs(generated_dir)
# save parameters
with open(path.normpath(path.join(generated_dir, "params.txt")), "a") as f:
f.write("HIDDEN_LAYERS = {}\n".format(HIDDEN_LAYERS))
f.write("LEARNING_DECAY = {}\n".format(LEARNING_DECAY))
f.write("LEARNING_RATE = {}\n".format(LEARNING_RATE))
f.write("MOMENTUM = {}\n".format(MOMENTUM))
f.write("TRAINING_ITERATIONS = {}\n".format(TRAINING_ITERATIONS))
f.write("BATCH_LEARNING = {}\n".format(BATCH_LEARNING))
f.write("VALIDATION_PROPORTION = {}\n".format(VALIDATION_PROPORTION))
# Save the Trained Neural Network
uniqueFileName = path.normpath(path.join(generated_dir, "data.pkl"))
writeMode = 'wb' # Write Bytes
pickle.dump(neuralNet, open(uniqueFileName, writeMode))
import matplotlib.pyplot as plot
# Plot the results of training
plot.plot(trainingErrors, 'b')
plot.ylabel("Training Error")
plot.xlabel("Training Steps")
plot.savefig(path.normpath(path.join(generated_dir, "errors.png")))
plot.show()
plot.clf()
plot = NN2D.plotNN(network=neuralNet, lowerBound=-6.0, upperBound=6.0, step=0.1)
if VALIDATION_PROPORTION != 0.0 or VALIDATION_PROPORTION != 0:
plot = NN2D.plotBarComparison(trainingErrors, validationErrors)
plot.savefig(path.normpath(path.join(generated_dir, "result.png")))
plot.show()
f.write(repr(hidden_to_out))
f.write('\n')
print 'Create network'
net = buildNetwork(NUM_LINES * NUM_COLUMNS, HIDDEN_LAYER_SIZE, 1, bias=True)
ds = None
trainer = None
step = 100
count = 0
while True:
print 'Create dataset'
ds = SupervisedDataSet(NUM_LINES * NUM_COLUMNS, 1)
set_dataset(ds, count * step, (count + 1) * step)
print 'Train'
trainer = BackpropTrainer(net, ds)
start = time.time()
trainer.trainUntilConvergence()
print time.time() - start
# Export net
# get_connections(net)
print 'save network from ' + str(count * step) + ' to ' + str(
(count + 1) * step)
get_connections_to_file(net, 'network_' + str(count) + '.data')
count += 1
class ml_attack(object):
"""docstring for ml_attack"""
def __init__(self, pufsimu, pufSize, numOfchallenges):
self.pufSize = pufSize
self.numOfchallenges = numOfchallenges
self.pufsimu = pufsimu
def run(self):
# create challenge list
self.chall_list = pufsim.genChallengeList(self.pufSize, self.numOfchallenges)
# build network
self.net = buildNetwork(self.pufSize, 2**self.pufSize, 1, bias=True)
# set dataset
self.ds = SupervisedDataSet(self.pufSize, 1)
for challenge in self.chall_list:
# chg = changeChallenge(challenge)
# chg_res = 1 if self.pufsimu.challengeBit(challenge) == 1 else -1
# self.ds.addSample(chg, [chg_res,])
# add challenges multiple times
self.ds.addSample(challenge, [self.pufsimu.challengeBit(challenge),])
self.ds.addSample(challenge, [self.pufsimu.challengeBit(challenge),])
self.ds.addSample(challenge, [self.pufsimu.challengeBit(challenge),])
self.ds.addSample(challenge, [self.pufsimu.challengeBit(challenge),])
# create trainer
self.trainer = BackpropTrainer(self.net,
dataset=self.ds,
learningrate = 0.01,
momentum = 0.,
weightdecay=0.)
#self.trainer.setData(self.ds)
# train network
a = self.trainer.trainUntilConvergence(dataset=self.ds,
#trainingData=self.ds,
#validationData=self.ds,
maxEpochs=100,
verbose=False,
continueEpochs=10,
validationProportion=0.25)
return 0
def validate(self):
complete_chall_list = pufsim.genChallengeList(self.pufSize, 2 ** self.pufSize)
corr_count = 0
for challenge in complete_chall_list:
pufResult = self.pufsimu.challengeBit(challenge)
# chg = changeChallenge(challenge)
chg = challenge
annResult = -1
if (self.net.activate(chg)[0] >= 0.5):
annResult = 1
else:
annResult = 0
#print "challenge:", challenge, "with result", pufResult, "and ANN result", annResult, "from", self.net.activate(chg)[0]
if (pufResult == annResult):
corr_count = corr_count + 1
print "Possible challenges:", 2**self.pufSize, "with correct guesses:", corr_count
print "Ratio", (float(corr_count) / 2 ** self.pufSize)
return (float(corr_count) / 2 ** self.pufSize)
def trainFromFile(self, filename):
trainer = BackpropTrainer(self.net,
self.createDataSetFromFile(filename))
trainer.trainUntilConvergence(maxEpochs=10)
ds.addSample(input, target)
# create a large random data set
import random
random.seed()
trainingSet = SupervisedDataSet(2, 1);
for ri in range(0,1000):
input,target = dataModel[random.getrandbits(2)];
trainingSet.addSample(input, target)
from pybrain.tools.shortcuts import buildNetwork
net = buildNetwork(2, 2, 1, bias=True)
from pybrain.supervised.trainers import BackpropTrainer
trainer = BackpropTrainer(net, ds, learningrate = 0.001, momentum = 0.99)
trainer.trainUntilConvergence(verbose=True, dataset=trainingSet, maxEpochs=10)
'''
print '0,0->', net.activate([0,0])
print '0,1->', net.activate([0,1])
print '1,0->', net.activate([1,0])
print '1,1->', net.activate([1,1])
'''
#learn XOR with a nerual network with saving of the learned paramaters
import pybrain
from pybrain.datasets import *
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
ds = SupervisedDataSet(48, 1)
for input in lines:
input = input.split(",")
[float(i) for i in input if i != '']
ds.addSample(input[1:], input[0])
train, test = ds.splitWithProportion(0.25)
nn = buildNetwork(48, 20, 1, bias=True, outclass=SigmoidLayer)
nn.reset()
trainer = BackpropTrainer(nn, train)
training_errors, validation_errors = trainer.trainUntilConvergence()
j = 0
print(
'erros de treino ------------------------------------------------------------'
)
for value in training_errors:
#print(training_errors)
print("%s %s" % (value, j))
j += 1
print(
'erros de validacao ----------------------------------------------------------'
)
k = 0
for val in validation_errors:
#print(training_errors)
print("%s %s" % (val, k))
