def buildSharedCrossedNetwork(): """ build a network with shared connections. Two hiddne modules are symetrically linked, but to a different input neuron than the output neuron. The weights are random. """ N = FeedForwardNetwork('shared-crossed') h = 1 a = LinearLayer(2, name='a') b = LinearLayer(h, name='b') c = LinearLayer(h, name='c') d = LinearLayer(2, name='d') N.addInputModule(a) N.addModule(b) N.addModule(c) N.addOutputModule(d) m1 = MotherConnection(h) m1.params[:] = scipy.array((1, )) m2 = MotherConnection(h) m2.params[:] = scipy.array((2, )) N.addConnection(SharedFullConnection(m1, a, b, inSliceTo=1)) N.addConnection(SharedFullConnection(m1, a, c, inSliceFrom=1)) N.addConnection(SharedFullConnection(m2, b, d, outSliceFrom=1)) N.addConnection(SharedFullConnection(m2, c, d, outSliceTo=1)) N.sortModules() return N
def custom_build_network(layer_sizes): net = FeedForwardNetwork() layers = [] inp = SigmoidLayer(layer_sizes[0], name='visible') h1 = SigmoidLayer(layer_sizes[1], name='hidden1') h2 = SigmoidLayer(layer_sizes[2], name='hidden2') out = SigmoidLayer(layer_sizes[3], name='out') bias = BiasUnit(name='bias') net.addInputModule(inp) net.addModule(h1) net.addModule(h2) net.addOutputModule(out) net.addModule(bias) net.addConnection(FullConnection(inp, h1)) net.addConnection(FullConnection(h1, h2)) net.addConnection(FullConnection(h2, out)) net.addConnection(FullConnection(bias, h1)) net.addConnection(FullConnection(bias, h2)) net.addConnection(FullConnection(bias, out)) net.sortModules() return net
def buildXor(self): self.params['dataset'] = 'XOR' d = ClassificationDataSet(2) d.addSample([0., 0.], [0.]) d.addSample([0., 1.], [1.]) d.addSample([1., 0.], [1.]) d.addSample([1., 1.], [0.]) d.setField('class', [[0.], [1.], [1.], [0.]]) self.trn_data = d self.tst_data = d global trn_data trn_data = self.trn_data nn = FeedForwardNetwork() inLayer = TanhLayer(2, name='in') hiddenLayer = TanhLayer(3, name='hidden0') outLayer = ThresholdLayer(1, name='out') nn.addInputModule(inLayer) nn.addModule(hiddenLayer) nn.addOutputModule(outLayer) in_to_hidden = FullConnection(inLayer, hiddenLayer) hidden_to_out = FullConnection(hiddenLayer, outLayer) nn.addConnection(in_to_hidden) nn.addConnection(hidden_to_out) nn.sortModules() nn.randomize() self.net_settings = str(nn.connections) self.nn = nn
def main(): a = 0 for i in range(0, 100): inLayer = SigmoidLayer(2) hiddenLayer = SigmoidLayer(3) outLayer = SigmoidLayer(1) net = FeedForwardNetwork() net.addInputModule(inLayer) net.addModule(hiddenLayer) net.addOutputModule(outLayer) in_to_hidden = FullConnection(inLayer, hiddenLayer) hidden_to_out = FullConnection(hiddenLayer, outLayer) net.addConnection(in_to_hidden) net.addConnection(hidden_to_out) net.sortModules() ds = SupervisedDataSet(2, 1) ds.addSample((1, 1), (0)) ds.addSample((1, 0), (1)) ds.addSample((0, 1), (1)) ds.addSample((0, 0), (0)) trainer = BackpropTrainer(net, ds) trainer.trainUntilConvergence() out = net.activate((1, 1)) if (out < 0.5): a = a + 1 print(str(a) + "/100")
def createNet(): net = FeedForwardNetwork() modules = add_modules(net) add_connections(net, modules) # finish up net.sortModules() #gradientCheck(net) return net
def _buildNetwork(*layers, **options): """This is a helper function to create different kinds of networks. `layers` is a list of tuples. Each tuple can contain an arbitrary number of layers, each being connected to the next one with IdentityConnections. Due to this, all layers have to have the same dimension. We call these tuples 'parts.' Afterwards, the last layer of one tuple is connected to the first layer of the following tuple by a FullConnection. If the keyword argument bias is given, BiasUnits are added additionally with every FullConnection. Example: _buildNetwork( (LinearLayer(3),), (SigmoidLayer(4), GaussianLayer(4)), (SigmoidLayer(3),), ) """ bias = options['bias'] if 'bias' in options else False net = FeedForwardNetwork() layerParts = iter(layers) firstPart = iter(layerParts.next()) firstLayer = firstPart.next() net.addInputModule(firstLayer) prevLayer = firstLayer for part in chain(firstPart, layerParts): new_part = True for layer in part: net.addModule(layer) # Pick class depending on wether we entered a new part if new_part: ConnectionClass = FullConnection if bias: biasUnit = BiasUnit('BiasUnit for %s' % layer.name) net.addModule(biasUnit) net.addConnection(FullConnection(biasUnit, layer)) else: ConnectionClass = IdentityConnection new_part = False conn = ConnectionClass(prevLayer, layer) net.addConnection(conn) prevLayer = layer net.addOutputModule(layer) net.sortModules() return net
def buildSlicedNetwork(): """ build a network with shared connections. Two hiddne modules are symetrically linked, but to a different input neuron than the output neuron. The weights are random. """ N = FeedForwardNetwork('sliced') a = LinearLayer(2, name='a') b = LinearLayer(2, name='b') N.addInputModule(a) N.addOutputModule(b) N.addConnection(FullConnection(a, b, inSliceTo=1, outSliceFrom=1)) N.addConnection(FullConnection(a, b, inSliceFrom=1, outSliceTo=1)) N.sortModules() return N
def createNN(): nn = FeedForwardNetwork() inLayer = TanhLayer(4, name='in') hiddenLayer = TanhLayer(6, name='hidden0') outLayer = ThresholdLayer(3) nn.addInputModule(inLayer) nn.addModule(hiddenLayer) nn.addOutputModule(outLayer) in_to_hidden = FullConnection(inLayer, hiddenLayer) hidden_to_out = FullConnection(hiddenLayer, outLayer) nn.addConnection(in_to_hidden) nn.addConnection(hidden_to_out) nn.sortModules() return nn
def buildIris(self): self.params['dataset'] = 'iris' self.trn_data, self.tst_data = pybrainData(0.5) global trn_data trn_data = self.trn_data nn = FeedForwardNetwork() inLayer = TanhLayer(4, name='in') hiddenLayer = TanhLayer(6, name='hidden0') outLayer = ThresholdLayer(3, name='out') nn.addInputModule(inLayer) nn.addModule(hiddenLayer) nn.addOutputModule(outLayer) in_to_hidden = FullConnection(inLayer, hiddenLayer) hidden_to_out = FullConnection(hiddenLayer, outLayer) nn.addConnection(in_to_hidden) nn.addConnection(hidden_to_out) nn.sortModules() nn.randomize() self.net_settings = str(nn.connections) self.nn = nn
def buildTDnetwork(self): # create network and modules net = FeedForwardNetwork() inp = LinearLayer(self.n_input, name="Input") h1 = SigmoidLayer(10, name='sigm') outp = LinearLayer(1, name='output') # add modules net.addOutputModule(outp) net.addInputModule(inp) net.addModule(h1) # create connections from input net.addConnection(FullConnection(inp, h1, name="input_LSTM")) # create connections to output net.addConnection(FullConnection(h1, outp, name="LSTM_outp")) # finish up net.sortModules() net.randomize() return net
def buildParity(self): self.params['dataset'] = 'parity' self.trn_data = ParityDataSet(nsamples=75) self.trn_data.setField('class', self.trn_data['target']) self.tst_data = ParityDataSet(nsamples=75) global trn_data trn_data = self.trn_data nn = FeedForwardNetwork() inLayer = TanhLayer(4, name='in') hiddenLayer = TanhLayer(6, name='hidden0') outLayer = ThresholdLayer(1, name='out') nn.addInputModule(inLayer) nn.addModule(hiddenLayer) nn.addOutputModule(outLayer) in_to_hidden = FullConnection(inLayer, hiddenLayer) hidden_to_out = FullConnection(hiddenLayer, outLayer) nn.addConnection(in_to_hidden) nn.addConnection(hidden_to_out) nn.sortModules() nn.randomize() self.net_settings = str(nn.connections) self.nn = nn
ds.addSample((1, 1), (0, )) for input, target in ds: print(input, target) #define layers and connections inLayer = LinearLayer(2) hiddenLayerOne = SigmoidLayer(4, "one") hiddenLayerTwo = SigmoidLayer(4, "two") outLayer = LinearLayer(1) inToHiddenOne = FullConnection(inLayer, hiddenLayerOne) hiddenOneToTwo = FullConnection(hiddenLayerOne, hiddenLayerTwo) hiddenTwoToOut = FullConnection(hiddenLayerTwo, outLayer) #wire the layers and connections to a net net = FeedForwardNetwork() net.addInputModule(inLayer) net.addModule(hiddenLayerOne) net.addModule(hiddenLayerTwo) net.addOutputModule(outLayer) net.addConnection(inToHiddenOne) net.addConnection(hiddenOneToTwo) net.addConnection(hiddenTwoToOut) net.sortModules() print(net) trainer = BackpropTrainer(net, ds) for i in range(20): for j in range(1000):
def buildBMTrainer(self): x, y = self.readexcel() # 模拟size条数据: # self.writeexcel(size=100) # resx=contrib(x,0.9) # print '**********************' # print resx # x1=x[:,[3,4,5,6,7,8,9,10,11,0,1,2]] # resx1=contrib(x1) # print '**********************' # print resx1 self.realy = y per = int(len(x)) # 对数据进行归一化处理(一般来说使用Sigmoid时一定要归一化) self.sx = MinMaxScaler() self.sy = MinMaxScaler() xTrain = x[:per] xTrain = self.sx.fit_transform(xTrain) yTrain = y[:per] yTrain = self.sy.fit_transform(yTrain) # 初始化前馈神经网络 self.__fnn = FeedForwardNetwork() # 构建输入层,隐藏层和输出层,一般隐藏层为3-5层,不宜过多 inLayer = LinearLayer(x.shape[1], 'inLayer') hiddenLayer0 = SigmoidLayer(int(self.hiddendim / 3), 'hiddenLayer0') hiddenLayer1 = TanhLayer(self.hiddendim, 'hiddenLayer1') hiddenLayer2 = SigmoidLayer(int(self.hiddendim / 3), 'hiddenLayer2') outLayer = LinearLayer(self.rescol, 'outLayer') # 将构建的输出层、隐藏层、输出层加入到fnn中 self.__fnn.addInputModule(inLayer) self.__fnn.addModule(hiddenLayer0) self.__fnn.addModule(hiddenLayer1) self.__fnn.addModule(hiddenLayer2) self.__fnn.addOutputModule(outLayer) # 对各层之间建立完全连接 in_to_hidden = FullConnection(inLayer, hiddenLayer0) hidden_to_hidden0 = FullConnection(hiddenLayer0, hiddenLayer1) hidden_to_hidden1 = FullConnection(hiddenLayer1, hiddenLayer2) hidden_to_out = FullConnection(hiddenLayer2, outLayer) # 与fnn建立连接 self.__fnn.addConnection(in_to_hidden) self.__fnn.addConnection(hidden_to_hidden0) self.__fnn.addConnection(hidden_to_hidden1) 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 = BMBackpropTrainer(self.__fnn, DS, learningrate=0.0001, verbose=self.verbose) if self.myalg: trainingErrors = trainer.bmtrain(maxEpochs=10000, verbose=True, continueEpochs=3000, totalError=0.0001) else: trainingErrors = trainer.trainUntilConvergence( maxEpochs=10000, continueEpochs=3000, validationProportion=0.1) # CV = CrossValidator(trainer, DS, n_folds=4, valfunc=ModuleValidator.MSE) # CV.validate() # CrossValidator # trainingErrors = trainer.trainUntilConvergence(maxEpochs=10000,continueEpochs=5000, validationProportion=0.1) # self.finalError = trainingErrors[0][-2] # self.finalerror=trainingErrors[0][-2] # if (self.verbose): # print '最后总体容差:', self.finalError self.__sy = self.sy self.__sx = self.sx for i in range(len(xTrain)): a = self.sy.inverse_transform( self.__fnn.activate(xTrain[i]).reshape(-1, 1)) self.restest.append( self.sy.inverse_transform( self.__fnn.activate(xTrain[i]).reshape(-1, 1))[0][0])
from pybrain.supervised.trainers.backprop import BackpropTrainer from pybrain.tools.customxml.networkwriter import NetworkWriter from pybrain.structure.networks.feedforward import FeedForwardNetwork from pybrain.structure.modules.linearlayer import LinearLayer from pybrain.structure.modules.sigmoidlayer import SigmoidLayer from pybrain.structure.connections.full import FullConnection from pybrain.structure.modules.biasunit import BiasUnit # Next we transform the data into a vectorized format so that it can be used as a training set 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)
from pybrain.structure.modules.sigmoidlayer import SigmoidLayer from pybrain.structure.networks.feedforward import FeedForwardNetwork from pybrain.structure.networks.recurrent import RecurrentNetwork from pybrain.supervised.trainers import BackpropTrainer from pybrain.tools.customxml import NetworkWriter import handWrittenRecognition import MNIST_Data # create an Object to get the data source dataObject = MNIST_Data.MNIST_Processing() traininglist = dataObject.neural_data_set traininglabels = dataObject.neural_label_set # step1 #create neural network fnn = FeedForwardNetwork() #set three layers, input+ hidden layer+ output 28*28=784 # the first feature extraction #inLayer = LinearLayer(784,name='inLayer') # the second feature extraction inLayer = LinearLayer(28, name='inLayer') hiddenLayer = SigmoidLayer(30, name='hiddenLayer0') outLayer = LinearLayer(10, name='outLayer') #There are a couple of different classes of layers. For a complete list check out the modules package. #add these three Layers into neural network fnn.addInputModule(inLayer) fnn.addModule(hiddenLayer)
from pybrain.datasets.supervised import SupervisedDataSet from pybrain.structure.connections.full import FullConnection from pybrain.structure.modules.linearlayer import LinearLayer from pybrain.structure.modules.sigmoidlayer import SigmoidLayer from pybrain.structure.networks.feedforward import FeedForwardNetwork from pybrain.supervised.trainers.backprop import BackpropTrainer network = FeedForwardNetwork() # create network inputLayer = SigmoidLayer(1) # maybe LinearLayer ? hiddenLayer = SigmoidLayer(4) outputLayer = SigmoidLayer(1) # maybe LinearLayer ? network.addInputModule(inputLayer) network.addModule(hiddenLayer) network.addOutputModule(outputLayer) # Connection network.addConnection(FullConnection(inputLayer, hiddenLayer)) network.addConnection(FullConnection(hiddenLayer, outputLayer)) network.sortModules() dataTrain = SupervisedDataSet(1, 1) # input, target dataTrain.addSample( 1, 0.76 ) # it seems to me that input(our x), target(value y) from function sin(x)*sin(2*x) trainer = BackpropTrainer( network, dataTrain) # it's back prop, we use our network and our data print(trainer.train()) # i think it's value trained print(network.params) # i think that are wights