def __init__(self, indim, outdim, hiddim=6): Module.__init__(self, indim, outdim) self._network = Network() self._in_layer = LinearLayer(indim + outdim) self._hid_layer = LSTMLayer(hiddim) self._out_layer = LinearLayer(outdim) self._bias = BiasUnit() self._network.addInputModule(self._in_layer) self._network.addModule(self._hid_layer) self._network.addModule(self._bias) self._network.addOutputModule(self._out_layer) self._hid_to_out_connection = FullConnection(self._hid_layer, self._out_layer) self._in_to_hid_connection = FullConnection(self._in_layer, self._hid_layer) self._network.addConnection(self._hid_to_out_connection) self._network.addConnection(self._in_to_hid_connection) self._network.addConnection(FullConnection(self._bias, self._hid_layer)) self._network.sortModules() self.offset = self._network.offset self.backprojectionFactor = 0.01
def __init__(self, boardSize, convSize, numFeatureMaps, **args): inputdim = 2 FeedForwardNetwork.__init__(self, **args) inlayer = LinearLayer(inputdim * boardSize * boardSize, name='in') self.addInputModule(inlayer) # we need some treatment of the border too - thus we pad the direct board input. x = convSize / 2 insize = boardSize + 2 * x if convSize % 2 == 0: insize -= 1 paddedlayer = LinearLayer(inputdim * insize * insize, name='pad') self.addModule(paddedlayer) # we connect a bias to the padded-parts (with shared but trainable weights). bias = BiasUnit() self.addModule(bias) biasConn = MotherConnection(inputdim) paddable = [] if convSize % 2 == 0: xs = range(x) + range(insize - x + 1, insize) else: xs = range(x) + range(insize - x, insize) paddable.extend(crossproduct([range(insize), xs])) paddable.extend(crossproduct([xs, range(x, boardSize + x)])) for (i, j) in paddable: self.addConnection( SharedFullConnection(biasConn, bias, paddedlayer, outSliceFrom=(i * insize + j) * inputdim, outSliceTo=(i * insize + j + 1) * inputdim)) for i in range(boardSize): inmod = ModuleSlice(inlayer, outSliceFrom=i * boardSize * inputdim, outSliceTo=(i + 1) * boardSize * inputdim) outmod = ModuleSlice(paddedlayer, inSliceFrom=((i + x) * insize + x) * inputdim, inSliceTo=((i + x) * insize + x + boardSize) * inputdim) self.addConnection(IdentityConnection(inmod, outmod)) self._buildStructure(inputdim, insize, paddedlayer, convSize, numFeatureMaps) self.sortModules()
def build_ann(indim, outdim): ann = FeedForwardNetwork() ann.addInputModule(LinearLayer(indim, name='in')) ann.addModule(SigmoidLayer(5, name='hidden')) # ann.addModule(Normal(2,name='hidden')) ann.addOutputModule(SoftmaxLayer(outdim, name='out')) ann.addModule(BiasUnit(name='bias')) ann.addConnection(FullConnection(ann['in'], ann['hidden'])) ann.addConnection(FullConnection(ann['hidden'], ann['out'])) # ann.addConnection(FullConnection(ann['in'], ann['out'])) ann.addConnection(FullConnection(ann['bias'], ann['out'])) ann.addConnection(FullConnection(ann['bias'], ann['hidden'])) ann.sortModules() # ann = buildNetwork(indim, outdim, outclass=SoftmaxLayer) return ann
def __init__(self, outdim, hiddim=15): """ Create an EvolinoNetwork with for sequences of dimension outdim and hiddim dimension of the RNN Layer.""" indim = 0 Module.__init__(self, indim, outdim) self._network = RecurrentNetwork() self._in_layer = LinearLayer(indim + outdim) self._hid_layer = LSTMLayer(hiddim) self._out_layer = LinearLayer(outdim) self._bias = BiasUnit() self._network.addInputModule(self._in_layer) self._network.addModule(self._hid_layer) self._network.addModule(self._bias) self._network.addOutputModule(self._out_layer) self._in_to_hid_connection = FullConnection(self._in_layer, self._hid_layer) self._bias_to_hid_connection = FullConnection(self._bias, self._hid_layer) self._hid_to_out_connection = FullConnection(self._hid_layer, self._out_layer) self._network.addConnection(self._in_to_hid_connection) self._network.addConnection(self._bias_to_hid_connection) self._network.addConnection(self._hid_to_out_connection) self._recurrent_connection = FullConnection(self._hid_layer, self._hid_layer) self._network.addRecurrentConnection(self._recurrent_connection) self._network.sortModules() self._network.reset() self.offset = self._network.offset self.backprojectionFactor = 0.01
aramdata = open("ARAMData.txt","r") #ChampionDictionary holds all the riot static data about each champion. The Riot IDs are the keys of the dictionary championdictionary = DatabaseActions.CreateChampionDictionary() #Creates a Neural Network of Appropriate size predictionNet = FeedForwardNetwork() inLayer = LinearLayer(len(championdictionary)) hiddenLayer = SigmoidLayer(5) outLayer = SigmoidLayer(1) predictionNet.addInputModule(inLayer) predictionNet.addModule(hiddenLayer) predictionNet.addOutputModule(outLayer) predictionNet.addModule(BiasUnit(name = 'bias')) in_to_hidden = FullConnection(inLayer,hiddenLayer) hidden_to_out = FullConnection(hiddenLayer,outLayer) predictionNet.addConnection(in_to_hidden) predictionNet.addConnection(hidden_to_out) predictionNet.addConnection(FullConnection(predictionNet['bias'],hiddenLayer)) predictionNet.addConnection(FullConnection(predictionNet['bias'],outLayer)) predictionNet.sortModules() trainingSet = SupervisedDataSet(len(championdictionary),1) #Takes each game and turns it into a vector. -1 is stored if the champion is on the opposing team, 1 if the champion is on the player's team #and 0 if it wasn't played. The vector is then fed into the Neural Network's Training Set
from pybrain.structure import FeedForwardNetwork from pybrain.structure.modules.sigmoidlayer import SigmoidLayer from pybrain.structure.modules.linearlayer import LinearLayer from pybrain.structure.modules.biasunit import BiasUnit from pybrain.structure.connections.full import FullConnection rede = FeedForwardNetwork() camadaEntrada = LinearLayer(2) camadaOculta = SigmoidLayer(3) camadaSaida = SigmoidLayer(1) bias1 = BiasUnit() bias2 = BiasUnit() rede.addModule(camadaEntrada) rede.addModule(camadaOculta) rede.addModule(camadaSaida) rede.addModule(bias1) rede.addModule(bias2) entradaOculta = FullConnection(camadaEntrada, camadaOculta) ocultaSaida = FullConnection(camadaOculta, camadaSaida) biasOculta = FullConnection(bias1,camadaOculta) biasSaida = FullConnection(bias2,camadaSaida) rede.sortModules() print(rede) print(entradaOculta.params) print(ocultaSaida.params) print(biasOculta.params) print(biasSaida.params)
def build_exp_ann(indim, outdim): ann = FeedForwardNetwork() ann.addInputModule(LinearLayer(indim, name='in')) ann.addModule(SigmoidLayer(24, name='hidden')) ann.addOutputModule(SigmoidLayer(outdim, name='out')) ann.addModule(BiasUnit(name='bias')) hidd_neur_i = 0 for cols, rows in ((1, 8), (4, 4)): #(2,2), (4,4), height = int(32 / rows) width = int(32 / cols) for col in range(cols): for row in range(rows): if width < 32: for line in range(height): fr = col * width + line * 32 + row * 32 * height to = fr + width slices = { 'inSliceFrom': fr, 'inSliceTo': to, 'outSliceFrom': hidd_neur_i, 'outSliceTo': hidd_neur_i + 1, 'name': "%dx%d group (%dx%d) %d line Input(%d-%d) -> Hidden(%d-%d)" % (cols, rows, col + 1, row + 1, line, fr, to, hidd_neur_i, hidd_neur_i + 1) } ann.addConnection( FullConnection(ann['in'], ann['hidden'], **slices)) else: fr = row * width * height to = fr + width * height slices = { 'inSliceFrom': fr, 'inSliceTo': to, 'outSliceFrom': hidd_neur_i, 'outSliceTo': hidd_neur_i + 1, 'name': "%dx%d group (%dx%d) %d line Input(%d-%d) -> Hidden(%d-%d)" % (cols, rows, col + 1, row + 1, 0, fr, to, hidd_neur_i, hidd_neur_i + 1) } ann.addConnection( FullConnection(ann['in'], ann['hidden'], **slices)) hidd_neur_i += 1 ann.addConnection(FullConnection(ann['hidden'], ann['out'])) ann.addConnection(FullConnection(ann['bias'], ann['out'])) ann.addConnection(FullConnection(ann['bias'], ann['hidden'])) ann.sortModules() return ann