def neuralnetworktrain(self): dataset = self.getdata() # Constructing a multiple output neural network. # Other neural network architectures will also be experimented, # like using different single output neural networks. net = FeedForwardNetwork() inp = LinearLayer(9) h1 = SigmoidLayer(20) h2 = TanhLayer(10) outp = LinearLayer(3) # Adding the modules to the architecture net.addOutputModule(outp) net.addInputModule(inp) net.addModule(h1) net.addModule(h2) # Creating the connections net.addConnection(FullConnection(inp, h1)) net.addConnection(FullConnection(h1, h2)) net.addConnection(FullConnection(h2, outp)) net.sortModules() # Training the neural network using Backpropagation t = BackpropTrainer(net, learningrate=0.01, momentum=0.5, verbose=True) t.trainOnDataset(dataset, 5) t.testOnData(verbose=False) # Saving the trained neural network information to file self.writetrainedinfo(net)
def computeModel(self, path, user): # Create a supervised dataset for training. trndata = SupervisedDataSet(24, 1) tstdata = SupervisedDataSet(24, 1) #Fill the dataset. for number in range(0,10): for variation in range(0,7): # Pass all the features as inputs. trndata.addSample(self.getSample(user, number, variation),(user.key,)) for variation in range(7,10): # Pass all the features as inputs. tstdata.addSample(self.getSample(user, number, variation),(user.key,)) # Build the LSTM. n = buildNetwork(24, 50, 1, hiddenclass=LSTMLayer, recurrent=True, bias=True) # define a training method trainer = BackpropTrainer(n, dataset = trndata, momentum=0.99, learningrate=0.00002) # carry out the training trainer.trainOnDataset(trndata, 2000) valueA = trainer.testOnData(tstdata) print '\tMSE -> {0:.2f}'.format(valueA) self.saveModel(n, '.\NeuralNets\SavedNet_%d' %(user.key)) return n
def train_dataset1(waze_speeds, drive_speeds): ds = SupervisedDataSet(1, 1) drive_speeds = np.sort(drive_speeds) i = 0 while i < len(waze_speeds): indata = drive_speeds[i] outdata = drive_speeds[i] print drive_speeds[i] ds.addSample(indata, outdata) i = i + len(waze_speeds) / 5 n = buildNetwork(ds.indim, 8, 8, ds.outdim, recurrent=True) t = BackpropTrainer(n, learningrate=0.001, momentum=0.05, verbose=True) t.trainOnDataset(ds, 3000) t.testOnData(verbose=True) predicted_values = [] predicted_values.append(n.activate(20)) predicted_values.append(n.activate(40)) print predicted_values return predicted_values
def train(): logging.basicConfig(filename="logfile.log", level=logging.DEBUG) accents = ['CH', 'EN', 'IN', 'IR', 'IT', 'JA', 'KO'] net = buildNetwork(13, 3, 7, hiddenclass=TanhLayer) ds = SupervisedDataSet(13, 7) logging.info("Started training network") try: speakers = os.listdir('samples') for speaker in speakers: samples = glob('samples/{}/part*'.format(speaker)) for sample in samples: s = json.load(open(sample)) out = [0, 0, 0, 0, 0, 0, 0] out[accents.index(s['accent'])] = 1 for c in s['ceps']: ds.addSample(c, out) trainer = BackpropTrainer(net) trainer.trainOnDataset(ds, 10000) trainer.testOnData(ds, verbose=True) NetworkWriter.writeToFile(net, 'models/model-{}.xml'.format(int(time()))) except Exception as e: msg = "Something bad happened: {}".format(e.message) print msg logging.error(msg)
def simpleNeuralNetworkTrain(fileName, numFeatures, numClasses, possibleOutputs, numHiddenNodes, numTrainingEpochs): data = np.genfromtxt(fileName) trnIn = data[:, 0:5] trnOut = data[:, 6] trnOut = [int(val) for val in trnOut] normalizeData(trnIn, numFeatures) trndata = ClassificationDataSet(numFeatures, possibleOutputs, nb_classes=numClasses) for row in range(0, len(trnIn)): tempListOut = [] tempListIn = [] tempListOut.append(int(trnOut[row])) for i in range(0, numFeatures): tempListIn.append(trnIn[row][i]) trndata.addSample(tempListIn, tempListOut) trndata._convertToOneOfMany() # When running for the first time myNetwork = buildNetwork(numFeatures, numHiddenNodes, numClasses, outclass=SoftmaxLayer, bias=True, recurrent=False) # Read from file after the first try. # myNetwork = NetworkReader.readFrom('firstTime.xml') # Use saved results. trainer = BackpropTrainer(myNetwork, dataset=trndata, momentum=0.0, verbose=True, weightdecay=0.0) for i in range(numTrainingEpochs): trainer.trainOnDataset(dataset=trndata)
def train_net(data_set, n, epochs=1): num_inputs = len(data_set[0][0][n]) ds = SupervisedDataSet(num_inputs, 2) for i in range(len(data_set)): try: ds.appendLinked(data_set[i][0][n], (data_set[i][1], data_set[i][2])) except: continue print str(len(ds)) + ' points successfully aquired' net = FeedForwardNetwork() net.addInputModule(LinearLayer(num_inputs, name='input')) net.addInputModule(BiasUnit(name='bias')) net.addOutputModule(LinearLayer(2, name='output')) net.addModule(SigmoidLayer(int((num_inputs + 2) / 2.), name='sigmoid')) net.addModule(TanhLayer(10, name='tanh')) net.addConnection(FullConnection(net['bias'], net['sigmoid'])) net.addConnection(FullConnection(net['bias'], net['tanh'])) net.addConnection(FullConnection(net['input'], net['sigmoid'])) net.addConnection(FullConnection(net['sigmoid'], net['tanh'])) net.addConnection(FullConnection(net['tanh'], net['output'])) net.sortModules() trainer = BackpropTrainer(net, learningrate=0.01, momentum=0.1, verbose=True) trainer.trainOnDataset(ds) trainer.trainEpochs(epochs) return net
def buildBMTrainer(self): x, y = self.readexcel() per = int(len(x)) # 对数据进行归一化处理(一般来说使用Sigmoid时一定要归一化) sx = MinMaxScaler() sy = MinMaxScaler() xTrain = x[:per] xTrain = sx.fit_transform(xTrain) yTrain = y[:per] yTrain = sy.fit_transform(yTrain) # 初始化前馈神经网络 DS = SupervisedDataSet(x.shape[1], self.rescol) for i in range(len(x)): DS.addSample(x[i], y[i]) self.__fnn = buildNetwork(DS.indim,28,28,DS.outdim,recurrent=True) # 采用BP进行训练,训练至收敛,最大训练次数为1000 trainer = BackpropTrainer(self.__fnn, learningrate=0.01, verbose=self.verbose) trainer.trainOnDataset(DS,1000) trainer.testOnData(verbose=True) # trainer. # trainingErrors = trainer.trainUntilConvergence(maxEpochs=10000,continueEpochs=2000, validationProportion=0.5) # for i in range(10): # trainingErrors = trainer.trainUntilConvergence(maxEpochs=15000, validationProportion=0) # print '测试:'+str(trainingErrors[0][-2]) # self.finalError = trainingErrors[0][-2] # if (self.verbose): # print '最后总体容差:', self.finalError self.__sy = sy
def entrenarSonoliento(red): #Se inicializa el dataset ds = SupervisedDataSet(4096,1) """Se crea el dataset, para ello procesamos cada una de las imagenes obteniendo los rostros, luego se le asignan los valores deseados del resultado la red neuronal.""" for i,c in enumerate(os.listdir(os.path.dirname(path + '/static/img/sleepy/'))): a = 0 while a < 50: try: a += 1 im3 = cv2.imread(path + '/static/img/sleepy/'+c) procesado = p.procesarImagen(im3) cara = d.deteccionFacial1(procesado) ds.addSample(cara.flatten(),10) except: pass trainer = BackpropTrainer(red, ds) print "Entrenando hasta converger" trainer.trainOnDataset(ds,100) NetworkWriter.writeToFile(red, 'rna_somnolencia.xml') #para entrenar operadores manualmente #red_operador = NetworkReader.readFrom('rna_operador.xml') #entrenarOperador(red_operador) #para entrenar somnolencia manualmente #red_somno = NetworkReader.readFrom('rna_somnolencia.xml') #entrenarSonoliento(red_somno)
def anntrain(xdata,ydata):#,epochs): #print len(xdata[0]) ds=SupervisedDataSet(len(xdata[0]),1) #ds=ClassificationDataSet(len(xdata[0]),1, nb_classes=2) for i,algo in enumerate (xdata): ds.addSample(algo,ydata[i]) #ds._convertToOneOfMany( ) esto no net= FeedForwardNetwork() inp=LinearLayer(len(xdata[0])) h1=SigmoidLayer(1) outp=LinearLayer(1) net.addOutputModule(outp) net.addInputModule(inp) net.addModule(h1) #net=buildNetwork(len(xdata[0]),1,1,hiddenclass=TanhLayer,outclass=SoftmaxLayer) net.addConnection(FullConnection(inp, h1)) net.addConnection(FullConnection(h1, outp)) net.sortModules() trainer=BackpropTrainer(net,ds)#, verbose=True)#dataset=ds,verbose=True) #trainer.trainEpochs(40) trainer.trainOnDataset(ds,40) #trainer.trainUntilConvergence(ds, 20, verbose=True, validationProportion=0.15) trainer.testOnData()#verbose=True) #print 'Final weights:',net.params return net
def train_neural_network(): start = time.clock() ds = get_ds() # split main data to train and test parts train, test = ds.splitWithProportion(0.75) # build nn with 10 inputs, 3 hidden layers, 1 output neuron net = buildNetwork(10,3,1, bias=True) # use backpropagation algorithm trainer = BackpropTrainer(net, train, momentum = 0.1, weightdecay = 0.01) # plot error trnError, valError = trainer.trainUntilConvergence(dataset = train, maxEpochs = 50) plot_error(trnError, valError) print "train the model..." trainer.trainOnDataset(train, 500) print "Total epochs: %s" % trainer.totalepochs print "activate..." out = net.activateOnDataset(test).argmax(axis = 1) percent = 100 - percentError(out, test['target']) print "%s" % percent end = time.clock() print "Time: %s" % str(end-start)
def train_callback(): trainer = BackpropTrainer(net, learningrate=0.01, momentum=0.0, verbose=True) print 'MSE before', trainer.testOnData(ds, verbose=True) trainer.trainOnDataset(ds, 2000) print 'MSE after', trainer.testOnData(ds, verbose=True)
def update_nn(net, inputs, outputs, learningrate=0.001, momentum=0.99): ds = SupervisedDataSet(3, 3) ds.addSample(list(inputs), outputs) train = BackpropTrainer(net, ds, learningrate=learningrate, momentum=momentum) train.trainOnDataset(ds) return net
def nn(tx, ty, rx, ry, iterations): network = buildNetwork(14, 5, 5, 1) ds = ClassificationDataSet(14,1, class_labels=["<50K", ">=50K"]) for i in xrange(len(tx)): ds.addSample(tx[i], [ty[i]]) trainer = BackpropTrainer(network, ds) trainer.trainOnDataset(ds, iterations) NetworkWriter.writeToFile(network, "network.xml") results = sum((np.array([round(network.activate(test)) for test in rx]) - ry)**2)/float(len(ry)) return results
def nn(tx, ty, rx, ry, iterations): network = buildNetwork(14, 5, 5, 1) ds = ClassificationDataSet(14, 1, class_labels=["<50K", ">=50K"]) for i in xrange(len(tx)): ds.addSample(tx[i], [ty[i]]) trainer = BackpropTrainer(network, ds) trainer.trainOnDataset(ds, iterations) NetworkWriter.writeToFile(network, "network.xml") results = sum((np.array([round(network.activate(test)) for test in rx]) - ry)**2) / float(len(ry)) return results
def build_network(): # get iris data iris = datasets.load_iris() d, t = iris.data, iris.target # build dataset ds = _get_classification_dataset() for i in range(len(d)): ds.addSample(d[i], t[i]) print "Dataset input: {}".format(ds['input']) print "Dataset output: {}".format(ds['target']) print "Dataset input length: {}".format(len(ds['input'])) print "Dataset output length: {}".format(len(ds['target'])) print "Dataset length: {}".format(len(ds)) print "Dataset input|output dimensions are {}|{}".format( ds.indim, ds.outdim) # split dataset train_data, test_data = _split_with_proportion(ds, 0.70) print "Train Data length: {}".format(len(train_data)) print "Test Data length: {}".format(len(test_data)) # encode with one output neuron per class train_data._convertToOneOfMany() test_data._convertToOneOfMany() print "Train Data input|output dimensions are {}|{}".format( train_data.indim, train_data.outdim) print "Test Data input|output dimensions are {}|{}".format( test_data.indim, test_data.outdim) # build network network = buildNetwork(INPUT, HIDDEN, CLASSES, outclass=SoftmaxLayer) # train network trainer = BackpropTrainer(network, dataset=train_data, momentum=0.1, verbose=True, weightdecay=0.01) trainer.trainOnDataset(train_data, 500) print "Total epochs: {}".format(trainer.totalepochs) # test network output = network.activateOnDataset(test_data).argmax(axis=1) print "Percent error: {}".format(percentError(output, test_data['class'])) # return network return network
def estimateNot(): ds_not = SupervisedDataSet(1, 1) ds_not.addSample( (0,) , (1,)) ds_not.addSample( (1,) , (0,)) net = buildNetwork(1, 100, 1, bias=True) trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.99) trainer.trainOnDataset(ds_not, 3000) trainer.testOnData() print '\nthe prediction for NOT value:' print 'NOT 0 = ', net.activate((0,)) print 'NOT 1 = ', net.activate((1,))
def estimateNot(): ds_not = SupervisedDataSet(1, 1) ds_not.addSample( (0,) , (1,)) ds_not.addSample( (1,) , (0,)) net = buildNetwork(1, 10, 1, bias=True) trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.99) trainer.trainOnDataset(ds_not, 3000) trainer.testOnData() print '\nthe prediction for NOT value:' print 'NOT 0 = ', net.activate((0,)) print 'NOT 1 = ', net.activate((1,))
def RunNet(net, dataset, train_epochs): "a function to build a neural net and test on it, for testing purposes right now" #print net.activate([2, 1]) #ds = SupervisedDataSet(15, 1) #ds.addSample((1,1,1,1,1,1,1,1,1,1,1,1,1,1,1), (100)) #ds.addSample((0,0,0,0,0,0,0,0,0,0,0,0,0,0,0), (0)) #trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.99, verbose = True) trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.5, verbose = True) trainer.trainOnDataset(dataset, train_epochs) trainer.testOnData(verbose = True)
def buildAndTrain(ds): net = buildNetwork(2, 4, 1, bias=True) # try: # f = open('_learned', 'r') # net = pickle.load(f) # f.close() # except: trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.99) trainer.trainOnDataset(ds, 1000) trainer.testOnData() return net
def xtrain(self): dataset = self.getdata() # Constructing a two hidden layes Neural Network net = buildNetwork(9, 15, 5, 1, recurrent=True) # Training using Back Propagation trainer = BackpropTrainer(net, learningrate=0.01, momentum=0.75, weightdecay=0.02, verbose=True) trainer.trainOnDataset(dataset, 10) trainer.testOnData(verbose=False) # Saving the trained neural network information to file self.writetrainedinfo(net)
class BackpropNet: def __init__(self, input_size, hidden_layer_size, output_size): self._input_size = input_size self._output_size = output_size self._net = buildNetwork(input_size, hidden_layer_size, output_size) self._trainer = BackpropTrainer(self._net, learningrate=0.001) def process(self, inp): return self._net.activate(inp) def train(self, inp, output): dataset = SupervisedDataSet(self._input_size, self._output_size) dataset.addSample(inp, output) self._trainer.trainOnDataset(dataset)
def estimateNor(): ds_nor = SupervisedDataSet(2, 1) ds_nor.addSample( (0,0) , (1,)) ds_nor.addSample( (0,1) , (0,)) ds_nor.addSample( (1,0) , (0,)) ds_nor.addSample( (1,1) , (0,)) net = buildNetwork(2, 10, 1, bias=True) trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.99) trainer.trainOnDataset(ds_nor, 3000) trainer.testOnData() print '\nthe prediction for NOR value:' print '1 NOR 1 = ', net.activate((1,1)) print '1 NOR 0 = ', net.activate((1,0)) print '0 NOR 1 = ', net.activate((0,1)) print '0 NOR 0 = ', net.activate((0,0))
def estimateAnd(): ds_and = SupervisedDataSet(2, 1) ds_and.addSample( (0,0) , (0,)) ds_and.addSample( (0,1) , (0,)) ds_and.addSample( (1,0) , (0,)) ds_and.addSample( (1,1) , (1,)) net = buildNetwork(2, 4, 1, bias=True) trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.99) trainer.trainOnDataset(ds_and, 3000) trainer.testOnData() print '\nthe prediction for AND value:' print '1 AND 1 = ', net.activate((1,1)) print '1 AND 0 = ', net.activate((1,0)) print '0 AND 1 = ', net.activate((0,1)) print '0 AND 0 = ', net.activate((0,0))
def estimateAnd(): ds_and = SupervisedDataSet(2, 1) ds_and.addSample((0, 0), (0, )) ds_and.addSample((0, 1), (0, )) ds_and.addSample((1, 0), (0, )) ds_and.addSample((1, 1), (1, )) net = buildNetwork(2, 4, 1, bias=True) trainer = BackpropTrainer(net, learningrate=0.01, momentum=0.99) trainer.trainOnDataset(ds_and, 3000) trainer.testOnData() print '\nthe prediction for AND value:' print '1 AND 1 = ', net.activate((1, 1)) print '1 AND 0 = ', net.activate((1, 0)) print '0 AND 1 = ', net.activate((0, 1)) print '0 AND 0 = ', net.activate((0, 0))
def estimateNor(): ds_nor = SupervisedDataSet(2, 1) ds_nor.addSample( (0,0) , (1,)) ds_nor.addSample( (0,1) , (0,)) ds_nor.addSample( (1,0) , (0,)) ds_nor.addSample( (1,1) , (0,)) net = buildNetwork(2, 100, 1, bias=True) trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.99) trainer.trainOnDataset(ds_nor, 3000) trainer.testOnData() print '\nthe prediction for NOR value:' print '1 NOR 1 = ', net.activate((1,1)) print '1 NOR 0 = ', net.activate((1,0)) print '0 NOR 1 = ', net.activate((0,1)) print '0 NOR 0 = ', net.activate((0,0))
def build_network(): # get iris data iris = datasets.load_iris() d,t = iris.data, iris.target # build dataset ds = _get_classification_dataset() for i in range(len(d)): ds.addSample(d[i],t[i]) print "Dataset input: {}".format(ds['input']) print "Dataset output: {}".format(ds['target']) print "Dataset input length: {}".format(len(ds['input'])) print "Dataset output length: {}".format(len(ds['target'])) print "Dataset length: {}".format(len(ds)) print "Dataset input|output dimensions are {}|{}".format(ds.indim, ds.outdim) # split dataset train_data,test_data = _split_with_proportion(ds, 0.70) print "Train Data length: {}".format(len(train_data)) print "Test Data length: {}".format(len(test_data)) # encode with one output neuron per class train_data._convertToOneOfMany() test_data._convertToOneOfMany() print "Train Data input|output dimensions are {}|{}".format(train_data.indim, train_data.outdim) print "Test Data input|output dimensions are {}|{}".format(test_data.indim, test_data.outdim) # build network network = buildNetwork(INPUT,HIDDEN,CLASSES,outclass=SoftmaxLayer) # train network trainer = BackpropTrainer(network,dataset=train_data,momentum=0.1,verbose=True,weightdecay=0.01) trainer.trainOnDataset(train_data, 500) print "Total epochs: {}".format(trainer.totalepochs) # test network output = network.activateOnDataset(test_data).argmax(axis=1) print "Percent error: {}".format(percentError(output, test_data['class'])) # return network return network
class PHC_NN(PHC_FA): '''PHC with neural function approximation. ''' delta=0.1 maxNumberofAverage=30 weightdecay=0.001 trainingEpochPerUpdateWight=2 def __init__(self, num_features, num_actions, indexOfAgent=None): PHC_FA.__init__(self, num_features, num_actions, indexOfAgent) self.linQ = buildNetwork(num_features + num_actions, (num_features + num_actions), 1, hiddenclass = SigmoidLayer, outclass = LinearLayer) self.linPolicy = buildNetwork(num_features, (num_features + num_actions), num_actions, hiddenclass = SigmoidLayer,outclass = SigmoidLayer) self.trainer4LinQ=BackpropTrainer(self.linQ,weightdecay=self.weightdecay) self.trainer4LinPolicy=BackpropTrainer(self.linPolicy,weightdecay=self.weightdecay) def _pi(self, state): """Given state, compute probabilities for each action.""" values = np.array(self.linPolicy.activate(r_[state])) z=np.sum(values) return (values/z).flatten() def _qValues(self, state): """ Return vector of q-values for all actions, given the state(-features). """ values = np.array([self.linQ.activate(r_[state, one_to_n(i, self.num_actions)]) for i in range(self.num_actions)]) return values.flatten() def _updateWeights(self, state, action, reward, next_state): """ state and next_state are vectors, action is an integer. """ #update Q-value function approximator target=reward + self.rewardDiscount * max(self._qValues(next_state)) inp=r_[asarray(state), one_to_n(action, self.num_actions)] self.trainer4LinQ=BackpropTrainer(self.linQ,weightdecay=self.weightdecay) ds = SupervisedDataSet(self.num_features+self.num_actions,1) ds.addSample(inp, target) self.trainer4LinQ.trainOnDataset(ds) #Update policy bestAction=r_argmax(self._qValues(state)) target= one_to_n(bestAction, self.num_actions) inp=r_[asarray(state)] ds = SupervisedDataSet(self.num_features,self.num_actions) ds.addSample(inp, target) self.trainer4LinPolicy=BackpropTrainer(self.linPolicy, learningrate=self.delta, weightdecay=self.weightdecay) self.trainer4LinPolicy.setData(ds) self.trainer4LinPolicy.trainEpochs(epochs=self.trainingEpochPerUpdateWight)
def Treinar(): print 'Inicializando o treinamento da Rede......Aguarde' ds = SupervisedDataSet(50,1) with open('trainning.txt') as f: for line in f: if line[0] != '#': line = line.replace('\n','') line = line.split(',') exemplo = [] for x in line: exemplo.append(x) ds.addSample(exemplo[1:],exemplo[:1]) # o 1: pega o primeiro valor que e targer. ## Dataset #trainer = BackpropTrainer(net, learningrate = 0.04, momentum = 0.07, verbose = False) trainer = BackpropTrainer(net, learningrate = 0.04, momentum = 0.07, verbose = False) trainer.trainOnDataset(ds,10000) NetworkWriter.writeToFile(net, 'filename.xml') print 'Treinado e Pronto'
def main(): # Declare length of input and output vectors here, to change later lenInput = 6 lenOutput = 4 lenHidden = 8 # change this? labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'] # Initialize data set used for training data = ClassificationDataSet(lenInput, lenOutput, class_labels=labels) # Get input and output vectors from file, build dataset with open('../heartsMoves.csv', 'rb') as csvfile: reader = csv.reader(csvfile, delimiter=",", quotechar="|") firstLine = True for row in reader: if firstLine: labels = row if not firstLine: rowInput = map(float,row[:lenInput]) rowOutput = map(float, row[lenInput:]) #pdb.set_trace() data.addSample(rowInput, rowOutput) firstLine = False ########################################## # DATASET IS BUILT, NOW TRAIN NEURAL NET # ########################################## # build network fnn = buildNetwork(lenInput, lenHidden, lenOutput) # train it with data trainer = BackpropTrainer(fnn, dataset=data, momentum=.1, verbose=False, weightdecay=0.01) trainer.trainOnDataset(data) #print 'final weights:', fnn.params #################################### # NET IS TRAINED, NOW SAVE TO DISK # #################################### fileObject = open(filename, 'w') pickle.dump(fnn, fileObject) fileObject.close()
def genTrain(rnaNmbr, gen, epochs, genPath, dataset): """ #Treinamento de uma geracao (backpropagation) ##Parametros -rnaNmbr-> numero de redes neurais de cada geracao - Inteiro -gen-> numero da geracao para o treinamento - Inteiro -epochs-> numero de iteracoes de treino para cada rna - Inteiro -genPath-> endereco para a pasta que aloca as geracoes de um sistema genetico - String -dataset-> array contendo os dados do dataset - Array de Float ##Retorno none """ k = 0 inNmbr = len(dataset[0]) outNmbr = len(dataset[1]) ds = SupervisedDataSet(inNmbr, outNmbr) for i in range(len(dataset)/2): ds.addSample(dataset[k], dataset[k+1]) k = k+2 for l in range(rnaNmbr): rna = NetworkReader.readFrom(genPath+'/gen'+str(gen)+'/rna'+str(l+1)+'.xml') t = BackpropTrainer(rna , learningrate=0.01, momentum=0.1, verbose=True) t.trainOnDataset(ds, epochs) NetworkWriter.writeToFile(rna, genPath+'/gen'+str(gen)+'/rna'+str(l+1)+'.xml') print "Geracao: {:}".format(l+1)
def vali(): from pybrain.tools.validation import ModuleValidator from pybrain.tools.validation import CrossValidator with open('new_data1.txt') as data_file: data = json.load(data_file) m = [d[0] for d in data] case = [min([a for a, s, d in m]), float(max([a for a, s, d in m])-min([a for a, s, d in m]))] week = [min([s for a, s, d in m]), float(max([s for a, s, d in m])-min([s for a, s, d in m]))] grid = [min([d for a, s, d in m]), float(max([d for a, s, d in m])-min([d for a, s, d in m]))] ds = SupervisedDataSet(3, 1) import random random.shuffle(data) print len(data) for i in xrange(0, len(data)): # print "Adding {}th data sample".format(i), x1 = float(data[i][0][0] - case[0])/case[1] x2 = float(data[i][0][1] - week[0])/week[1] x3 = float(data[i][0][2] - grid[0])/grid[1] input = (x1, x2, x3) output = data[i][1] ds.addSample(input, output) # print ":: Done" print "Train" net = buildNetwork(3, 3, 1, bias=True) tstdata, trndata = ds.splitWithProportion( 0.33 ) trainer = BackpropTrainer(net, trndata) mse = [] modval = ModuleValidator() for i in range(100): trainer.trainEpochs(1) trainer.trainOnDataset(dataset=trndata) cv = CrossValidator(trainer, trndata, n_folds=10, valfunc=modval.MSE) mse_val = cv.validate() print "MSE %f @ %i" % (mse_val, i) mse.append(mse_val) with open('cross_validation.json', 'w') as outfile: json.dump(mse, outfile, indent=4)
def problemC(): ds_and = SupervisedDataSet(3, 1) ds_and = SupervisedDataSet(3, 1) ds_and.addSample( (0,0,0) , (1,)) ds_and.addSample( (0,0,1) , (1,)) ds_and.addSample( (0,1,0) , (1,)) ds_and.addSample( (0,1,1) , (0,)) ds_and.addSample( (1,0,0) , (1,)) ds_and.addSample( (1,0,1) , (0,)) ds_and.addSample( (1,1,0) , (1,)) ds_and.addSample( (1,1,1) , (0,)) net = buildNetwork(3, 10, 1, bias=True) trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.99) trainer.trainOnDataset(ds_and, 3000) trainer.testOnData() print '\n3) NOT ( (A OR B) AND C) ' print '0 0 0 = ', net.activate((0,0,0)) print '0 0 1 = ', net.activate((0,0,1)) print '0 1 0 = ', net.activate((0,1,0)) print '0 1 1 = ', net.activate((0,1,1)) print '1 0 0 = ', net.activate((1,0,0)) print '1 0 1 = ', net.activate((1,0,1)) print '1 1 0 = ', net.activate((1,1,0)) print '1 1 1 = ', net.activate((1,1,1))
# Read all info on the csv. for line in tf.readlines(): data = [float(x) for x in line.strip().split(',') if x != ''] indata = tuple(data[:8]) outdata = tuple(data[8:]) ds.addSample(indata,outdata) ''' Make the actual neural networks TOPOLOGY: 8 in, 8 hidden-0, 8 hidden-1, 8 out. Hidden layers subject to change ''' n = buildNetwork(ds.indim,8,8,ds.outdim,recurrent=True) #change learningrate based on gradient t = BackpropTrainer(n,learningrate=0.01,momentum=0.5,verbose=True) # 100 iterations t.trainOnDataset(ds,100) t.testOnData(verbose=True) # Our prediction given 8 inputs, will print 8 estimated outputs guess = n.activate((1,2,3,4,5,6,7,8)) print 'Final weights:',n.params # Print our Guess print '\nGUESS???' + str(guess) #print n['in'], n['out'], n[h0], n['h1'] print (printConnections(n))
from pybrain.datasets import * from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised.trainers import BackpropTrainer import pickle if __name__ == "__main__": ds = SupervisedDataSet(2, 1) ds.addSample((0, 0), (0, )) ds.addSample((0, 1), (1, )) ds.addSample((1, 0), (1, )) ds.addSample((1, 1), (0, )) net = buildNetwork(2, 4, 1, bias=True) # try: # f = open('_learned', 'r') # net = pickle.load(f) # f.close() # except: trainer = BackpropTrainer(net, learningrate=0.01, momentum=0.99) trainer.trainOnDataset(ds, 3000) trainer.testOnData() # f = open('_learned', 'w') # pickle.dump(net, f) # f.close() print net.activate((1, 1)) print net.activate((1, 0)) print net.activate((0, 1)) print net.activate((0, 0))
start_time=time.time() #our data set has 4 input parameters and 3 classes ds = SupervisedDataSet(4,3) tf=open('IRIS.csv','r') for line in tf.readlines(): data = [float(x) for x in line.strip().split(',') if x != ''] indata = tuple(data[:4]) outdata = tuple(data[4:]) ds.addSample(indata,outdata) print ds.indim print ds.outdim # pybrain.tools.shortcuts.buildNetwork(*layers, **options) #Build arbitrarily deep networks. #layers should be a list or tuple of integers, that indicate how many neurons the layers should have. #change the hidden layer neurons to maximise the accuracy n = buildNetwork(ds.indim,3,ds.outdim,recurrent=True) #bpa t = BackpropTrainer(n,learningrate=0.01,momentum=0.5,verbose=True) t.trainOnDataset(ds,5) t.testOnData(verbose=True) end_time=time.time() print "time taken is ",end_time-start_time," seconds"
def nn_run(self, hidden_dim, num_epoch, learningrate_, lrdecay_, weightdecay_, num_classes, X_train, y_train): # # NN HYP # # hidden_dim = 100 # bias_ = True # # SoftmaxLayer, TanhLayer, SigmoidLayer, LSTMLayer, LinearLayer, GaussianLayer # hiddenclass_ = TanhLayer # outclass_ = SoftmaxLayer # # num_epoch = 4 # # if len(sys.argv)>0: # # num_epoch = int(sys.argv[1]) # # learningrate_ = 0.01 # # lrdecay_ = 1.0 # momentum_ = 0.1 # batchlearning_ = False # # weightdecay_ = 0.01 # # NN HYP net = buildNetwork(SHAPE[0] * SHAPE[1] * 3, hidden_dim, num_classes, bias=self.bias_, hiddenclass=self.hiddenclass_, outclass=self.outclass_) train_ds = SupervisedDataSet(SHAPE[0] * SHAPE[1] * 3, num_classes) test_ds = SupervisedDataSet(SHAPE[0] * SHAPE[1] * 3, num_classes) if batch_size ==0: # for feature, label in zip(X_train, y_train): for feature, label in zip(X_train, y_train): train_ds.addSample(feature, label) # for feature, label in zip(X_test, y_test): # test_ds.addSample(feature, label) # checking for model if os.path.isfile("models/" + model_name + ".pkl"): tmp = "Using previous " + model_name + " model...\n" print(tmp) f.write(tmp) trainer = pickle.load(open("models/" + model_name + ".pkl", "rb")) else: # tmp = "Training " + model_name + " on set " + str(division_num) + "\n" # print(tmp) # f.write(tmp) trainer = BackpropTrainer(net, train_ds, learningrate=learningrate_, lrdecay=lrdecay_, momentum=self.momentum_, verbose=True, batchlearning=self.batchlearning_, weightdecay=weightdecay_) # different trainig calls # trainer.train() trainer.trainEpochs(epochs=num_epoch) # trainer.trainOnDataset(dataset) # trainer.trainUntilConvergence(dataset=None, maxEpochs=None, # verbose=None, continueEpochs=10, validationProportion=0.25) # different trainig calls # print("Saving model") # pickle.dump(trainer, open("models/"+ model_name+ ".pkl", "wb")) elif batch_size>0: trainer = BackpropTrainer(net, learningrate=learningrate_, lrdecay=lrdecay_, momentum=self.momentum_, verbose=True, batchlearning=self.batchlearning_, weightdecay=weightdecay_) for epoch in range(num_epoch): print("\n epoch {}".format(epoch)) for i in range(X_train.shape[0] // batch_size): X_ = X_train[i * batch_size:(i + 1) * batch_size][:] y_ = y_train[i * batch_size:(i + 1) * batch_size] tmp = "epoch {}, batch {}".format(epoch, i) print(tmp) f.write(tmp) train_ds = SupervisedDataSet(SHAPE[0] * SHAPE[1] * 3, num_classes) for feature, label in zip(X_, y_): train_ds.addSample(feature, label) # train_ds.batches("batches", batch_size) # for feature, label in zip(X_test, y_test): # test_ds.addSample(feature, label) # checking for model if os.path.isfile("models/" + model_name + ".pkl"): tmp = "Using previous " + model_name + " model...\n" print(tmp) f.write(tmp) trainer = pickle.load(open("models/" + model_name + ".pkl", "rb")) else: # tmp = "Training " + model_name + " on set " + str(division_num) + "\n" # print(tmp) # f.write(tmp) # trainer = BackpropTrainer(net, learningrate=learningrate_, lrdecay=lrdecay_, # momentum=self.momentum_, verbose=True, # batchlearning=self.batchlearning_, # weightdecay=weightdecay_) # different trainig calls # trainer.train() trainer.trainOnDataset(train_ds) # trainer.trainOnDataset(dataset) # trainer.trainUntilConvergence(dataset=None, maxEpochs=None, # verbose=None, continueEpochs=10, validationProportion=0.25) # different trainig calls # print("Saving model") # pickle.dump(trainer, open("models/"+ model_name+ ".pkl", "wb")) # tmp = eval(" ", " ", test_precs, model_name, # X_train, y_train, net, svm, f, tr_=True) # print("eval {}".format(tmp)) return net
__author__ = 'davidoregan' from pybrain.datasets import * from pybrain.utilities import percentError from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised.trainers import BackpropTrainer from pybrain.structure.modules import SoftmaxLayer ds = SupervisedDataSet(6,3) tf = open('MiscIdeas/../MiscIdeas/carData.csv','r') for line in tf.readlines(): data = [float(x) for x in line.strip().split(',') if x != ''] indata = tuple(data[:6]) outdata = tuple(data[6:]) ds.addSample(indata,outdata) n = buildNetwork(ds.indim,8,8,ds.outdim,recurrent=True) t = BackpropTrainer(n,learningrate=0.01,momentum=0.5,verbose=True) t.trainOnDataset(ds,1000) t.testOnData(verbose=True)
tsts.setField('input',x.reshape(len(x),1)) tsts.setField('target',s.reshape(len(s),1)) #read the train DataSet from file trndata = SupervisedDataSet.loadFromFile(os.path.join(os.getcwd(),'trndata')) #create the trainer t = BackpropTrainer(n, learningrate = 0.01 , momentum = mom) #train the neural network from the train DataSet cterrori=1.0 print "trainer momentum:"+str(mom) for iter in range(25): t.trainOnDataset(trndata, 1000) ctrndata = mv.calculateModuleOutput(n,trndata) cterr = v.MSE(ctrndata,trndata['target']) relerr = abs(cterr-cterrori) cterrori = cterr print 'iteration:',iter+1,'MSE error:',cterr myplot(trndata,ctrndata,iter=iter+1) if cterr < 1.e-5 or relerr < 1.e-7: break #write the network using xml file myneuralnet = os.path.join(os.getcwd(),'myneuralnet.xml') if os.path.isfile(myneuralnet): NetworkWriter.appendToFile(n,myneuralnet) else: NetworkWriter.writeToFile(n,myneuralnet)
def __init__(self, dir, testDir=None, doTest = True, ignoreKlass = [], includeKlass = None): logger.info("Start building " + self.__class__.__name__) self.__mutex = threading.Semaphore() self.__dir = dir self.__testDir = testDir or dir self.__filenameToUrl = self.__readLogFile() freqDists = {} ignore = stopwords.words('english') featureFd = FreqDist() klassSize = {} for klassId in self.__klasses(ignoreKlass, includeKlass): freqDist = FreqDist() size = 0 for url, txt in self.__documents(klassId).items(): txt = tokenize(txt) size += 1 for part in txt: if part.isalnum() and part not in ignore: freqDist.inc(part) featureFd.inc(part) #for bigram in nltk.bigrams(txt): # freqDist.inc(bigram) # featureFd.inc(bigram) freqDists[klassId] = freqDist klassSize[klassId] = size selectedKlasses = self.__klasses(ignoreKlass, includeKlass) logger.info("Klasses:" + str(selectedKlasses)) documentsWithLabel = [(document, correctKlass) for correctKlass in selectedKlasses for url, document in self.__documents(correctKlass).items()] testDocumentsWithLabel = [(document, correctKlass) for correctKlass in selectedKlasses for url, document in self.__testDocuments(correctKlass).items()[:100]] random.shuffle(documentsWithLabel) self.__featuresGenerator = FeatureGenerator(freqDists, featureFd, klassSize) outSize = len(klassSize) logger.info(u"Build data set") trainset = SupervisedDataSet(300, outSize) for doc, label in testDocumentsWithLabel: trainset.addSample( self.__featuresGenerator(doc) , [1 if k is label else -1 for k in selectedKlasses]) #logger.info(trainset) logger.info(u"Build network") self.__classifier = buildNetwork(300, 500, outSize, bias=True)#, fast=True) trainer = BackpropTrainer(self.__classifier, verbose=True) logger.info(u"Train...") trainer.trainOnDataset(trainset, 20) trainer.testOnData(verbose=True) logger.info(u"Classifier learned") f = open('/tmp/_learned', 'w') pickle.dump(self.__classifier, f) f.close() if doTest: testset = trainset ref = [selectKlassName(selectedKlasses, out) for feat, out in testset] test = [selectKlassName(selectedKlasses, self.__classifier.activate(features)) for features, cat in testset] #for correctKlass, klass, featuresWithLabel in zip(ref, test, testset): # if correctKlass != klass: # pd = self.__classifier.prob_classify(dict(featuresWithLabel[0])) # labelProbList = sorted( [(sample, pd.logprob(sample)) for sample in pd.samples()], key=lambda x: x[1], reverse=True) # logger.info( correctKlass + " as " + klass + ": " + str([(correctKlass, "%.2f" % prob) for correctKlass, prob in labelProbList])) # logger.info([(key, value)for key, value in featuresWithLabel[0].items() if value > 0]) # logger.info(self.__findDocumentByKlassAndFeatures(correctKlass, featuresWithLabel[0])) logger.info("\n" + ConfusionMatrix(ref, test).pp())
class Agent(object): def __init__(self, use_brain): self.price_belief_high = random.uniform(PRICE_LOW, PRICE_HIGH) self.price_belief_low = random.uniform(PRICE_LOW, self.price_belief_high) self.price = random.uniform(self.price_belief_low, self.price_belief_high) self.consumption_value_low = random.randint(15, 60) #Killowats used per day self.consumption_value_high = random.randint(self.consumption_value_low, 60) self.production_value = random.randint(2, 15) #Square Meters of Solar Panels self.no_trades = 0 self.wealth = 0 self.supply = 0 self.demand = 0 self.weather = 1.0 self.power = 0.0 self.reserve_power = 0.0 self.observed_prices = [] #Prices which the agent successfully traded. self.use_brain = use_brain self.price_history = [] self.wealth_history = [] if use_brain: self.brain = buildNetwork(3, 40, 1) self.memory = SupervisedDataSet(3, 1) self.trainer = BackpropTrainer(self.brain) def sell(self, units, price): self.observed_prices.append(price) self.power -= units self.no_trades += 1 self.wealth += (units * price) def buy(self, units, price): self.observed_prices.append(price) self.power += units self.no_trades += 1 self.wealth -= (units * price) def day_begin(self, weather, market): self.price_history.append(self.price) self.wealth_history.append(self.wealth) self.weather = weather self.consumption_value = random.randint(self.consumption_value_low, self.consumption_value_high) self.power = ((self.production_value * self.weather) - self.consumption_value) #Use any reserve power if we have it. if self.reserve_power > 0: self.power += self.reserve_power self.reserve_power = 0 #Update Supply and Demand unless "Smart Agent" if not self.use_brain or self.power <= 0 or len(market.price_history) < 3: self.update_supply_demand(market) return #Predict price buyers = [agent for agent in market.agents if agent.demand > 0] sellers = [agent for agent in market.agents if agent.supply > 0] supply = sum(seller.supply for seller in sellers) demand = sum(buyer.demand for buyer in buyers) weather = self.weather predicted_price = self.brain.activate((weather, supply, demand))[0] #Store power instead of selling it if price is going to be low. threshold = statistics.median(market.price_history) #(PRICE_LOW + PRICE_HIGH) * 0.5 if predicted_price < threshold: self.reserve_power += self.power self.power = 0 self.update_supply_demand(market) def day_end(self, market): if not self.use_brain: return supply = market.asks[-1] demand = market.bids[-1] weather = self.weather price = market.price_history[-1] self.price_belief_low = self.brain.activate((weather, supply, demand))[0] self.price_belief_high = self.brain.activate((weather, supply, demand))[0] self.price = random.uniform(self.price_belief_low, self.price_belief_high) self.price_history[-1] = self.price self.memory.clear() self.memory.addSample((weather, supply, demand), (price,)) self.trainer.trainOnDataset(self.memory) def update_price_belief(self, market, did_sell, success): public_mean_price = market.average_price() mean = (self.price_belief_low + self.price_belief_high) / 2 confidence_sigma = 0.05 delta_mean = mean - public_mean_price if success: #If overpaid or undersold, shift towards mean if not did_sell and delta_mean > SIGNIFICANT: self.price_belief_low -= delta_mean / 2 self.price_belief_high -= delta_mean / 2 elif did_sell and delta_mean < -SIGNIFICANT: self.price_belief_low -= delta_mean / 2 self.price_belief_high -= delta_mean / 2 #increase confidence in price self.price_belief_low += confidence_sigma * mean self.price_belief_high -= confidence_sigma * mean else: #Shift belief towards means self.price_belief_low -= delta_mean / 2 self.price_belief_high -= delta_mean / 2 #Need lots of power? Buy for higher price if (not did_sell and self.demand > self.production_value * 2): confidence_sigma *= 2 #Lots of power to sell? sell for lower price elif(did_sell and self.supply > self.consumption_value * 2): confidence_sigma *= 2 #Otherise, check supply/demand else: asks = sum(market.asks) / len(market.asks) bids = sum(market.bids) / len(market.bids) supply_vs_demand = (asks - bids) / (asks + bids) if supply_vs_demand > SIG_IMBALANCE or supply_vs_demand < -SIG_IMBALANCE: new_mean = public_mean_price * (1-supply_vs_demand) delta_to_mean = mean - new_mean self.price_belief_high -= delta_mean / 2 self.price_belief_low -= delta_mean / 2 #decrease confidence in price self.price_belief_low -= confidence_sigma * mean self.price_belief_high += confidence_sigma * mean self.price = random.uniform(self.price_belief_low, self.price_belief_high) def update_supply_demand(self, market): self.demand = 0 self.supply = 0 if self.power > 0: if len(self.observed_prices) < 3: self.supply = self.power else: self.supply = round(self.power * self.price_favorability(market.average_price())) if self.supply < 1: self.supply = 0 self.reserve_power = self.power - self.supply elif self.power < 0: if len(self.observed_prices) < 3: self.demand = self.power * -1 else: f = (1 - self.price_favorability(market.average_price())) self.demand = round(self.power * f) * -1 if self.demand < 0: self.demand = 0 def price_favorability(self, value): max_n = max(self.observed_prices) min_n = min(self.observed_prices) value -= min_n max_n -= min_n min_n = 0 value = value / max_n if value < 0: value = 0 if value > 1: value = 1 return value @property def price_belief_high(self): return self._price_belief_high @property def price_belief_low(self): return self._price_belief_low @price_belief_high.setter def price_belief_high(self, value): if value < PRICE_LOW: value = PRICE_LOW elif value > PRICE_HIGH: value = PRICE_HIGH self._price_belief_high = value @price_belief_low.setter def price_belief_low(self, value): if value < PRICE_LOW: value = PRICE_LOW elif value > PRICE_HIGH: value = PRICE_HIGH self._price_belief_low = value
tst_ds, trn_ds = ds.splitWithProportion(0.2) # print "train data" # for inpt, target in trn_ds: # print inpt, target # print "test data" # for inpt, target in tst_ds: # print inpt, target # More information about trainers: http://pybrain.org/docs/api/supervised/trainers.html print "Training started" trainer.trainOnDataset(trn_ds, 10) # trainer.trainUntilConvergence(trn_ds, maxEpochs=100, verbose=True, continueEpochs=10, validationProportion=0.25) # trainer.testOnData(tst_ds, verbose=True) # exercise: how to get network error value for a given epoch? # from: http://stackoverflow.com/questions/8150772/pybrain-how-to-print-a-network-nodes-and-weights def display_net(net): for mod in net.modules: print("Module:", mod.name) if mod.paramdim > 0: print("--parameters:", mod.params) for conn in net.connections[mod]:
ds.clear() k = 0 for inp,targ in testdata: testSet.appendLinked(inp,targ-1) for inp,targ in traindata: trainSet.appendLinked(inp,targ-1) trainSet._convertToOneOfMany(bounds=[0, 1]) testSet._convertToOneOfMany(bounds=[0, 1]) if(camada2==0): net = buildNetwork(trainSet.indim,camada1,trainSet.outdim, recurrent = True) else : net = buildNetwork(trainSet.indim,camada1,camada2,trainSet.outdim, recurrent = True) trainer = BackpropTrainer(net,dataset = trainSet,learningrate = Learning,momentum = Momentum, verbose = True) trainer.trainOnDataset(trainSet,Ciclos) out = net.activateOnDataset(testSet) out = out.argmax(axis=1) acerto = total = i = 0 for data in testSet: if data[1][0] == 1 and out[i] == 0: acerto += 1 total += 1 elif data[1][1] == 1 and out[i] == 1: acerto += 1 total += 1 elif data[1][2] == 1 and out[i] == 2: acerto += 1 total += 1
def train_separate_nets(data_set, test_data, arousal_net, valence_net, epochs=1): num_inputs = 4 arousal_ds = SupervisedDataSet(num_inputs, 1) valence_ds = SupervisedDataSet(num_inputs, 1) for i in range(len(data_set)): try: arousal_ds.appendLinked(data_set[i], (data_set[i][1])) valence_ds.appendLinked(data_set[i], (data_set[i][2])) except: continue print str( len(arousal_ds)) + ' points successfully aquired for arousal analysis' print str( len(valence_ds)) + ' points successfully aquired for valence analysis' arousal_trainer = BackpropTrainer(arousal_net, learningrate=0.05, momentum=0.08, verbose=True) valence_trainer = BackpropTrainer(valence_net, learningrate=0.01, momentum=0.05, verbose=True) arousal_trainer.trainOnDataset(arousal_ds) valence_trainer.trainOnDataset(valence_ds) mean_internal_errors = [] mean_errors = [] for j in range(epochs / 50): arousal_trainer.trainEpochs(50) valence_trainer.trainEpochs(50) print str((j + 1) * 50) + '/' + str(epochs) + ' complete' sq_arousal_errors = [(arousal_net.activate(datum[0]) - datum[1])**2 for datum in test_data] sq_valence_errors = [(valence_net.activate(datum[0]) - datum[2])**2 for datum in test_data] errors = [ sqrt(sq_arousal_errors[i] + sq_valence_errors[i]) for i in range(len(sq_arousal_errors)) ] mean_errors.append(np.mean(errors)) sq_arousal_errors = [ (arousal_net.activate(data_set[i][0]) - data_set[i][1])**2 for i in range(len(data_set)) ] sq_valence_errors = [ (valence_net.activate(data_set[i][0]) - data_set[i][2])**2 for i in range(len(data_set)) ] errors = [ sqrt(sq_arousal_errors[i] + sq_valence_errors[i]) for i in range(len(sq_arousal_errors)) ] mean_internal_errors.append(np.mean(errors)) return arousal_net, valence_net, mean_errors, mean_internal_errors
alldata.addSample([1,1],[1]) alldata.addSample([1,1],[1]) alldata.addSample([1,1],[1]) alldata.addSample([1,1],[1]) alldata.addSample([1,1],[1]) tstdata, trndata = alldata.splitWithProportion( 0.25 ) trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) #We can also examine the dataset 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] fnn = buildNetwork( trndata.indim, 5, trndata.outdim, recurrent=False ) trainer = BackpropTrainer( fnn, dataset=trndata, momentum=0.1, verbose=True, weightdecay=0.01 ) # I am not sure about this, I don't think my production code is implemented like this modval = ModuleValidator() for i in range(1000): trainer.trainEpochs(1) trainer.trainOnDataset(dataset=trndata) cv = CrossValidator( trainer, trndata, n_folds=5, valfunc=modval.MSE ) print "MSE %f @ %i" %( cv.validate(), i ) print tstdata print ">", trainer.testOnClassData(dataset=tstdata)
# dividindo os dados para teste e validação test_data, val_data = part_data.splitWithProportion(0.5) print('Quantidade para teste: %d' % len(test_data)) print('Quantidade para validação: %d' % len(val_data)) from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised.trainers import BackpropTrainer net = buildNetwork(datasets.indim, 3, datasets.outdim) trainer = BackpropTrainer(net, dataset=train_data, learningrate=0.01, momentum=0.1, verbose=True) train_erros, val_erros = trainer.trainUntilConvergence(dataset=train_data, maxEpochs=100) import matplotlib.pyplot as plt plt.plot(train_erros, 'b', val_erros, 'r') plt.show() print(trainer.totalepochs) # OUtra forma de treinar trainer.trainOnDataset(train_data, 500) out = net.activateOnDataset(test_data) for i in range(len(out)): print('out: %f, correct: %f' % (out[i], test_data['target'][i]))
import pybrain from pybrain.datasets import * from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised.trainers import BackpropTrainer import pickle dataset_and = SupervisedDataSet(2, 1) dataset_and.addSample( (0,0) , (0,)) dataset_and.addSample( (0,1) , (0,)) dataset_and.addSample( (1,0) , (0,)) dataset_and.addSample( (1,1) , (1,)) net_and = buildNetwork(2, 4, 1, bias=True) trainer_and = BackpropTrainer(net_and, learningrate = 0.01, momentum = 0.99) trainer_and.trainOnDataset(dataset_and, 3000) trainer_and.testOnData(verbose=True) ###################################################### dataset_or = SupervisedDataSet(2, 1) dataset_or.addSample( (0,0) , (0,)) dataset_or.addSample( (0,1) , (1,)) dataset_or.addSample( (1,0) , (1,)) dataset_or.addSample( (1,1) , (1,)) net_or = buildNetwork(2, 4, 1, bias=True) trainer_or = BackpropTrainer(net_or, learningrate = 0.01, momentum = 0.99) trainer_or.trainOnDataset(dataset_or, 3000) trainer_or.testOnData(verbose=True)
from pybrain.supervised.trainers import BackpropTrainer import pickle if __name__ == "__main__": ds = SupervisedDataSet(2, 1) ds.addSample( (0,0) , (1,)) ds.addSample( (0,1) , (0,)) ds.addSample( (1,0) , (0,)) ds.addSample( (1,1) , (0,)) net = buildNetwork(2, 4, 4, 1, bias=True) # try: # f = open('_learned', 'r') # net = pickle.load(f) # f.close() # except: trainer = BackpropTrainer(net, learningrate = 0.01, momentum = 0.99) trainer.trainOnDataset(ds, 3000) trainer.testOnData() # f = open('_learned', 'w') # pickle.dump(net, f) # f.close() print net.activate((1,1)) print net.activate((1,0)) print net.activate((0,1)) print net.activate((0,0))
def group_into_sets(speed_limits, waze_speeds, drive_speeds): data = [] for i in range(len(waze_speeds)): datum = {} datum["order"] = i datum["speed_limit"] = speed_limits[i] datum["waze_speed"] = waze_speeds[i] datum["drive_speed"] = drive_speeds[i] print datum data.append(datum) ranges = [] for i in range(6): ranges.append([]) for i in range(len(data)): datum = data[i] waze_speed = datum["waze_speed"] if (waze_speed < 10): ranges[0].append(datum) elif (waze_speed < 20): ranges[1].append(datum) elif (waze_speed < 30): ranges[2].append(datum) elif (waze_speed < 40): ranges[3].append(datum) elif (waze_speed < 50): ranges[4].append(datum) else: ranges[5].append(datum) unsorted_data = [] for group in ranges: if (len(group) > 0): ds = SupervisedDataSet(1, 1) for i in range(len(group)): print group[i] indata = group[i]["waze_speed"] outdata = group[i]["drive_speed"] ds.addSample(indata, outdata) n = buildNetwork(ds.indim, 8, 8, ds.outdim, recurrent=True) t = BackpropTrainer(n, learningrate=0.001, momentum=0.05, verbose=True) t.trainOnDataset(ds, 1000) t.testOnData(verbose=True) for i in range(len(group)): group[i]["predicted_speed"] = n.activate( group[i]["waze_speed"]) unsorted_data.append(group[i]) predicted_speeds = [] for i in range(len(unsorted_data)): for datum in unsorted_data: if (datum["order"] == i): predicted_speeds.append(datum["predicted_speed"]) break return predicted_speeds
net.addInputModule(inp) net.addModule(h1) net.addModule(bias) # create connections net.addConnection(IdentityConnection(inp, h1)) net.addConnection(FullConnection(h1, outp)) #net.addConnection(FullConnection(bias, outp)) #net.addConnection(FullConnection(bias, h1)) # finish up net.sortModules() # initialize the backprop trainer and train trainer = BackpropTrainer(net, ds, momentum=.99, learningrate=0.01) trainer.trainOnDataset(ds,10) trainer.testOnData(verbose=True) print 'Final weights:',net.params print net test_x = test_x[0] preds_y = [] index_inpoints = size_ls for i in range(len(xt)): pred_y = net.activate(test_x) test_x = test_x[1:] test_x.append(pred_y[0])
DS = SupervisedDataSet( 1, 1 ) #Append Linked: x,y for i in range(len(df)): DS.appendLinked((x_norm.ix[i]),(y_norm.ix[i])) # #### Build and use the Trainer # In[ ]: #Learning Rate shouldnt be bigger than 0.01 t = BackpropTrainer(fnn, learningrate = 0.01, momentum = 0.99, verbose = True,lrdecay=0.9999) #Training on the DataSet with 1500 epochs t.trainOnDataset(DS, 1500) # # Model Evaluation # In[ ]: y_pred = fnn.activateOnDataset(DS) #"DeNormalize" Again to turn the data into the original monetary value y_pred = y_pred * wy # In[ ]: #Create the DataSet for a RegressionLine
alldata.addSample([-1, -1], [0]) alldata.addSample([-1, -1], [0]) alldata.addSample([-1, -1], [0]) alldata.addSample([-1, -1], [0]) alldata.addSample([1, 1], [1]) alldata.addSample([1, 1], [1]) alldata.addSample([1, 1], [1]) alldata.addSample([1, 1], [1]) alldata.addSample([1, 1], [1]) tstdata, trndata = alldata.splitWithProportion(0.25) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() # We can also examine the dataset 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] fnn = buildNetwork( trndata.indim, 5, trndata.outdim, recurrent=False ) trainer = BackpropTrainer( fnn, dataset=trndata, momentum=0.1, verbose=True, weightdecay=0.01 ) # I am not sure about this, I don't think my production code is implemented like this modval = ModuleValidator() trainer.trainEpochs(20) trainer.trainOnDataset(dataset=trndata) cv = CrossValidator( trainer, trndata, n_folds=5, valfunc=modval.MSE ) print "MSE %f" %( cv.validate() )
out_len = 10 NET_SHAPE = (inp_len, inp_len // 2, inp_len // 4, out_len) train_err = [0] * len(offsets) test_err = [0] * len(offsets) print 'training_set_max_size:', train_size, '\n' for i, o in enumerate(offsets): print 'learning a neural net with training_set_size=' + str(o) print 'getting data', cifar_data = datasets.cifar_nn(offset=o) print 'building net', net = buildNetwork(*NET_SHAPE) print 'training', trainer = BackpropTrainer(net, cifar_data['train_nn']) trainer.trainOnDataset(cifar_data['train_nn'], 5) print 'validating' train_err[i] = mean_squared_error(cifar_data['train']['labels'], [ net.activate(cifar_data['train']['data'][i]) for k in xrange(len(cifar_data['train']['data'])) ]) test_err[i] = mean_squared_error(cifar_data['test']['labels'], [ net.activate(cifar_data['test']['data'][i]) for k in xrange(len(cifar_data['test']['data'])) ]) print 'train_err: ' + str(train_err[i]) print 'test_err: ' + str(test_err[i]) print '---' # Plot results print 'plotting results'