def _constructNetwork(self, nIn, nOut, params):
''' Construct the network '''
nHidden = params.setdefault('nHidden', 2)
hiddenSize = np.empty(nHidden)
for i in range(nHidden):
pstr = 'hiddenSize[' + str(i) + ']'
hiddenSize[i] = params.setdefault(pstr, nIn + nOut)
# Construct network
ann = FeedForwardNetwork()
# Add layers
layers = []
layers.append(LinearLayer(nIn))
for nHid in hiddenSize:
layers.append(SoftmaxLayer(nHid))
layers.append(LinearLayer(nOut))
ann.addOutputModule(layers[-1])
ann.addInputModule(layers[0])
for mod in layers[1:-1]:
ann.addModule(mod)
# Connections
for i, mod in enumerate(layers):
if i < len(layers) - 1:
conn = FullConnection(mod, layers[i+1])
ann.addConnection(conn)
# Sort the modules
ann.sortModules()
return ann
def ann_network():
nn = FeedForwardNetwork()
# define the activation function and # of nodes per layer
in_layer = LinearLayer(13)
hidden_layer = SigmoidLayer(5)
bias_unit = BiasUnit(name='bias')
out_layer = LinearLayer(1)
# add modules to the network
nn.addInputModule(in_layer)
nn.addModule(hidden_layer)
nn.addModule(bias_unit)
nn.addOutputModule(out_layer)
# define connections between the nodes
hidden_with_bias = FullConnection(hidden_layer, bias_unit)
in_to_hidden = FullConnection(in_layer, hidden_layer)
hidden_to_out = FullConnection(hidden_layer, out_layer)
# add connections to the network
nn.addConnection(in_to_hidden)
nn.addConnection(hidden_with_bias)
nn.addConnection(hidden_to_out)
# perform network interal initialization
nn.sortModules()
return nn
def buildMLP(dataSet, num_hidden):
'''
Function that builds a feed forward network based
on the datset inputed.
The hidden layer has nodes equal to num_hidden.
'''
#make the network
network = FeedForwardNetwork()
#make network layers
inputLayer = LinearLayer(dataSet.indim)
hiddenLayer = SigmoidLayer(num_hidden)
outputLayer = LinearLayer(dataSet.outdim)
#add the layers to the network
network.addInputModule(inputLayer)
network.addModule(hiddenLayer)
network.addOutputModule(outputLayer)
#add bias
network.addModule(BiasUnit(name='bias'))
#create connections between layers
inToHidden = FullConnection(inputLayer, hiddenLayer)
hiddenToOut = FullConnection(hiddenLayer, outputLayer)
#connect bias
network.addConnection(FullConnection(network['bias'], outputLayer))
network.addConnection(FullConnection(network['bias'], hiddenLayer))
#add connections to the network
network.addConnection(inToHidden)
network.addConnection(hiddenToOut)
network.sortModules()
return network
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 BackupNetwork(genome=None):
#initial a network [12,12,4] and initial weights are baseline policy versions
from pybrain.structure import FeedForwardNetwork,LinearLayer,TanhLayer,FullConnection
network = FeedForwardNetwork()
inLayer= LinearLayer(12)
hiddenLayer = LinearLayer(12)
outLayer = TanhLayer(4)
network.addInputModule(inLayer)
network.addModule(hiddenLayer)
network.addOutputModule(outLayer)
weights = []
if(genome == None):
import pickle
weights = pickle.load(open("seed"))
else:
weights = genome
in_to_hidden = FullConnection(inLayer,hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer,outLayer)
for i in range(0,144):
in_to_hidden.params[i] = weights[i]
for j in range(0,48):
hidden_to_out.params[j] = weights[j+144]
network.addConnection(in_to_hidden)
network.addConnection(hidden_to_out)
network.sortModules()
return network
def buildNet(input_size, hidden_size):
n = FeedForwardNetwork()
in1Layer = LinearLayer(input_size)
in2Layer = LinearLayer(input_size)
hidden1Layer = SigmoidLayer(hidden_size)
hidden2Layer = SigmoidLayer(hidden_size)
hidden3Layer = SigmoidLayer(2)
outLayer = LinearLayer(1)
n.addInputModule(in1Layer)
n.addInputModule(in2Layer)
n.addModule(hidden1Layer)
n.addModule(hidden2Layer)
n.addModule(hidden3Layer)
n.addOutputModule(outLayer)
in1_to_hidden1 = FullConnection(in1Layer, hidden1Layer)
in2_to_hidden2 = FullConnection(in2Layer, hidden2Layer)
hidden1_to_hidden3 = FullConnection(hidden1Layer, hidden3Layer)
hidden2_to_hidden3 = FullConnection(hidden2Layer, hidden3Layer)
hidden3_to_out = FullConnection(hidden3Layer, outLayer)
n.addConnection(in1_to_hidden1)
n.addConnection(in2_to_hidden2)
n.addConnection(hidden1_to_hidden3)
n.addConnection(hidden2_to_hidden3)
n.addConnection(hidden3_to_out)
n.sortModules()
return n
def main():
n = FeedForwardNetwork()
in_layer = LinearLayer(2)
hidden_layer = SigmoidLayer(3)
out_layer = LinearLayer(1)
n.addInputModule(in_layer)
n.addModule(hidden_layer)
n.addOutputModule(out_layer)
in_to_hidden = FullConnection(in_layer, hidden_layer)
hidden_to_out = FullConnection(hidden_layer, out_layer)
n.addConnection(in_to_hidden)
n.addConnection(hidden_to_out)
n.sortModules()
print(">>> print n")
print(n)
print(">>> n.activate([1, 2])")
print(n.activate([1, 2]))
print(">>> in_to_hidden.params")
print(in_to_hidden.params)
print(">>> hidden_to_out.params")
print(hidden_to_out.params)
print(">>> n.params")
print(n.params)
def __init__(self, index, name, params):
self.name = name
self.index = index
self.liste = []#ClassificationDataSet(17, 1, nb_classes=4)
self.status_good = True
self.number_of_moves = 0
self.number_of_sound_moves = 0
n = FeedForwardNetwork()
self.inLayer = LinearLayer(5)
self.hiddenLayer1 = SigmoidLayer(15)
self.hiddenLayer2 = SigmoidLayer(15)
self.hiddenLayer3 = SigmoidLayer(15)
self.outLayer = LinearLayer(4)
n.addInputModule(self.inLayer)
n.addModule(self.hiddenLayer1)
n.addModule(self.hiddenLayer2)
n.addModule(self.hiddenLayer3)
n.addOutputModule(self.outLayer)
from pybrain.structure import FullConnection
in_to_hidden = FullConnection(self.inLayer, self.hiddenLayer1)
hidden_to_hidden1 = FullConnection(self.hiddenLayer1, self.outLayer2)
hidden_to_hidden2 = FullConnection(self.hiddenLayer2, self.outLayer3)
hidden_to_out = FullConnection(self.hiddenLayer3, self.outLayer)
n.addConnection(in_to_hidden)
n.addConnection(hidden_to_hidden1)
def construct_neural_network(number_of_hidden_nodes, number_of_hidden_layers, inputdim, outputdim):
"""
Constructs a neural network with a given amount of hidden layers and nodes per hidden layer
"""
input_layer = LinearLayer(inputdim)
hidden_layers = []
output_layer = SoftmaxLayer(outputdim)
# Nodes of the neural network
fnn = FeedForwardNetwork()
fnn.addInputModule(input_layer)
for i in range(number_of_hidden_layers):
sigm = SigmoidLayer(number_of_hidden_nodes)
hidden_layers.append(sigm)
fnn.addModule(sigm)
fnn.addOutputModule(output_layer)
bias = BiasUnit()
fnn.addModule(bias)
# Connections of the neural network
input_connection = FullConnection(input_layer, hidden_layers[0])
fnn.addConnection(input_connection)
fnn.addConnection(FullConnection(bias, hidden_layers[0]))
for i in range(len(hidden_layers) - 1):
full = FullConnection(hidden_layers[i], hidden_layers[i+1])
fnn.addConnection(full)
fnn.addConnection(FullConnection(bias, hidden_layers[i+1]))
output_connection = FullConnection(hidden_layers[-1], output_layer)
fnn.addConnection(output_connection)
fnn.addConnection(FullConnection(bias, hidden_layers[0]))
fnn.sortModules()
return fnn
class NNet(FunctionApproximator): def __init__(self, num_features, num_hidden_neurons): super(NNet,self).__init__(num_features) self.ds = SupervisedDataSet(num_features, 1) self.net = FeedForwardNetwork() self.net.addInputModule(LinearLayer(num_features, name='in')) self.net.addModule(LinearLayer(num_hidden_neurons, name='hidden')) self.net.addOutputModule(LinearLayer(1, name='out')) self.net.addConnection(FullConnection(self.net['in'], self.net['hidden'], name='c1')) self.net.addConnection(FullConnection(self.net['hidden'], self.net['out'], name='c2')) self.net.sortModules() def getY(self, inpt): #giving NAN return self.net.activate(inpt) def update(self, inpt, target): q_old = self.qvalue(state, action) q_new = self.qvalue(new_state, new_action) target = q_old + self.alpha*(reward + (self.gamma*q_new)-q_old) self.ds.addSample(inpt, target) # print inpt.shape, target.shape # print inpt, target trainer = BackpropTrainer(self.net, self.ds) # try: # trainer.trainUntilConvergence() # except: trainer.train()
def createNLayerFFNet(historySize, n, k): net = FeedForwardNetwork() # Create and add layers net.addInputModule(LinearLayer(historySize * 2, name='in')) net.addOutputModule(LinearLayer(1, name='out')) # Create and add connections between the layers baseLayerName = 'hidden%i' connectionName = 'c%i' net.addModule(SigmoidLayer(k, name=baseLayerName % 0)) net.addConnection(FullConnection(net['in'], net[baseLayerName % 0], name=connectionName % 0)) for i in xrange(1, n): layerName = baseLayerName % i inLayerName = baseLayerName % (i-1) net.addModule(SigmoidLayer(k, name=layerName)) net.addConnection(FullConnection(net[inLayerName], net[layerName], name=connectionName % (i-1))) net.addConnection(FullConnection(net[baseLayerName % (n-1)], net['out'], name=connectionName % (n-1))) # Preps the net for use net.sortModules() return net
def __init__(self, index, name, params):
self.name = name
self.index = index
self.status_good = True
n = FeedForwardNetwork()
self.inLayer = LinearLayer(17)
self.hiddenLayer = SigmoidLayer(5)
self.outLayer = LinearLayer(4)
n.addInputModule(self.inLayer)
n.addModule(self.hiddenLayer)
n.addOutputModule(self.outLayer)
from pybrain.structure import FullConnection
in_to_hidden = FullConnection(self.inLayer, self.hiddenLayer)
hidden_to_out = FullConnection(self.hiddenLayer, self.outLayer)
n.addConnection(in_to_hidden)
n.addConnection(hidden_to_out)
n.sortModules()
for j, i in enumerate(params[0]):
n.connections[self.hiddenLayer][0].params[j] = i
for j, i in enumerate(params[1]):
n.connections[self.inLayer][0].params[j] = i
self.n = n
class MyNet: def __init__(self, file='config.xml'): self.net = FeedForwardNetwork() self.file = file def constructNet(self, input, hidden, output): inputLayer = LinearLayer(input) hiddenLayer = TanhLayer(hidden) outputLayer = LinearLayer(output) self.net.addInputModule(inputLayer) self.net.addModule(hiddenLayer) self.net.addOutputModule(outputLayer) conn1 = FullConnection(inputLayer, hiddenLayer) conn2 = FullConnection(hiddenLayer, outputLayer) self.net.addConnection(conn1) self.net.addConnection(conn2) def setup(self): self.net.sortModules() def saveToFile(self,file='config.xml'): NetworkWriter.writeToFile(self.net, file) def loadFromFile(self, file='config.xml'): self.net = NetworkReader.readFrom(file)
def build_deep_network(linear_dimensions):
neural_net = FeedForwardNetwork()
inLayer = LinearLayer(linear_dimensions)
hiddenLayer_1 = SigmoidLayer(100)
hiddenLayer_2 = SigmoidLayer(100)
hiddenLayer_3 = SigmoidLayer(50)
outLayer = LinearLayer(1)
neural_net.addInputModule(inLayer)
neural_net.addModule(hiddenLayer_1)
neural_net.addModule(hiddenLayer_2)
neural_net.addModule(hiddenLayer_3)
neural_net.addOutputModule(outLayer)
in_to_hidden_1 = FullConnection(inLayer, hiddenLayer_1)
hidden_1_to_hidden_2 = FullConnection(hiddenLayer_1, hiddenLayer_2)
hidden_2_to_hidden_3 = FullConnection(hiddenLayer_2, hiddenLayer_3)
hidden_3_to_output = FullConnection(hiddenLayer_3, outLayer)
neural_net.addConnection(in_to_hidden_1)
neural_net.addConnection(hidden_1_to_hidden_2)
neural_net.addConnection(hidden_2_to_hidden_3)
neural_net.addConnection(hidden_3_to_output)
neural_net.sortModules()
return neural_net
def crearRN():
#Se crea la red neuronal
n = FeedForwardNetwork()
#Se declaran las laminas de entrada, las laminas escondidas y las de salida de la red neuronal
inLayer = LinearLayer(4096)
hiddenLayer = SigmoidLayer(3)
outLayer = LinearLayer(1)
#Se agregan los layers a la red neuronal
n.addInputModule(inLayer)
n.addModule(hiddenLayer)
n.addOutputModule(outLayer)
#Se declaran las conexiones de los nodos
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer, outLayer)
#Se establecen las conexiones en los layers de la red neuronal
n.addConnection(in_to_hidden)
n.addConnection(hidden_to_out)
#Red neuronal lista para usar
n.sortModules()
return n
def _createRBF(self):
# choose random centers on map
for i in range(self.numCenters):
self.centers.append(self.env._randomInitPose())
# create an RBF network
params = FeedForwardNetwork()
inLayer = LinearLayer(self.task.outdim)
hiddenLayer = RBFLayer(self.numCenters, self.centers)
#inLayer = RBFLayer(self.numCenters, self.centers)
outLayer = LinearLayer(self.task.indim)
params.addInputModule(inLayer)
params.addModule(hiddenLayer)
params.addOutputModule(outLayer)
in_to_hidden = FullConnection(inLayer,hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer,outLayer)
params.addConnection(in_to_hidden)
params.addConnection(hidden_to_out)
params.sortModules()
return params
def build_network(self, layers=None, end=1):
layerobjects = []
for item in layers:
try:
t, n = item
if t == "sig":
if n == 0:
continue
layerobjects.append(SigmoidLayer(n))
except TypeError:
layerobjects.append(LinearLayer(item))
n = FeedForwardNetwork()
n.addInputModule(layerobjects[0])
for i, layer in enumerate(layerobjects[1:-1]):
n.addModule(layer)
connection = FullConnection(layerobjects[i], layerobjects[i+1])
n.addConnection(connection)
n.addOutputModule(layerobjects[-1])
connection = FullConnection(layerobjects[-2], layerobjects[-1])
n.addConnection(connection)
n.sortModules()
return n
def initalize_nn():
global in_to_hidden
global hidden_to_hidden2
global hidden_to_out
# Old code (regression)
n = FeedForwardNetwork()
# n = buildNetwork( 2, 3, data.outdim, outclass=SoftmaxLayer )
inLayer = LinearLayer(2)
hiddenLayer = SigmoidLayer(3)
hiddenLayer2 = SigmoidLayer(3)
outLayer = LinearLayer(1)
n.addInputModule(inLayer)
n.addModule(hiddenLayer)
n.addModule(hiddenLayer2)
n.addOutputModule(outLayer)
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_hidden2 = FullConnection(hiddenLayer, hiddenLayer2)
hidden_to_out = FullConnection(hiddenLayer2, outLayer)
n.addConnection(in_to_hidden)
n.addConnection(hidden_to_hidden2)
n.addConnection(hidden_to_out)
n.sortModules()
return n
def create_ff_network(options):
"""Create the FeedForware network
:param options: The input options.
:return:
"""
# Create FF network
net = FeedForwardNetwork()
# Create each Layer instance
in_layer = LinearLayer(options['inUnitCount'])
hidden_layer = SigmoidLayer(options['hiddenUnitCount'])
out_layer = LinearLayer(options['outUnitCount'])
# Build network layer topology
net.addInputModule(in_layer)
net.addModule(hidden_layer)
net.addOutputModule(out_layer)
in_to_hidden = FullConnection(in_layer, hidden_layer)
hidden_to_out = FullConnection(hidden_layer, out_layer)
net.addConnection(in_to_hidden)
net.addConnection(hidden_to_out)
# Complete structure network
net.sortModules()
return net
def trainedANN():
n = FeedForwardNetwork()
n.addInputModule(LinearLayer(4, name='in'))
n.addModule(SigmoidLayer(6, name='hidden'))
n.addOutputModule(LinearLayer(2, name='out'))
n.addConnection(FullConnection(n['in'], n['hidden'], name='c1'))
n.addConnection(FullConnection(n['hidden'], n['out'], name='c2'))
n.sortModules()
draw_connections(n)
# d = generateTrainingData()
d = getDatasetFromFile(root.path()+"/res/dataSet")
t = BackpropTrainer(n, d, learningrate=0.001, momentum=0.75)
t.trainOnDataset(d)
# FIXME: I'm not sure the recurrent ANN is going to converge
# so just training for fixed number of epochs
count = 0
while True:
globErr = t.train()
print globErr
if globErr < 0.01:
break
count += 1
if count == 20:
return trainedANN()
exportANN(n)
draw_connections(n)
return n
def create_network():
# Create the network itself
network = FeedForwardNetwork()
# Create layers
NUMBER_OF_INPUT_BYTES = 1600 # because at input we have picture 40x40 size
NUMBER_OF_HIDDEN_LAYERS = 10 # number of hidden layers
NUMBER_OF_OUTPUT_CLASSES = 8 # because in output we have 8 classes
inLayer = LinearLayer( NUMBER_OF_INPUT_BYTES )
hiddenLayer = SigmoidLayer( NUMBER_OF_HIDDEN_LAYERS )
outLayer = LinearLayer( NUMBER_OF_OUTPUT_CLASSES )
# Create connections between layers
# We create FullConnection - each neuron of one layer is connected to each neuron of other layer
in_to_hidden = FullConnection( inLayer, hiddenLayer )
hidden_to_out = FullConnection( hiddenLayer, outLayer )
# Add layers to our network
network.addInputModule( inLayer )
network.addModule( hiddenLayer )
network.addOutputModule( outLayer )
# Add connections to network
network.addConnection( in_to_hidden )
network.addConnection( hidden_to_out )
# Sort modules to make multilayer perceptron usable
network.sortModules()
# prepare array to activate network
d_letter_array = read_array( "d" )
# activate network
network.activate( d_letter_array )
return network
def trained_cat_dog_ANN():
n = FeedForwardNetwork()
d = get_cat_dog_trainset()
input_size = d.getDimension('input')
n.addInputModule(LinearLayer(input_size, name='in'))
n.addModule(SigmoidLayer(input_size+1500, name='hidden'))
n.addOutputModule(LinearLayer(2, name='out'))
n.addConnection(FullConnection(n['in'], n['hidden'], name='c1'))
n.addConnection(FullConnection(n['hidden'], n['out'], name='c2'))
n.sortModules()
n.convertToFastNetwork()
print 'successful converted to fast network'
t = BackpropTrainer(n, d, learningrate=0.0001)#, momentum=0.75)
count = 0
while True:
globErr = t.train()
print globErr
count += 1
if globErr < 0.01:
break
if count == 30:
break
exportCatDogANN(n)
return n
def training(d):
# net = buildNetwork(d.indim, 55, d.outdim, bias=True,recurrent=False, hiddenclass =SigmoidLayer , outclass = SoftmaxLayer)
net = FeedForwardNetwork()
inLayer = SigmoidLayer(d.indim)
hiddenLayer1 = SigmoidLayer(d.outdim)
hiddenLayer2 = SigmoidLayer(d.outdim)
outLayer = SigmoidLayer(d.outdim)
net.addInputModule(inLayer)
net.addModule(hiddenLayer1)
net.addModule(hiddenLayer2)
net.addOutputModule(outLayer)
in_to_hidden = FullConnection(inLayer, hiddenLayer1)
hidden_to_hidden = FullConnection(hiddenLayer1, hiddenLayer2)
hidden_to_out = FullConnection(hiddenLayer2, outLayer)
net.addConnection(in_to_hidden)
net.addConnection(hidden_to_hidden)
net.addConnection(hidden_to_out)
net.sortModules()
print net
t = BackpropTrainer(net, d, learningrate = 0.9,momentum=0.9, weightdecay=0.01, verbose = True)
t.trainUntilConvergence(continueEpochs=1200, maxEpochs=1000)
NetworkWriter.writeToFile(net, 'myNetwork'+str(time.time())+'.xml')
return t
def trainSupervised(self,
num,
ds,
initialLearningrate=0.002,
decay=0.9999,
myWeightdecay=0.8,
momentum=0):
n = FeedForwardNetwork()
n.addInputModule(self.inLayer)
n.addModule(self.hiddenLayer)
n.addModule(self.b)
n.addOutputModule(self.outLayer)
n.addConnection(self.in_to_hidden)
n.addConnection(self.hidden_to_out)
n.addConnection(self.b_to_hidden)
n.addConnection(self.b_to_out)
n.sortModules()
self.supervisedNet = n
self.supervisedTrainer = BackpropTrainer(n, ds,
learningrate=initialLearningrate,
lrdecay=decay,
verbose=True,
weightdecay=myWeightdecay,
batchlearning=True,
momentum=momentum)
self.supervisedTrainer.trainEpochs(num)
def evalFunc(ds):
trains = []
tests = []
epochsNums = []
parameters = range(1, 40)
testAmount = 10
for i in parameters:
trainError = 0
testError = 0
for testNum in range(testAmount):
tstdata, trndata = ds.splitWithProportion(0.25)
hidden_size = i
numOfEpocs = 10
"""
n = buildNetwork( 1, hidden_size, 1, bias = True )
"""
inLayer = LinearLayer(len(ds.getSample(0)[0]))
hiddenLayer = SigmoidLayer(hidden_size)
outLayer = LinearLayer(len(ds.getSample(0)[1]))
n = FeedForwardNetwork()
n.addInputModule(inLayer)
n.addModule(hiddenLayer)
b = BiasUnit()
n.addModule(b)
n.addOutputModule(outLayer)
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer, outLayer)
b_to_hidden = FullConnection(b, hiddenLayer)
b_to_out = FullConnection(b, outLayer)
n.addConnection(in_to_hidden)
n.addConnection(hidden_to_out)
n.addConnection(b_to_hidden)
n.addConnection(b_to_out)
n.sortModules()
# print n.activate([1, 2])
trainer = BackpropTrainer(n, trndata) # , verbose=True, weightdecay=0)
trainer.trainUntilConvergence(
verbose=True, validationProportion=0.15, maxEpochs=epochsNum, continueEpochs=10
)
trainError += printError(n, trndata, "trndata", ds.outputMax, ds.outputMin)
testError += printError(n, tstdata, "tstdata", ds.outputMax, ds.outputMin)
epochsNums.append(epochsNum)
# print n.activateOnDataset(tstdata)
trains.append(trainError / testAmount)
tests.append(testError / testAmount)
plt.plot(parameters, trains, label="train " + ds.label)
plt.plot(parameters, tests, label="test " + ds.label)
plt.legend().draggable()
plt.title("Hidden layer size influance (" + str(epochsNum) + " epochs)")
plt.xlabel("Hidden layer size")
plt.ylabel("Normalized RMSE")
plt.grid()
class NeuralNetwork(BaseEstimator, RegressorMixin):
def __init__(
self,
inp_neu=4,
hid_neu=3,
out_neu=1,
learn_rate=0.1,
nomentum=0.5,
weight_dec=0.0001,
epochs=100,
split_prop=0.25,
):
self.inp_neu = inp_neu
self.hid_neu = hid_neu
self.out_neu = out_neu
self.learn_rate = learn_rate
self.nomentum = nomentum
self.weight_dec = weight_dec
self.epochs = epochs
self.split_prop = split_prop
def data(self, X, y=None):
DS = SupervisedDataSet(self.inp_neu, self.out_neu)
for i in range(0, len(X)):
DS.addSample((X[i][0], X[i][1], X[i][2], X[i][3]), y[i]) # ATTENTION pas optimisé pour toutes les tailles
return DS
def fit(self, X, y):
self.n = FeedForwardNetwork()
self.n.addInputModule(SigmoidLayer(self.inp_neu, name="in"))
self.n.addModule(SigmoidLayer(self.hid_neu, name="hidden"))
self.n.addOutputModule(LinearLayer(self.out_neu, name="out"))
self.n.addConnection(FullConnection(self.n["in"], self.n["hidden"], name="c1"))
self.n.addConnection(FullConnection(self.n["hidden"], self.n["out"], name="c2"))
self.n.sortModules() # initialisation
self.tstdata, trndata = self.data(X, y).splitWithProportion(self.split_prop)
trainer = BackpropTrainer(
self.n, trndata, learningrate=self.learn_rate, momentum=self.nomentum, weightdecay=self.weight_dec
)
trainer.trainUntilConvergence(verbose=True, maxEpochs=self.epochs)
return self
def predict(self, X):
self.yhat = []
for i in X:
self.yhat.append(float(self.n.activate(i)))
self.yhat = np.array(self.yhat)
return self.yhat
def score(self, y):
vect_se = (self.yhat - y) ** 2
mse = float(np.sum(vect_se)) / float(len(vect_se))
return mse
def fromModules(cls, visible, hidden, bias, con, biascon):
net = FeedForwardNetwork()
net.addInputModule(visible)
net.addModule(bias)
net.addOutputModule(hidden)
net.addConnection(con)
net.addConnection(biascon)
net.sortModules()
return cls(net)
def buildNN(indim=4, hiddim=6, outdim=3):
net = FeedForwardNetwork()
net.addInputModule(TanhLayer(indim, name = 'i'))
net.addModule(TanhLayer(hiddim, name = 'h'))
net.addOutputModule(ThresholdLayer(outdim, name = 'o', threshold=0.5))
net.addConnection(FullConnection(net['i'], net['h']))
net.addConnection(FullConnection(net['h'], net['o']))
net.sortModules()
return net
def testMdlstm(self):
net = FeedForwardNetwork()
net.addInputModule(LinearLayer(1, name='in'))
net.addModule(MDLSTMLayer(1, 1, name='hidden'))
net.addOutputModule(LinearLayer(1, name='out'))
net.addConnection(FullConnection(net['in'], net['hidden']))
net.addConnection(FullConnection(net['hidden'], net['out']))
net.sortModules()
self.equivalence_feed_forward(net, net.convertToFastNetwork())
def mlpClassifier(X,y,train_indices, test_indices, mom=0.1,weightd=0.01, epo=5):
X_train, y_train, X_test, y_test = X[train_indices],y[train_indices], X[test_indices], y[test_indices]
#Converting the data into a dataset which is easily understood by PyBrain.
tstdata = ClassificationDataSet(X.shape[1],target=1,nb_classes=8)
trndata = ClassificationDataSet(X.shape[1],target=1,nb_classes=8)
# print "shape of X_train & y_train: " + str(X_train.shape) + str(y_train.shape)
for i in range(y_train.shape[0]):
trndata.addSample(X_train[i,:], y_train[i])
for i in range(y_test.shape[0]):
tstdata.addSample(X_test[i,:], y_test[i])
trndata._convertToOneOfMany()
tstdata._convertToOneOfMany()
#printing the specs of data
# 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]
#The neural-network used
# print "Building Network..."
#input layer, hidden layer of size 10(very small), output layer
ANNc = FeedForwardNetwork()
inLayer = LinearLayer(trndata.indim, name="ip")
hLayer1 = TanhLayer(100, name = "h1")
hLayer2 = SigmoidLayer(100, name = "h2")
outLayer = SoftmaxLayer(trndata.outdim, name = "op")
ANNc.addInputModule(inLayer)
ANNc.addModule(hLayer1)
ANNc.addModule(hLayer2)
ANNc.addOutputModule(outLayer)
ip_to_h1 = FullConnection(inLayer, hLayer1, name = "ip->h1")
h1_to_h2 = FullConnection(hLayer1, hLayer2, name = "h1->h2")
h2_to_op = FullConnection(hLayer2, outLayer, name = "h2->op")
ANNc.addConnection(ip_to_h1)
ANNc.addConnection(h1_to_h2)
ANNc.addConnection(h2_to_op)
ANNc.sortModules()
# print "Done. Training the network."
#The trainer used, in our case Back-propagation trainer
trainer = BackpropTrainer( ANNc, dataset=trndata, momentum=mom, verbose=True, weightdecay=weightd)
trainer.trainEpochs( epo )
#The error
trnresult = percentError( trainer.testOnClassData(dataset=trndata), trndata['class'] )
tstresult = percentError( trainer.testOnClassData(dataset=tstdata ), tstdata['class'] )
# print "Done."
return ANNc, trainer.totalepochs, (100 - trnresult), (100 - tstresult)
net = FeedForwardNetwork() inl = LinearLayer(2) hidl = SigmoidLayer(2) outl = LinearLayer(1) b = BiasUnit() #6.7 #Create connections in_to_h = FullConnection(inl, hidl) h_to_out = FullConnection(hidl, outl) bias_to_h = FullConnection(b, hidl) bias_to_out = FullConnection(b, outl) #Add modules to net net.addInputModule(inl) net.addModule(hidl) net.addModule(b) net.addOutputModule(outl) #Add connections to net and sort net.addConnection(in_to_h) net.addConnection(h_to_out) net.addConnection(bias_to_h) net.addConnection(bias_to_out) net.sortModules() #6.8 #input data d = [(0, 0), (0, 1), (1, 0), (1, 1)] #target class
def test_neural_nets(ds):
def plot_errors(x, train_err, test_err):
plt.plot(x, train_err, label='Training error')
plt.xlabel('Epochs')
plt.ylabel('Error')
plt.title('Training error using backpropagation')
plt.legend()
plt.show()
input_size = len(ds.train.x[0]) # no. of attributes
target_size = 1
hidden_size = 5
iterations = 1000
n = FeedForwardNetwork()
in_layer = LinearLayer(34)
hidden_layer = [SigmoidLayer(20), SigmoidLayer(20), SigmoidLayer(20)]
out_layer = LinearLayer(1)
n.addInputModule(in_layer)
for layer in hidden_layer:
n.addModule(layer)
n.addOutputModule(out_layer)
in_to_hidden = FullConnection(in_layer, hidden_layer[0])
h1 = FullConnection(hidden_layer[0], hidden_layer[1])
h2 = FullConnection(hidden_layer[1], hidden_layer[2])
hidden_to_out = FullConnection(hidden_layer[2], out_layer)
n.addConnection(in_to_hidden)
n.addConnection(h1)
n.addConnection(h2)
n.addConnection(hidden_to_out)
n.sortModules()
print n
train_nnds = SupervisedDataSet(input_size, target_size)
train_nnds.setField('input', ds.train.x)
one_train_reshaped = np.array(ds.train.y).reshape(-1,1)
train_nnds.setField('target', one_train_reshaped)
trainer = BackpropTrainer( n, train_nnds )
epochs, train_acc, test_acc = [], [], []
for i in xrange(iterations):
trainer.train()
train_pred_y = []
# Compute percent training error
for row in ds.train.x:
p = int( round( n.activate(row)[0] ) )
if p >= 1: p = 1
else: p = 0 # sometimes rounding takes us to 2 or -1
train_pred_y.append(p)
train_error = percentError(train_pred_y, ds.train.y)
if i%25 == 0 or i==iterations-1:
epochs.append(i)
train_acc.append(train_error)
print "Train error", train_error
plot_errors(epochs, train_acc, test_acc)
def trainet2(data, nhide=8, nhide1=8, epo=10, wd=.1, fn=''):
alldata = data
tstdata_temp, trndata_temp = alldata.splitWithProportion(0.5)
tstdata = ClassificationDataSet(alldata.indim, nb_classes=alldata.nClasses)
for n in range(0, tstdata_temp.getLength()):
tstdata.addSample(
tstdata_temp.getSample(n)[0],
tstdata_temp.getSample(n)[1])
trndata = ClassificationDataSet(alldata.indim, nb_classes=alldata.nClasses)
for n in range(0, trndata_temp.getLength()):
trndata.addSample(
trndata_temp.getSample(n)[0],
trndata_temp.getSample(n)[1])
tstdata._convertToOneOfMany()
trndata._convertToOneOfMany()
net = FeedForwardNetwork()
inLayer = LinearLayer(trndata.indim)
hiddenLayer = TanhLayer(nhide)
hiddenLayer1 = TanhLayer(nhide1)
outLayer = LinearLayer(trndata.outdim)
net.addInputModule(inLayer)
net.addModule(hiddenLayer)
net.addModule(hiddenLayer1)
net.addOutputModule(outLayer)
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_hidden = FullConnection(hiddenLayer, hiddenLayer1)
hidden_to_out = FullConnection(hiddenLayer1, outLayer)
net.addConnection(in_to_hidden)
net.addConnection(hidden_to_hidden)
net.addConnection(hidden_to_out)
net.sortModules()
net.bias = True
trainer = BackpropTrainer(net,
dataset=trndata,
verbose=True,
weightdecay=wd,
momentum=0.1)
edata = []
msedata = []
for i in range(epo):
trainer.trainEpochs(1)
trnresult = percentError(trainer.testOnClassData(), trndata['class'])
tstresult = percentError(trainer.testOnClassData(dataset=tstdata),
tstdata['class'])
tod = trainer.testOnData(verbose=False)
print("epoch: %4d" % trainer.totalepochs,
" train error: %5.2f%%" % trnresult,
" test error: %5.2f%%" % tstresult, " layers: ", nhide1,
" N_tourn: ", alldata.indim / 2)
edata.append([trnresult, tstresult])
msedata.append([i, tod])
with open(fn + ".dta", 'w') as fp:
json.dump(edata, fp)
with open(fn + ".mse", 'w') as fp:
json.dump(msedata, fp)
return net
def getFitness(self, smMatrix): #Store the sm state into memory
fit = 0
#Fitness function (3) *************************************************************
#Record the sm data for this loop and consider its properties
#print(smMatrix)
#print(len(smMatrix))
#net = buildNetwork(3,10,1, bias = True)
net = FeedForwardNetwork()
inp = LinearLayer(3)
h1 = SigmoidLayer(10)
outp = LinearLayer(1)
# add modules
net.addOutputModule(outp)
net.addInputModule(inp)
net.addModule(h1)
# create connections
iToH = FullConnection(inp, h1)
hToO = FullConnection(h1, outp)
net.addConnection(iToH)
net.addConnection(hToO)
# finish up
net.sortModules()
ds = SupervisedDataSet(3, 1)
trainSet = []
for index_x, x in enumerate(smMatrix):
if index_x > 0 and index_x < len(smMatrix) - 1:
#trainSet.append( [smMatrix[index_x][0], smMatrix[index_x][1], smMatrix[index_x][2], smMatrix[index_x+1][3] ] )
ds.addSample(([
smMatrix[index_x][0], smMatrix[index_x][1],
smMatrix[index_x][2]
]), (smMatrix[index_x + 1][3]))
#print(trainSet)
#print(ds)
trainer = BackpropTrainer(net, ds, weightdecay=0.01)
err = trainer.trainUntilConvergence(maxEpochs=50)
#Visualize the network performance and structure.
#nn = NNregression(ds, epoinc = 10)
#nn.setupNN()
#nn.runTraining()
#self.pesos_conexiones(net)
#print("Input to hidden", iToH.params)
#print("H to output", hToO.params)
#print(iToH.params)
n1 = iToH.params
n1a = zip(*[iter(n1)] * 3)
n2 = hToO.params
sums = []
for x in n1a:
sumr = 0
for y in x:
sumr = sumr + abs(y)
sums.append(sumr)
sums2 = []
for x in n2:
sums2.append(abs(x))
#Choose those neurons that have inputs below a threshold value
a1 = [index for index, value in enumerate(sums) if value > 2.0]
a2 = [index for index, value in enumerate(sums2) if value > 0.5]
inter = len(set(a1).intersection(set(a2)))
fit = inter
#fit = sum(n1a[:]) + sum(n2[:])
print fit
return fit
def BuildNN(self):
"""
This function builds a FeedForwardNetwork object based on
the data that was used to create the NNBuilder object
"""
nn = FeedForwardNetwork()
# Set up the Layers
inputLayer = LinearLayer(len(self.getInput()))
outputLayer = SigmoidLayer(self.OUTPUT_NODES)
# Add to NN
nn.addInputModule(inputLayer)
nn.addOutputModule(outputLayer)
# Handle multiple hidden layers, add to NN
topology = self.getHiddenLayers()
hiddenLayers = []
for i in range(0, len(topology)):
size = int(topology[i])
hlayer = SigmoidLayer(size)
nn.addModule(hlayer)
hiddenLayers.append(hlayer)
# Get the bias for each hidden layer
biasList = []
for i in range(0, len(topology)):
bias = BiasUnit(name="bias" + str(i))
nn.addModule(bias)
biasList.append(bias)
# Manually connect input layer to first hidden,
# and output layer to last hidden. Then connect all other
# hidden layers
input2hidden = FullConnection(inputLayer, hiddenLayers[0])
hidden2output = FullConnection(hiddenLayers[-1], outputLayer)
# If there was more than 1 hidden layer connect them together
hiddenConList = []
biasConList = []
if len(topology) > 1:
for i in range(0, len(topology) - 1):
# Connect current layer to next layer
connection = FullConnection(hiddenLayers[i],
hiddenLayers[i + 1])
hiddenConList.append(connection)
# Make connection for bias
biasConList.append(FullConnection(biasList[i],
hiddenLayers[i]))
# Since we only looped to < len(topology) - 1, have to get the last layer
last = len(topology) - 1
biasConList.append(FullConnection(biasList[last], hiddenLayers[last]))
# Add connections to the NN
nn.addConnection(input2hidden)
for i in hiddenConList:
nn.addConnection(i)
for i in biasConList:
nn.addConnection(i)
nn.addConnection(hidden2output)
# Not sure what this does but need to call it
nn.sortModules()
self.nn = nn
return nn
out_vec = np.concatenate((out_vec, [inp[out, :]]), axis=0)
inp_vec = np.concatenate((inp1_vec, inp2_vec), axis=1)
#building the dataset
dataset = SupervisedDataSet(2 * num_words, num_words)
for i in range(len(sorted_list) + 1):
dataset.addSample(inp_vec[i, :], out_vec[i, :])
tstdata, trndata = dataset.splitWithProportion(0.25)
#building the network
net = FeedForwardNetwork()
input_layer = LinearLayer(2 * num_words, name='input_layer')
hidden_layer = TanhLayer(num_words, name='hidden')
output_layer = SigmoidLayer(num_words, name='output_layer')
net.addInputModule(input_layer)
net.addModule(hidden_layer)
net.addOutputModule(output_layer)
net.addConnection(
FullConnection(input_layer, hidden_layer, name='in_to_hidden'))
net.addConnection(
FullConnection(hidden_layer, output_layer, name='hidden_to_out'))
net.sortModules()
#backpropagation
trainer = BackpropTrainer(net,
dataset=trndata,
momentum=0.1,
verbose=True,
weightdecay=0.01)
#error checking part
for i in range(10):
# Camada de entrada LinearLayer camadaEntrada = LinearLayer(2) # Criação da camada oculta com 3 neuronios camadaOculta = SigmoidLayer(3) # Criação da saida com apenas um neuronio camadaSaida = SigmoidLayer(1) # Criação das unidades de Bias bias1 = BiasUnit() bias2 = BiasUnit() # construindo a rede neural rede.addModule(camadaEntrada) rede.addModule(camadaOculta) rede.addModule(camadaSaida) rede.addModule(bias1) rede.addModule(bias2) # Ligação entre entrada e camada oculta # FullConnection -> ligação de um neuronio # com todos os outros da outra camada entradaOculta = FullConnection(camadaEntrada, camadaOculta) ocultaSaida = FullConnection(camadaOculta, camadaSaida) biasOCulta = FullConnection(bias1, camadaOculta) biasSaida = FullConnection(bias2, camadaSaida) # Construir a rede neural rede.sortModules()
class BMTrainer:
#隐藏层神经元节点数：
hiddendim = 3
#读取训练数据源文件：
srcname = 'trainer.xlsx'
#存储训练数据文件：
destname = 'buildBMTrainer.xml'
#源文件中结果列为几列（输出层节点数）
rescol = 1
#是否显示计算中间迭代过程
verbose = True
#总体容差
finalerror = 0
__fnn = None
__sy = None
def __init__(self,
_hiddendim=3,
_srcnmae='trainer.xlsx',
_destname='buildBMTrainer.xml'):
self.hiddendim = _hiddendim
self.srcname = _srcnmae
self.destname = _destname
def readexcel(self):
workbook = xlrd.open_workbook(self.srcname)
sheet1 = workbook.sheet_by_index(0)
if (self.verbose):
print('训练集共：' + str(sheet1.nrows) + '行，' + str(sheet1.ncols) +
'列；其中结果为：' + str(self.rescol) + '列')
# data = np.empty()
# target = np.empty()
# for i, d in enumerate(sheet1):
# data[i] = np.asarray(d[:-1], dtype=np.float64)i
# target[i] = np.asarray(d[-1], dtype=np.float64)
# test = [[0 for i in range(sheet1.nrows)] for j in range(sheet1.ncols)]
if (sheet1.nrows > 1 and sheet1.ncols > self.rescol):
x = np.zeros((sheet1.nrows - 1, sheet1.ncols - self.rescol),
dtype=np.float)
y = np.zeros((sheet1.nrows - 1, self.rescol), dtype=np.float)
for i in range(sheet1.nrows - 1):
for j in range(sheet1.ncols):
if (j < sheet1.ncols - self.rescol):
# print sheet1.cell(i + 1, j).value
x[i][j] = sheet1.cell(i + 1, j).value
else:
y[i][j - sheet1.ncols + self.rescol] = sheet1.cell(
i + 1, j).value
return x, y
def buildBMTrainer(self):
# print np.random.rand(1)
# print np.random.rand(1)
x, y = self.readexcel()
# 从sklearn数据集中读取用来模拟的数据
# boston = load_boston()
# x = boston.data
# y = boston.target.reshape(-1, 1)
# for i in range(0,x.shape[0]):
# for j in range(0,x.shape[1]):
# print (x[i][j])
# print x.shape
# sys.exit();
# for x in x:
# print x
# print x
# print y
# sys.exit(0)
# 直接采用不打乱的方式进行7:3分离训练集和测试集
# per = int(len(x) * 0.7)
per = int(len(x))
# 对数据进行归一化处理（一般来说使用Sigmoid时一定要归一化）
sx = MinMaxScaler()
sy = MinMaxScaler()
xTrain = x[:per]
xTrain = sx.fit_transform(xTrain)
yTrain = y[:per]
# print yTrain
yTrain = sy.fit_transform(yTrain)
# print yTrain
# print sy.inverse_transform(yTrain)
# sys.exit()
# xTest = x[per:]
# xTest = sx.transform(xTest)
# yTest = y[per:]
# yTest = sy.transform(yTest)
# print xTest.shape
# for x in xTest:
# print x
# sys.exit()
# 初始化前馈神经网络
self.__fnn = FeedForwardNetwork()
# 构建输入层，隐藏层和输出层，一般隐藏层为3-5层，不宜过多
inLayer = LinearLayer(x.shape[1], 'inLayer')
# hiddenLayer = TanhLayer(3, 'hiddenLayer')
hiddenLayer = TanhLayer(self.hiddendim, 'hiddenLayer')
outLayer = LinearLayer(self.rescol, 'outLayer')
# hiddenLayer1 = TanhLayer(5, 'hiddenLayer1')
# outLayer = LinearLayer(1, 'outLayer')
# 将构建的输出层、隐藏层、输出层加入到fnn中
self.__fnn.addInputModule(inLayer)
self.__fnn.addModule(hiddenLayer)
# fnn.addModule(hiddenLayer1)
self.__fnn.addOutputModule(outLayer)
# 对各层之间建立完全连接
in_to_hidden = FullConnection(inLayer, hiddenLayer)
# in_to_hidden.setName('in_to_hidden')
# in_to_hidden._setParameters([0 for i in range(30)])
hidden_to_out = FullConnection(hiddenLayer, outLayer)
# hidden_to_out.setName('hidden_to_out')
# hidden_to_out._setParameters([1 for i in range(3)])
# hidden_to_hidden = FullConnection(hiddenLayer,hiddenLayer1 )
# hidden_to_out = FullConnection(hiddenLayer1, outLayer)
# 与fnn建立连接
self.__fnn.addConnection(in_to_hidden)
# fnn.addConnection(hidden_to_hidden)
self.__fnn.addConnection(hidden_to_out)
self.__fnn.sortModules()
# 初始化监督数据集
DS = SupervisedDataSet(x.shape[1], self.rescol)
# 将训练的数据及标签加入到DS中
# for i in range(len(xTrain)):
# DS.addSample(xTrain[i], yTrain[i])
for i in range(len(xTrain)):
DS.addSample(xTrain[i], yTrain[i])
# 采用BP进行训练，训练至收敛，最大训练次数为1000
trainer = BackpropTrainer(self.__fnn,
DS,
learningrate=0.001,
verbose=self.verbose)
trainingErrors = trainer.trainUntilConvergence(maxEpochs=10000)
self.finalError = trainingErrors[0][-2]
if (self.verbose):
print('最后总体容差:', self.finalError)
self.__sy = sy
# print "1"
# print fnn.activate(x)
for i in range(len(xTrain)):
print(
sy.inverse_transform(
self.__fnn.activate(xTrain[i]).reshape(-1, 1)))
# sys.exit()
# print sy.inverse_transform(fnn.activate(x))[0]
# 在测试集上对其效果做验证
# values = []
# sy.inverse_transform()
# for x in xTest:
# values.append(sy.inverse_transform(fnn.activate(x))[0])
# for x in xTest:
# x1 = fnn.activate(x)
# x2 = sy.inverse_transform(x1.reshape(-1, 1))
# values.append(x2[0])
# print "2"
# 计算RMSE (Root Mean Squared Error)均方差
# totalsum = sum(map(lambda x: x ** 0.5, map(lambda x, y: pow(x - y, 2), boston.target[per:], values))) / float(len(xTest))
# print totalsum
# print "3"
# 将训练数据进行保存
def saveresult(self):
NetworkWriter.writeToFile(self.__fnn, self.destname)
joblib.dump(self.__sy, 'sy.pkl', compress=3)
class NeuralNet(regression):
'''
#deprecated
def __init__(self, inputDim, outputDim):
\'''
Initializes class parameters
Input:
\'''
regression.__init__(self,inputDim, outputDim)
#self.net = buildNetwork(inputDim, outputDim)
self.net = FeedForwardNetwork()
inLayer = LinearLayer(inputDim)
hiddenLayer1 = TanhLayer(10)
hiddenLayer2 = TanhLayer(10)
outLayer = SigmoidLayer(outputDim)
self.net.addInputModule(inLayer)
self.net.addModule(hiddenLayer1)
self.net.addModule(hiddenLayer2)
self.net.addOutputModule(outLayer)
in_to_hidden1 = FullConnection(inLayer, hiddenLayer1)
hidden1_to_hidden2=FullConnection(hiddenLayer1, hiddenLayer2)
hidden2_to_out = FullConnection(hiddenLayer2, outLayer)
self.net.addConnection(in_to_hidden1)
self.net.addConnection(hidden1_to_hidden2)
self.net.addConnection(hidden2_to_out)
self.net.sortModules()
self.shape=self.net.params.shape
self.ds = SupervisedDataSet(self.inputDimension, self.outputDimension)
'''
def __init__(self, rs):
regression.__init__(self,rs)
self.learningRate=rs.learningRate
self.momentum=rs.momentum
self.net = FeedForwardNetwork()
#input Layer
inLayer = layersDict[rs.inputLayer](rs.inputDim)
self.net.addInputModule(inLayer)
#outputLayer
outLayer = layersDict[rs.outputLayer](rs.outputDim)
self.net.addOutputModule(outLayer)
#no hidden Layer
if(len(rs.hiddenLayers)==0):
#connection between input and output Layer
in_to_out = FullConnection(inLayer, outLayer)
self.net.addConnection(in_to_out)
if(rs.bias==True):
bias= BiasUnit('bias')
self.net.addModule(bias)
bias_to_out = FullConnection(bias, outLayer)
self.net.addConnection(bias_to_out)
else :
#hidden Layers
hiddenLayers=[]
for layer in rs.hiddenLayers:
tmp=layersDict[layer[0]](layer[1])
self.net.addModule(tmp)
hiddenLayers.append(tmp)
#connection between input and first hidden Layer
in_to_hidden=FullConnection(inLayer,hiddenLayers[0])
self.net.addConnection(in_to_hidden)
#connection between hidden Layers
i=0
for i in range(1,len(hiddenLayers)):
hidden_to_hidden=FullConnection(hiddenLayers[i-1],hiddenLayers[i])
self.net.addConnection(hidden_to_hidden)
#connection between last hidden Layer and output Layer
hidden_to_out= FullConnection(hiddenLayers[i],outLayer)
self.net.addConnection(hidden_to_out)
if(rs.bias==True):
bias=BiasUnit('bias')
self.net.addModule(bias)
for layer in hiddenLayers :
bias_to_hidden = FullConnection(bias, layer)
self.net.addConnection(bias_to_hidden)
bias_to_out = FullConnection(bias, outLayer)
self.net.addConnection(bias_to_out)
#initilisation of weight
self.net.sortModules()
self.shape=self.net.params.shape
self.net._setParameters(np.random.normal(0.0,0.1,self.shape))
self.ds = SupervisedDataSet(self.inputDimension, self.outputDimension)
#print(self.net)
def setTheta(self, theta):
self.net._setParameters(theta.reshape(self.shape))
def getTheta(self):
return self.net.params
def load(self,thetaFile):
'''
load wheight of the neural network from the thetafile
'''
self.net._setParameters(np.loadtxt(thetaFile+".theta"))
#print ("theta LOAD : ", self.net.params)
return self.net.params
def getTrainingData(self, inputData, outputData):
'''
Verifies the validity of the given input and output data
Data should be organized by columns
Input: -inputdata, numpy N-D array
-outputData, numpy N-D array
'''
regression.getTrainingData(self,inputData, outputData)
for i in range(self.numberOfSamples):
self.ds.addSample(inputData[i],outputData[i])
def train(self):
'''
Perform batch regression
'''
trainer = BackpropTrainer(self.net, self.ds, learningrate=self.learningRate, momentum=self.momentum)
minError=10
while(True):
error=trainer.train()
print(self.meanSquareError())
if(error<minError):
minError=error
self.saveTheta(self.rs.path+self.rs.thetaFile+".theta")
#trainer.trainUntilConvergence(maxEpochs=10, verbose=True)
#trainer.trainEpochs(10)
def computeOutput(self, inputVal):
'''
Returns the output depending on the given input and theta
Input: -inputVal: numpy N-D array
-theta: numpy N-D array
Output: -fa_out: numpy N-D array, output approximated
'''
assert(inputVal.shape[0]==self.inputDimension), "NeuralNet: Bad input format : " + str(inputVal.shape[0])+"/"+str(self.inputDimension)
output=self.net.activate(inputVal)
#print(output)
return output
def meanSquareError(self):
output=self.net.activateOnDataset(self.ds)
return np.mean((self.outputData - output)**2)
for seq in item_seqs:
for i in xrange(len(seq) - 1):
inp = seq[:i] + [0] * (6 - i)
print inp, seq[i]
ds.addSample(inp, seq[i])
net = FeedForwardNetwork()
inp = LinearLayer(6)
h1 = SigmoidLayer(6)
outp = LinearLayer(1)
# add modules
net.addOutputModule(outp)
net.addInputModule(inp)
net.addModule(h1)
# create connections
net.addConnection(FullConnection(inp, h1))
net.addConnection(FullConnection(h1, outp))
# finish up
net.sortModules()
# initialize the backprop trainer and train
trainer = BackpropTrainer(net, ds)
trainer.trainOnDataset(ds, 1000)
trainer.testOnData(verbose=False)
print net.activate((0, 0, 0, 0, 0, 0))
import pdb
#初始化前馈神经网络 fnn = FeedForwardNetwork() #构建输入层，隐藏层和输出层，一般隐藏层为3-5层，不宜过多 inLayer = LinearLayer(x.shape[1], 'inLayer') # hiddenLayer = TanhLayer(3, 'hiddenLayer') hiddenLayer = TanhLayer(12, 'hiddenLayer') outLayer = LinearLayer(1, 'outLayer') # hiddenLayer1 = TanhLayer(5, 'hiddenLayer1') # outLayer = LinearLayer(1, 'outLayer') #将构建的输出层、隐藏层、输出层加入到fnn中 fnn.addInputModule(inLayer) fnn.addModule(hiddenLayer) # fnn.addModule(hiddenLayer1) fnn.addOutputModule(outLayer) #对各层之间建立完全连接 in_to_hidden = FullConnection(inLayer, hiddenLayer) hidden_to_out = FullConnection(hiddenLayer, outLayer) # hidden_to_hidden = FullConnection(hiddenLayer,hiddenLayer1 ) # hidden_to_out = FullConnection(hiddenLayer1, outLayer) #与fnn建立连接 fnn.addConnection(in_to_hidden) # fnn.addConnection(hidden_to_hidden) fnn.addConnection(hidden_to_out) fnn.sortModules()
class MP_Pybrain(Regression):
"""
Fully connected multilayer perceptron using pybrain library.
"""
def __init__(self, train_data, hyper, n_targets=None, label_targets=None):
"""
------------
train_data: pandas DataFrame
Contains columns for features and for target variables. The names of the target variables ends
with the suffix "_tau"
hyper: dictionary
It contains the hyperparameters necessary to run all the functionalities of the model.
They are the following:
"structure" is a list of integers determining the number of neurons in each hidden layer
"epochs" an integer specifying the maximum number of epochs to run during every training session
"learning_rate" a float giving the learning rate of the gradient descend
"momentum" a float giving the value of the momentum for the algorithm
"batch" a bool. If True the method performs full batch learning, i.e. updates of the weights is done
using all the instances of the training set. Else, normal online method is performed
Other parameters regarding cross validation are explained in the base class
"""
Regression.__init__(self, train_data, hyper, n_targets=n_targets, label_targets=label_targets)
self.N = FeedForwardNetwork()
self.structure = [self.n_feature] + hyper['structure'] + [self.n_target]
self._build_net(self.structure)
self.res_params = [self.N.params[i] for i in range(len(self.N.params))]
self.train_fraction = hyper['train_fraction']
self.seed = hyper['seed']
self.epochs = hyper['epochs']
self.learning_rate = hyper['learning_rate']
self.momentum = hyper['momentum']
self.batch = bool(hyper['batch'])
def learn(self, train_data = None, seed = None):
"""
Performs single run training, and it is designed to be called after network instantiation.
----------
train_data: pandas Dataframe
It needs to contain datetime objects on index, and both features and target variables.
The target variables need to end with the suffix "_tau". If None the self.train_set
variable passed at the moment of instantiation will be used.
Returns: tuple(MP_Pybrain object,float)
It returns the model with the lowest training error, and the value of the training error.
"""
if train_data is not None:
self.train_set = train_data
self.randomize()
ds_train, ds_valid = self._build_dataset(self.train_set)
trainer = BackpropTrainer(self.N, ds_train, learningrate=self.learning_rate,
momentum=self.momentum,batchlearning=self.batch)
trainer.train()
e_train = [self._error(ds_train)]
e_valid = [self._error(ds_valid)]
final_model = copy(self)
fin_error_train = e_train[0]
fin_error_valid = e_valid[0]
for i in range(1,self.epochs):
if i%10 == 0:
print "epoch: ", i
trainer.train()
e_train.append(self._error(ds_train))
e_valid.append(self._error(ds_valid))
if e_train[-1] < fin_error_train:
final_model = deepcopy(self)
fin_error_train = e_train[-1]
fin_error_valid = e_valid[-1]
return final_model, fin_error_train, fin_error_valid
def xvalidate(self, train_data = None, folds = None):
"""
Performs n-folds cross-validation on the a data set. The method is designed to reset the network
to an initial configuration (decided at the moment of instantiation) every time a new training is
started. The purpose is to make model comparison and returning an average error given a specific
data set and collection of hyper-parameters. At the moment training and validation sets are chosen
based on the input sequence of data, i.e. there is no random shuffling of the instances of the data set.
----------
train_data: pandas Dataframe
It needs to contain datetime objects on index, and both features and target variables.
The target variables need to end with the suffix "_tau". If None the self.train_set
variable passed at the moment of instantiation will be used.
folds: integer
The number of training/validation partition used in the method. If None it needs to be
passed in the constructor when instantiating the object for the first time. If not passed
ever, the method cannot work and an exception needs to be thrown.
Returns: list, float, float
A list of all the models trained for each fold, the mean train error and the cross-validation error,
i.e. the average of NRMSE for all the training/validation partitions created.
"""
if train_data is not None:
self.train_set = train_data
if folds is not None:
self.cv_folds = folds
train, validation = self._build_folds(random=False)
models = []
train_error = []
cv_error = []
for i in range(self.cv_folds):
print "Cross-validation Fold: ", i+1
self.randomize()
model, error, _ = self.learn(train_data=train[i])
models.append(deepcopy(model))
train_error.append(error)
predicted, actual = self.test(validation[i])
e = 0
for k in predicted.keys():
e += errors.RMSE(np.array(actual[k]),np.array(predicted[k]))
cv_error.append(e)
return models, np.mean(train_error), np.mean(cv_error)
def test(self, data):
"""
Tests the trained model on data. The usage is two fold: 1) Internal usage to calculate errors on validation
sets. 2) For external usage when a test set is provided. Both the validation and test set need to contain target
columns. For prediction, where target variables are unknown, please refer to the function self.predict below.
----------
data: pandas Dataframe
A pandas dataframe. A deepcopy of it will be made and only the feature columns will be considered.
Due to the functionality of the pyBrain library we require (at the moment) that the order of the
colums is the same as the one of the training set used for training.
Returns: pandas Dataframe
A Dataframe with columns containing the predictions of the different target variables and same index as
the input DataFrame
"""
data_x = data[self.features]
data_y = data[self.targets]
predicted = np.array([])
for i in range(len(data_x)):
predicted = np.append(predicted, self.N.activate(data_x.values[i]))
return pd.DataFrame(predicted, index=data.index, columns=self.targets), data_y
def predict(self, data):
"""
It returns target variables given a set of features, using the model trained and saved.
---------
data: pandas Dataframe
It must contain all the feature columns used for training of the model
Returns: pandas Dataframe
It contains the prediction on the target variables. The name of the variables is the same as the one
provided at the moment of instantiation of object.
"""
data_x = data[self.features]
predicted = np.array([])
for i in range(len(data_x)):
predicted = np.append(predicted, self.N.activate(data_x.values[i]))
return pd.DataFrame(predicted, index=data_x.index, columns=self.targets)
def randomize(self):
self.N.randomize()
pass
### Private functions ###
def _error(self, ds):
"""
Calculates the RMSE over an input dataset, given the current state of the network.
ds: Supervised dataset pybrain style
Returns: float
The total error between prediction and actual values.
"""
predicted = np.array([list(self.N.activate(x)) for x in ds['input']]).transpose()
actual = np.array([list(x) for x in ds['target']]).transpose()
total_error = [errors.RMSE(np.array(actual[i]),np.array(predicted[i])) for i in range(len(actual))]
return sum(total_error)
def _build_net(self,s):
layers = [LinearLayer(s[0])]
self.N.addInputModule(layers[0])
for i in range(1,len(s)-1):
layers.append(SigmoidLayer(s[i]))
self.N.addModule(layers[i])
layers.append(SigmoidLayer(s[-1]))
self.N.addOutputModule(layers[-1])
self._build_connections(layers)
def _build_connections(self, l):
for i,j in zip(l,l[1:]):
a = FullConnection(i,j)
self.N.addConnection(a)
self.N.sortModules()
def _build_dataset(self, data):
"""
Given a input training Dataframe with features and targets it returns the formatted training and validation
datasets for pybrain usage, and randomly shuffled according to the self.seed given at instantiation.
----------
data: pandas Dataframe
It must contains both features and target columns
Returns: (pybrain dataset, pybrain dataset)
The first is the training dataset and the second is the validation dataset
"""
np.random.seed(self.seed)
permutation = np.random.permutation(np.arange(len(data)))
sep = int(self.train_fraction * len(data))
x = data[self.features]
y = data[self.targets]
ds_train = SupervisedDataSet(self.n_feature, self.n_target)
ds_valid = SupervisedDataSet(self.n_feature, self.n_target)
for i in permutation[:sep]:
ds_train.addSample(x.values[i], y.values[i])
for i in permutation[sep:]:
ds_valid.addSample(x.values[i], y.values[i])
return ds_train, ds_valid
if (__name__) == '__main__':
trainingData = getTrainingData()
network = FeedForwardNetwork()
inputLayer = LinearLayer(1)
hiddenLayer = SigmoidLayer(3)
outputLayer = LinearLayer(1)
inToMid = FConnect(inputLayer, hiddenLayer)
midToOut = FConnect(hiddenLayer, outputLayer)
data = DataSet(1, 1)
network.addInputModule(inputLayer)
network.addModule(hiddenLayer)
network.addOutputModule(outputLayer)
network.addConnection(inToMid)
network.addConnection(midToOut)
network.sortModules()
for item in trainingData:
data.addSample((item[0], ), (item[1], ))
trainer = BackpropTrainer(network,
dataset=data,
momentum=0.1,
verbose=True,
weightdecay=0.01)
trainer.train()
class ANN:
def __init__(self):
self.name = "ANN"
def getParams(self):
return self.in_to_hidden.params, self.hidden_to_out.params
def create_network(self, nFeatures, hidden1Size=20, nClasses=1):
# create network object
self.ffn = FeedForwardNetwork()
# create layer objects
inLayer = LinearLayer(nFeatures, name="input")
hiddenLayer = SigmoidLayer(hidden1Size, name="hidden1")
#hiddenLayer2 = SigmoidLayer(hidden2Size, name="hidden2")
outLayer = LinearLayer(nClasses, name="output")
# add layers to feed forward network
self.ffn.addInputModule(inLayer)
self.ffn.addModule(hiddenLayer)
#self.ffn.addModule(hiddenLayer2)
self.ffn.addOutputModule(outLayer)
# add bias unit to layers
self.ffn.addModule(BiasUnit(name='bias'))
# establish connections between layers
self.in_to_hidden = FullConnection(inLayer, hiddenLayer)
#hidden_to_hidden = FullConnection(hiddenLayer, hiddenLayer2)
self.hidden_to_out = FullConnection(hiddenLayer, outLayer)
# print "into hidden: {}".format(len(in_to_hidden.params))
# print "into out: {}".format(len(hidden_to_out.params))
# add connections to network
self.ffn.addConnection(self.in_to_hidden)
#self.ffn.addConnection(hidden_to_hidden)
self.ffn.addConnection(self.hidden_to_out)
# necessary, sort layers into correct/certain order
self.ffn.sortModules()
# dataset object
self.train_ds = SupervisedDataSet(nFeatures, nClasses)
self.validate_ds = SupervisedDataSet(nFeatures, nClasses)
# train network
def train(self, TrainX, TrainY, ValidateX, ValidateY):
# clear old dataset
self.train_ds.clear()
self.validate_ds.clear()
# add data to dataset object (ds)
for i in range(TrainX.shape[0]):
self.train_ds.addSample(TrainX[i], TrainY[i])
for i in range(ValidateX.shape[0]):
self.validate_ds.addSample(ValidateX[i], ValidateY[i])
# randomiz weights
self.ffn.randomize()
# Backprop trainer object
self.trainer = BackpropTrainer(self.ffn,
learningrate=.0775,
momentum=.1)
try:
with Timer() as t:
self.train_errors, self.val_errors \
= self.trainer.trainUntilConvergence(trainingData=self.train_ds, \
validationData=self.validate_ds, \
maxEpochs=500, \
continueEpochs=10)
#return self.train_errors, self.val_errors
except:
print "Error occured while training model in ANN."
#finally:
# print("ANN.py - Time to trainUntilConvergence: {:.03f} sec.".format(t.interval))
return 'ANN'
# predict depenent variable for dataset
def predict(self, data):
# if only make prediction for one sample
if (len(data.shape) == 1):
return self.ffn.activate(data)
else:
outputs = np.zeros(data.shape[0])
for i in range(data.shape[0]):
outputs[i] = self.ffn.activate(data[i])
return outputs
# net = buildNetwork(len(t), len(t), 1)
#initialize a feed foward network
net = FeedForwardNetwork()
#create layers for FFN
inLayer = LinearLayer(
len(t)) #sets up the number of nodes based on 'length' of the loaded image
hiddenLayer = SigmoidLayer(len(t))
outLayer = LinearLayer(
10) #you need ten outputs - one for each digit(0,1,2,3 etc)
# add layers to FFN
net.addInputModule(inLayer)
net.addModule(hiddenLayer)
net.addOutputModule(outLayer)
#create connections between the layers
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer, outLayer)
#add connections
net.addConnection(in_to_hidden)
net.addConnection(hidden_to_out)
net.sortModules()
print net
digits = load_digits()
X, y = digits.data, digits.target
def part2():
'''
Determine the minimal number of hidden units
required to train the network successfully
using multiple hidden layers
'''
'''
# Parameters
HIDDEN_NODES = 8
LEARNING_DECAY = 0.9999 # Set in range [0.9, 1]
LEARNING_RATE = 0.08 # Set in range [0, 1]
MOMENTUM = 0.0 # Set in range [0, 0.5]
TRAINING_ITERATIONS = 1000
BATCH_LEARNING = False
VALIDATION_PROPORTION = 0.0
SPARSE_LENGTH = 16
'''
# Parameters
HIDDEN_NODES = 4
LEARNING_DECAY = 0.9999 # Set in range [0.9, 1]
LEARNING_RATE = 0.111 # Set in range [0, 1]
MOMENTUM = 0.05 # Set in range [0, 0.5]
TRAINING_ITERATIONS = 5000
BATCH_LEARNING = False
VALIDATION_PROPORTION = 0.0
SPARSE_LENGTH = 16
# Get the dataset
dataset = sparse_coding.generateFull(SPARSE_LENGTH)
validationSet = sparse_coding.generateFull(SPARSE_LENGTH)
dataset, classes = sparse_coding.toClassificationDataset(dataset)
inDimension = dataset.indim
outDimension = dataset.outdim
print inDimension
print outDimension
# Set up the neral network layers
inLayer = LinearLayer(inDimension, name='input')
hiddenLayer1 = SigmoidLayer(HIDDEN_NODES, name='hidden1')
hiddenLayer2 = TanhLayer(HIDDEN_NODES, name='hidden2')
outLayer = LinearLayer(outDimension, name='output')
# Set up the connections
input_to_hidden1 = FullConnection(inLayer, hiddenLayer1, name='in_h1')
hidden1_to_hidden2 = FullConnection(hiddenLayer1,
hiddenLayer2,
name='h1_h2')
hidden2_to_output = FullConnection(hiddenLayer2, outLayer, name='h2_out')
hidden1_to_output = FullConnection(hiddenLayer1, outLayer, name='h2_out')
# Create the network and add the information
neuralNet = FeedForwardNetwork()
neuralNet.addInputModule(inLayer)
neuralNet.addModule(hiddenLayer1)
neuralNet.addModule(hiddenLayer2)
neuralNet.addOutputModule(outLayer)
neuralNet.addConnection(input_to_hidden1)
neuralNet.addConnection(hidden1_to_hidden2)
neuralNet.addConnection(hidden2_to_output)
neuralNet.addConnection(hidden1_to_output)
neuralNet.sortModules()
print neuralNet
# Train the network
trainer = BackpropTrainer(neuralNet,
dataset,
learningrate=LEARNING_RATE,
momentum=MOMENTUM,
lrdecay=LEARNING_DECAY,
batchlearning=BATCH_LEARNING)
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% Validation Data 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 the output path if it doesn't exist
generated_dir = path.abspath(
path.join("generated", "Q2Task2-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_NODES))
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))
# 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()
from mpl_toolkits.mplot3d import Axes3D
figure = plot.figure()
axis = figure.add_subplot(111, projection='3d')
colors = ['r', 'y', 'g', 'c', 'b', 'k']
for sample in validationSet:
classifier = sparse_coding.getClassifier(sample)
activationResult = neuralNet.activate(sample)
axis.bar(range(len(sample)),
activationResult,
classifier,
zdir='y',
color=colors[:len(sample)])
plot.savefig(path.normpath(path.join(generated_dir, "activations.png")))
plot.show()
net = FeedForwardNetwork()
# Layers
inputLayer = LinearLayer(
2
) # The input values wonn't pass by a activation function. 2 is the number of neurons
holdLayer = SigmoidLayer(3)
outputLayer = SigmoidLayer(1)
# Bias
bias1 = BiasUnit()
bias2 = BiasUnit()
# Add the net pieces
net.addModule(inputLayer)
net.addModule(holdLayer)
net.addModule(outputLayer)
net.addModule(bias1)
net.addModule(bias2)
# Connections
holdInput = FullConnection(inputLayer, holdLayer)
holdOutput = FullConnection(holdLayer, outputLayer)
holdBias = FullConnection(bias1, holdLayer)
outputBias = FullConnection(bias2, outputLayer)
# Create a neural net
net.sortModules()
print(net)
class NFQIteration:
_gamma = 0.9
_epochs = 500 #1000
_epochsNN = 100
def __init__(self):
self.Q = FeedForwardNetwork()
# La funcion de valor se representa con una red neuronal
# Input: S = (Angulo, Velocidad angular, Posicion), A = accion
# Output: Valor
# 2 capas ocultas de 5 neuronas cada una
# Funcion de activacion sigmoidea
inLayer = SigmoidLayer(4, name="Input Layer")
hiddenLayer1 = SigmoidLayer(5, name="Hidden Layer 1")
hiddenLayer2 = SigmoidLayer(5, name="Hidden Layer 2")
outLayer = SigmoidLayer(1, name="Output Layer")
self.Q.addInputModule(inLayer)
self.Q.addModule(hiddenLayer1)
self.Q.addModule(hiddenLayer2)
self.Q.addOutputModule(outLayer)
connInToHidden1 = FullConnection(inLayer, hiddenLayer1)
connHidden1ToHidden2 = FullConnection(hiddenLayer1, hiddenLayer2)
connHidden2ToOut = FullConnection(hiddenLayer2, outLayer)
self.Q.addConnection(connInToHidden1)
self.Q.addConnection(connHidden1ToHidden2)
self.Q.addConnection(connHidden2ToOut)
self.Q.sortModules()
def train(self, transitionSamples):
print "Entrenando..."
k = 0
trainer = RPropMinusTrainer(self.Q, batchlearning=True)
#trainer = BackpropTrainer(self.Q, batchlearning=False)
TS = SupervisedDataSet(4, 1)
while (k < self._epochs):
if k % 10 == 0:
print "\t ", k
# Genero training set en base a las muestras
# Input: Vector de 4 dimensiones (angulo, vel.angular, pos, accion)
# Target: Valor
TS.clear()
for s, a, s_1, costo in transitionSamples:
# Tomo Q para s', para todas las acciones posibles
# (vector con el valor para s', para cada una de las 3 acciones posibles)
# Q_s1 = [ self.Q.activate([s_1.angulo, s_1.velocidadAngular, s_1.posicion, b]) for b in range(Accion.maxValor + 1) ]
valDerecha = self.Q.activate([
s_1.angulo, s_1.velocidadAngular, s_1.posicion,
Accion.DERECHA
])
valIzquierda = self.Q.activate([
s_1.angulo, s_1.velocidadAngular, s_1.posicion,
Accion.IZQUIERDA
])
if valDerecha >= 1 or valDerecha <= 0:
print "Q incorrecta: ", valDerecha
if valIzquierda >= 1 or valIzquierda <= 0:
print "Q incorrecta: ", valIzquierda
# Input y Target para la red neuronal
inputVal = (s.angulo, s.velocidadAngular, s.posicion, a)
if costo == 0:
targetVal = costo
else:
targetVal = costo + self._gamma * min(
valDerecha, valIzquierda)
if targetVal > 1 or targetVal < 0:
print "Target incorrecto: ", targetVal
TS.addSample(inputVal, targetVal)
# Entreno la red neuronal
trainer.setData(TS)
trainer.train() # 1 epoch
#trainer.trainEpochs(self._epochsNN)
k = k + 1
class NET():
def __init__(self, arg):
self.inputsize = arg[0]
self.outputsize = arg[-1]
self.hiden = arg[1:-1]
self.err = 1
self.old_err = 1
b = []
b.append(self.inputsize)
b += self.hiden
b.append(self.outputsize)
#print b#"%s, %s, %s, hiddenclass=TanhLayer"%(self.inputsize, self.hiden, self.outputsize)
self.net = FeedForwardNetwork()
self.inputlayer = LinearLayer(self.inputsize, "Input")
self.net.addInputModule(self.inputlayer)
self.outputlayer = LinearLayer(self.outputsize, "Output")
self.net.addOutputModule(self.outputlayer)
self.hidenlayers = []
for i in xrange(len(self.hiden)):
self.hidenlayers.append(SigmoidLayer(self.hiden[i], "hiden%s" % i))
self.net.addModule(self.hidenlayers[-1])
self.net.addConnection(
FullConnection(self.inputlayer, self.outputlayer))
for i in xrange(len(self.hidenlayers)):
self.net.addConnection(
FullConnection(self.inputlayer, self.hidenlayers[i]))
self.net.addConnection(
FullConnection(self.hidenlayers[i], self.outputlayer))
for i in xrange(len(self.hidenlayers)):
for j in xrange(i + 1, len(self.hidenlayers)):
self.net.addConnection(
FullConnection(self.hidenlayers[i], self.hidenlayers[j]))
#self.print_conections(self.net)
self.net.sortModules()
self.ds = SupervisedDataSet(self.inputsize, self.outputsize)
def Update(self, hiden, h):
self.net = FeedForwardNetwork()
self.inputlayer = LinearLayer(self.inputsize, "Input")
self.net.addInputModule(self.inputlayer)
self.outputlayer = LinearLayer(self.outputsize, "Output")
self.net.addOutputModule(self.outputlayer)
self.hidenlayers = []
for i in xrange(len(hiden)):
self.hidenlayers.append(SigmoidLayer(hiden[i], "hiden%s" % i))
self.net.addModule(self.hidenlayers[-1])
self.net.addConnection(
FullConnection(self.inputlayer, self.outputlayer))
for i in xrange(len(self.hidenlayers)):
self.net.addConnection(
FullConnection(self.inputlayer, self.hidenlayers[i]))
self.net.addConnection(
FullConnection(self.hidenlayers[i], self.outputlayer))
for i in xrange(len(self.hidenlayers)):
for j in xrange(i + 1, len(self.hidenlayers)):
if i < h:
self.net.addConnection(
FullConnection(self.hidenlayers[i],
self.hidenlayers[j]))
elif i == h:
self.net.addConnection(
FullConnection(self.hidenlayers[i],
self.hidenlayers[j],
inSliceTo=hiden[i] - 1))
else:
self.net.addConnection(
FullConnection(self.hidenlayers[i],
self.hidenlayers[j]))
#self.print_conections(self.net)
self.net.sortModules()
self.hiden = hiden
def print_conections(self, n):
print("BEGIN")
for mod in n.modules:
print(mod)
for conn in n.connections[mod]:
print(conn)
for cc in range(len(conn.params)):
print(conn.whichBuffers(cc), conn.params[cc])
print("END")
def AddData(self, datainput, dataoutput, learningrate):
if len(dataoutput) != len(datainput):
print("Not equals data", len(dataoutput), len(datainput))
return 1
self.ds = SupervisedDataSet(self.inputsize, self.outputsize)
for i in xrange(len(dataoutput)):
self.ds.appendLinked(datainput[i], dataoutput[i])
self.trainer = BackpropTrainer(self.net,
dataset=self.ds,
learningrate=learningrate)
return 0
def TrainNet(self, epoch, error):
if epoch <= 5:
epoch = 5
i = 0
count = 0
while i < epoch:
if error == self.err:
break
self.err = self.trainer.train()
if self.err == self.old_err:
count += 1
else:
count = 0
if count == 3:
self.err = self.old_err
return (self.err, 1)
self.old_err = self.err
i += 1
#self.SaveNet('%s %s_%s_%s.work'%(self.err, self.inputsize, self.hiden, self.outputsize))
return [self.err, 0]
def TrainNetOnce(self):
self.err = self.trainer.train()
return self.err
def SaveNet(self, filename=None):
if filename == None:
NetworkWriter.writeToFile(
self.net, '%s %s_%s_%s.xml' %
(self.err, self.inputsize, self.hiden, self.outputsize))
else:
NetworkWriter.writeToFile(self.net, filename)
def LoadNet(self, fname):
self.net = NetworkReader.readFrom(fname)
tree = ET.parse(fname)
x = tree.getroot()
l = []
for modules in x.findall('Network/Modules/SigmoidLayer/dim'):
l.append(int(modules.get("val")))
self.hiden = l[:]
self.inputsize = self.net.indim
self.outputsize = self.net.outdim
def TestNet(self, inp):
if len(inp) != self.inputsize:
return 0
return self.net.activate(inp[:])
def UpdateWeights(self, f1, f2=None):
n = NetworkReader.readFrom(f1)
if f2 != None:
n2 = NetworkReader.readFrom(f2)
def DictParams(n):
l1 = []
for mod in n.modules:
l = []
for conn in n.connections[mod]:
if conn.paramdim > 0:
l.append([conn.outmod.name, conn.params])
d = dict(l)
l1.append([mod.name, d])
d1 = dict(l1)
return d1
d1 = DictParams(n)
if f2 != None:
d2 = DictParams(n2)
d3 = DictParams(self.net)
params = np.array([])
if f2 != None:
for i in d2:
for j in d2[i]:
try:
b = d3[i][j][:]
b[:d2[i][j].size] = d2[i][j][:]
d3[i].update({j: b})
except:
pass
for i in d1:
for j in d1[i]:
try:
b = d3[i][j][:]
b[:d1[i][j].size] = d1[i][j][:]
d3[i].update({j: b})
except:
pass
for i in d3["Input"]:
params = np.hstack((params, d3["Input"][i]))
for i in xrange(len(self.hiden)):
for j in d3["hiden%s" % i]:
params = np.hstack((params, d3["hiden%s" % i][j]))
self.net._setParameters(params)
# Here we instantiate a Feed-Forward Network. annet = FeedForwardNetwork() # Creation of the input layer: Here the integer denotes the number of nodes we wish to have in the layer. inLayer = LinearLayer(2, 'inlyr') # Creation of the hidden layer. hid1Layer = SigmoidLayer(2, 'hiddenlyr') # Creation of the Output layer. outLayer = LinearLayer(1, 'outlyr') # Instantiating the Bias Unit. bias_val = BiasUnit() # Adding the corresponding layers to the network. annet.addInputModule(inLayer) annet.addModule(hid1Layer) annet.addModule(bias_val) annet.addOutputModule(outLayer) # Adding the connections b/w layers pair-wise. # Note # FullConnection denotes all the nodes of one layer are connected to all nodes in the next layer. annet.addConnection(FullConnection(inLayer, hid1Layer)) annet.addConnection(FullConnection(bias_val, hid1Layer)) annet.addConnection(FullConnection(hid1Layer, outLayer)) # The method performs internal management of the specifications. annet.sortModules()
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
class NetworkManager(object):
def __init__(self, hidden_layers, ally_champ_obj_list,
enemy_champ_obj_list):
self.ally_champ_obj_list = ally_champ_obj_list
self.enemy_champ_obj_list = enemy_champ_obj_list
self.set_nodes()
self.network = FeedForwardNetwork()
connect_queue = Queue.Queue()
for layer in xrange(0, hidden_layers):
connect_queue.put(
TanhLayer(self.input_node_count,
name='hidden_layer_{}'.format(layer)))
connect_queue.put(SigmoidLayer(1, name='output_layer'))
prev_layer = LinearLayer(self.input_node_count, name='input_layer')
self.network.addInputModule(prev_layer)
while not connect_queue.empty():
current_layer = connect_queue.get()
if current_layer.name == 'output_layer':
self.network.addOutputModule(current_layer)
else:
self.network.addModule(current_layer)
bias = BiasUnit()
bias_connection = FullConnection(
bias,
current_layer,
name="bias_to_{}_connection".format(current_layer.name))
self.network.addModule(bias)
self.network.addConnection(bias_connection)
connection = FullConnection(prev_layer,
current_layer,
name="{}_to_{}_connection".format(
prev_layer.name,
current_layer.name))
self.network.addConnection(connection)
prev_layer = current_layer
self.network.sortModules()
def get_node_count(self):
return (len(self.ally_champ_obj_list) + len(self.enemy_champ_obj_list))
def set_nodes(
self
): #TEMPORARY SET_NODE - PERFORMS QUERYSET EVERYTIME - SHOULD EVENTUALLY STORE VALUES AS NODES
node_list = {}
match_count = 0
champion_list = list(
enumerate(self.ally_champ_obj_list + self.enemy_champ_obj_list))
self.input_node_count = len(champion_list)
while len(champion_list) != 0:
pid, prime = champion_list.pop()
data = {}
queryset = Player.objects.filter(champion=prime)
for (cid, champ) in champion_list:
if pid <= 4 and cid <= 4:
ally = True
elif pid > 4 and cid > 4:
ally = True
else:
ally = False
if ally:
matches = queryset.filter(ally_heroes=champ)
else:
matches = queryset.filter(enemy_heroes=champ)
match_count += len(matches)
data[champ] = {
'ally': ally,
'wins': matches.filter(winner=True).count(),
'loses': matches.filter(winner=False).count()
}
node_list[prime] = data
self.node_set = node_list
def train_network(self):
training_set = SupervisedDataSet(self.input_node_count, 1)
validation_set = SupervisedDataSet(self.input_node_count, 1)
champion_list = list(
enumerate(self.ally_champ_obj_list + self.enemy_champ_obj_list))
while len(champion_list) != 0:
pid, prime = champion_list.pop()
for (cid, champ) in champion_list:
input_set = [0] * self.input_node_count
input_set[pid] = 1
input_set[cid] = 1
wins = self.node_set[prime][champ]['wins']
loses = self.node_set[prime][champ]['loses']
for win in xrange(0, wins):
training_set.addSample(input_set, [1])
for loss in xrange(0, loses):
training_set.addSample(input_set, [0])
print 'Training Set Length = ', len(training_set)
ally_list = self.ally_champ_obj_list
enemy_list = self.enemy_champ_obj_list
prime = ally_list.pop()
validation_queryset = Player.objects.filter(champion=prime)
print len(validation_queryset)
for ally in ally_list:
validation_queryset = validation_queryset.filter(ally_heroes=ally)
print len(validation_queryset)
for enemy in enemy_list:
validation_queryset = validation_queryset.filter(
enemy_heroes=enemy)
print len(validation_queryset)
print 'Validation Set Length = ', len(validation_queryset)
validation_wins = validation_queryset.filter(winner=True).count()
validation_loses = validation_queryset.filter(winner=False).count()
for win in xrange(0, validation_wins):
validation_set.addSample([1] * self.input_node_count, [1])
for loss in xrange(0, validation_loses):
validation_set.addSample([1] * self.input_node_count, [0])
if not validation_set:
print 'There is no Validation Set, more error in output'
else:
print 'Raw Win Rate = ', str(
float(validation_wins) /
float(validation_wins + validation_loses))
trainer = BackpropTrainer(self.network, learningrate=0.5)
trainer.trainUntilConvergence(
validationData=validation_set,
trainingData=training_set,
dataset=training_set,
continueEpochs=10,
maxEpochs=50,
convergence_threshold=1,
)
return str(
float(validation_wins) / float(validation_wins + validation_loses))
def run_network(self):
input_set = [1] * self.input_node_count
return self.network.activate(input_set)
# 2 é a quantidade de neurônio para camada de entrada EntryLayer = LinearLayer(2) # camada oculta com 3 neurônios HideLayer = SigmoidLayer(3) # camada de saída com 1 neurônio ExitLayer = SigmoidLayer(1) # unidades de Bias com neurônios extras bias1 = BiasUnit() bias2 = BiasUnit() # Adicionando os modulos a rede com as configurações iniciais network.addModule(EntryLayer) network.addModule(HideLayer) network.addModule(ExitLayer) network.addModule(bias1) network.addModule(bias2) # Conectando as camadas EntryToHideLayer = FullConnection(EntryLayer, HideLayer) HideToExitLayer = FullConnection(HideLayer, ExitLayer) biasToHideLayer = FullConnection(bias1, HideLayer) biasToExitLayer = FullConnection(bias2, ExitLayer) # rede neural e suas estruturas iram ser criadas network.sortModules() print(network)
from pybrain.structure import FeedForwardNetwork from pybrain.structure import LinearLayer, SigmoidLayer, BiasUnit from pybrain.structure import FullConnection network = FeedForwardNetwork() inputLayer = LinearLayer(2) hiddenLayer = SigmoidLayer(3) outputLayer = SigmoidLayer(1) bias1 = BiasUnit() bias2 = BiasUnit() network.addModule(bias1) network.addModule(bias2) network.addModule(inputLayer) network.addModule(hiddenLayer) network.addModule(outputLayer) inputHidden = FullConnection(inputLayer, hiddenLayer) hiddenOutput = FullConnection(hiddenLayer, outputLayer) biasToHidden = FullConnection(bias1, hiddenLayer) biasToOutput = FullConnection(bias2, outputLayer) #initialize layers + modules are sorted topologically network.sortModules() print(network) print(biasToHidden.params)
""" from pybrain.structure import FeedForwardNetwork from pybrain.structure import LinearLayer, SigmoidLayer, BiasUnit from pybrain.structure import FullConnection rede = FeedForwardNetwork() camada_de_entrada = LinearLayer(2) camada_oculta = SigmoidLayer(3) camada_saida = SigmoidLayer(1) bias_1 = BiasUnit() bias_2 = BiasUnit() rede.addModule(camada_de_entrada) rede.addModule(camada_oculta) rede.addModule(camada_saida) rede.addModule(bias_1) rede.addModule(bias_2) entradaOculta = FullConnection(camada_de_entrada, camada_oculta) Oculta_a_saida = FullConnection(camada_oculta, camada_saida) biasOculta = FullConnection(bias_1, camada_oculta) biasSaida = FullConnection(bias_2, camada_saida) rede.sortModules() print(rede) print(entradaOculta.params)
class NNInitializer:
#A few constants for this function....
NEURAL_NET_OBJECT_PATH = "../PickledObjects/NeuralNets/"
TRAINING_SET_OBJECT_PATH = "../PickledObjects/TrainingSets/"
NUMBER_OF_DATA_SETS = 100000
NUMBER_OF_INPUTS = 5
NUMBER_OF_OUTPUTS = 5
def __init__(self):
pass
def initNetwork(self):
#Intiailize Neural Nets
self.neuralNet = FeedForwardNetwork()
#Define and add each set of layers
inLayer = LinearLayer(5)
hiddenLayer = SigmoidLayer(15)
outLayer = LinearLayer(5)
self.neuralNet.addInputModule(inLayer)
self.neuralNet.addModule(hiddenLayer)
self.neuralNet.addOutputModule(outLayer)
#Create conenctions
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer, outLayer)
self.neuralNet.addConnection(in_to_hidden)
self.neuralNet.addConnection(hidden_to_out)
#Sort the NeuralNet
self.neuralNet.sortModules()
#Add supervised data sets
ds = SupervisedDataSet(NNInitializer.NUMBER_OF_INPUTS,
NNInitializer.NUMBER_OF_OUTPUTS)
inputSet, outputSet = self.loadTrainingSet('scents_based_input',
'scents_based_output')
#inputSet, outputSet = self.generateTrainingSet()
print "Adding samples to data set...."
for i, val in enumerate(inputSet):
# print "Input Set: "
# print inputSet[i]
# print "Output Set: "
# print outputSet[i]
ds.addSample(inputSet[i], outputSet[i])
print "Done."
print "Starting training...."
#Perform Training
trainer = BackpropTrainer(self.neuralNet, ds)
trainer.train()
print "Done."
#Generate a training set for the neural net
def generateTrainingSet(self):
print "Generating random training samples...."
inputSet = []
outputSet = []
for i in range(0, NNInitializer.NUMBER_OF_DATA_SETS):
trainingInput = [] #start w/ an empty list
trainingOutput = [
0
] * NNInitializer.NUMBER_OF_OUTPUTS #start w/ list of all 0's
for j in range(0, NNInitializer.NUMBER_OF_INPUTS):
trainingInput.append(random.triangular(
0.0, 1.0,
0.985)) #add randomInputs between 0 -> 1, inclusive
#print trainingInput
maxVal = max(trainingInput)
maxIndex = trainingInput.index(maxVal)
trainingInput = [i / maxVal for i in trainingInput]
trainingOutput[
maxIndex] = 1 #the max sense should be the correct movement output
inputSet.append(tuple(trainingInput))
outputSet.append(tuple(trainingOutput))
print "Done."
return (inputSet, outputSet)
def loadTrainingSet(self, inputFilename, outputFilename):
file_path = NNInitializer.TRAINING_SET_OBJECT_PATH + inputFilename
fd = open(file_path, "rb")
inputSet = pickle.load(fd)
fd.close()
file_path = NNInitializer.TRAINING_SET_OBJECT_PATH + outputFilename
fd = open(file_path, "rb")
outputSet = pickle.load(fd)
fd.close()
return (inputSet, outputSet)
def saveNetwork(self, filename):
file_path = NNInitializer.NEURAL_NET_OBJECT_PATH + filename
fd = open(file_path, "wb")
pickle.dump(self.neuralNet, fd)
fd.close()
print "Neural net saved at: " + file_path
def readNetwork(self, filename):
file_path = NNInitializer.NEURAL_NET_OBJECT_PATH + filename
fd = open(file_path, "rb")
self.neuralNet = pickle.load(fd)
fd.close()
return self.neuralNet
def set_pybrain_nn(X, y):
params_len = len(X[0])
print(params_len)
hidden_size = 100
output_layer_num = 2
epochs = 200
# init and train
net = FeedForwardNetwork()
""" Next, we're constructing the input, hidden and output layers. """
inLayer = LinearLayer(params_len)
hiddenLayer = SigmoidLayer(hidden_size)
hiddenLayer1 = SigmoidLayer(hidden_size)
hiddenLayer2 = SigmoidLayer(hidden_size)
outLayer = LinearLayer(output_layer_num)
""" (Note that we could also have used a hidden layer of type TanhLayer, LinearLayer, etc.)
Let's add them to the network: """
net.addInputModule(inLayer)
net.addModule(hiddenLayer)
net.addModule(hiddenLayer1)
net.addModule(hiddenLayer2)
net.addOutputModule(outLayer)
""" We still need to explicitly determine how they should be connected. For this we use the most
common connection type, which produces a full connectivity between two layers (or Modules, in general):
the 'FullConnection'. """
in2hidden = FullConnection(inLayer, hiddenLayer)
hidden2hidden = FullConnection(hiddenLayer, hiddenLayer1)
hidden2hidden1 = FullConnection(hiddenLayer1, hiddenLayer2)
hidden2out = FullConnection(hiddenLayer2, outLayer)
net.addConnection(in2hidden)
net.addConnection(hidden2hidden)
net.addConnection(hidden2hidden1)
net.addConnection(hidden2out)
""" All the elements are in place now, so we can do the final step that makes our MLP usable,
which is to call the 'sortModules()' method. """
net.sortModules()
#ds = SupervisedDataSet(params_len, output_layer_num)
ds = ClassificationDataSet(params_len, output_layer_num, nb_classes=2)
ds.setField('input', X)
ds.setField('target', y)
trainer = BackpropTrainer(net, ds)
print("training for {} epochs...".format(epochs))
#trainer.trainUntilConvergence(verbose=True)
#trainer.train()
for i in range(epochs):
mse = trainer.train()
rmse = sqrt(mse)
print("training RMSE, epoch {}: {}".format(i + 1, rmse))
pickle.dump(net, open('model/nn_brain', 'wb'))
print trainer.train() # tuple containing the errors for every training epoch. print trainer.trainUntilConvergence() ############### Feed forward networks ###################### n = FeedForwardNetwork() # Constructing input, output & hidden layers & giving names to the network inLayer = LinearLayer(2, name='in') hiddenLayer = SigmoidLayer(3, name='hidden') outLayer = LinearLayer(1, name='out') n.addInputModule(inLayer) n.addModule(hiddenLayer) n.addOutputModule(outLayer) # Full Connection class - add connections/synapses in_to_hidden = FullConnection(inLayer, hiddenLayer) hidden_to_out = FullConnection(hiddenLayer, outLayer) n.addConnection(in_to_hidden) n.addConnection(hidden_to_out) #makes our MLP usable, n.sortModules() print n.activate([1, 2]) print n #Recureent Connection Class -which looks back in time one timestep.
fnn = FeedForwardNetwork()
# create layers: 9 input layer nodes (8 features + 1 bias), 3 hidden layer nodes, 10 output layer nodes
bias = BiasUnit(name='bias unit')
input_layer = LinearLayer(64 * 64 * 3, name='input layer')
hidden_layer = SigmoidLayer(64 * 64 * 3 / 2, name='hidden layer')
output_layer = SigmoidLayer(2, name='output layer')
# create connections with full connectivity between layers
bias_to_hidden = FullConnection(bias, hidden_layer, name='bias-hid')
bias_to_output = FullConnection(bias, output_layer, name='bias-out')
input_to_hidden = FullConnection(input_layer, hidden_layer, name='in-hid')
hidden_to_output = FullConnection(hidden_layer, output_layer, name='hid-out')
# add layers & connections to network
fnn.addModule(bias)
fnn.addInputModule(input_layer)
fnn.addModule(hidden_layer)
fnn.addOutputModule(output_layer)
fnn.addConnection(bias_to_hidden)
fnn.addConnection(input_to_hidden)
fnn.addConnection(hidden_to_output)
fnn.addConnection(bias_to_output)
fnn.sortModules()
# set up trainer that takes network & training dataset as input
# train model until convergence
trainer = BackpropTrainer(fnn,
dataset=trainingData,
verbose=True,
#---------------------------------------------- # Feed Forward Networks #---------------------------------------------- from pybrain.structure import FeedForwardNetwork from pybrain.structure import LinearLayer, SigmoidLayer from pybrain.structure import FullConnection n = FeedForwardNetwork() # Construct input, hidden and output layers inLayer = LinearLayer(2) hiddenlayer = SigmoidLayer(3) outLayer = LinearLayer(1) # Add layers to the network n.addInputModule(inLayer) n.addModule(hiddenlayer) n.addOutputModule(outLayer) # Add full connection between the neurons of each layer in_to_hidden = FullConnection(inLayer, hiddenlayer) hidden_to_out = FullConnection(hiddenlayer, outLayer) # Final step: Necessary for sorting the modules, and other internal initialization n.sortModules() #---------------------------------------------- # Examining a Network #---------------------------------------------- n.activate([1, 2])
