for i in range(len(df['Entrada'])):
RNAdata.addSample(float(df['Entrada'][i] / max(df['Entrada'])),
float(df['Saída'][i] /
max(df['Saída']))) #normalizando dados de 0 a 1
#Inicializando rede Neural
RNA = buildNetwork(
1, 100, 500, 1000, 500, 100, 1, bias=True
) #buildNetwork(num Neuronios na entrada, num neuronio na camada oculta, num neuronio na saida)
#print(RNA['in'])
#print(RNA['hidden0'])
#print(RNA['out'])
#print(RNA['bias'])
#Treinamento
trainer = BackpropTrainer(RNA, RNAdata)
x_err = [] #lista que vai armazenar o range de epocas
y_err = [] #lista que vai armazenar o erro em %
for i in range(2000): #treinando a rede neural com numero de epocas
y_err.append(trainer.train() * 100)
x_err.append(i + 1)
NetworkWriter.writeToFile(
RNA, 'assets/treinoRNA/topologia02.xml') #Salvando RNA Treinada
#Simulando saida de dados
#saida = RNA.activate([0.40])*max(df['Saída']) #convetendo valor normalizado para mesma escala dos dados de saida
#print(saida)
#Criando variavel de entrada e saida para plotar o grafico com a rede neural treinada
entrada = sorted([random() for x in range(100)])
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure import *
import time
now = time.time()
print now
net = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer)
ds = SupervisedDataSet(2, 1)
ds.addSample((0, 0), (0, ))
ds.addSample((0, 1), (1, ))
ds.addSample((1, 0), (1, ))
ds.addSample((1, 1), (0, ))
print ds
trainer = BackpropTrainer(net, ds)
d = 1
while d > 1e-5:
d = trainer.train()
print("结果:")
print net.activate([0, 0])
print net.activate([0, 1])
print net.activate([1, 0])
print net.activate([1, 1])
print time.time() - now
DS.appendLinked(Xv[i, :].tolist()[0], [yv[i].A[0][0]])
DS._convertToOneOfMany()
return DS
DS_train = conv2DS(X_train, y_train)
DS_test = conv2DS(X_test, y_test)
# A neural network without a hidden layer will simulate logistic regression (albeit very slowly)
fnn = buildNetwork(DS_train.indim,
DS_train.outdim,
outclass=SoftmaxLayer,
bias=True)
trainer = BackpropTrainer(fnn,
dataset=DS_train,
momentum=0.1,
verbose=True,
weightdecay=0.01)
# Train for 100 iterations.
for i in range(50):
trainer.trainEpochs(1)
ote = fnn.activateOnDataset(DS_test)
ErrorRate = (np.argmax(ote, 1) != y_test.T).mean(dtype=float)
print('Error rate (ensemble): {0}%'.format(100 * ErrorRate))
figure(1)
def neval(xval):
return argmax(fnn.activateOnDataset(conv2DS(np.asmatrix(xval))), 1)
def MSP(X):
weight = np.array([
2. / 10.5, 2. / 10.5, 2. / 10.5, 1. / 10.5, 1. / 10.5, 0.5 / 10.5,
0.5 / 10.5, 0.5 / 10.5, 0.5 / 10.5, 0.5 / 10.5
])
return np.dot(X, weight)
y = MSP(X)
for i in xrange(0, X.shape[0]):
d.addSample(X[i, :], y[i])
tol_max = 1e-3
max_iter = 200
trainer = BackpropTrainer(n, d, learningrate=1e-3, momentum=0.9)
erroDpc = []
iter_t = 0
while max_iter > 0:
tol = trainer.train()
erroDpc.append(tol)
max_iter -= 1
print 'erro: ', tol
if tol <= tol_max:
break
iter_t += 1
print 'Responda com 1 para sim e 0 para não'
print iter_t
q = np.zeros((1, 10))
target_size = y_train.shape[1]
# prepare dataset
ds = ClassificationDataSet(input_size, target_size, nb_classes=3)
ds.setField('input', x_train)
ds.setField('target', y_train)
tstdata, trndata = ds.splitWithProportion(0.25)
# init and train
net = buildNetwork(input_size, hidden_size, target_size, outclass=SoftmaxLayer)
trainer = BackpropTrainer(net,
dataset=trndata,
learningrate=0.01,
verbose=True,
weightdecay=.01)
print "training for {} epochs...".format(epochs)
trainer.trainUntilConvergence(verbose=True,
validationProportion=validation_proportion,
maxEpochs=epochs,
continueEpochs=continue_epochs)
trnresult = percentError(trainer.testOnClassData(), trndata['target'])
tstresult = percentError(trainer.testOnClassData(dataset=tstdata),
tstdata['target'])
print("epoch: %4d" % trainer.totalepochs, " train error: %5.2f%%" % trnresult,
" test error: %5.2f%%" % tstresult)
def initRNA():
global d
global erroDpc
q = np.array([[Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8, Q9, Q10]])
InterL=InterLayer.get()
LRate=LearnR.get()
beta=Momentum.get()
Iter=IterMax.get()
erro=Tol.get()
intervaloA=intervaloInicial.get()
intervaloB=intervaloFinal.get()
print q
print b
print f
print InterL
print LRate
print beta
print erro
print Iter
print intervaloA
print intervaloB
n = buildNetwork(10,InterL,1, bias=b, hiddenclass=eval(f))
d = SupervisedDataSet(10,1)
getRandomSample()
trainer = BackpropTrainer(n, d, learningrate = LRate, momentum=beta)
tol_max = erro
n._setParameters(np.random.uniform(intervaloA,intervaloB,n.params.shape[0]))
####para que o gráfico plote de forma única
erroDpc = [] #limpa os dados a cada plot
plt.clf() #limpa o plot
plt.ion() # plota de forma interativa
iter_t = 0
while Iter>0:
erro = trainer.train()
erroDpc.append(erro)
Iter -= 1
print 'geração:',iter_t,' | erro: ', erro
if erro<=tol_max:
break
iter_t += 1
plt.plot(erroDpc, c='r')
plt.xlabel('Epoca')
plt.ylabel('Erro')
plt.title('Decaimento do erro')
plt.pause(0.002)
r = n.activate(q[0,:])
print" Chance real", MSP(q)
real.set(MSP(q)*100)
print"predito",
predict.set(r*100)
if (r*100>80):
Perigo = StringVar()
Perigo.set("PERIGO")
labelPerigo = Label(app, textvariable=Perigo,bg = "red", font = "Helvetica 13 bold")
labelPerigo.place(x = 665, y = 650)
if (r*100>50 and r*100<80):
Alerta = StringVar()
Alerta.set("ALERTA")
labelAlerta = Label(app, textvariable=Alerta,bg = "orange", font = "Helvetica 13 bold")
labelAlerta.place(x = 665, y = 650)
if (r*100>30 and r*100<50):
Atencao = StringVar()
Atencao.set("ATENÇÃO")
labelAtencao = Label(app, textvariable=Atencao,bg = "yellow", font = "Helvetica 13 bold")
labelAtencao.place(x = 665, y = 650)
if (r*100>0 and r*100<30):
SemRisco = StringVar()
SemRisco.set("SEM DE RISCO")
labelSemRisco = Label(app, textvariable=SemRisco,bg = "green", font = "Helvetica 13 bold")
labelSemRisco.place(x = 665, y = 650)
print(rede['out'])
print(rede['bias'])
# Criação da base de dados de treinamento, para esse exemplo, operador XOR
base = SupervisedDataSet(2, 1)
# Primeiros parâmetros são as entradas e o segundo a saída esperada
base.addSample((0, 0), (0, ))
base.addSample((0, 1), (1, ))
base.addSample((1, 0), (1, ))
base.addSample((1, 1), (0, ))
print(base['input'])
print(base['target'])
treinamento = BackpropTrainer(rede,
dataset=base,
learningrate=0.01,
momentum=0.06)
for i in range(1, 30000):
erro = treinamento.train()
if i % 1000 == 0:
print("Erro: %s" % erro)
print(np.round(rede.activate([0, 0])))
print(np.round(rede.activate([1, 0])))
print(np.round(rede.activate([0, 1])))
print(np.round(rede.activate([1, 1])))
"""from pybrain.structure import FeedForwardNetwork
from pybrain.structure import LinearLayer, SigmoidLayer, BiasUnit
from pybrain.structure import FullConnection
for c, yy, t in zip(c2_test, y2_test, t_test):
if yy != 0:
test_data.addSample(c, [t])
for c, yy, t in zip(c2_all, y2_all, t_all):
# if yy != 0:
all_data.addSample(c, [t])
train_data._convertToOneOfMany()
test_data._convertToOneOfMany()
all_data._convertToOneOfMany()
print("building")
fnn = buildNetwork( train_data.indim, 15, train_data.outdim, fast=True,
outclass = SoftmaxLayer)
trainer = BackpropTrainer( fnn, dataset=train_data, momentum=0.2, verbose=True, learningrate=0.05, lrdecay=1.0)
# trainer = RPropMinusTrainer( fnn, dataset=train_data, momentum=0.1, verbose=True, learningrate=0.01, lrdecay=1.0)
# trainer.trainUntilConvergence()
best = fnn.copy()
best_test = 1
for i in range(5):
print("training")
trainer.trainEpochs(1)
print("testing")
# trnresult = trainer.testOnData()
tstresult = trainer.testOnData( dataset=test_data )
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
'''
implementation of BP network
'''
from pybrain.tools.shortcuts import buildNetwork # for building network raw model
from pybrain.structure import SoftmaxLayer # for output layer activation function
from pybrain.supervised.trainers import BackpropTrainer # for model trainer
# network structure
n_h = 5 # hidden layer nodes number
net = buildNetwork(19, n_h, 2, outclass=SoftmaxLayer)
# 1.1 model training, using standard BP algorithm
trainer = BackpropTrainer(net, trndata)
trainer.trainEpochs(1) # training for once
# 1.2 model training, using accumulative BP algorithm
# trainer = BackpropTrainer(net, trndata, batchlearning=True)
# trainer.trainEpochs(50)
# err_train, err_valid = trainer.trainUntilConvergence(maxEpochs=50)
# convergence curve for accumulative BP algorithm process
# import matplotlib.pyplot as plt
# plt.plot(err_train,'b',err_valid,'r')
# plt.title('BP network classification')
# plt.ylabel('accuracy')
# plt.xlabel('epochs')
# plt.show()
training_data._convertToOneOfMany()
test_data._convertToOneOfMany()
#********************End of Data Preparation***************************
#********************NN With BackPropagation***************************
fnn_backprop = buildNetwork(training_data.indim,
2,
training_data.outdim,
bias=True,
outclass=SoftmaxLayer)
trainer = BackpropTrainer(fnn_backprop,
dataset=training_data,
momentum=0.1,
verbose=True,
weightdecay=0.01)
epochs = 10
trnerr_backprop = []
tsterr_backprop = []
for i in xrange(epochs):
# If you set the 'verbose' trainer flag, this will print the total error as it goes.
trainer.trainEpochs(1)
#output_train = testOnClassData_custom(fnn_backprop, dataset=training_data)
output_train = trainer.testOnClassData()
for tr in output_train:
#print("This is the training output value: ", tr)
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.utilities import percentError
numHidden = 30
# Following classification code: http://pybrain.org/docs/tutorial/fnn.html
# Output layer is softmax (normalizes to 0-1)
# Apparently momentum reduces oscillation, gives faster convergence
# See here: http://page.mi.fu-berlin.de/rojas/neural/chapter/K8.pdf
net = buildNetwork(ds.indim, numHidden, ds.outdim, outclass=SoftmaxLayer)
# net = net topology
# ds = input and output desired
# We multiply the weights by "weightdecay" to keep themf rom growing too large
# -- This is a regularization method
trainer = BackpropTrainer(net, ds, momentum=0.1, weightdecay=0.01)
# # Train the network once
# errorVal = trainer.train()
# print(errorVal)
# Train the network
numEpochs = 10
import sys
for i in range(numEpochs):
errorVals = trainer.train()
# Print how network is doing so far
trnresult = percentError(trainer.testOnClassData(), ds['class'])
# print("Epochs:", trainer.totalepochs)
#print("Percent error on training data:", trnresult)
sys.stdout.write(str(trnresult) + "%\n") # same as print
def graphNN(ticker, date, epochs, verbose):
"""
The function builds a data set of stock prices, normalizes that data set, builds a linked data set to
train the neural network, generates a neural network, trains the network, makes predictions, analyzes the
predictions against testing data to generate statistics for comparison, and uses the statistics to
generate graphs as a png file.
:param ticker: the stock sticker to train and predict on
:param date: the date to split the data on to create training and testing
:param epochs: the number of times to train the network
:param verbose: boolean value for verbose output
:return tomorrowPrice: the price prediction for tomorrow
:return totalTime: the total time in seconds it took to train the network on the data set
:return averageTimePerEpoch: the average time per training run
:return averagePercentError:the average percent error of the predictions and the testing data
:return minPercentError:the minimum percent error of the predictions and the testing data
"""
# request stock prices and split by the specified date to create training and testing data sets
if verbose: print 'Requesting data...'
data = getStockPrices(ticker, frequency="daily", update=True)
trainData, testData = splitByDate(data, date)
xTrain, yTrain = preprocessStocks(trainData)
xTest, yTest = preprocessStocks(testData)
# allocate space for predictions and error values
fucturePredictions = []
trainingPredictions = []
percentError = []
if verbose: print 'complete.'
if verbose: print 'Normalizing data...'
# normalize the values to a percentage of their max values to increase network training speed
xTrain, yTrain, xTest, yTest, priceScaleFactor, timeScaleFactor = normalize(
xTrain, yTrain, xTest, yTest)
if verbose: print 'complete.'
if verbose: print 'Building dataset...'
# build a linked data set to allow for training and error calculation
ds = SupervisedDataSet(1, 1)
for i in range(0, len(xTrain)):
ds.appendLinked(xTrain[i], yTrain[i])
if verbose: print 'complete.'
if verbose: print 'Buidling network...'
rnn = buildNetwork(1,
3,
3,
3,
3,
3,
3,
3,
3,
1,
bias=True,
recurrent=True,
hiddenclass=TanhLayer)
if verbose: print 'complete'
if verbose: print 'Training network...'
trainer = BackpropTrainer(rnn, ds, learningrate=0.01)
totalTime, averageTimePerEpoch, trainerErrorValues, epochTimes = trainNetwork(
trainer, epochs, verbose)
if verbose: print 'Training network 100.0% complete.'
if verbose: print 'Predicting...'
# prime the network
for i in xTrain:
rnn.activate(i)
# make predictions with network on the training data to show general shape of approximated function
for i in xTrain:
trainingPredictions.append(rnn.activate(i))
# make predictions with the network on the testing data to validate the accuracy of the network
for i in xTest:
fucturePredictions.append(rnn.activate(i))
# predict tomorrow's price
tomorrowPrice = rnn.activate(xTest[len(xTest) - 1] + 1) * priceScaleFactor
if verbose: print 'complete.'
if verbose: print 'Generating graphs...'
# denormalize
xTrain, yTrain, xTest, yTest, fucturePredictions, trainingPredictions = denormalize(
xTrain, yTrain, xTest, yTest, fucturePredictions, trainingPredictions,
priceScaleFactor, timeScaleFactor)
# calculate percent error
for i in range(0, len(yTest)):
percentError.append((abs(
(yTest[i] - fucturePredictions[i]) / yTest[i]) * 100))
# calculates statistics on the analysis of the network
sumPercentError = sum(percentError)
averagePercentError = sumPercentError / len(percentError)
numDataPoints = len(xTrain) + len(xTest)
minPercentError = min(percentError)
# generate the graphs and save them to the working directory
graphOutput(xTrain, yTrain, xTest, yTest, fucturePredictions,
trainingPredictions, ticker)
if verbose: print 'complete.'
# returns
return tomorrowPrice, numDataPoints, totalTime, averageTimePerEpoch, averagePercentError, minPercentError
testdata = data[(len(data) / 2) + 1:]
print "Importing actual data"
actualdata = numpy.genfromtxt('trainR.csv', delimiter=',')
print "Adding samples to dataset and setting up neural network"
ds = ClassificationDataSet(784, 10, nb_classes=10)
for x in traindata:
ds.addSample(tuple(x[1:]), tuple(x[0:1]))
ds._convertToOneOfMany(bounds=[0, 1])
net = buildNetwork(784, 100, 10, bias=True, outclass=SoftmaxLayer)
print "Training the neural network"
trainer = BackpropTrainer(net,
dataset=ds,
momentum=0.1,
verbose=True,
weightdecay=0.01)
for i in range(3):
# train the network for 1 epoch
trainer.trainEpochs(1)
# evaluate the result on the training and test data
trnresult = percentError(trainer.testOnClassData(),
[x[0] for x in traindata])
# print the result
print "epoch: " + str(
trainer.totalepochs) + " train error: " + str(trnresult)
print ""
def __init__(self):
self.refcase = None
self.ranking = [] # (casenum, caseorder, performance )
self.failed = [] # (casenum, caseorder, performance )
self.casenums = []
# configure for case generation
if State.direct.has_key('casegen'):
if len(State.direct['casegen']) != 1:
raise UserException('Only one CASEGEN directive is allowed')
sub = State.direct['casegen'][0][0] # (sub, stmt, span)
subsub = sub.cases[0][0][0]
item = SrcFile.applymap(subsub.case[0][0][0])
attrs = SrcFile.applymap(subsub.case[0][1])
if item == 'rand':
self.selectfunc, self.prefunc, self.postfunc, self.updatefunc = casegen_functions_random
elif item == 'dtree':
self.selectfunc, self.prefunc, self.postfunc, self.updatefunc = casegen_functions_dtree
else:
raise UserException(
'%s is not valid cage generation algorithm' % item)
else:
self.selectfunc, self.prefunc, self.postfunc, self.updatefunc = casegen_functions_random
# configure for measurment
self.measure = {}
for sub, stmt, span in State.direct['measure']:
for subsub in sub.cases[0][0]:
item = SrcFile.applymap(subsub.case[0][0][0])
attrs = SrcFile.applymap(subsub.case[0][1])
self.measure[item] = attrs
# configure for verification
self.verify = {}
for sub, stmt, span in State.direct['verify']:
for subsub in sub.cases[0][0]:
item = SrcFile.applymap(subsub.case[0][0][0])
attrs = SrcFile.applymap(subsub.case[0][1])
self.verify[item] = attrs
self.rank_var = State.direct['rank'][0][0].cases[0][0][0].case[0][0][0]
self.rank_attrs = State.direct['rank'][0][0].cases[0][0][0].case[0][1]
# build Neural Network
casenum, casenumseq, directs, objs = get_directs(
self.selectfunc, self.prefunc, self.postfunc)
self.casesizes = []
for caseidx, caseobj in casenumseq:
self.casesizes.append(
max(1, int(math.ceil(math.log(caseobj.size, 2)))))
self.NN_input_size = sum(self.casesizes)
self.NN_hidden_layers = 4
self.NN_target_size = 1
self.NN_net = buildNetwork(self.NN_input_size,
self.NN_hidden_layers,
self.NN_target_size,
bias=True)
self.NN_trainer = BackpropTrainer(self.NN_net,
momentum=0.1,
weightdecay=0.01,
learningrate=0.01)
self.NN_ds = SupervisedDataSet(self.NN_input_size, self.NN_target_size)
self.NN_basket_size = 1000
self.NN_min_dataset_size = min(20, State.cases['size'])
self.NN_amp_factor = 1.0
def testBaseLine(self):
#return # disable slow test for now
logger.info("Running 20NG NB baseline...")
logger.info("Calculating TF-IDF on 20ng data set...")
news_train = load_mlcomp('20news-18828', 'train')
news_test = load_mlcomp('20news-18828', 'test')
target_names = news_test.target_names
vectorizer = TfidfVectorizer(encoding='latin1')
X_train = vectorizer.fit_transform(
(open(f).read() for f in news_train.filenames))
y_train = news_train.target
X_test = vectorizer.transform(
(open(f).read() for f in news_test.filenames))
y_test = news_test.target
del news_train, news_test
logger.info("Running MultinomialNB...")
clf = MultinomialNB().fit(X_train, y_train)
print(
classification_report(y_test,
clf.predict(X_test),
target_names=target_names))
del clf
logger.info("Running pybrain...")
from pybrain.datasets import ClassificationDataSet
from pybrain.utilities import percentError
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import SoftmaxLayer
from pybrain.tools.xml.networkwriter import NetworkWriter
from pybrain.tools.xml.networkreader import NetworkReader
trndata = ClassificationDataSet(len(vectorizer.get_feature_names()),
1,
nb_classes=len(target_names),
class_labels=target_names)
for i, x in enumerate(X_train):
#print x, y_train[i]
trndata.addSample(x.toarray(), y_train[i])
trndata._convertToOneOfMany()
del X_train, y_train
tstdata = ClassificationDataSet(len(vectorizer.get_feature_names()),
1,
nb_classes=len(target_names),
class_labels=target_names)
for i, x in enumerate(X_test):
tstdata.addSample(x.toarray(), y_test[i])
tstdata._convertToOneOfMany()
del X_test, y_test
logger.info("Building network...")
fnn = buildNetwork(trndata.indim,
100,
trndata.outdim,
outclass=SoftmaxLayer)
trainer = BackpropTrainer(fnn,
dataset=trndata,
momentum=0.1,
learningrate=0.01,
verbose=True,
weightdecay=0.01)
logger.info("Training pybrain for 50 epochs...")
trainer.trainEpochs(50)
pred = fnn.activateOnDataset(tstdata)
pred = np.argmax(pred, axis=1) # argmax gives the class
print(classification_report(y_test, pred, target_names=target_names))
#print inp, out
dataset.addSample(inp, [out])
#Some Pybrain Magic
dataset._convertToOneOfMany()
return dataset
train_dataset = create_dataset(train, train_labels)
test_dataset = create_dataset(test, test_labels)
# 784=28*28 inputs 20 middle layer, 10 outputs, Softmax is recommended for classification
network = buildNetwork(784,100, 20,10, outclass=SoftmaxLayer)
trainer = BackpropTrainer(network, dataset = train_dataset, weightdecay=0.01)
def one_iteration():
print "Training"
trainer.trainEpochs(1)
print "Testing on testing dataset"
tstresult = percentError(trainer.testOnClassData(dataset = test_dataset),test_dataset['class'])
print "Error %5.2f" % tstresult
rsamples = [get_random_sample_with_label() for i in range(10)]
rsample, rlabel = zip(*rsamples)
net2Filename)
if not isfile(net1Filename):
NetworkWriter.writeToFile(network1, net1Filename)
if not isfile(net2Filename):
NetworkWriter.writeToFile(network2, net2Filename)
trainingSets1 = SupervisedDataSet(1, 1)
trainingSets2 = SupervisedDataSet(1, 1)
[
trainingSets1.addSample(trainingSetsA[i], a(trainingSetsA[i]))
for i in range(len(trainingSetsA))
]
[
trainingSets2.addSample(trainingSetsB[i], b(trainingSetsB[i]))
for i in range(len(trainingSetsB))
]
trainer1 = BackpropTrainer(network1, trainingSets1, learningrate=0.1)
trainer2 = BackpropTrainer(network2, trainingSets2, learningrate=0.1)
trainer1.trainUntilConvergence()
trainer2.trainUntilConvergence()
trainOutputA = []
trainOutputB = []
validateOutputA = []
validateOutputB = []
errA = []
errB = []
[
trainOutputA.append(a(trainingSetsA[i]))
for i in range(len(trainingSetsA))
]
[
trainOutputB.append(b(trainingSetsB[i]))
with open('vsample.csv', 'rb') as f:
reader = csv.reader(f)
for row in reader:
d_input = map(float, row[1:10])
output = map(float, row[10])
n_input = d_input / numpy.linalg.norm(d_input)
ds.addSample(d_input, output)
temp_ds.addSample(d_input)
#print ds
cfg = RbmGibbsTrainerConfig()
cfg.maxIter = 3
rbm = Rbm.fromDims(9, 5)
trainer = BackpropTrainer(net,
dataset=ds,
learningrate=0.001,
weightdecay=0.01,
verbose=True)
#trainer = DeepBeliefTrainer(net, dataset=temp_ds)
#trainer = RbmBernoulliTrainer(rbm, temp_ds, cfg)
for i in range(30):
trainer.trainEpochs(30)
print 'Expected:1 [FRAUD] ', net.activate(
[49, 2.6, 0.98, 4.3, 1.48, 10, 2.5, 6, 67])
print 'Expected:0 [NOT FRAUD] ', net.activate(
[78, 5, 4.4, 4.5, 2.99, 3, 1.3, 10, 59])
print 'Expected:1 [FRAUD] ', net.activate(
[57, 2, 0.1, 1.15, 0.47, 7, 1.8, 6, 73])
print 'Expected:0 [NOT FRAUD] ', net.activate(
[65, 3, 11.1, 1.8, 0.6, 4, 4, 4.5, 90])
#Build net and training
from pybrain.tools.shortcuts import buildNetwork
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)
#Build arbitrarily deep networks
#`layers` should be a list or tuple of integers, that indicate how many
#neurons the layers should have.
trainer = BackpropTrainer(bp_nn,
dataset = trndata,
verbose = True,
momentum = 0.5,
learningrate = 0.0001,
batchlearning = True)
#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 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.
#If `batchlearning` is set, the parameters are updated only at the end of
#each epoch. Default is False.
err_train, err_valid = trainer.trainUntilConvergence(maxEpochs = 1000,
validationProportion = 0.25)
#If no dataset is given, the dataset passed during Trainer initialization is
#used. validationProportion is the ratio of the dataset that is used for the
#validation dataset.
# Add input layer, hiddern layer and output layer into fnn
fnn.addInputModule(inLayer)
fnn.addModule(hiddenLayer)
fnn.addOutputModule(outLayer)
# Create full connection between each layer
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer, outLayer)
# Create connection with fnn
fnn.addConnection(in_to_hidden)
fnn.addConnection(hidden_to_out)
fnn.sortModules()
# Train fnn using BP until convergence
trainer = BackpropTrainer(fnn, ds_train, learningrate = 0.01, verbose = True,
weightdecay = 0.1)
# batchlearning = True, weightdecay = 0.1, momentum
err_train, err_valid = trainer.trainUntilConvergence(maxEpochs = 1000)
# convergence curve
import matplotlib.pyplot as plt
plt.plot(err_train, 'b', err_valid, 'r')
plt.show()
# model testing
from pybrain.utilities import percentError
testResult = percentError(trainer.testOnClassData(), ds_test['target'])
print("epoch: %d" % trainer.totalepochs, "test error: %f%%" % testResult)
#%%
# Save model and result
def exec_algo(xml_file, output_location):
rootObj = ml.parse(xml_file)
#Getting the root element so that we get the subclasses and its members and member function
xmlParamDetails = rootObj.MachineLearning.classification
#Gather param values from the XML parsed object
file = open(xmlParamDetails.datafile)
var_inp = xmlParamDetails.input
var_out = xmlParamDetails.output
classes = xmlParamDetails.classes
split = xmlParamDetails.split
learningrate = xmlParamDetails.algorithm.MultiLayerPerceptron.learningRate
momentum = xmlParamDetails.algorithm.MultiLayerPerceptron.momentum
epochs = xmlParamDetails.algorithm.MultiLayerPerceptron.epochs
hiddenNeurons = int(
xmlParamDetails.algorithm.MultiLayerPerceptron.hiddenLayers)
hiddenLayer = xmlParamDetails.algorithm.MultiLayerPerceptron.hiddenLayerActivation
outputLayer = xmlParamDetails.algorithm.MultiLayerPerceptron.outputLayerActivation
delimiter = xmlParamDetails.delimiter
DS = ClassificationDataSet(var_inp, var_out, nb_classes=classes)
for line in file.readlines():
data = [float(x) for x in line.strip().split(',') if x != '']
inp = tuple(data[:var_inp])
output = tuple(data[var_inp:])
DS.addSample(inp, output)
tstdata, trndata = DS.splitWithProportion(split)
trdata = ClassificationDataSet(trndata.indim, var_out, nb_classes=classes)
tsdata = ClassificationDataSet(tstdata.indim, var_out, nb_classes=classes)
for i in xrange(trndata.getLength()):
trdata.addSample(trndata.getSample(i)[0], trndata.getSample(i)[1])
for i in xrange(tstdata.getLength()):
tsdata.addSample(tstdata.getSample(i)[0], tstdata.getSample(i)[1])
trdata._convertToOneOfMany()
tsdata._convertToOneOfMany()
fnn = FeedForwardNetwork()
inputLayer = LinearLayer(trdata.indim)
if hiddenLayer == 'Sigmoid':
hiddenLayer = SigmoidLayer(hiddenNeurons)
elif hiddenLayer == 'Softmax':
hiddenLayer = SoftmaxLayer(hiddenNeurons)
else:
hiddenLayer = LinearLayer(hiddenNeurons)
if outputLayer == 'Sigmoid':
outputLayer = SigmoidLayer(trdata.outdim)
elif outputLayer == 'Softmax':
outputLayer = SoftmaxLayer(trdata.outdim)
else:
outputLayer = LinearLayer(trdata.outdim)
fnn.addInputModule(inputLayer)
fnn.addModule(hiddenLayer)
fnn.addOutputModule(outputLayer)
in_to_hidden = FullConnection(inputLayer, hiddenLayer)
hidden_to_outputLayer = FullConnection(hiddenLayer, outputLayer)
fnn.addConnection(in_to_hidden)
fnn.addConnection(hidden_to_outputLayer)
fnn.sortModules()
trainer = BackpropTrainer(fnn,
dataset=trdata,
verbose=True,
learningrate=learningrate,
momentum=momentum)
trainer.trainEpochs(epochs=epochs)
trresult = percentError(trainer.testOnClassData(), trdata['class'])
print("Training accuracy : %f " % (100 - trresult))
ts = time.time()
directory = output_location + sep + str(int(ts))
makedirs(directory)
fileObject = open(
output_location + sep + str(int(ts)) + sep + 'pybrain_MLP', 'w')
pickle.dump(trainer, fileObject)
pickle.dump(fnn, fileObject)
fileObject.close()
# Create Recurrent Network Structure
net = RecurrentNetwork()
net.addInputModule(LinearLayer(2, name='in'))
net.addModule(LinearLayer(1, name='hidden'))
net.addOutputModule(LinearLayer(1, name='out'))
net.addConnection(FullConnection(net['in'], net['hidden'], name='c1'))
net.addConnection(FullConnection(net['hidden'], net['out'], name='c2'))
#net.addRecurrentConnection(FullConnection(net['hidden'], net['hidden'], name='c3'))
net.addRecurrentConnection(FullConnection(net['out'], net['out'], name='c3'))
net.sortModules()
# Train network
trainer = BackpropTrainer(net,
ds,
learningrate=0.01,
batchlearning=True,
verbose=True)
#trainUntilConvergence does not work for RNNs, because validationProportion
#rearranges the order of the input samples
#trainErr = trainer.trainUntilConvergence(maxEpochs=50,validationProportion=0.2)
#plotCost(trainErr[1])
trainErr = np.zeros(10)
print "Network before training"
print_network(net)
print ""
for i in range(10):
trainErr[i] = trainer.train()
print_network(net)
print ""
net.reset()
def main():
trndata, tstdata = createDS()
for repeat in xrange(repeats):
print 'trial', repeat
iter_trn_results = []
iter_tst_results = []
nn = createNN(4, 6, 3)
nn.randomize()
hiddenAstrocyteLayer, outputAstrocyteLayer = \
associateAstrocyteLayers(nn)
trainer = BackpropTrainer(nn,
dataset=trndata,
learningrate=0.01,
momentum=0.1,
verbose=False,
weightdecay=0.0)
for grand_iter in xrange(iterations):
if grand_iter == 0:
trainer.train()
# trainNGA(nn, trndata, hiddenAstrocyteLayer, outputAstrocyteLayer)
trainer.train()
trnresult = percentError(trainer.testOnClassData(),
trndata['class'])
iter_trn_results.append(trnresult)
tstresult = percentError(trainer.testOnClassData(dataset=tstdata),
tstdata['class'])
iter_tst_results.append(tstresult)
if not grand_iter % 100:
print 'epoch %4d' % trainer.totalepochs, 'train error %5.2f%%'\
% trnresult, 'test error %5.2f%%' % tstresult
# MAKE SURE NOT IN ITER LOOP
all_trn_results.append(iter_trn_results)
all_tst_results.append(iter_tst_results)
assert array(iter_trn_results).shape == (iterations, ), \
array(iter_trn_results).shape
assert array(iter_tst_results).shape == (iterations, ), \
array(iter_tst_results).shape
assert array(all_trn_results).shape == (repeats, iterations), \
array(all_trn_results).shape
assert array(all_tst_results).shape == (repeats, iterations), \
array(all_tst_results).shape
a = datetime.datetime.now().utctimetuple()
time_string = str(a[3]) + str(a[4]) + '_' + str(a[2]) + '-' + \
str(a[1]) + '-' + str(a[0])
if os.environ['OS'] == 'Windows_NT':
sep = '\\'
else:
sep = '/'
pybrain_dir = os.getcwd() + sep
assert pybrain_dir[-10:-1] == 'mypybrain', \
'is actually this ' + pybrain_dir[-10:-1]
os.mkdir(pybrain_dir + 'experiment_results' + sep + time_string)
trnf = open(
pybrain_dir + 'experiment_results' + sep + time_string +
'/all_trn_results.out', 'w')
np.savetxt(trnf, all_trn_results)
tstf = open(
pybrain_dir + 'experiment_results' + sep + time_string +
'/all_tst_results.out', 'w')
np.savetxt(tstf, all_tst_results)
20, # number of hidden units
3,
bias=True,
hiddenclass=SigmoidLayer,
outclass=LinearLayer)
net4 = buildNetwork(
5,
15, # number of hidden units
15, # number of hidden units
3,
bias=True,
hiddenclass=SigmoidLayer,
outclass=LinearLayer)
#initialize the structures
net2.randomize()
net2.sortModules()
net4.randomize()
net4.sortModules()
#create trainers
#train for set amount of epochs
#save networks to disc
trainer2 = BackpropTrainer(net2, ds2, verbose=True)
trainer2.trainEpochs(nEpochs)
NetworkWriter.writeToFile(net2, net_fold + 'network_Type2H1NewSTD.xml')
trainer4 = BackpropTrainer(net4, ds2, verbose=True)
trainer4.trainEpochs(nEpochs)
NetworkWriter.writeToFile(net4, net_fold + 'network_Type2H2NewSTD.xml')
print 'Work completed. Check out the networks have been saved'
print inpt, target print '\nInputs' print ds['input'] print '\nOutputs/Targets' print ds['target'] # ds.clear(); ################## Trainers ##################### from pybrain import TanhLayer from pybrain.supervised.trainers import BackpropTrainer net = buildNetwork(2, 3, 1, bias=True, hiddenclass=TanhLayer) trainer = BackpropTrainer(net, ds) print trainer.train() # tuple containing the errors for every training epoch. print trainer.trainUntilConvergence() ############### Feed forward networks ###################### from pybrain.structure import FeedForwardNetwork n = FeedForwardNetwork() # Constructing input, output & hidden layers & giving names to the network from pybrain.structure import LinearLayer, SigmoidLayer inLayer = LinearLayer(2, name='in') hiddenLayer = SigmoidLayer(3, name='hidden')
#----------
# build the network
#----------
from pybrain.structure import SigmoidLayer, LinearLayer
from pybrain.tools.shortcuts import buildNetwork
net = buildNetwork(1,
3, # number of hidden units
1
)
#----------
# train
#----------
from pybrain.supervised.trainers import BackpropTrainer
trainer = BackpropTrainer(net, ds, verbose=True)
trainer.trainUntilConvergence(maxEpochs = 20)
print 'Network details:'
disp_network(net)
print net.params
#----------
# evaluate
#----------
# neural net approximation
pylab.plot(xvalues,
[ net.activate([x]) for x in xvalues ], linewidth = 2,
color = 'blue', label = 'NN output')
# target function
pylab.plot(xvalues,
dataX = normalizer.transform(dataX)
# / scalarization && normalization
# training dataset construction
for i in range(0, len(dataX)):
ds.addSample(dataX[i], dataY[i])
# / training dataset construction
# nn && trainer construction
net = buildNetwork(ds.indim, (ds.indim + ds.outdim) / 2,
ds.outdim,
bias=True,
outclass=SoftmaxLayer) # building the n
trainer = BackpropTrainer(net,
ds,
learningrate=0.15,
momentum=0,
verbose=False) # building the trainer
# / nn && trainer construction
# training
trainer.trainUntilConvergence(maxEpochs=maxEpk) # Train, until convergence
# for epoch in range(0,1000):
# trainer.train()
# / training
# cross validation
win = 0
for i in range(0, len(datapX)):
toPredict = datapX[i]
if scale_data == 1:
print "First sample (input, target, class):"
#print trndata['input'][0], trndata['target'][0], trndata['class'][0]
# <codecell>
fnn = buildNetwork(trndata.indim,
trndata.indim * 2,
trndata.outdim,
outclass=SoftmaxLayer,
hiddenclass=SigmoidLayer)
# <codecell>
trainer = BackpropTrainer(fnn,
dataset=trndata,
momentum=0.1,
lrdecay=1.0,
verbose=True,
weightdecay=0.001)
# <codecell>
for i in range(0, 3):
trainer.trainEpochs(1)
# <codecell>
trainer.testOnClassData()[:20], list(targets_train[:20])
# <codecell>
trnresult = percentError(trainer.testOnClassData(), trndata['class'])
def train_separate_nets(data_set,
test_data,
n,
arousal_net,
valence_net,
epochs=1):
num_inputs = len(data_set[0][0][n])
arousal_ds = SupervisedDataSet(num_inputs, 1)
valence_ds = SupervisedDataSet(num_inputs, 1)
for i in range(len(data_set)):
try:
arousal_ds.appendLinked(data_set[i][0][n], (data_set[i][1]))
valence_ds.appendLinked(data_set[i][0][n], (data_set[i][2]))
except:
print 'WARNING: INSUFFICIENT INPUT SIZE'
continue
print str(
len(arousal_ds)) + ' points successfully aquired for arousal analysis'
print str(
len(valence_ds)) + ' points successfully aquired for valence analysis'
arousal_trainer = BackpropTrainer(arousal_net,
learningrate=0.01,
momentum=0.05,
verbose=True)
valence_trainer = BackpropTrainer(valence_net,
learningrate=0.01,
momentum=0.05,
verbose=True)
arousal_trainer.trainOnDataset(arousal_ds)
valence_trainer.trainOnDataset(valence_ds)
mean_internal_errors = []
mean_errors = []
# Calculate initial error
sq_arousal_errors = [(arousal_net.activate(datum[0][n]) - datum[1])**2
for datum in test_data]
sq_valence_errors = [(valence_net.activate(datum[0][n]) - datum[2])**2
for datum in test_data]
errors = [
sqrt(sq_arousal_errors[i] + sq_valence_errors[i])
for i in range(len(sq_arousal_errors))
]
mean_errors.append(np.mean(errors))
sq_arousal_errors = [
(arousal_net.activate(data_set[i][0][n]) - data_set[i][1])**2
for i in range(len(data_set))
]
sq_valence_errors = [
(valence_net.activate(data_set[i][0][n]) - data_set[i][2])**2
for i in range(len(data_set))
]
errors = [
sqrt(sq_arousal_errors[i] + sq_valence_errors[i])
for i in range(len(sq_arousal_errors))
]
mean_internal_errors.append(np.mean(errors))
for j in range(epochs / 50):
arousal_trainer.trainEpochs(50)
valence_trainer.trainEpochs(50)
print 'Method ' + str(n) + ' - ' + str(
(j + 1) * 50) + '/' + str(epochs) + ' complete'
sq_arousal_errors = [(arousal_net.activate(datum[0][n]) - datum[1])**2
for datum in test_data]
sq_valence_errors = [(valence_net.activate(datum[0][n]) - datum[2])**2
for datum in test_data]
errors = [
sqrt(sq_arousal_errors[i] + sq_valence_errors[i])
for i in range(len(sq_arousal_errors))
]
mean_errors.append(np.mean(errors))
sq_arousal_errors = [
(arousal_net.activate(data_set[i][0][n]) - data_set[i][1])**2
for i in range(len(data_set))
]
sq_valence_errors = [
(valence_net.activate(data_set[i][0][n]) - data_set[i][2])**2
for i in range(len(data_set))
]
errors = [
sqrt(sq_arousal_errors[i] + sq_valence_errors[i])
for i in range(len(sq_arousal_errors))
]
mean_internal_errors.append(np.mean(errors))
return arousal_net, valence_net, mean_errors, mean_internal_errors
if __name__ == "__main__":
t = loadImage('krests/krest1.png')
net = buildNetwork(len(t), len(t), 1)
dataset = SupervisedDataSet(len(t), 1)
dataset.addSample(loadImage('krests/krest1.png'), 100)
dataset.addSample(loadImage('krests/krest2.png'), 100)
dataset.addSample(loadImage('krests/krest3.png'), 100)
dataset.addSample(loadImage('krests/krest4.png'), 100)
dataset.addSample(loadImage('krests/krest5.png'), 100)
dataset.addSample(loadImage('nols/nol1.png'), -100)
dataset.addSample(loadImage('nols/nol2.png'), -100)
dataset.addSample(loadImage('nols/nol3.png'), -100)
dataset.addSample(loadImage('nols/nol4.png'), -100)
dataset.addSample(loadImage('nols/nol5.png'), -100)
dataset.addSample(loadImage('nols/nol6.png'), -100)
dataset.addSample(loadImage('nols/nol7.png'), -100)
#dataset.addSample(loadImage('stable/bullet1.png'), 0)
trainer = BackpropTrainer(net, dataset)
error = 10
iteration = 0
while error > 0.001:
error = trainer.train()
iteration += 1
print("Error on iteration {0} is {1}".format(iteration, error))
print("\nResult for 'krest.png': ",
net.activate(loadImage('krests/krest.png')))
print("\nResult for 'nol.png': ", net.activate(loadImage('nols/nol.png')))
