def train(self, params): """ Train TDNN network on buffered dataset history :param params: :return: """ # self.net = buildNetwork(params['encoding_num'] * params['num_lags'], # params['num_cells'], # params['encoding_num'], # bias=True, # outputbias=True) ds = SupervisedDataSet(params['encoding_num'] * params['num_lags'], params['encoding_num']) history = self.window(self.history, params['learning_window']) n = params['encoding_num'] for i in xrange(params['num_lags'], len(history)): targets = numpy.zeros((1, n)) targets[0, :] = self.encoder.encode(history[i]) features = numpy.zeros((1, n * params['num_lags'])) for lags in xrange(params['num_lags']): features[0, lags * n:(lags + 1) * n] = self.encoder.encode( history[i - (lags + 1)]) ds.addSample(features, targets) trainer = BackpropTrainer(self.net, dataset=ds, verbose=params['verbosity'] > 0) if len(history) > 1: trainer.trainEpochs(params['num_epochs'])
class EightBitBrain(object): def __init__(self, dataset, inNodes, outNodes, hiddenNodes, classes): self.__dataset = ClassificationDataSet(inNodes, classes-1) for element in dataset: self.addDatasetSample(self._binaryList(element[0]), element[1]) self.__dataset._convertToOneOfMany() self.__network = buildNetwork(inNodes, hiddenNodes, self.__dataset.outdim, recurrent=True) self.__trainer = BackpropTrainer(self.__network, learningrate = 0.01, momentum = 0.99, verbose = True) self.__trainer.setData(self.__dataset) def _binaryList(self, n): return [int(c) for c in "{0:08b}".format(n)] def addDatasetSample(self, argument, target): self.__dataset.addSample(argument, target) def train(self, epochs): self.__trainer.trainEpochs(epochs) def activate(self, information): result = self.__network.activate(self._binaryList(information)) highest = (0,0) for resultClass in range(len(result)): if result[resultClass] > highest[0]: highest = (result[resultClass], resultClass) return highest[1]
def train(self, epochs=None): trainer = BackpropTrainer( self.net, self.training_data ) if epochs: trainer.trainEpochs(epochs) else: trainer.trainUntilConvergence()
class PerceptronPyBrainFilter(LinearPerceptron): # PYBRAIN def __init__(self, *args, **kwargs): super(PerceptronPyBrainFilter, self).__init__(*args, **kwargs) # input, hidden_layers, output self.perceptron = buildNetwork(self.num_last_measures, 0, 1, \ hiddenclass=pybrain.structure.modules.SigmoidLayer, #@UndefinedVariable \ outclass=pybrain.structure.modules.SigmoidLayer) #@UndefinedVariable # input dimension, target dimension self.pointer = 0 self.data = SupervisedDataSet(self.num_last_measures, 1) for _i in xrange(self.dataset_size): self.data.addSample([0] * self.num_last_measures, 0) self.trainer = BackpropTrainer(self.perceptron, self.data, learningrate=self.learning_rate) # This call does some internal initialization which is necessary before the net can finally # be used: for example, the modules are sorted topologically. self.perceptron.sortModules() def train(self): self.trainer.trainEpochs(1) def guess(self, x): return self.perceptron.activate(x) def apply(self, x): if len(self.lag_buffer) < self.lag - 1: if len(self.last_measures) < self.num_last_measures: self.last_measures.append(x) else: self.lag_buffer.append(x) return x self.lag_buffer.append(x) #self.data.addSample(tuple(self.last_measures), self.lag_buffer[-1]) self.data['input'][self.pointer] = np.array(self.last_measures) self.train() if len(self.data) == self.dataset_size: #del self.data[0] #self.data.removeSample #self.data.removeSample pass del self.last_measures[0] self.last_measures.append(self.lag_buffer[0]) del self.lag_buffer[0] return self.guess(self.last_measures)
class PerceptronPyBrainFilter(LinearPerceptron): # PYBRAIN def __init__(self, *args, **kwargs): super(PerceptronPyBrainFilter, self).__init__(*args, **kwargs) # input, hidden_layers, output self.perceptron = buildNetwork(self.num_last_measures, 0, 1, \ hiddenclass=pybrain.structure.modules.SigmoidLayer, #@UndefinedVariable \ outclass=pybrain.structure.modules.SigmoidLayer) #@UndefinedVariable # input dimension, target dimension self.pointer = 0 self.data = SupervisedDataSet(self.num_last_measures, 1) for _i in xrange(self.dataset_size): self.data.addSample([0] * self.num_last_measures, 0) self.trainer = BackpropTrainer(self.perceptron, self.data, learningrate=self.learning_rate) # This call does some internal initialization which is necessary before the net can finally # be used: for example, the modules are sorted topologically. self.perceptron.sortModules() def train(self): self.trainer.trainEpochs(1) def guess(self, x): return self.perceptron.activate(x) def apply(self, x): if len(self.lag_buffer) < self.lag - 1: if len(self.last_measures) < self.num_last_measures: self.last_measures.append(x) else: self.lag_buffer.append(x) return x self.lag_buffer.append(x) #self.data.addSample(tuple(self.last_measures), self.lag_buffer[-1]) self.data['input'][self.pointer] = np.array(self.last_measures) self.train() if len(self.data) == self.dataset_size: #del self.data[0] #self.data.removeSample #self.data.removeSample pass del self.last_measures[0] self.last_measures.append(self.lag_buffer[0]) del self.lag_buffer[0] return self.guess(self.last_measures)
def trainNetwork(self, net, dataset): print("Started Training: " + strftime("%Y-%m-%d %H:%M:%S", gmtime())) t = BackpropTrainer(net, dataset, learningrate=0.01, momentum=0, verbose=False) t.trainEpochs(epochs=1) print("Finished Training: " + strftime("%Y-%m-%d %H:%M:%S", gmtime())) return t
def network(dataset, input_list): num_words = len(input_list) #dividing the dataset into training and testing data tstdata, trndata = dataset.splitWithProportion(0.25) #building the network net = RecurrentNetwork() input_layer1 = LinearLayer(num_words, name='input_layer1') input_layer2 = LinearLayer(num_words, name='input_layer2') hidden_layer = TanhLayer(num_words, name='hidden_layer') output_layer = SoftmaxLayer(num_words, name='output_layer') net.addInputModule(input_layer1) net.addInputModule(input_layer2) net.addModule(hidden_layer) net.addOutputModule(output_layer) net.addConnection(FullConnection(input_layer1, hidden_layer, name='in1_to_hidden')) net.addConnection(FullConnection(input_layer2, hidden_layer, name='in2_to_hidden')) net.addConnection(FullConnection(hidden_layer, output_layer, name='hidden_to_output')) net.addConnection(FullConnection(input_layer1, output_layer, name='in1_to_out')) net.addConnection(FullConnection(input_layer2, output_layer, name='in2_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): trainer.trainEpochs(1) trnresult = percentError(trainer.testOnClassData(), trndata['target']) tstresult = percentError(trainer.testOnClassData(dataset=tstdata), tstdata['target']) print "epoch: %4d" % trainer.totalepochs print " train error: %5.10f%%" % trnresult print " test error: %5.10f%%" % tstresult return net
def training_and_testing(): nn = init_neural_network() training = learning.get_labeled_data( '%strain-images-idx3-ubyte.gz' % (database_folder), '%strain-labels-idx1-ubyte.gz' % (database_folder), '%strainig' % (database_folder)) test = learning.get_labeled_data( '%st10k-images-idx3-ubyte.gz' % (database_folder), '%st10k-labels-idx1-ubyte.gz' % (database_folder), '%stest' % (database_folder)) FEATURES = N_INPUT_LAYER print("Caracteristicas a analizar: %i" % FEATURES) testdata = ClassificationDataSet(FEATURES, 1, nb_classes=OUTPUT_LAYER) trainingdata = ClassificationDataSet(FEATURES, 1, nb_classes=OUTPUT_LAYER) for i in range(len(test['data'])): testdata.addSample(test['data'][i], test['label'][i]) for j in range(len(training['data'])): trainingdata.addSample(training['data'][j], training['label'][j]) trainingdata._convertToOneOfMany() testdata._convertToOneOfMany() trainer = BackpropTrainer(nn, dataset=trainingdata, momentum=MOMENTUM, verbose=True, weightdecay=W_DECAY, learningrate=L_RATE, lrdecay=L_DECAY) for i in range(EPOCHS): trainer.trainEpochs(1) trnresult = percentError(trainer.testOnClassData(), trainingdata['class']) tstresult = percentError(trainer.testOnClassData(dataset=testdata), testdata['class']) print("epoch: %4d" % trainer.totalepochs, " train error: %5.2f%%" % trnresult, " test error: %5.2f%%" % tstresult) return nn
def network(dataset, input_list): num_words = len(input_list) #dividing the dataset into training and testing data tstdata, trndata = dataset.splitWithProportion(0.25) #building the network net = RecurrentNetwork() input_layer1 = LinearLayer(num_words, name='input_layer1') input_layer2 = LinearLayer(num_words, name='input_layer2') hidden_layer = TanhLayer(num_words, name='hidden_layer') output_layer = SoftmaxLayer(num_words, name='output_layer') net.addInputModule(input_layer1) net.addInputModule(input_layer2) net.addModule(hidden_layer) net.addOutputModule(output_layer) net.addConnection( FullConnection(input_layer1, hidden_layer, name='in1_to_hidden')) net.addConnection( FullConnection(input_layer2, hidden_layer, name='in2_to_hidden')) net.addConnection( FullConnection(hidden_layer, output_layer, name='hidden_to_output')) net.addConnection( FullConnection(input_layer1, output_layer, name='in1_to_out')) net.addConnection( FullConnection(input_layer2, output_layer, name='in2_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): trainer.trainEpochs(1) trnresult = percentError(trainer.testOnClassData(), trndata['target']) tstresult = percentError(trainer.testOnClassData(dataset=tstdata), tstdata['target']) print "epoch: %4d" % trainer.totalepochs print " train error: %5.10f%%" % trnresult print " test error: %5.10f%%" % tstresult return net
def training_and_testing(): nn= init_neural_network() training = learning.get_labeled_data('%strain-images-idx3-ubyte.gz'%(database_folder), '%strain-labels-idx1-ubyte.gz'%(database_folder) ,'%strainig'%(database_folder)) test = learning.get_labeled_data('%st10k-images-idx3-ubyte.gz'%(database_folder), '%st10k-labels-idx1-ubyte.gz'%(database_folder), '%stest'%(database_folder)) FEATURES = N_INPUT_LAYER print("Caracteristicas a analizar: %i"%FEATURES) testdata = ClassificationDataSet(FEATURES,1,nb_classes=OUTPUT_LAYER) trainingdata = ClassificationDataSet(FEATURES,1,nb_classes=OUTPUT_LAYER) for i in range(len(test['data'])): testdata.addSample(test['data'][i],test['label'][i]) for j in range(len(training['data'])): trainingdata.addSample(training['data'][j],training['label'][j]) trainingdata._convertToOneOfMany() testdata._convertToOneOfMany() trainer = BackpropTrainer(nn,dataset=trainingdata,momentum=MOMENTUM,verbose=True, weightdecay=W_DECAY,learningrate=L_RATE,lrdecay=L_DECAY) for i in range(EPOCHS): trainer.trainEpochs(1) trnresult = percentError(trainer.testOnClassData(), trainingdata['class']) tstresult = percentError(trainer.testOnClassData( dataset=testdata), testdata['class']) print("epoch: %4d" % trainer.totalepochs, " train error: %5.2f%%" % trnresult, " test error: %5.2f%%" % tstresult) return nn
random.seed(6) net = initializeTDNNnet(nDimInput=X.shape[1], nDimOutput=1, numNeurons=200) predictedInput = np.zeros((len(sequence), )) targetInput = np.zeros((len(sequence), )) trueData = np.zeros((len(sequence), )) for i in xrange(nTrain, len(sequence) - predictionStep): Y = net.activate(X[i]) if i % 336 == 0 and i > numLags: ds = SupervisedDataSet(X.shape[1], 1) for i in xrange(i - nTrain, i): ds.addSample(X[i], T[i]) trainer = BackpropTrainer(net, dataset=ds, verbose=1) trainer.trainEpochs(30) predictedInput[i] = Y[-1] targetInput[i] = sequence['data'][i + predictionStep] trueData[i] = sequence['data'][i] print "Iteration {} target input {:2.2f} predicted Input {:2.2f} ".format( i, targetInput[i], predictedInput[i]) predictedInput = (predictedInput * stdSeq) + meanSeq targetInput = (targetInput * stdSeq) + meanSeq trueData = (trueData * stdSeq) + meanSeq saveResultToFile(dataSet, predictedInput, 'tdnn') plt.figure() plt.plot(targetInput)
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): trainer.trainEpochs(1) trnresult = percentError(trainer.testOnClassData(), trndata['target']) tstresult = percentError(trainer.testOnClassData(dataset=tstdata), tstdata['target']) trigram_file = open('trigram.txt', 'w') trigram_file.writelines(["%s\n" % item for item in sorted_list]) word_file = open('word_list', 'w') word_file.writelines(["%s\n" % item for item in input_list]) word_file.close() trigram_file.close() text_file.close()
from pybrain.supervised import BackpropTrainer # passa as dimensões dos vetores de entrada e do objetivo dataset = SupervisedDataSet(2, 1) dataset.addSample([1,1], [0]) dataset.addSample([1,0], [1]) dataset.addSample([0,1], [1]) dataset.addSample([0,0], [0]) #print(dataset.indim) network = buildNetwork(dataset.indim, 4, dataset.outdim, bias=True) trainer = BackpropTrainer(network, dataset, learningrate=0.01, momentum=0.99) for epoch in range(1000): # treina por 1000 epocas trainer.train() ''' Outros modos de treinos trainer.trainEpochs(1000) trainer.trainUntilConvergence -> treinar até a convergência ''' test_data = SupervisedDataSet(2, 1) test_data.addSample([1,1], [0]) test_data.addSample([1,0], [1]) test_data.addSample([0,1], [1]) test_data.addSample([0,0], [0]) trainer.testOnData(test_data, verbose=True)
random.seed(6) net = initializeTDNNnet(nDimInput=X.shape[1], nDimOutput=1, numNeurons=200) predictedInput = np.zeros((len(sequence),)) targetInput = np.zeros((len(sequence),)) trueData = np.zeros((len(sequence),)) for i in xrange(nTrain, len(sequence)-predictionStep): Y = net.activate(X[i]) if i % 336 == 0 and i > numLags: ds = SupervisedDataSet(X.shape[1], 1) for i in xrange(i-nTrain, i): ds.addSample(X[i], T[i]) trainer = BackpropTrainer(net, dataset=ds, verbose=1) trainer.trainEpochs(30) predictedInput[i] = Y[-1] targetInput[i] = sequence['data'][i+predictionStep] trueData[i] = sequence['data'][i] print "Iteration {} target input {:2.2f} predicted Input {:2.2f} ".format( i, targetInput[i], predictedInput[i]) predictedInput = (predictedInput * stdSeq) + meanSeq targetInput = (targetInput * stdSeq) + meanSeq trueData = (trueData * stdSeq) + meanSeq saveResultToFile(dataSet, predictedInput, 'tdnn') plt.figure() plt.plot(targetInput)
print(len(ds)) print 'starting training' # trainer = RPropMinusTrainer(n, dataset=ds) # trainer = BackpropTrainer(n, dataset=ds) # trainer.trainUntilConvergence() # trainer.train() trainer = BackpropTrainer(net, ds) train_errors = [] # save errors for plotting later EPOCHS_PER_CYCLE = 10 CYCLES = 50 EPOCHS = EPOCHS_PER_CYCLE * CYCLES for i in xrange(CYCLES): trainer.trainEpochs(EPOCHS_PER_CYCLE) train_errors.append(trainer.testOnData()) epoch = (i+1) * EPOCHS_PER_CYCLE # print("\r epoch {}/{}".format(epoch, EPOCHS), end="") print(epoch, EPOCHS, train_errors[-1]) # #stdout.flush() print() print("final error =", train_errors[-1]) # Plot the errors (note that in this simple toy example, we are testing and training on the same dataset, which is of course not what you'd do for a real project!): # plt.plot(range(0, EPOCHS, EPOCHS_PER_CYCLE), train_errors) # plt.xlabel('epoch') # plt.ylabel('error') # plt.show()
trndata._convertToOneOfMany( bounds=[0.,1.] ) tstdata._convertToOneOfMany( bounds=[0.,1.] ) if exists("params.xml"): rnn = NetworkReader.readFrom('params.xml') else: # construct LSTM network - note the missing output bias rnn = buildNetwork( trndata.indim, 5, trndata.outdim, hiddenclass=LSTMLayer, outclass=SoftmaxLayer, outputbias=False, recurrent=True) # define a training method trainer = BackpropTrainer( rnn, dataset=trndata, momentum=0.1, weightdecay=0.01) # lets training (exclamation point) for i in range(100): # setting the ephocs for the training trainer.trainEpochs( 2 ) # calculating the error trnresult = (1.0-testOnSequenceData(rnn, trndata)) tstresult = (1.0-testOnSequenceData(rnn, tstdata)) #print("train error: %5.2f%%" % trnresult, ", test error: %5.2f%%" % tstresult) # activating the softmax layer out = rnn.activate(X_train[0]) out = out.argmax(axis=0) index=0 # evaluate the net in test data result = [] for x in X_test:
from pybrain.tools.shortcuts import buildNetwork from pybrain.structure import SoftmaxLayer # 输入数据是 19维,输出是两维,隐层设置为5层 # 输出层使用Softmax激活,其他:学习率(learningrate=0.01),学习率衰减(lrdecay=1.0,每次训练一步学习率乘以), # 详细(verbose=False)动量因子(momentum=0最后时步的梯度?),权值衰减?(weightdecay=0.0) n_h = 5 net = buildNetwork(19, n_h, 2, outclass=SoftmaxLayer) # Step 2 : 构建前馈网络标准BP算法 from pybrain.supervised import BackpropTrainer trainer_sd = BackpropTrainer(net, traindata) # # 或者使用累积BP算法,训练次数50次 # trainer_ac = BackpropTrainer(net, traindata, batchlearning=True) # trainer_ac.trainEpochs(50) # err_train, err_valid = trainer_ac.trainUntilConvergence(maxEpochs=50) for i in range(50): # 训练50次,每及测试结果次打印训练结果 trainer_sd.trainEpochs(1) # 训练网络一次, # 引入训练误差和测试误差 from pybrain.utilities import percentError trainresult = percentError(trainer_sd.testOnClassData(), traindata['class']) testresult = percentError(trainer_sd.testOnClassData(dataset=testdata), testdata['class']) # 打印错误率 print('Epoch: %d', trainer_sd.totalepochs, 'train error: ', trainresult, 'test error: ', testresult)
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): trainer.trainEpochs(1) trnresult = percentError(trainer.testOnClassData(), trndata['target']) tstresult = percentError(trainer.testOnClassData(dataset=tstdata), tstdata['target']) trigram_file = open('trigram.txt', 'w') trigram_file.writelines(["%s\n" % item for item in sorted_list]) word_file = open('word_list', 'w') word_file.writelines(["%s\n" % item for item in input_list]) word_file.close() trigram_file.close() text_file.close()
from pybrain.datasets import SupervisedDataSet from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised import BackpropTrainer # passa as dimensões dos vetores de entrada e do objetivo dataset = SupervisedDataSet(2, 1) dataset.addSample([1, 1], [0]) dataset.addSample([1, 0], [1]) dataset.addSample([0, 1], [1]) dataset.addSample([0, 0], [0]) network = buildNetwork(dataset.indim, 4, dataset.outdim, bias=True) trainer = BackpropTrainer(network, dataset, learningrate=0.01, momentum=0.99) ''' for epoch in range(1000): # treina por 1000 épocas trainer.train() ''' trainer.trainEpochs(1000) ''' treinar até a convergência: trainer.trainUntilConvergence ''' test_data = SupervisedDataSet(2, 1) test_data.addSample([1, 1], [0]) test_data.addSample([1, 0], [1]) test_data.addSample([0, 1], [1]) test_data.addSample([0, 0], [0]) trainer.testOnData(test_data, verbose=True)
from pybrain.datasets import SupervisedDataSet from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised import BackpropTrainer # UTILIZANDO REDES NEURAIS PARA SIMULAR PORTA LOGICA AND # DEFININDO QUANTAS ENTRADAS E QUANTAS SAIDAS A REDE NEURAL DEVE POSSUIR parametros = SupervisedDataSet(2, 1) # DEFININDO PARAMETROS DE ENTRADA E SAIDA parametros.addSample([0, 0], [0]) parametros.addSample([0, 1], [0]) parametros.addSample([1, 0], [0]) parametros.addSample([1, 1], [1]) # CONSTRUINDO A REDE NEURAL # 2 - PARAMETROS DE ENTRADA # 10 - NEURONIOS NA CAMADA INTERMEDIARIA # 1 - SAIDA rede_neural = buildNetwork(2, 10, 1, bias=True, outputbias=True) # TREINANDO A REDE NEURAL treinamento = BackpropTrainer(rede_neural, parametros, momentum=0.5) treinamento.trainEpochs(1000) # SIMULANDO A REDE NEURAL parametros_teste = SupervisedDataSet(2, 1) # DEFININDO PARAMETROS DE ENTRADA E SAIDA parametros_teste.addSample([0, 0], [0]) treinamento.testOnData(parametros_teste, True)