pylab.ylabel('y')
pylab.title('Neuron Number:' + str(nneuron))
pylab.grid(True)
plotname = os.path.join(plotdir, ('jpq2layers_plot' + str(iter)))
pylab.savefig(plotname)
# set-up the neural network
nneuron = 5
mom = 0.98
netname = "LSL-" + str(nneuron) + "-" + str(mom)
mv = ModuleValidator()
v = Validator()
n = FeedForwardNetwork(name=netname)
inLayer = LinearLayer(1, name='in')
hiddenLayer = SigmoidLayer(nneuron, name='hidden0')
outLayer = LinearLayer(1, name='out')
biasinUnit = BiasUnit(name="bhidden0")
biasoutUnit = BiasUnit(name="bout")
n.addInputModule(inLayer)
n.addModule(hiddenLayer)
n.addModule(biasinUnit)
n.addModule(biasoutUnit)
n.addOutputModule(outLayer)
in_to_hidden = FullConnection(inLayer, hiddenLayer)
bias_to_hidden = FullConnection(biasinUnit, hiddenLayer)
bias_to_out = FullConnection(biasoutUnit, outLayer)
hidden_to_out = FullConnection(hiddenLayer, outLayer)
n.addConnection(in_to_hidden)
n.addConnection(bias_to_hidden)
n.addConnection(bias_to_out)
def ffn(nodesNum, trainingTime):
"""构建神经网络"""
n = FeedForwardNetwork()
inLayer = LinearLayer(6) #构建神经网络的三层
hiddenLayer1 = SigmoidLayer(nodesNum)
hiddenLayer2 = SigmoidLayer(nodesNum)
hiddenLayer3 = SigmoidLayer(nodesNum)
hiddenLayer4 = SigmoidLayer(nodesNum)
hiddenLayer5 = SigmoidLayer(nodesNum)
hiddenLayer6 = SigmoidLayer(nodesNum)
hiddenLayer7 = SigmoidLayer(nodesNum)
hiddenLayer8 = SigmoidLayer(nodesNum)
hiddenLayer9 = SigmoidLayer(nodesNum)
hiddenLayer10 = SigmoidLayer(nodesNum)
outLayer = LinearLayer(1)
n.addInputModule(inLayer) #将三层加入网络中
n.addModule(hiddenLayer1)
n.addModule(hiddenLayer2)
n.addModule(hiddenLayer3)
n.addModule(hiddenLayer4)
n.addModule(hiddenLayer5)
n.addModule(hiddenLayer6)
n.addModule(hiddenLayer7)
n.addModule(hiddenLayer8)
n.addModule(hiddenLayer9)
n.addModule(hiddenLayer10)
n.addOutputModule(outLayer)
in_to_hidden = FullConnection(inLayer, hiddenLayer1) #设置连接模式
hidden_to_hidden1 = FullConnection(hiddenLayer1, hiddenLayer2)
hidden_to_hidden2 = FullConnection(hiddenLayer2, hiddenLayer3)
hidden_to_hidden3 = FullConnection(hiddenLayer3, hiddenLayer4)
hidden_to_hidden4 = FullConnection(hiddenLayer4, hiddenLayer5)
hidden_to_hidden5 = FullConnection(hiddenLayer5, hiddenLayer6)
hidden_to_hidden6 = FullConnection(hiddenLayer6, hiddenLayer7)
hidden_to_hidden7 = FullConnection(hiddenLayer7, hiddenLayer8)
hidden_to_hidden8 = FullConnection(hiddenLayer8, hiddenLayer9)
hidden_to_hidden9 = FullConnection(hiddenLayer9, hiddenLayer10)
hidden_to_out = FullConnection(hiddenLayer10, outLayer)
n.addConnection(in_to_hidden) #将连接加入网络
n.addConnection(hidden_to_hidden1)
n.addConnection(hidden_to_hidden2)
n.addConnection(hidden_to_hidden3)
n.addConnection(hidden_to_hidden4)
n.addConnection(hidden_to_hidden5)
n.addConnection(hidden_to_hidden6)
n.addConnection(hidden_to_hidden7)
n.addConnection(hidden_to_hidden8)
n.addConnection(hidden_to_hidden9)
n.addConnection(hidden_to_out)
n.sortModules() #使网络可用
print(n)
"""建立数据集"""
ds = SupervisedDataSet(6, 1) #六个输入，一个输出
#表查询语句
cur1 = conn.cursor()
cur1.execute(
'select * from szzs_rise_and_fall_rate limit 2,9999999999999999;')
result1 = cur1.fetchall()
fv = [] #特征
for res in result1:
a = []
a.append(float(list(res)[1]))
a.append(float(list(res)[2]))
a.append(float(list(res)[3]))
a.append(float(list(res)[4]))
a.append(float(list(res)[5]))
a.append(float(list(res)[6]))
fv.append(a)
cur2 = conn.cursor()
cur2.execute(
'select rise_fall_rate_next from szzs_rise_and_fall_rate limit 2,9999999999999999;'
)
result2 = cur2.fetchall()
cla = [] #分类
for res in result2:
cla.append(float(list(res)[0]))
cur3 = conn.cursor()
cur3.execute('select * from szzs_rise_and_fall_rate order by date desc;')
result3 = cur3.fetchmany(1)
test = [] #测试数据
for res in result3:
test.append(float(list(res)[1]))
test.append(float(list(res)[2]))
test.append(float(list(res)[3]))
test.append(float(list(res)[4]))
test.append(float(list(res)[5]))
test.append(float(list(res)[6]))
for i in range(0, len(fv)):
ds.addSample(fv[i], cla[i])
dataTrain, dataTest = ds.splitWithProportion(
0.8) #百分之八十的数据用于训练，百分之二十的数据用于测试
"""训练神经网络"""
trainer = BackpropTrainer(n, dataset=dataTrain) #神经网络和数据集
trainer.trainEpochs(trainingTime) #训练次数
return n.activate(test)
from pybrain.structure import RecurrentNetwork
#estructuras FeedForwardNetwork and RecurrentNetwork
from pybrain.structure import LinearLayer, SigmoidLayer, TanhLayer
#modulos BiasUnit,GaussianLayer, LinearLayer, LSTMLayer, MDLSTMLayer, SigmoidLayer, SoftmaxLayer, StateDependentLayer, TanhLayer
from pybrain.structure import FullConnection
#conectores
n = RecurrentNetwork(name='red de prueba1') #n = red
n.addInputModule(LinearLayer(
2,
name='entradas')) #agrega el modulo de 'entrada' a la red con 2 entradas
n.addModule(SigmoidLayer(3, name='ocultas')
) #agrega el modulo de 'oculta' a la red con 3 capas ocultas
#n.addModule(TanhLayer(3, name = 'ocultas'))#agrega el modulo de 'oculta' a la red con 3 capas ocultas
n.addOutputModule(LinearLayer(
1, name='salidas')) #agrega el modulo de 'salida' a la red con 1 salida
#flujo de informacion entre las capas
n.addConnection(
FullConnection(n['entradas'], n['ocultas'], name='con1')
) #agrega y conecta el modulo de conexion de capa 'entrada' a la red con las capas ocultas
n.addConnection(
FullConnection(n['ocultas'], n['salidas'], name='con2')
) #agrega y conecta el modulo de conexion de capa 'salida' a la red con las capas ocultas
n.addRecurrentConnection(
FullConnection(n['ocultas'], n['ocultas'], name='con3')) #metodo adicional
""" Created on Fri Apr 17 14:26:43 2020 @author: joao """ from pybrain.structure import FeedForwardNetwork from pybrain.structure import LinearLayer, SigmoidLayer, BiasUnit from pybrain.structure import FullConnection #criação da rede neural rede = FeedForwardNetwork() #criação das camadas camada_entrada = LinearLayer(2) camada_oculta = SigmoidLayer(3) camada_saida = SigmoidLayer(1) bias_1 = BiasUnit() bias_2 = BiasUnit() #inicialização das camadas dentro da rede neural rede.addModule(camada_entrada) rede.addModule(camada_oculta) rede.addModule(camada_saida) rede.addModule(bias_1) rede.addModule(bias_2) #ligação entre as camadas ligacao_entrada_oculta = FullConnection(camada_entrada, camada_oculta) ligacao_oculta_saida = FullConnection(camada_oculta, camada_saida)
print('====================================')
print('====================================')
print(' GRAPHS:', GRAPHS)
print(' HIDDENLAYERS:', HIDDENLAYERS)
print(' LEARNINGRATE:', LEARNINGRATE)
print(' MOMENTUM:', MOMENTUM)
print('====================================')
print('====================================')
# Prepare recurrent network
net = RecurrentNetwork()
# Add layers
net.addInputModule(LinearLayer(N * N, name='in'))
for layer in range(1, HIDDENLAYERS + 1):
net.addModule(SigmoidLayer(N * N, name='hidden' + str(layer)))
net.addOutputModule(TanhLayer(N * N, name='out'))
# Add connections between layers
net.addConnection(FullConnection(net['in'], net['hidden1']))
for layer in range(1, HIDDENLAYERS):
net.addConnection(
FullConnection(net['hidden' + str(layer)],
net['hidden' + str(layer + 1)]))
net.addConnection(FullConnection(net['hidden' + str(HIDDENLAYERS)],
net['out']))
net.addRecurrentConnection(
FullConnection(net['hidden' + str(HIDDENLAYERS)], net['hidden1']))
net.sortModules()
# Trainer
from pybrain.structure import FeedForwardNetwork from pybrain.structure import LinearLayer, SigmoidLayer, BiasUnit from pybrain.structure import FullConnection rede = FeedForwardNetwork() camadaEntrada = LinearLayer(2) camadaOculta = SigmoidLayer(3) camadaSaida = SigmoidLayer(1) #bias camada oculta bias1 = BiasUnit() #bias camada saida bias2 = BiasUnit() # adicionando as camadas dentro da rede (principal) rede.addModule(camadaEntrada) rede.addModule(camadaOculta) rede.addModule(camadaSaida) rede.addModule(bias1) rede.addModule(bias2) # ligação entre camada entrada e camada oculta entradaOculta = FullConnection(camadaEntrada, camadaOculta) ocultaSaida = FullConnection(camadaOculta, camadaSaida) # ligação bias 1 para camada oculta biasOculta = FullConnection(bias1, camadaOculta) # ligação bias 2 para camada saida
def neural_network(data_model, classes, runs):
# Python brain
from pybrain.structure import FullConnection, FeedForwardNetwork, LinearLayer, SigmoidLayer, SoftmaxLayer
from pybrain.datasets import ClassificationDataSet
from pybrain.utilities import percentError
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.tools.xml.networkwriter import NetworkWriter
from pybrain.tools.xml.networkreader import NetworkReader
import csv
# Build Network
try:
n = NetworkReader.readFrom('resources/net.xml')
print 'Loading previous network'
except:
print 'Generating new network'
# Create a new Network
n = FeedForwardNetwork()
# Define the input layer
inLayer = LinearLayer(len(data_model[0][0]))
# Define a hidden layer
hiddenLayer = SigmoidLayer(10)
hiddenLayer2 = SigmoidLayer(10)
# Define the output layer
outLayer = LinearLayer(classes)
# Add layers to network n
n.addInputModule(inLayer)
n.addModule(hiddenLayer)
n.addModule(hiddenLayer2)
n.addOutputModule(outLayer)
# Create layers
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_hidden2 = FullConnection(hiddenLayer, hiddenLayer2)
hidden2_to_out = FullConnection(hiddenLayer2, outLayer)
# Add connectors to network n
n.addConnection(in_to_hidden)
n.addConnection(hidden_to_hidden2)
n.addConnection(hidden2_to_out)
# Finish Network
n.sortModules()
# Other Stuff
ds = ClassificationDataSet(len(data_model[0][0]), 1, nb_classes=classes)
# di = ClassificationDataSet(2,1,0)
for o in data_model:
ds.addSample(o[0], o[1])
testing_data, training_data = ds.splitWithProportion(0.3)
training_data._convertToOneOfMany()
testing_data._convertToOneOfMany()
print "Number of training patterns: ", len(training_data)
print "Input and output dimensions: ", training_data.indim, training_data.outdim
print "First sample (input, target, class):"
print training_data['input'][0], training_data['target'][0], training_data[
'class'][0]
trainer = BackpropTrainer(n, dataset=training_data)
smart = []
dumb = []
with open("resources/minimum_error.csv", 'rb') as f:
reader = csv.reader(f)
for row in reader:
smart.append(row)
smart[0] = float(smart[0][0])
print 'The minimum error from previous runs =', smart[0]
for t in range(runs):
trainer.trainEpochs(1)
trnresult = percentError(trainer.testOnClassData(),
training_data['class'])
tstresult = percentError(trainer.testOnClassData(dataset=testing_data),
testing_data['class'])
print "epoch: %4d" % trainer.totalepochs, " train error: %5.5f%%" % trnresult, " test error: %5.5f%%" % tstresult
smart.append(tstresult)
if tstresult <= min(smart):
NetworkWriter.writeToFile(n, 'resources/net.xml')
print 'Best!'
else:
dumb.append('1')
print 'Worst!'
minimum_error = []
minimum_error.append(min(smart))
with open("resources/minimum_error.csv", 'wb') as f:
writer = csv.writer(f)
writer.writerow(minimum_error)
print 'Minimum error (current state)', min(smart)
return n
""" Created on Fri May 1 21:12:45 2020 @author: aasousa """ from pybrain.structure import FeedForwardNetwork from pybrain.structure import LinearLayer, SigmoidLayer, BiasUnit from pybrain.structure import FullConnection # criação da rede rede = FeedForwardNetwork() # criando as camadas da rede camadaEntrada = LinearLayer(2) # com quantidade de neurônios camadaOculta = SigmoidLayer(3) # camada oculta com a função sigmoid camadaSaida = SigmoidLayer(1) # camada de saída com a função sigmoid bias_camada_oculta = BiasUnit() bias_camada_saida = BiasUnit() # adicionado as camadas dentro da rede neural rede.addModule(camadaEntrada) rede.addModule(camadaOculta) rede.addModule(camadaSaida) rede.addModule(bias_camada_oculta) rede.addModule(bias_camada_saida) # realizando a conexão com as camadas da rede entradaOculta = FullConnection(camadaEntrada, camadaOculta) ocultaSaida = FullConnection(camadaOculta, camadaSaida)
def __init__(self,learningrate = 0.001,inputneurons = 2,hiddenneurons =50,outputneurons = 2,testondata= True, \
momentum = 0.2,train_percent = 99,recurnet = False):
"""
Neural networks class
assign a learning rate of your choice , default is 0.01
inputneurons = number of neurons on input layer: can be set to the input dimension of the data
hiddenneurons= keep it more than inputneurons in general
outputneurons = output dimension of your data
testondata = If you want to print out the performance of your neural net, defaults to true
"""
assert (hiddenneurons > inputneurons), "Number of hiddenneurons can't be lesser than inputneurons"
self.learningrate = learningrate
self.inputneurons = inputneurons
self.hiddenneurons = hiddenneurons
self.outputneurons = outputneurons
#momentum is the parameter to realize how efficiently the learning will get out of a local minima,
#not sure what to put as an appropriate value
self.momentum = momentum
#Construct network here
self.mlpnetwork = buildNetwork(self.inputneurons, self.hiddenneurons, self.outputneurons, bias=True,recurrent=recurnet)
self.mlpnetwork.sortModules()
print self.mlpnetwork,"-----------------------------------"
self.trainer = None
self.validation = testondata
self.data = None
self.learnedNetwork = None
self.train_percent = (1. *train_percent )/100
#creating a feedforward network
self.ffn = FeedForwardNetwork()
inlayer = LinearLayer(inputneurons)
hiddenlayer1 = SigmoidLayer(4)
hiddenlayer2 = SigmoidLayer(2)
outlayer = LinearLayer(outputneurons)
#assigning them to layers
self.ffn.addInputModule(inlayer)
self.ffn.addModule(hiddenlayer1)
self.ffn.addModule(hiddenlayer2)
self.ffn.addOutputModule(outlayer)
#defining connections
in_to_hidden1 = FullConnection(inlayer,hiddenlayer1)
hidden1_to_hidden2 = FullConnection(hiddenlayer1,hiddenlayer2)
hidden2_to_out = FullConnection(hiddenlayer2,outlayer)
#explicitly adding them to network
self.ffn.addConnection(in_to_hidden1)
self.ffn.addConnection(hidden1_to_hidden2)
self.ffn.addConnection(hidden2_to_out)
#explicitly call sortmodules
self.ffn.sortModules()
print "created network successfully...."
def generate_network_forecaster(history_size=1):
#Building Network proccess-------------------------------------------------------
net = FeedForwardNetwork()
inLayer = LinearLayer(history_size)
hiddenLayer0 = SigmoidLayer(history_size)
hiddenLayer1 = LinearLayer(3)
outLayer = LinearLayer(1)
net.addInputModule(inLayer)
net.addModule(hiddenLayer0)
net.addModule(hiddenLayer1)
net.addOutputModule(outLayer)
net.addConnection(FullConnection(inLayer, hiddenLayer0))
#net.addConnection(FullConnection(inLayer, outLayer))
#net.addConnection(FullConnection(hiddenLayer0, outLayer))
net.addConnection(FullConnection(hiddenLayer0, hiddenLayer1))
net.addConnection(FullConnection(hiddenLayer1, outLayer))
net.sortModules()
AUX = 0.1
print net
##Net with 3 inputs, 8 hidden neurons in a layer and 8 in another, and 1 out.
#net = buildNetwork(3,8,8,1)
#Making Forecaster---------------------------------------------------------------
def learn(self, data, lag, epoch=60):
self.samples.clear()
self.true_predictions = 0 #This numbers indicates how long the net was used to predict a event rather than using another method because haven't enought data.
self.predictions = 0
self.lag = lag
for i in range(len(data) - (lag + self.history_size)):
self.samples.addSample(
[data[j][1] * AUX for j in range(i, i + self.history_size)],
data[i + lag + self.history_size][1] * AUX)
print 'Training'
elapsed = os.times()[-1] #take time as miliseconds
self.trainer.trainUntilConvergence(
maxEpochs=epoch) # , validationProportion = 0.01)
elapsed = os.times()[-1] - elapsed
if elapsed <= 60:
time = '%2.1f seconds.' % elapsed
elif elapsed <= 3600:
time = '%d minutes and %2.1f seconds.' % (elapsed / 60,
elapsed % 60)
else:
time = '%d hours, %d minutes and %2.1f seconds.' % (
elapsed / 3600, elapsed / 60, elapsed % 60)
print 'Trained along', time
def predict(self, lag):
if self.initialized:
return self.mem
else:
if 'vect' in dir(self):
return self.vect[-1]
else:
raise Exception("Forecaster " + self.name +
" don't initialized.")
def update(self, data):
if self.initialized:
self.vect.append(data[1])
if len(self.vect) > self.history_size:
self.vect = self.vect[1:]
self.mem = self.net.activate(map(lambda x: x * AUX,
self.vect)) * (1 / AUX)
else:
self.mem = data[1]
if 'vect' in dir(self):
self.vect.append(data[1])
else:
self.vect = [data[1]]
if len(self.vect) >= self.history_size:
self.initialized = True
NN = Forecaster(name='Neural Net',
predict_function=predict,
update_function=update,
learn_function=learn)
NN.history_size = history_size
NN.net = net
NN.samples = SupervisedDataSet(history_size, 1)
NN.trainer = BackpropTrainer(NN.net, NN.samples)
return NN
def build(self, filename=None):
"""Build and train a network according to a supplied configuration file. The config file should be in
the following format :
line number == 1 | input layer size <tab> hidden layer size <tab> output layer size
line number == 2 | acceptable error
line number <= 3 | input 1 <tab> input 2 <tab> | <tab> output 1 <tab> output 2
<tab> : tab separator
If multiple hidden layer sizes are specified on the first line , multiple hidden layers will be
included in the built network. E.g. 5 <tab> 4 <tab> 3 <tab> 2 <tab> will built a net with 4 neurons at
the input layer, 4 at the first hidden layer, 3 at the second hidden layer, and 2 at the output layer.
Multiple input and output states can be specified in the training data in a similar way.
Blank lines in the data set will be ignored. This is useful for separating training data for
readability.
See red_net_config.txt for an example network config file.
"""
if filename is None: # if no filename is supplied
filename = self.filename # use filename given at init
if filename != self.filename: # if new filename has been given
self.filename = filename # store new filename
config_file = open(filename, 'rb') # open the data file
config_lines = list(csv.reader(
config_file, delimiter='\t')) # read as csv with tab delim's
layers = [int(size)
for size in config_lines[0]] # split off layer config
acceptable_error = float(
config_lines[1][0]) # split off acceptable error
dataset = config_lines[2:] # split off data set
# build empty network TODO variable network types
self.network = FeedForwardNetwork() # build the net
# form layers TODO variable layer types
input_size = layers[0]
output_size = layers[-1]
input_layer = LinearLayer(input_size) # form input layer
hidden_layers = [SigmoidLayer(size)
for size in layers[1:-1]] # form hidden layers
output_layer = SigmoidLayer(output_size) # form output layer
# add layers to network
self.network.addInputModule(input_layer) # add input layer
[self.network.addModule(layer)
for layer in hidden_layers] # add hidden layers
self.network.addOutputModule(output_layer) # add output layer
# form connections TODO variable connection types and topologies
in_to_h = FullConnection(
input_layer, hidden_layers[0]) # form input -> first hidden
h_to_out = FullConnection(hidden_layers[-1],
output_layer) # form last hidden -> output
h_to_h = [] # list for hidden conn's
for x in range(len(hidden_layers)): # count through hidden layers
if x is not len(hidden_layers) - 1: # if not at last hidden layer
hh_conn = FullConnection(
hidden_layers[x], # form hidden n ->
hidden_layers[x + 1]) # hidden n + 1 connection
h_to_h.append(hh_conn) # add to list of hidden conn's
# add connections to network
self.network.addConnection(in_to_h) # add input -> first hidden
self.network.addConnection(h_to_out) # add last hidden -> output
[self.network.addConnection(hh_conn)
for hh_conn in h_to_h] # add hidden n -> hidden n + 1
# solidify network
self.network.sortModules() # sort network topology
# train network TODO variable trainer types
self.dataset = SupervisedDataSet(input_size,
output_size) # form data set
for mapping in dataset:
input_data = tuple(
[float(input_state) for input_state in mapping[0:input_size]])
output_data = tuple(
float(output_state)
for output_state in mapping[0 - output_size:])
if input_data is not tuple([]):
self.dataset.addSample(input_data, output_data)
trainer = BackpropTrainer(self.network, self.dataset) # form trainer
trained = False # set trained flag to False
epoch = 0 # set epoch to 0
self._pause = False
while trained is False: # as long as net isn't trained
if self._pause: time.sleep(1) # if paused, wait a second
else:
epoch += 1 # increment epoch counter
error = trainer.train() # reduce the error
print('epoch : %i error : %f' % (epoch, error)
) # print current error
if error < acceptable_error: # if error is acceptable
trained = True # set trained flag to True
def execute_mlp(n_neurons, data_size, learn_rate, momentum_rate, f):
dic = {'Iris-setosa\n': 0, 'Iris-versicolor\n': 1, 'Iris-virginica\n': 2}
filename = "iris.txt"
file = read_file(filename)
file = change_class_name(file, dic)
file = str_to_number(file)
file_array = np.array(file)
data = normalize_data(file_array)
#data = order_data(data)
data = data[::-1] #INTERTENDO A ORDEM DOS ITENS
inputs = data[:, :-1] #COPIAR TODAS AS COLUNAS MENOS A ULTIMA
targets = data[:, -1] #COPIAR ULTIMA COLUNA
train_data_temp, test_data_temp = train_test_data(data, data_size)
train_data = ClassificationDataSet(
4, nb_classes=3) #TAMANHO DA ENTRADA, NUMERO DE CLASSES
test_data = ClassificationDataSet(
4, nb_classes=3) #TAMANHO DA ENTRADA, NUMERO DE CLASSES
cont = 0
for n in range(0, len(train_data_temp)):
train_data.addSample(train_data_temp[n][:-1], [train_data_temp[n][-1]])
#print(train_data.getSample(cont))
#cont = cont + 1
for n in range(0, len(test_data_temp)):
test_data.addSample(test_data_temp[n][:-1], [test_data_temp[n][-1]])
train_data._convertToOneOfMany()
test_data._convertToOneOfMany()
'''
print ("Number of training patterns: ", len(train_data))
print ("Input and output dimensions: ", train_data.indim, train_data.outdim)
print ("First sample (input, target, class):")
print (test_data['input'][0], test_data['target'][0], test_data['class'][0])
'''
network = FeedForwardNetwork()
inLayer = SigmoidLayer(train_data.indim)
first_hiddenLayer = SigmoidLayer(n_neurons)
second_hiddenLayer = SigmoidLayer(n_neurons)
outLayer = SigmoidLayer(train_data.outdim)
network.addInputModule(inLayer)
network.addModule(first_hiddenLayer)
network.addModule(second_hiddenLayer)
network.addOutputModule(outLayer)
in_to_hidden = FullConnection(inLayer, first_hiddenLayer)
hidden_to_hidden = FullConnection(first_hiddenLayer, second_hiddenLayer)
hidden_to_out = FullConnection(second_hiddenLayer, outLayer)
network.addConnection(in_to_hidden)
network.addConnection(hidden_to_hidden)
network.addConnection(hidden_to_out)
network.sortModules()
#trainer = BackpropTrainer( network, dataset=train_data, momentum=momentum_rate, verbose=False, weightdecay=learn_rate)
trainer = BackpropTrainer(network, dataset=train_data, verbose=False)
for i in range(1):
trainer.trainEpochs(1000)
result = trainer.testOnClassData(test_data, return_targets=True)
#result = classification(result[1],result[0])
print(result)
f.write(str(result))
f.flush()
def main():
#sample patches from image database
myCleaver = imageCleaver()
#instantiate NN with size as defined in image cleaver class.
#TODO: size should be input to imageCleaver class.
# net = buildNetwork(myCleaver.sizePatches*myCleaver.sizePatches, (myCleaver.sizePatches*myCleaver.sizePatches)/2.0, myCleaver.sizePatches*myCleaver.sizePatches, bias = True)
net = FeedForwardNetwork()
inLayer = LinearLayer(myCleaver.sizePatches * myCleaver.sizePatches)
hiddenLayer = SigmoidLayer(
(myCleaver.sizePatches * myCleaver.sizePatches) / 4.0)
outLayer = LinearLayer(myCleaver.sizePatches * myCleaver.sizePatches)
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()
# fileObject = open('pickledNet.dat','r')
# net = pickle.load(fileObject)
# fileObject.close()
# net = NetworkReader.readFrom('filename.xml')
# print(net.activate([2, 1]))
#Put imageCleaver dataset into pyBrain dataset format.
ds = SupervisedDataSet(myCleaver.sizePatches * myCleaver.sizePatches,
myCleaver.sizePatches * myCleaver.sizePatches)
for i in range(myCleaver.concImgArray.shape[1]):
ds.addSample(myCleaver.concImgArray.T[i] / 256.0,
myCleaver.concImgArray.T[i] / 256.0)
# for inpt, target in ds:
# print inpt, target
trainer = BackpropTrainer(net, ds)
for i in range(1):
print(trainer.train())
# fileObject = open('pickledNet.dat', 'w')
# pickle.dump(net, fileObject)
# fileObject.close()
# NetworkWriter.writeToFile(net, 'testNetwork8.xml')
# saveNetParamsToFile(net)
# loadNetParamsFromFile(net)
imitationActivations = net.activate(myCleaver.concImgArray.T[0] / 256.0)
imitation = np.reshape(imitationActivations,
(myCleaver.sizePatches, myCleaver.sizePatches))
plt.figure(1)
plt.title('Input vs output')
plt.subplot(221)
plt.imshow(myCleaver.patchDataBase[0],
cmap=plt.cm.gray,
interpolation='nearest',
vmin=0,
vmax=256)
plt.title('input')
plt.subplot(223)
plt.imshow(imitation * 256,
cmap=plt.cm.gray,
interpolation='nearest',
vmin=0,
vmax=256)
plt.title('imitation')
## plt.show()
# print 'imitation'
# print imitation*256
imitationActivations2 = net.activate(myCleaver.concImgArray.T[1] / 256.0)
imitation2 = np.reshape(imitationActivations2,
(myCleaver.sizePatches, myCleaver.sizePatches))
# plt.figure(2)
# plt.title('Input vs output2')
plt.subplot(222)
plt.imshow(myCleaver.patchDataBase[1],
cmap=plt.cm.gray,
interpolation='nearest',
vmin=0,
vmax=256)
plt.title('input2')
plt.subplot(224)
plt.imshow(imitation2 * 256,
cmap=plt.cm.gray,
interpolation='nearest',
vmin=0,
vmax=256)
plt.title('imitation2')
## plt.subplot_tool()
plt.show()
# print 'imitation2'
# print imitation2*256#
#################################################################
#calculate and show each hidden nodes learned function, i.e. which input vector maximally excites the hidden node, with constrain ||x||^2 <=1
#################################################################
learned = []
#convert dims from float to integer
i2hid = int(in_to_hidden.indim)
i2hod = int(in_to_hidden.outdim)
print i2hid
print i2hod
#go through each hidden node
for i in range(i2hod):
print('i: ', i)
one_learned = []
sumOfWeights = 0
#go through weights for the ith hidden node, sum weights
for j in range(i2hid):
print('j1: ', j)
#add to sum, the value of connection between input
sumOfWeights += (in_to_hidden.params[i * i2hid + j])**2
#for each input, calculate effect on hidden node by summing all om inputs
for j in range(i2hid):
print('j2: ', j)
one_learned.append(in_to_hidden.params[i * i2hid + j] /
math.sqrt(sumOfWeights))
learned.append(one_learned)
fig3, axes = plt.subplots(nrows=int(math.sqrt(len(learned))),
ncols=(int(math.sqrt(len(learned)))))
for dat, ax in zip(learned, axes.flat):
# The vmin and vmax arguments specify the color limits
im = ax.imshow(np.reshape(
dat, (myCleaver.sizePatches, myCleaver.sizePatches)),
cmap=plt.cm.gray,
interpolation='nearest')
#print(len(myCleaver.patchDataBase))
#print(myCleaver.getImages)
#getTrainingSet()
# print 'np.array(net.activate(myCleaver.concImgArray.T[0]/256.0))'
# print net.activate(myCleaver.concImgArray.T[0]/256.0)
# print 'np.array(net.activate(myCleaver.concImgArray.T[1]/256.0))'
# print net.activate(myCleaver.concImgArray.T[1]/256.0)
# print('')
#
# print('the two inputs')
# print(ds.getSample(0))
# print(ds.getSample(1))
# print('')
#
# print('original inputs')
# print(myCleaver.concImgArray.T[0]/256.0)
# print(myCleaver.concImgArray.T[1]/256.0)
# print('')
#
# print('first activation')
# print(net.activate(myCleaver.concImgArray.T[0]/256.0))
# print('second activation')
# print(net.activate(myCleaver.concImgArray.T[1]/256.0))
# print(net.params)
# print(net)
# print(net.outmodules)
#
#
# net = buildNetwork(4,2,4, bias = True)
# print('simple net activation')
# print(net.activate((1,2,3,4)))
# print('simple net activation2')
# print(net.activate((5,4,3,2)))
# print('')
#
for mod in net.modules:
print "Module:", mod.name
if mod.paramdim > 0:
print "--parameters:", mod.params
for conn in net.connections[mod]:
print "-connection to", conn.outmod.name
if conn.paramdim > 0:
print "- parameters", conn.params
if hasattr(net, "recurrentConns"):
print "Recurrent connections"
for conn in net.recurrentConns:
print "-", conn.inmod.name, " to", conn.outmod.name
if conn.paramdim > 0:
print "- parameters", conn.params
from pybrain.structure import FeedForwardNetwork, SigmoidLayer, LinearLayer, FullConnection from pybrain.datasets import SupervisedDataSet from pybrain.supervised.trainers import BackpropTrainer import numpy as np net = FeedForwardNetwork() l_in = LinearLayer(4) l_hid = SigmoidLayer(6) l_out = LinearLayer(3) net.addInputModule(l_in) net.addModule(l_hid) net.addOutputModule(l_out) i2h = FullConnection(l_in, l_hid) h2o = FullConnection(l_hid, l_out) net.addConnection(i2h) net.addConnection(h2o) net.sortModules() print(net) dataset = SupervisedDataSet(4, 3) dataset.addSample((1, 0, 0, 0), (1, 0, 0)) dataset.addSample((0, 1, 0, 0), (0, 1, 0)) dataset.addSample((0, 0, 0, 1), (0, 0, 1)) dataset.addSample((0, 0, 1, 1), (0, 0, 1)) dataset.addSample((0, 0, 1, 0), (0, 1, 0)) dataset.addSample((1, 1, 0, 0), (1, 0, 0))
def defineArquitetura(self):
self.camada_entrada = LinearLayer(self.camada_entrada, name="entrada")
self.camada_oculta = SigmoidLayer(self.camada_oculta, name="oculta")
self.camada_saida = LinearLayer(self.camada_saida, name="saida")
self.adicionaEstrutura()
from pybrain.structure import FeedForwardNetwork n = FeedForwardNetwork() from pybrain.structure import LinearLayer, SigmoidLayer inLayer = LinearLayer(2, name="Foo The II of LinearLayer") hiddenLayer = SigmoidLayer(3, name="Bob the Pesant") outLayer = LinearLayer(1, name="Foo The II Royal Decree") n.addInputModule(inLayer) n.addModule(hiddenLayer) n.addOutputModule(outLayer) from pybrain.structure import FullConnection in_to_hidden = FullConnection(inLayer, hiddenLayer) hidden_to_out = FullConnection(hiddenLayer, outLayer) n.addConnection(in_to_hidden) n.addConnection(hidden_to_out) n.sortModules() #print n from pybrain.structure import RecurrentNetwork n = RecurrentNetwork() n.addInputModule(LinearLayer(2, name='in')) n.addModule(SigmoidLayer(3, name='hidden')) n.addOutputModule(LinearLayer(1, name='out')) n.addConnection(FullConnection(n['in'], n['hidden'], name='c1')) n.addConnection(FullConnection(n['hidden'], n['out'], name='c2')) n.addRecurrentConnection(FullConnection(n['hidden'], n['hidden'], name='c3'))
DS = SupervisedDataSet(150, 34)
# add data element to the dataset
for i in np.arange(len(input)):
DS.addSample(input[i], output[i])
# you can get your input/output this way
X = DS['input']
Y = DS['target']
# createa neural network
fnn = FeedForwardNetwork()
# create three layers
inLayer = LinearLayer(150, name='inLayer')
hiddenLayer0 = SigmoidLayer(50, name='hiddenLayer0')
outLayer = SigmoidLayer(34, name='outLayer')
# add three layers to the neural network
fnn.addInputModule(inLayer)
fnn.addModule(hiddenLayer0)
fnn.addOutputModule(outLayer)
# link three layers
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)
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()
ds_train, ds_test = ds.splitWithProportion(TRAIN_SIZE) #%% # Определение основных констант HIDDEN_NEURONS_NUM = 10 # Количество нейронов, содержащееся в скрытом слое сети HIDDEN_NEURONS_NUM2 = 20 MAX_EPOCHS = 250 # Максимальное число итераций алгоритма оптимизации параметров сети #%% np.random.seed(0) net = FeedForwardNetwork() inLayer = LinearLayer(N) hiddenLayer = SigmoidLayer(HIDDEN_NEURONS_NUM) #hiddenLayer2 = SigmoidLayer(HIDDEN_NEURONS_NUM2) #outLayer = LinearLayer(1) outLayer = SigmoidLayer(1) net.addInputModule(inLayer) net.addModule(hiddenLayer) #net.addModule(hiddenLayer2) net.addOutputModule(outLayer) net.addConnection(FullConnection(inLayer, hiddenLayer)) #net.addConnection(FullConnection(hiddenLayer,hiddenLayer2)) #net.addConnection(FullConnection(hiddenLayer2, outLayer)) net.addConnection(FullConnection(hiddenLayer, outLayer)) net.sortModules() #net = buildNetwork(ds_train.indim, HIDDEN_NEURONS_NUM, ds_train.outdim, bias=True,outclass=SoftmaxLayer)
from pybrain.structure import FeedForwardNetwork from pybrain.structure import LinearLayer, SigmoidLayer from pybrain.structure import FullConnection n = FeedForwardNetwork() inLayer = LinearLayer(2) hiddenLayer = SigmoidLayer(3) outLayer = LinearLayer(1) 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() print n.activate([1, 2]) print in_to_hidden.params
def trainNetwork(train_ds, test_ds,
train_ds_labels, test_ds_labels,
features,
learningrate, lrdecay,
momentum, weightdecay,
hidden_layers,
time_limit_seconds):
fnn = FeedForwardNetwork()
inLayer = LinearLayer(train_ds.indim)
fnn.addInputModule(inLayer)
lastLayer = inLayer
connection_number = 0 # connection-0 is the connection from the input layer.
for hidden_layer_size in hidden_layers:
# hiddenLayer = SigmoidLayer(hidden_layer_size)
hiddenLayer = TanhLayer(hidden_layer_size)
fnn.addModule(hiddenLayer)
fnn.addConnection(
FullConnection(lastLayer, hiddenLayer,
name="connection-%d" % connection_number))
connection_number = connection_number + 1
bias = BiasUnit()
fnn.addModule(bias)
fnn.addConnection(FullConnection(bias, hiddenLayer))
lastLayer = hiddenLayer
outLayer = SigmoidLayer(train_ds.outdim)
fnn.addOutputModule(outLayer)
fnn.addConnection(
FullConnection(lastLayer, outLayer,
name="connection-%d" % connection_number))
bias = BiasUnit()
fnn.addModule(bias)
fnn.addConnection(FullConnection(bias, outLayer))
fnn.sortModules()
trainer = BackpropTrainer(fnn, dataset=train_ds,
learningrate=learningrate,
lrdecay=lrdecay,
momentum=momentum,
verbose=False,
weightdecay=weightdecay)
# Train
(initial_train_error, initial_train_F1) = percentClassErrorAndF1(fnn, train_ds, train_ds_labels, features)
train_errors = [initial_train_error]
train_F1s = [initial_train_F1]
(initial_test_error, initial_test_F1) = percentClassErrorAndF1(fnn, test_ds, test_ds_labels, features)
test_errors = [initial_test_error]
test_F1s = [initial_test_F1]
train_algo_errors = [trainer.testOnData(train_ds) * 100]
test_algo_errors = [trainer.testOnData(test_ds) * 100]
epochs = [0]
try:
start_time = time.time()
for i in range(200):
for _ in xrange(50):
train_algo_error = trainer.train() * 100.0
if math.isnan(train_algo_error):
break
if math.isnan(train_algo_error):
break
(trnresult, trnF1) = percentClassErrorAndF1(fnn, train_ds, train_ds_labels, features)
(tstresult, tstF1) = percentClassErrorAndF1(fnn, test_ds, test_ds_labels, features)
test_algo_error = trainer.testOnData(test_ds)* 100
now_time = time.time()
time_left = time_limit_seconds - (now_time - start_time)
print("epoch %3d:" % trainer.totalepochs,
" train error: %6.4f%%" % train_algo_error,
" test error: %6.4f%%" % test_algo_error,
" train F1: %s" % ", ".join([("%.2f" % x) for x in trnF1]),
" test F1: %s" % ", ".join([("%.2f" % x) for x in tstF1]),
" %ds left" % int(round(time_left)))
epochs.append(trainer.totalepochs)
train_errors.append(trnresult)
train_F1s.append(trnF1)
test_errors.append(tstresult)
test_F1s.append(tstF1)
train_algo_errors.append(train_algo_error)
test_algo_errors.append(test_algo_error)
if time_left <= 0:
print("Timeout: Time to report the results.")
break;
# if test_algo_errors[-1] < 4:
# print("Good enough? Don't want to overtrain")
# break;
except KeyboardInterrupt:
# Someone pressed Ctrl-C, try to still plot the data.
print("Aborted training...")
pass
return (fnn, epochs, train_algo_errors, test_algo_errors, train_F1s, test_F1s)
#
if (DEBUG > 2):
pp(trndata)
#
# now build a feedforward neural network
#
# Configuration:
#
# Input Layer dimension: 2
# 2 hidden layers with 5 sigmoid neurons
# Output layer has 3 Softmax neurons
#
net = FeedForwardNetwork()
inLayer = LinearLayer(2)
hiddenLayer1 = SigmoidLayer(5)
hiddenLayer2 = SigmoidLayer(5)
outLayer = SoftmaxLayer(3)
#
# add those layers (modules)
#
net.addInputModule(inLayer)
net.addModule(hiddenLayer1)
net.addModule(hiddenLayer2)
net.addOutputModule(outLayer)
#
# do the plumbing
#
in_to_hidden1 = FullConnection(inLayer, hiddenLayer1)
hidden1_to_hidden2 = FullConnection(hiddenLayer1, hiddenLayer2)
hidden2_to_out = FullConnection(hiddenLayer2, outLayer)
nY1 = no.normalize01(y1)
epocas = 3000
DS = SupervisedDataSet(1, 1)
#DS.appendLinked([1],[2])
#DS.appendLinked([2],[3])
for i in range(len(nX1)):
DS.appendLinked((nX1[i]), (nY1[i]))
#Creiando rede FF
n = FeedForwardNetwork()
#Construindo Módulos
inLayer = LinearLayer(DS.indim)
hiddenLayer = SigmoidLayer(8)
hiddenLayer2 = SigmoidLayer(12)
outLayer = LinearLayer(DS.outdim)
#Adicionando os módulos criados a rede
n.addInputModule(inLayer)
n.addModule(hiddenLayer)
n.addModule(hiddenLayer2)
n.addOutputModule(outLayer)
#Deve ser explicito como os módulos devem estar conectados
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_hidden2 = FullConnection(hiddenLayer, hiddenLayer2)
hidden2_to_out = FullConnection(hiddenLayer2, outLayer)