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 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'])
def gradientCheck(module, tolerance=0.0001, dataset=None): """ check the gradient of a module with a randomly generated dataset, (and, in the case of a network, determine which modules contain incorrect derivatives). """ if module.paramdim == 0: print('Module has no parameters') return True if dataset: d = dataset else: d = buildAppropriateDataset(module) b = BackpropTrainer(module) res = b._checkGradient(d, True) # compute average precision on every parameter precision = zeros(module.paramdim) for seqres in res: for i, p in enumerate(seqres): if p[0] == 0 and p[1] == 0: precision[i] = 0 else: precision[i] += abs((p[0] + p[1]) / (p[0] - p[1])) precision /= len(res) if max(precision) < tolerance: print('Perfect gradient') return True else: print('Incorrect gradient', precision) if isinstance(module, Network): index = 0 for m in module._containerIterator(): if max(precision[index:index + m.paramdim]) > tolerance: print('Incorrect module:', m, res[-1][index:index + m.paramdim]) index += m.paramdim else: print(res) return False
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 trained_cat_dog_RFCNN(): n = RecurrentNetwork() 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.addRecurrentConnection(FullConnection(n['out'], n['hidden'], name='nmc')) n.sortModules() 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 exportCatDogRFCNN(n) return n
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 train(self, **kwargs): if "verbose" in kwargs: verbose = kwargs["verbose"] else: verbose = False """t = BackpropTrainer(self.rnn, dataset=self.trndata, learningrate = 0.1, momentum = 0.0, verbose = True) for i in range(1000): t.trainEpochs(5) """ # pdb.set_trace() #print self.nn.outdim, " nn | ", self.trndata.outdim, " trndata " trainer = BackpropTrainer(self.nn, self.trndata, learningrate = 0.0005, momentum = 0.99) assert (self.tstdata is not None) assert (self.trndata is not None) b1, b2 = trainer.trainUntilConvergence(verbose=verbose, trainingData=self.trndata, validationData=self.tstdata, maxEpochs=10) #print b1, b2 #print "new parameters are: " #self.print_connections() return b1, b2
def trainedRNN(): n = RecurrentNetwork() 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.addRecurrentConnection(NMConnection(n['out'], n['out'], name='nmc')) # n.addRecurrentConnection(FullConnection(n['out'], n['hidden'], inSliceFrom = 0, inSliceTo = 1, outSliceFrom = 0, outSliceTo = 3)) n.sortModules() draw_connections(n) d = getDatasetFromFile(root.path()+"/res/dataSet") t = BackpropTrainer(n, d, learningrate=0.001, momentum=0.75) t.trainOnDataset(d) count = 0 while True: globErr = t.train() print globErr if globErr < 0.01: break count += 1 if count == 50: return trainedRNN() # exportRNN(n) draw_connections(n) return n
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 trainedRNN(): n = RecurrentNetwork() 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.addRecurrentConnection(NMConnection(n['out'], n['out'], name='nmc')) # n.addRecurrentConnection(FullConnection(n['out'], n['hidden'], inSliceFrom = 0, inSliceTo = 1, outSliceFrom = 0, outSliceTo = 3)) n.sortModules() draw_connections(n) d = getDatasetFromFile(root.path() + "/res/dataSet") t = BackpropTrainer(n, d, learningrate=0.001, momentum=0.75) t.trainOnDataset(d) count = 0 while True: globErr = t.train() print globErr if globErr < 0.01: break count += 1 if count == 50: return trainedRNN() # exportRNN(n) draw_connections(n) return n
def initializeNetwork(self): can1 = NNTrainData.NNTrainData(cv2.imread('NNTrain/can1.png'), self.encodingDict["can"]) can2 = NNTrainData.NNTrainData(cv2.imread('NNTrain/can2.png'), self.encodingDict["can"]) can3 = NNTrainData.NNTrainData(cv2.imread('NNTrain/can3.png'), self.encodingDict["can"]) stain1 = NNTrainData.NNTrainData(cv2.imread('NNTrain/stain1.png'), self.encodingDict["stain"]) stain2 = NNTrainData.NNTrainData(cv2.imread('NNTrain/stain2.png'), self.encodingDict["stain"]) stain3 = NNTrainData.NNTrainData(cv2.imread('NNTrain/stain3.png'), self.encodingDict["stain"]) dirt1 = NNTrainData.NNTrainData(cv2.imread('NNTrain/dirt1.png'), self.encodingDict["dirt"]) dirt2 = NNTrainData.NNTrainData(cv2.imread('NNTrain/dirt2.png'), self.encodingDict["dirt"]) dirt3 = NNTrainData.NNTrainData(cv2.imread('NNTrain/dirt3.png'), self.encodingDict["dirt"]) self.trainData.append(can1) self.trainData.append(can2) self.trainData.append(can3) self.trainData.append(stain1) self.trainData.append(stain2) self.trainData.append(stain3) self.trainData.append(dirt1) self.trainData.append(dirt2) self.trainData.append(dirt3) for x in self.trainData: x.prepareTrainData() self.net = buildNetwork(4, 3, 3, hiddenclass=TanhLayer, outclass=SoftmaxLayer) ds = SupervisedDataSet(4, 3) for x in self.trainData: ds.addSample((x.contours/100.0, x.color[0]/1000.0, x.color[1]/1000.0, x.color[2]/1000.0), x.output) trainer = BackpropTrainer(self.net, momentum=0.1, verbose=True, weightdecay=0.01) trainer.trainOnDataset(ds, 1000) trainer.testOnData(verbose=True) print "\nSiec nauczona\n"
def trained_cat_dog_RFCNN(): n = RecurrentNetwork() 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.addRecurrentConnection(FullConnection(n['out'], n['hidden'], name='nmc')) n.sortModules() 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 exportCatDogRFCNN(n) return n
def __init__(self, net, task, valueNetwork=None, **args): self.net = net self.task = task self.setArgs(**args) if self.valueLearningRate == None: self.valueLearningRate = self.learningRate if self.valueMomentum == None: self.valueMomentum = self.momentum if self.supervisedPlotting: from pylab import ion ion() # adaptive temperature: self.tau = 1. # prepare the datasets to be used self.weightedDs = ImportanceDataSet(self.task.outdim, self.task.indim) self.rawDs = ReinforcementDataSet(self.task.outdim, self.task.indim) self.valueDs = SequentialDataSet(self.task.outdim, 1) # prepare the supervised trainers self.bp = BackpropTrainer(self.net, self.weightedDs, self.learningRate, self.momentum, verbose=False, batchlearning=True) # CHECKME: outsource self.vnet = valueNetwork if valueNetwork != None: self.vbp = BackpropTrainer(self.vnet, self.valueDs, self.valueLearningRate, self.valueMomentum, verbose=self.verbose) # keep information: self.totalSteps = 0 self.totalEpisodes = 0
def generate_and_test_nn(): d = load_training_set() n = buildNetwork(d.indim, 13, d.outdim, hiddenclass=LSTMLayer, outclass=SoftmaxLayer, outputbias=False, recurrent=True) t = BackpropTrainer(n, learningrate=0.01, momentum=0.99, verbose=True) t.trainOnDataset(d, 1000) t.testOnData(verbose=True) return (n, d)
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 testOldTraining(hidden=15, n=None): d = XORDataSet() if n is None: n = buildNetwork(d.indim, hidden, d.outdim, recurrent=False) t = BackpropTrainer(n, learningrate=0.01, momentum=0., verbose=False) t.trainOnDataset(d, 250) t.testOnData(verbose=True)
def execute(self): network = self.networkFactoryMethod() trainer = BackpropTrainer(network, learningrate = self.learningrate, momentum = self.momentum) trainer.trainOnDataset(self.datasetForTraining, self.epochs) averageError = trainer.testOnData(self.datasetForTest) self.collectedErrors.append(averageError) return averageError
def main(): print '----- loading train/test datasets -----' train_ds, test_ds = create_datasets() print '----- building the network -----' net = ann_network() trainer = BackpropTrainer(net, learningrate=0.1, momentum=0.1, verbose=True) print '----- training the model -----' trainer.trainOnDataset(train_ds)
def learn_until_convergence(self, learning_rate, momentum, max_epochs, continue_epochs, verbose=True): if verbose: print "Training neural network..." trainer = BackpropTrainer(self.network, self.learn_data, learningrate=learning_rate, momentum=momentum) training_errors, validation_errors = trainer.trainUntilConvergence(continueEpochs=continue_epochs, maxEpochs=max_epochs) self.x = range(1, len(training_errors) + 1) self.err = training_errors return self.network
def training(d): """ Builds a network and trains it. """ n = buildNetwork(d.indim, 4, d.outdim,recurrent=True) t = BackpropTrainer(n, d, learningrate = 0.01, momentum = 0.99, verbose = True) for epoch in range(0,500): t.train() return t
def main(f_samples): f_reading = open(f_samples, 'r') global data data = [] for line in f_reading: line = line.split() data.append( (float(line[0]), float(line[-1])) ) #function data_module = lambda x: map( lambda z: data[z], filter( lambda y: y% 5 == x, xrange(len(data)) ) ) global data1 data1 = [data_module(0), data_module(1), data_module(2), data_module(3), data_module(4)] global data_transformed data_transformed = take(data, rate = 60) global data_transformed_training data_transformed_training = map( lambda x: data_transformed[x], filter( lambda x: uniform(0, 1) > 0.3, xrange(len(data_transformed)) )) #Learning process----------------------------------------------------------------- global net, samples, trainer net = FeedForwardNetwork() inLayer = LinearLayer(3) hiddenLayer0 = SigmoidLayer(1) hiddenLayer1 = SigmoidLayer(3) outLayer = LinearLayer(1) net.addInputModule(inLayer) # net.addModule(hiddenLayer0) # net.addModule(hiddenLayer1) net.addOutputModule(outLayer) # net.addConnection(FullConnection(inLayer, hiddenLayer0)) net.addConnection(FullConnection(inLayer, outLayer)) # net.addConnection(FullConnection(hiddenLayer0, outLayer)) # net.addConnection(FullConnection(hiddenLayer0, hiddenLayer1)) # net.addConnection(FullConnection(hiddenLayer1, outLayer)) net.sortModules() print net ##Net with 3 inputs, 8 hidden neurons in a layerand 8 in another, and 1 out. #net = buildNetwork(3,8,8,1) ##Set with 2 inputs and one output for each sample samples = SupervisedDataSet(3,1) for i in data_transformed_training: samples.addSample(i['past'], i['next'] - i['average']) trainer = BackpropTrainer(net, samples) print 'Training' trainer.trainUntilConvergence(maxEpochs= 10) print 'Comparing' compare_net_samples(net, data_transformed) print "Number of samples %d for training." %len(data_transformed_training)
def train(self, epochs=None): trainer = BackpropTrainer( self.net, self.training_data ) if epochs: trainer.trainEpochs(epochs) else: trainer.trainUntilConvergence()
def training(d): """ Builds a network and trains it. """ n = buildNetwork(d.indim, 4, d.outdim, recurrent=True) t = BackpropTrainer(n, d, learningrate=0.01, momentum=0.99, verbose=True) for epoch in range(0, 1000): t.train() return t
def initializeNetwork(self): self.net = buildNetwork(26, 15, 5, hiddenclass=TanhLayer, outclass=SoftmaxLayer) # 15 is just a mean ds = ClassificationDataSet(26, nb_classes=5) for x in self.train: ds.addSample(x.frequency, self.encodingDict[x.lang]) ds._convertToOneOfMany() trainer = BackpropTrainer(self.net, dataset=ds, weightdecay=0.01, momentum=0.1, verbose=True) trainer.trainUntilConvergence(maxEpochs=100)
def testTraining(): d = PrimesDataSet() d._convertToOneOfMany() n = buildNetwork(d.indim, 8, d.outdim, recurrent=True) t = BackpropTrainer(n, learningrate = 0.01, momentum = 0.99, verbose = True) t.trainOnDataset(d, 1000) t.testOnData(verbose=True) for i in range(15): print "Guess: %s || Real: %s" % (str(n.activate(i)), str(i in d.generatePrimes(10))) print d
def train(self, data, iterations=NETWORK_ITERATIONS): for item in data: self.dataset.addSample(item[0], item[1]) trainer = BackpropTrainer(self.network, self.dataset, learningrate=NETWORK_LEARNING_RATE, momentum=NETWORK_MOMENTUM) error = 0 for i in xrange(iterations): error = trainer.train() print (i + 1), error return error
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 result(request, form): dataset = SupervisedDataSet(2, 1) dados = form.cleaned_data # Adiciona a tabela XOR dataset.addSample([0, 0], [0]) dataset.addSample([0, 1], [1]) dataset.addSample([1, 0], [1]) dataset.addSample([1, 1], [0]) if dados['bias'] is None: bias = False else: bias = True # dimensões de entrada e saida, argumento 2 é a quantidade de camadas intermediárias network = buildNetwork(dataset.indim, int(dados['num_camadas']), dataset.outdim, bias=bias) trainer = BackpropTrainer(network, dataset, learningrate=float(dados['learningrate']), momentum=float(dados['momentum'])) pesos_iniciais = network.params network._setParameters(np.random.uniform(dados['peso_start'], dados['peso_end'], network.params.shape[0])) error = 1.00000000 epocasPercorridas = 0 errors = [] it = [] while epocasPercorridas < dados['epochs'] and error > dados['erro_max']: error = trainer.train() epocasPercorridas += 1 errors.append(error) it.append(epocasPercorridas) graph = [] idx = 0 for e in errors: temp = [] temp.append(idx) temp.append(e) idx +=1 graph.append(temp) context = {'form': form.cleaned_data, 'error': error, 'graph': json.dumps(graph), 'epocas': epocasPercorridas, 'pesos_iniciais': pesos_iniciais, 'pesos_finais': network.params, 'result00': network.activate([0, 0])[0], 'result01': network.activate([0, 1])[0], 'result10': network.activate([1, 0])[0], 'result11': network.activate([1, 1])[0]} return render(request, 'result.html', context)
def neuralNetworkRegression(X,Y): print ("NEURAL NETWORK REGRESSION") print ("Executing...") X_train, X_test, Y_train, Y_test = cross_validation.train_test_split(X, Y, test_size = 0.10, random_state = 5) Y_test = Y_test.reshape(-1,1) Y_train = Y_train.reshape(-1,1) RMSEerror = [] train = np.vstack((X_train, X_test)) # append both testing and training into one array outputTrain = np.vstack((Y_train, Y_test)) outputTrain = outputTrain.reshape( -1, 1 ) inputSize = train.shape[1] targetSize = outputTrain.shape[1] ds = SupervisedDataSet(inputSize, targetSize) ds.setField('input', train) ds.setField('target', outputTrain) hiddenSize = 100 epochs = 100 # got after parameter tuning # neural network training model net = buildNetwork( inputSize, hiddenSize, targetSize, bias = True ) trainer = BackpropTrainer(net, ds) # uncomment out to plot epoch vs rmse # takes time to execute as gets best epoch value # getting the best value of epochs print ("training for {} epochs...".format( epochs )) ''' for i in range(epochs): print (i) mse = trainer.train() rmse = mse ** 0.5 RMSEerror.append(rmse) plt.plot(range(epochs), RMSEerror) plt.xlabel("Epochs") plt.ylabel("RMSE") plt.title("RMSE vs Epochs") plt.savefig("../Graphs/Network/Question 2c/RMSE vs Epochs.png") plt.show() ''' print ("Model training in process...") train_mse, validation_mse = trainer.trainUntilConvergence(verbose = True, validationProportion = 0.15, maxEpochs = epochs, continueEpochs = 10) p = net.activateOnDataset(ds) mse = mean_squared_error(outputTrain, p) rmse = mse ** 0.5 print ("Root Mean Squared Error for Best Parameters : " + str(rmse))
def reset(self, params, repetition): print params self.nDimInput = 1 #3 self.inputEncoder = PassThroughEncoder() if params['output_encoding'] == None: self.outputEncoder = PassThroughEncoder() self.nDimOutput = 1 elif params['output_encoding'] == 'likelihood': self.outputEncoder = ScalarBucketEncoder() self.nDimOutput = self.outputEncoder.encoder.n if (params['dataset'] == 'nyc_taxi' or params['dataset'] == 'nyc_taxi_perturb_baseline'): self.dataset = NYCTaxiDataset(params['dataset']) else: raise Exception("Dataset not found") self.testCounter = 0 self.resets = [] self.iteration = 0 # initialize LSTM network random.seed(6) if params['output_encoding'] == None: self.net = buildNetwork(self.nDimInput, params['num_cells'], self.nDimOutput, hiddenclass=LSTMLayer, bias=True, outputbias=True, recurrent=True) elif params['output_encoding'] == 'likelihood': self.net = buildNetwork(self.nDimInput, params['num_cells'], self.nDimOutput, hiddenclass=LSTMLayer, bias=True, outclass=SigmoidLayer, recurrent=True) print self.net['out'] print self.net['hidden0'] self.trainer = BackpropTrainer(self.net, dataset=SequentialDataSet( self.nDimInput, self.nDimOutput), learningrate=0.01, momentum=0, verbose=params['verbosity'] > 0) (self.networkInput, self.targetPrediction, self.trueData) = \ self.dataset.generateSequence( prediction_nstep=params['prediction_nstep'], output_encoding=params['output_encoding'], noise=params['noise'])
def training(d): """ Builds a network and trains it. """ n = buildNetwork(d.indim, INPUTS-3,INPUTS-4, d.outdim,recurrent=True) print n; t = BackpropTrainer(n, d, learningrate = 0.02, momentum = 0.88) #for epoch in range(0,700): t.trainUntilConvergence(d, 1190) return t
def train_network(self, network, dataset): trainer = BackpropTrainer(network, dataset, learningrate=0.01, momentum=0.99, verbose=True) for epoch in range(0, 1000): trainer.train() return network
def train(self, train_data_set, test_data_set, epoch=100): trainer = BackpropTrainer(self.network, train_data_set) progress_bar = ProgressBar(epoch) for i in range(epoch): progress_bar.update(i+1) time.sleep(0.01) trainer.train() return trainer.testOnData(test_data_set, verbose=True)
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 train_network(d, iterations): print("Training") n = buildNetwork(d.indim, 4, d.outdim, bias=True) t = BackpropTrainer( n, d, learningrate=0.01, momentum=0.99, verbose=False) for epoch in range(iterations): t.train() return n
def testTraining(): print "Reading data" d = XORDataSet() traind,testd = d.splitWithProportion(0.8) print "Building network" n = buildNetwork(traind.indim, 4, traind.outdim, recurrent=True) print "Training" t = BackpropTrainer(n, learningrate = 0.01, momentum = 0.99, verbose = True) t.trainOnDataset(traind,100) testd = XORDataSet(begin=60000,end=80000) print t.module.params t.testOnData(testd,verbose= True)
def _train(X, Y, filename, epochs=50): global nn nn = buildNetwork(INPUT_SIZE, HIDDEN_LAYERS, OUTPUT_LAYER, bias=True, outclass=SoftmaxLayer) ds = ClassificationDataSet(INPUT_SIZE, OUTPUT_LAYER) for x, y in zip(X, Y): ds.addSample(x, y) trainer = BackpropTrainer(nn, ds) for i in xrange(epochs): error = trainer.train() print "Epoch: %d, Error: %7.4f" % (i+1, error) # trainer.trainUntilConvergence(verbose=True, maxEpochs=epochs, continueEpochs=10) if filename: NetworkWriter.writeToFile(nn, 'data/' + filename + '.nn')
def reset(self, params, repetition): random.seed(params['seed']) if params['encoding'] == 'basic': self.encoder = BasicEncoder(params['encoding_num']) elif params['encoding'] == 'distributed': self.encoder = DistributedEncoder( params['encoding_num'], maxValue=params['encoding_max'], minValue=params['encoding_min'], classifyWithRandom=params['classify_with_random']) else: raise Exception("Encoder not found") if params['dataset'] == 'simple': self.dataset = SimpleDataset() elif params['dataset'] == 'reber': self.dataset = ReberDataset(maxLength=params['max_length']) elif params['dataset'] == 'high-order': self.dataset = HighOrderDataset( numPredictions=params['num_predictions'], seed=params['seed']) else: raise Exception("Dataset not found") self.computeCounter = 0 self.history = [] self.resets = [] self.randoms = [] self.currentSequence = [] self.targetPrediction = [] self.replenishSequence(params, iteration=0) self.net = buildNetwork(params['encoding_num'], params['num_cells'], params['encoding_num'], hiddenclass=LSTMLayer, bias=True, outputbias=params['output_bias'], recurrent=True) self.trainer = BackpropTrainer(self.net, dataset=SequentialDataSet( params['encoding_num'], params['encoding_num']), learningrate=0.01, momentum=0, verbose=params['verbosity'] > 0) self.sequenceCounter = 0
def trainedLSTMNN(): """ n = RecurrentNetwork() inp = LinearLayer(100, name = 'input') hid = LSTMLayer(30, name='hidden') out = LinearLayer(1, name='output') #add modules n.addOutputModule(out) n.addInputModule(inp) n.addModule(hid) #add connections n.addConnection(FullConnection(inp, hid)) n.addConnection(FullConnection(hid, out)) n.addRecurrentConnection(FullConnection(hid, hid)) n.sortModules() """ n = buildNetwork(100, 50, 1, hiddenclass=LSTMLayer, outputbias=False, recurrent=True) print "Network created" d = load1OrderDataSet() print "Data loaded" t = BackpropTrainer(n, d, learningrate=0.001, momentum=0.75) # FIXME: I'm not sure the recurrent ANN is going to converge # so just training for fixed number of epochs print "Learning started" count = 0 while True: globErr = t.train() print "iteration #", count, " error = ", globErr if globErr < 0.1: break count = count + 1 # if (count == 60): # break # for i in range(100): # print t.train() exportANN(n) return n
def train(self): """t = BackpropTrainer(self.rnn, dataset=self.trndata, learningrate = 0.1, momentum = 0.0, verbose = True) for i in range(1000): t.trainEpochs(5) """ print self.nn.outdim, " nn | ", self.trndata.outdim, " trndata " trainer = BackpropTrainer(self.nn, self.trndata, learningrate = 0.0005, momentum = 0.99) b1, b2 = trainer.trainUntilConvergence(verbose=True, trainingData=self.trndata, validationData=self.tstdata, maxEpochs=10) print b1, b2 print "new parameters are: " self.print_connections()
def trained3ONN(): n = FeedForwardNetwork() inp = LinearLayer(176850, name='input') hid = LinearLayer(3, name='hidden') out = LinearLayer(1, name='output') #add modules n.addOutputModule(out) n.addInputModule(inp) n.addModule(hid) #add connections n.addConnection(FullConnection(inp, hid, inSliceTo=100, outSliceTo=1)) n.addConnection( FullConnection(inp, hid, inSliceFrom=100, inSliceTo=5150, outSliceFrom=1, outSliceTo=2)) n.addConnection(FullConnection(inp, hid, inSliceFrom=5150, outSliceFrom=2)) n.addConnection(FullConnection(hid, out)) n.sortModules() print "Network created" d = load3OrderDataSet() print "Data loaded" t = BackpropTrainer(n, d, learningrate=0.001, momentum=0.75) # FIXME: I'm not sure the recurrent ANN is going to converge # so just training for fixed number of epochs print "Learning started" count = 0 while True: globErr = t.train() print "iteration #", count, " error = ", globErr if globErr < 0.01: break count = count + 1 # if (count == 100): # break # for i in range(100): # print t.train() exportANN(n) return n
def training(self,d): """ Builds a network ,trains and returns it """ self.net = FeedForwardNetwork() inLayer = LinearLayer(4) # 4 inputs hiddenLayer = SigmoidLayer(3) # 5 neurons on hidden layer with sigmoid function outLayer = LinearLayer(2) # 2 neuron as output layer "add layers to NN" self.net.addInputModule(inLayer) self.net.addModule(hiddenLayer) self.net.addOutputModule(outLayer) "create connections" in_to_hidden = FullConnection(inLayer, hiddenLayer) hidden_to_out = FullConnection(hiddenLayer, outLayer) "add connections" self.net.addConnection(in_to_hidden) self.net.addConnection(hidden_to_out) "some unknown but necessary function :)" self.net.sortModules() print self.net "generate big sized training set" trainingSet = SupervisedDataSet(4,2) trainArr = self.generate_training_set() for ri in range(2000): input = ((trainArr[0][ri][0],trainArr[0][ri][1],trainArr[0][ri][2],trainArr[0][ri][3])) target = ((trainArr[1][ri][0],trainArr[1][ri][1])) trainingSet.addSample(input, target) "create backpropogation trainer" t = BackpropTrainer(self.net,d,learningrate=0.00001, momentum=0.99) while True: globErr = t.train() print "global error:", globErr if globErr < 0.0001: break return self.net
def build_net(self): if os.path.exists(self.NET_FILE): return NetworkReader.readFrom(self.NET_FILE) ds = ClassificationDataSet(len(feats), nb_classes=len(classes)) for c in classes: print c with codecs.open(os.path.join(self.data_root, c+".txt"), 'r', 'utf8') as f: for line in f: r = Record("11", line, c, "") ds.appendLinked(r.features(), [r.class_idx()]) ds._convertToOneOfMany([0, 1]) net = buildNetwork(ds.indim, int((ds.indim + ds.outdim)/2), ds.outdim, bias=True, hiddenclass=TanhLayer, outclass=SoftmaxLayer) trainer = BackpropTrainer(net, ds, momentum=0.75, verbose=True) trainer.trainUntilConvergence(maxEpochs=300) NetworkWriter.writeToFile(net, self.NET_FILE) return net
def train(self, dataSet): """ Builds a network and trains it. """ if os.stat(self.predictor_path).st_size != 0: self.network = NetworkReader.readFrom(self.predictor_path) else: self.network = buildNetwork(dataSet.indim, 4, dataSet.outdim,recurrent=True) t = None if len(dataSet) > 0: t = BackpropTrainer(self.network, dataSet, learningrate = self.learningrate, momentum = self.momentum, verbose = False) for epoch in range(0, self.epochs): t.train() NetworkWriter.writeToFile(self.network, self.predictor_path) return t
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 testTraining(): # the AnBnCn dataset (sequential) d = AnBnCnDataSet() # build a recurrent network to be trained hsize = 2 n = RecurrentNetwork() n.addModule(TanhLayer(hsize, name='h')) n.addModule(BiasUnit(name='bias')) n.addOutputModule(LinearLayer(1, name='out')) n.addConnection(FullConnection(n['bias'], n['h'])) n.addConnection(FullConnection(n['h'], n['out'])) n.addRecurrentConnection(FullConnection(n['h'], n['h'])) n.sortModules() # initialize the backprop trainer and train t = BackpropTrainer(n, learningrate=0.1, momentum=0.0, verbose=True) t.trainOnDataset(d, 200) # the resulting weights are in the network: print('Final weights:', n.params)
def dataset_manipulation(self): self.dataset = SupervisedDataSet(len(lib.entrada[0]), len(lib.saida[0])) ## Number of neurons in Hidden Layer nr_neurons = self.page_2.sb_nr_neurons.value() ## Number os epochs nr_epochs = self.page_2.sb_nr_epochs.value() ## Leaning rate: learn_rate = self.page_2.sb_rate.value() ## Momentum: momentum = self.page_2.sb_momentum.value() ## Adding Train Samples for i in range(lib.training): self.dataset.addSample(lib.entrada[i], lib.saida[i]) print('Training: %d' % lib.training) ## Buid Network self.network = buildNetwork(self.dataset.indim, nr_neurons, self.dataset.outdim, bias=True) ## Back Propagation Trainer self.trainer = BackpropTrainer(self.network, self.dataset, learn_rate, momentum) self.page_2.count_1.setText(str(lib.training)) self.page_2.count_2.setText(str(lib.validation)) self.page_2.count_3.setText(str(lib.testing)) QtGui.QApplication.processEvents() self.train_epochs(nr_epochs)
def get_third_nn(value, good_data, bad_data): build_network = FeedForwardNetwork() inLayer = LinearLayer(len(good_data[0])) hiddenLayer = SigmoidLayer(value) outLayer = SigmoidLayer(1) build_network.addInputModule(inLayer) build_network.addModule(hiddenLayer) build_network.addOutputModule(outLayer) in_to_hidden = FullConnection(inLayer, hiddenLayer) hidden_to_out = FullConnection(hiddenLayer, outLayer) in_to_out = FullConnection(inLayer, outLayer) build_network.addConnection(in_to_hidden) build_network.addConnection(hidden_to_out) build_network.addConnection(in_to_out) build_network.sortModules() trainer = BackpropTrainer(build_network, get_supervised_data_set(good_data, bad_data)) result = trainer.trainUntilConvergence() return result[0][-1]
def generate_forecasters(data, dtt, alpha): #Learning process----------------------------------------------------------------- global net, samples, trainer net = FeedForwardNetwork() inLayer = LinearLayer(3) hiddenLayer0 = SigmoidLayer(1) hiddenLayer1 = SigmoidLayer(3) outLayer = LinearLayer(1) net.addInputModule(inLayer) net.addModule(hiddenLayer0) # net.addModule(hiddenLayer1) net.addOutputModule(outLayer) # net.addConnection(FullConnection(inLayer, hiddenLayer0)) net.addConnection(FullConnection(inLayer, outLayer)) # net.addConnection(FullConnection(hiddenLayer0, outLayer)) # net.addConnection(FullConnection(hiddenLayer0, hiddenLayer1)) # net.addConnection(FullConnection(hiddenLayer1, outLayer)) net.sortModules() print net ##Net with 3 inputs, 8 hidden neurons in a layerand 8 in another, and 1 out. #net = buildNetwork(3,8,8,1) ##Set with 2 inputs and one output for each sample samples = SupervisedDataSet(3, 1) for i in dtt: samples.addSample(i['past'], i['next'] - i['average']) trainer = BackpropTrainer(net, samples) print 'Training' #trainer.trainUntilConvergence(maxEpochs= 1) #Making Forecasters--------------------------------------------------------------- aux = map(lambda x: x[0], data) def exp(self, a, x): self.exp = a * data[aux.index(x) - 1][1] + (1 - a) * self.exp return self.exp naive = Forecaster(name='Naive', predict_function=lambda x: data[aux.index(x) - 1][1]) exponential = Forecaster(name='Exponential') exponential.exp = data[0][1] exponential.predict = lambda x: exp(exponential, alpha, x) network = Forecaster(name='Network', predict_function=net.activate) return naive, exponential, network
def testTraining(): ds = WebsiteFeaturesDataSet() net = buildNetwork(ds.indim, 4, ds.outdim, recurrent=True) trainer = BackpropTrainer(net, learningrate=0.001, momentum=0.99, verbose=True) trainer.trainOnDataset(ds, 1000) trainer.testOnData(verbose=True) import pdb pdb.set_trace()
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 treinamento_Portas(list_Entrada_Saida, NumCamadasOcultas, taxa_aprendizado, epochs): # adiciona-se as amostras d_in = 0 d_out = 0 for d in list_Entrada_Saida: d_in = len(d[0]) d_out = len(d[1]) dataset = SupervisedDataSet(d_in, d_out) for l in list_Entrada_Saida: entrada = l[0] saida = l[1] dataset.addSample(entrada, saida) # construindo a rede network = buildNetwork( dataset.indim, NumCamadasOcultas, dataset.outdim, bias=True, hiddenclass=SigmoidLayer, outclass=SigmoidLayer, ) # utilizando o backpropagation trainer = BackpropTrainer(network, dataset, learningrate=taxa_aprendizado) # trainamento da rede for epocas in range(epochs): trainer.train() # teste da rede test_data = SupervisedDataSet(d_in, d_out) for l in list_Entrada_Saida: entrada = l[0] saida = l[1] test_data.addSample(entrada, saida) try: trainer.testOnData(test_data, verbose=True) except: pass
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