def __init__(self, motion, memory, sonar, posture): self.motionProxy = motion self.memoryProxy = memory self.sonarProxy = sonar self.postureProxy = posture self.useSensors = True self.inputLength = 26+18 self.outputLength = 26 self.sonarProxy.subscribe("Closed-Loop Motor Babbling") #Start the sonor self.set_stiffness(0.3) self.net = buildNetwork(INPUTSIZE,HIDDENSIZE,OUTPUTSIZE) #Hierarchical Control Networks self.netH1 = buildNetwork(INPUTSIZE,HIDDENSIZE,OUTPUTSIZE) self.netH2 = buildNetwork(INPUTSIZE,HIDDENSIZE,OUTPUTSIZE) self.sMemory1 = np.array([1]*(INPUTSIZE + PREDICTSIZE)) self.sMemory2 = np.array([1]*(INPUTSIZE + PREDICTSIZE)) self.mMemory1 = np.array([0]*OUTPUTSIZE) self.mMemory2 = np.array([0]*OUTPUTSIZE) # Access global joint limits. self.Body = motion.getLimits("Body") self.bangles = [1] * 26 self.othersens = [2] * 18 self.sMemory = np.array([1]*(INPUTSIZE + PREDICTSIZE)) self.mMemory = np.array([0]*OUTPUTSIZE) self.cl = curiosityLoop() self.rand = Random() self.rand.seed(int(time())) #Initialize a model dictionary self.models = dict()
def reset(self, params, repetition): print params self.nDimInput = 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) (self.networkInput, self.targetPrediction, self.trueData) = \ self.dataset.generateSequence( prediction_nstep=params['prediction_nstep'], output_encoding=params['output_encoding'])
def __init__(self, hidden, **args): self.setArgs(**args) if self.useSpecialInfo: net = buildNetwork(self.inGridSize**2+2, hidden, self.usedActions, outclass = SigmoidLayer) else: net = buildNetwork(self.inGridSize**2, hidden, self.usedActions, outclass = SigmoidLayer) ModuleMarioAgent.__init__(self, net)
def buildCustomNetwork(self, hiddenLayers, train_faces): myfnn = None print "building network..." if len(hiddenLayers) == 1: myfnn = buildNetwork( train_faces.indim, hiddenLayers[0], train_faces.outdim, outclass=SoftmaxLayer ) elif len(hiddenLayers) == 2: myfnn = buildNetwork( train_faces.indim, hiddenLayers[0], hiddenLayers[1], train_faces.outdim, outclass=SoftmaxLayer ) elif len(hiddenLayers) == 3: myfnn = buildNetwork( train_faces.indim, hiddenLayers[0], hiddenLayers[1], hiddenLayers[2], train_faces.outdim, outclass=SoftmaxLayer ) return myfnn
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.averagePolicy=[] self.trainer4LinQ=BackpropTrainer(self.linQ,weightdecay=self.weightdecay) self.trainer4LinPolicy=BackpropTrainer(self.linPolicy,weightdecay=self.weightdecay)
def buildFNN(testData, trainData): ''' Input: testing data object, training data object Output: Prints details of best FNN ''' accuracy=0 model = None params = None fnn = buildNetwork( trainData.indim, (trainData.indim + trainData.outdim)/2, trainData.outdim, hiddenclass=TanhLayer, outclass=SoftmaxLayer, bias='true' ) trainer = BackpropTrainer(fnn, dataset=trainData, momentum=0.1, verbose=False, weightdecay=0.01) a=calculateANNaccuracy(fnn, trainData, testData, trainer) if a>accuracy: model=fnn accuracy=a params='''network = [Hidden Layer = TanhLayer; Hidden Layer Units= (Input+Output)Units/2; Output Layer = SoftmaxLayer]\n''' fnn = buildNetwork( trainData.indim, trainData.indim, trainData.outdim, hiddenclass=TanhLayer, outclass=SoftmaxLayer, bias='true' ) trainer = BackpropTrainer(fnn, dataset=trainData, momentum=0.1, verbose=False, weightdecay=0.01) a=calculateANNaccuracy(fnn, trainData, testData, trainer) if a>accuracy: model=fnn accuracy=a params='''network = [Hidden Layer = TanhLayer; Hidden Layer Units = Input Units; Output Layer = SoftmaxLayer]\n''' fnn = buildNetwork( trainData.indim, (trainData.indim + trainData.outdim)/2, trainData.outdim, hiddenclass=TanhLayer, outclass=SigmoidLayer, bias='true' ) trainer = BackpropTrainer(fnn, dataset=trainData, momentum=0.1, verbose=False, weightdecay=0.01) a=calculateANNaccuracy(fnn, trainData, testData, trainer) if a>accuracy: model=fnn accuracy=a params='''network = [Hidden Layer = TanhLayer; Hidden Layer Units = (Input+Output)Units/2; Output Layer = SigmoidLayer]\n''' fnn = buildNetwork( trainData.indim, (trainData.indim + trainData.outdim)/2, trainData.outdim, hiddenclass=TanhLayer, outclass=SigmoidLayer, bias='true' ) trainer = BackpropTrainer(fnn, dataset=trainData, momentum=0.1, verbose=False, weightdecay=0.01) a=calculateANNaccuracy(fnn, trainData, testData, trainer) if a>accuracy: model=fnn accuracy=a params='''network = [Hidden Layer = TanhLayer; Hidden Layer Units = Input Units; Output Layer = SigmoidLayer]\n''' fnn = buildNetwork( trainData.indim, (trainData.indim + trainData.outdim)/2, (trainData.indim + trainData.outdim)/2, trainData.outdim, hiddenclass=TanhLayer, outclass=SoftmaxLayer, bias='true' ) trainer = BackpropTrainer(fnn, dataset=trainData, momentum=0.1, verbose=False, weightdecay=0.01) a=calculateANNaccuracy(fnn, trainData, testData, trainer) if a>accuracy: model=fnn accuracy=a params='''network = [TWO (2) Hidden Layers = TanhLayer; Hidden Layer Units = (Input+Output)Units/2; Output Layer = SoftmaxLayer]\n''' print '\nThe best model had '+str(accuracy)+'% accuracy and used the parameters:\n'+params+'\n'
def __init__(self, prev=5): # timsig beat, timsig denom, prev + curr dur/freq, prev 3 chords, bass note self.t_ds = SupervisedDataSet((prev+1) * 2 + 4, 2) self.t_net = buildNetwork((prev+1) * 2 + 4, 50, 75, 25, 2) self.t_freq_err = [] self.t_dur_err = [] self.b_ds = SupervisedDataSet((prev+1) * 2 + 4, 2) self.b_net = buildNetwork((prev+1) * 2 + 4, 50, 75, 25, 2) self.b_freq_err = [] self.b_dur_err = [] self.prev = prev self.corpus = []
def __init__(self, array=None): if array == None: ##self.net = [Network((18,18,1)) for i in range(9)] ##self.theta = [self.net[i].theta for i in range(9)] self.net = buildNetwork(18, 18, 9) self.theta = self.net.params else: ##self.theta = array ##self.net = [Network((18,18,1),self.theta[i]) for i in range(9)] self.theta = array self.net = buildNetwork(18, 18, 9) self.net._params = self.theta
def buildDecomposableNetwork(): """ three hidden neurons, with 2 in- and 2 outconnections each. """ n = buildNetwork(2, 3, 2, bias = False) ndc = NeuronDecomposableNetwork.convertNormalNetwork(n) # set all the weights to 1 ndc._setParameters(ones(12)) return ndc
def ANN( trainFeature, trainLabel, testFeature, testLabel, netStructure, para_rate, para_momentum ): # netStructure is a list [in, hidden, out], momentum is a parameter in SGD sampleNum = trainFeature.shape[0] featureNum = trainFeature.shape[1] Dataset = SupervisedDataSet(featureNum, 1) i = 0 while i < sampleNum: print(i) Dataset.addSample(list(trainFeature[i]), [trainLabel[i]]) i += 1 Network = buildNetwork( netStructure[0], netStructure[1], netStructure[2], netStructure[3], hiddenclass=SigmoidLayer, outclass=SigmoidLayer, ) T = BackpropTrainer(Network, Dataset, learningrate=para_rate, momentum=para_momentum, verbose=True) # print(Dataset['input']) errorList = [] errorList.append(T.testOnData(Dataset)) T.trainOnDataset(Dataset) errorList.append(T.testOnData(Dataset)) T.trainOnDataset(Dataset) while abs(T.testOnData(Dataset) - errorList[-1]) > 0.0001: T.trainOnDataset(Dataset) errorList.append(T.testOnData(Dataset)) pass # this step is for the output of predictedLabel print(np.array([Network.activate(x) for x in trainFeature])) # print(testLabel) print(Network.activate([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) return errorList
def main(): inputs = ReadCSV('./data/input.csv') outputs = ReadCSV('./data/output.csv') test_set = test.keys() train_set = [] for k in inputs.keys(): if k not in test_set: train_set.append(k) print "Number of training samples", len(train_set) print "Number of testing samples", len(test_set) net = buildNetwork(178, 6, 5) ds=SupervisedDataSet(178,5) for id in train_set: ds.addSample(inputs[id],outputs[id]) trainer = BackpropTrainer(net, ds, learningrate=0.001, momentum = 0.001) trainer.trainUntilConvergence(maxEpochs=1000, validationProportion = 0.5) for id in test_set: predicted = net.activate(inputs[id]) actual = outputs[id] print '-----------------------------' print test[id] print '-----------------------------' print 'Trait\t\tPredicted\tActual\tError' for i in range(0,5): error = abs(predicted[i] - actual[i])*100/4.0 print traits[i], '\t', predicted[i], '\t', actual[i], '\t', error,"%"
def neuralNetwork_eval_func(self, chromosome): node_num, learning_rate, window_size = self.decode_chromosome(chromosome) if self.check_log(node_num, learning_rate, window_size): return self.get_means_from_log(node_num, learning_rate, window_size)[0] folded_dataset = self.create_folded_dataset(window_size) indim = 21 * (2 * window_size + 1) mean_AUC = 0 mean_decision_value = 0 mean_mcc = 0 sample_size_over_thousand_flag = False for test_fold in xrange(self.fold): test_labels, test_dataset, train_labels, train_dataset = folded_dataset.get_test_and_training_dataset(test_fold) if len(test_labels) + len(train_labels) > 1000: sample_size_over_thousand_flag = True ds = SupervisedDataSet(indim, 1) for i in xrange(len(train_labels)): ds.appendLinked(train_dataset[i], [train_labels[i]]) net = buildNetwork(indim, node_num, 1, outclass=SigmoidLayer, bias=True) trainer = BackpropTrainer(net, ds, learningrate=learning_rate) trainer.trainUntilConvergence(maxEpochs=self.maxEpochs_for_trainer) decision_values = [net.activate(test_dataset[i]) for i in xrange(len(test_labels))] decision_values = map(lambda x: x[0], decision_values) AUC, decision_value_and_max_mcc = validate_performance.calculate_AUC(decision_values, test_labels) mean_AUC += AUC mean_decision_value += decision_value_and_max_mcc[0] mean_mcc += decision_value_and_max_mcc[1] if sample_size_over_thousand_flag: break if not sample_size_over_thousand_flag: mean_AUC /= self.fold mean_decision_value /= self.fold mean_mcc /= self.fold self.write_log(node_num, learning_rate, window_size, mean_AUC, mean_decision_value, mean_mcc) self.add_log(node_num, learning_rate, window_size, mean_AUC, mean_decision_value, mean_mcc) return mean_AUC
def measuredLearning(ds): trndata,tstdata = splitData(ds,.025) #build network ### # This network has no hidden layters, you might need to add some ### fnn = buildNetwork( trndata.indim, 22, trndata.outdim, outclass=SoftmaxLayer ) trainer = BackpropTrainer( fnn, verbose=True,dataset=trndata) #### # Alter this to figure out how many runs you want. Best to start small and be sure that you see learning. # Before you ramp it up. ### for i in range(150): trainer.trainEpochs(5) trnresult = percentError(trainer.testOnClassData(),trndata['class'] ) tstresult = percentError( trainer.testOnClassData( dataset=tstdata ), tstdata['class'] ) print "epoch: %4d" % trainer.totalepochs, \ " train error: %5.2f%%" % trnresult, \ " test error: %5.2f%%" % tstresult if(trnresult<.5): return
def createNN(indim, hiddim, outdim): nn = buildNetwork(indim, hiddim, outdim, bias=False, hiddenclass=TanhLayer, outclass=TanhLayer) nn.sortModules() return nn
def getErrorPercent(training_dataset, eval_dataset_list, num_hidden, num_epochs): num_datapoints = len(training_dataset) num_inputs = len(training_dataset[0][0]) num_outputs = len(training_dataset[0][1]) # print "Num Inputs:", num_inputs # print "Num Outputs:", num_outputs # print "Num Hidden Nodes:", num_hidden NN = buildNetwork(num_inputs, num_hidden, num_outputs, bias=True, hiddenclass=SigmoidLayer, outclass=SigmoidLayer) dataset = SupervisedDataSet(num_inputs, num_outputs) for datapoint in training_dataset: dataset.addSample(datapoint[0], datapoint[1]) trainer = BackpropTrainer(NN, dataset=dataset, momentum=0.0, verbose=False, weightdecay=0.0) for epoch in range(0, num_epochs): #print epoch trainer.train() errors = [] for eval_set in eval_dataset_list: total_percent_errors = [0]*num_outputs for jj in range(0, len(eval_set)): nn_out = NN.activate(eval_set[jj][0]) percent_error = computeError(eval_set[jj][1], nn_out) #print percent_error total_percent_errors = map(operator.add, percent_error, total_percent_errors) #print total_percent_errors errors.append(map(operator.div, total_percent_errors, [len(dataset)]*num_outputs)) #print errors return errors
def train(data): """ See http://www.pybrain.org/docs/tutorial/fnn.html Returns a neural network trained on the test data. Parameters: data - A ClassificationDataSet for training. Should not include the test data. """ network = buildNetwork( # This is where we specify the architecture of # the network. We can play around with different # parameters here. # http://www.pybrain.org/docs/api/tools.html data.indim, 5, data.outdim, hiddenclass=SigmoidLayer, outclass=SoftmaxLayer ) # We can fiddle around with this guy's options as well. # http://www.pybrain.org/docs/api/supervised/trainers.html trainer = BackpropTrainer(network, dataset=data) trainer.trainUntilConvergence(maxEpochs=20) return network
def trainNetwork(self,proportion = 0): if proportion != 0: tstdata, trndata = self.alldata.splitWithProportion( 0.01*proportion ) else: trndata = self.alldata trndata._convertToOneOfMany( ) if proportion != 0: tstdata._convertToOneOfMany( ) print "Number of training patterns: ", len(trndata) print "Input and output dimensions: ", trndata.indim, trndata.outdim self.fnn = buildNetwork( trndata.indim, self.hidden_layer_size, trndata.outdim, hiddenclass=SigmoidLayer,outclass=SoftmaxLayer ) self.trainer = BackpropTrainer( self.fnn, dataset=trndata, momentum=0.1, verbose=True, weightdecay=0.01) for i in range(self.iterations_number): self.trainer.trainEpochs( 1 ) trnresult = percentError( self.trainer.testOnClassData(), trndata['class'] ) if proportion != 0: tstresult = percentError( self.trainer.testOnClassData( dataset=tstdata ), tstdata['class'] ) if proportion != 0: print "epoch: %4d" % self.trainer.totalepochs, \ " train error: %5.2f%%" % trnresult, \ " test error: %5.2f%%" % tstresult else: print "epoch: %4d" % self.trainer.totalepochs, \ " train error: %5.2f%%" % trnresult
def nn_1(self): logging.info('Beginning Neural Network model.') class ThisNN(): # Used to abstract away fit function def __init__(self, nn, kg): self.nn = nn self.kg = kg def fit(self, X, Y): logging.info('Generating a Pybrain SupervisedDataSet') ds = SupervisedDataSet(X,Y) trainer = BackpropTrainer(self.nn,ds) for i in range(0,10): logging.debug(trainer.train()) # XXX Runs once logging.info('Training Neural Network until Convergence') cv = SupervisedDataSet(self.kg.X_cv[:,1:],self.kg.Y_cv[:,1:]) trainer.trainUntilConvergence(verbose=11, validationData=cv, trainingData=ds) def predict_x(self, X): Y = [] for i in range(0,X.shape[0]): Y.append(self.nn.activate(X[i,:])) return np.asarray(Y) net = buildNetwork(self.X_train.shape[1] - 1,3,1) # X - 1 to avoid ID this_nn = ThisNN(net,self) self.__fit(net,this_nn.fit) self.__score_cv(net,this_nn.predict_x) self.__score_test(net,this_nn.predict_x) self.predict_y_submission(this_nn.predict_x) self.write_submission('nn.csv') self.models['nn'] = net logging.info('Completed Neural Network model.') return net
def setUp(self): self.nn = buildNetwork(4,6,3, bias=False, hiddenclass=TanhLayer, outclass=TanhLayer) self.nn.sortModules() self.in_to_hidden, = self.nn.connections[self.nn['in']] self.hiddenAstroLayer = AstrocyteLayer(self.nn['hidden0'], self.in_to_hidden)
def __init__(self, inSize, outSize, LearningRate): self.learning_rate = LearningRate self.ds = SupervisedDataSet(inSize, outSize) self.net = buildNetwork(inSize, 10, outSize, hiddenclass=TanhLayer, bias=True) self.trainer = BackpropTrainer(self.net, self.ds, learningrate=self.learning_rate, verbose = False, weightdecay=WEIGHT_DECAY) self.prediction = [0] * outSize self.mse = 100 self.age=0 #Specific to Mai's code. Make input and output masks. self.inputMask = [1 for i in range(inSize)] # self.outputMask = [random.randint(0, 1) for i in range(outSize)] self.outputMask = [0]*outSize r = random.randint(0,outSize-1) self.outputMask[r] = 1 self.error = 0 self.errorHistory = [] self.dErrorHistory = [] self.slidingError = 0 self.dError = 0 self.fitness = 0 self.problem=r self.previousData=[]
def _InitNet(self): # ----------------------------------------------------------------------- self._pr_line(); print("| _InitNet(self): \n"); start_time = time.time(); # ----------------------------------------------------------------------- if self._NET_NAME: # ----------------------------------------------------------------------- self._SDS = SupervisedDataSet(900, 52); if self._NET_NEW: print('| Bulding new NET: '+self._NET_NAME) self._NET = buildNetwork(self._SDS.indim, self._NET_HIDDEN, self._SDS.outdim, bias=True); #,hiddenclass=TanhLayer) self._SaveNET(); else: print('| Reading NET from: '+self._NET_NAME) self._NET = NetworkReader.readFrom(self._NET_NAME) # ----------------------------------------------------------------------- print('| Making AutoBAK: '+str(self._MK_AUTO_BAK)) if self._MK_AUTO_BAK: NetworkWriter.writeToFile(self._NET, self._NET_NAME+".AUTO_BAK.xml"); # ----------------------------------------------------------------------- print("| Done in: "+str(time.time()-start_time)+'sec'); # ----------------------------------------------------------------------- else: print('| Unknown NET name: >|'+self._NET_NAME+'|<') exit();
def NeuralNetwork(tRiver, qRiver, pRiver, TRiver, qnewRiver, pnewRiver, TnewRiver): # build neural network with 20 neurons for historic data on flux, 3 for last 3 temp data, 3 for last precipitation, # hidden layer with more than input neurons (hinder specification) # and 3 output neurons (flux for next day, first derivative, second derivative Ndim = 10+3+3 Nout = 3 net = buildNetwork(Ndim, Ndim, Nout, hiddenclass=TanhLayer) ds = SupervisedDataSet(Ndim, Nout) # next big job: find data values to build up library of training set for t in range(len(tRiver)-3): input_flow = qRiver[t-20:2:t] input_prec = pRiver[t-3:t] input_temp = TRiver[t-3:t] input_vec = np.hstack([input_flow, input_prec, input_temp]) output_flow = np.hstack([qRiver[t:t+3]]) # first approx, split later for long predictions ds.addSample(input_vec, output_flow) trainer = BackpropTrainer(net, ds) #trainer.train() trainer.trainUntilConvergence() # now call it repeatedly on the second set prediction = net.activate(np.hstack([qnewRiver[:20], pnewRiver[:3], TnewRiver[:3]])) return prediction
def nnTest(tx, ty, rx, ry, iterations): print "NN start" print strftime("%a, %d %b %Y %H:%M:%S", localtime()) resultst = [] resultsr = [] positions = range(iterations) network = buildNetwork(16, 16, 1, bias=True) ds = ClassificationDataSet(16, 1, class_labels=["1", "0"]) for i in xrange(len(tx)): ds.addSample(tx[i], [ty[i]]) trainer = BackpropTrainer(network, ds, learningrate=0.05) validator = CrossValidator(trainer, ds, n_folds=10) print validator.validate() for i in positions: print trainer.train() resultst.append(sum((np.array([round(network.activate(test)) for test in tx]) - ty)**2)/float(len(ty))) resultsr.append(sum((np.array([round(network.activate(test)) for test in rx]) - ry)**2)/float(len(ry))) print i, resultst[i], resultsr[i] plt.plot(positions, resultst, 'g-', positions, resultsr, 'r-') plt.axis([0, iterations, 0, 1]) plt.ylabel("Percent Error") plt.xlabel("Network Epoch") plt.title("Neural Network Error") plt.savefig('nn.png', dpi=500) print "NN end" print strftime("%a, %d %b %Y %H:%M:%S", localtime())
def copyAndMutatePredictor(self, winner, loser,distribution): newLoser = deepcopy(self.predictors[winner]) self.predictors[loser] = newLoser self.predictors[loser].learning_rate = FLAGS.learning_rate self.predictors[loser].ds = SupervisedDataSet(10, 8) self.predictors[loser].net = buildNetwork(10,10,8, bias=True) self.predictors[loser].trainer = BackpropTrainer(self.predictors[loser].net, self.predictors[loser].ds, learningrate=self.predictors[loser].learning_rate, verbose = False, weightdecay=WEIGHT_DECAY) if FLAGS.replication: for i in range(len(self.predictors[loser].net.params)): if random.uniform(0,1)<FLAGS.replication_prob: self.predictors[loser].net.params[i] = self.predictors[winner].net.params[i] # self.predictors[loser].net._setParameters(self.predictors[loser].net.params) # why? if FLAGS.mutate_input: for i in range(len(self.predictors[loser].inputMask)): if random.uniform(0,1) < FLAGS.input_mutation_prob: if self.predictors[loser].inputMask[i] == 0: self.predictors[loser].inputMask[i] = 1 else: self.predictors[loser].inputMask[i] = 0 if random.uniform(0,1) < FLAGS.output_mutation_prob: self.predictors[loser].outputMask = [0]*World.state_size r = np.random.choice(range(World.state_size),p=distribution) self.predictors[loser].outputMask[r] = 1 self.predictors[loser].problem=r
def reset(self): FA.reset(self) # self.network = buildNetwork(self.indim, 2*(self.indim+self.outdim), self.outdim) self.network = buildNetwork(self.indim, self.outdim, bias=True) self.network._setParameters(random.normal(0, 0.1, self.network.params.shape)) self.pybdataset = SupervisedDataSet(self.indim, self.outdim)
def fit(self, X, y): self.nn = buildNetwork(*self.layers, bias=True, hiddenclass=SigmoidLayer) self.ds = SupervisedDataSet(self.layers[0], self.layers[-1]) for i, row in enumerate(X): self.ds.addSample(row.tolist(), y[i]) self.improve()
def run(self, fold, X_train, y_train, X_test, y_test): DS_train, DS_test = ClassificationData.convert_to_DS( X_train, y_train, X_test, y_test) NHiddenUnits = self.__get_best_hu(DS_train) fnn = buildNetwork( DS_train.indim, NHiddenUnits, DS_train.outdim, outclass=SoftmaxLayer, bias=True) trainer = BackpropTrainer( fnn, dataset=DS_train, momentum=0.1, verbose=False, weightdecay=0.01) trainer.trainEpochs(self.epochs) tstresult = percentError( trainer.testOnClassData(dataset=DS_test), DS_test['class']) print "NN fold: %4d" % fold, "; test error: %5.2f%%" % tstresult return tstresult / 100.0
def train_net(self,training_times_input=100,num_neroun=200,learning_rate_input=0.1,weight_decay=0.1,momentum_in = 0,verbose_input=True): ''' The main function to train the network ''' print self.trndata['input'].shape raw_input() self.network=buildNetwork(self.trndata.indim, num_neroun,self.trndata.outdim, bias=True, hiddenclass=SigmoidLayer, outclass = LinearLayer) self.trainer=BackpropTrainer(self.network, dataset=self.trndata, learningrate=learning_rate_input, momentum=momentum_in, verbose=True, weightdecay=weight_decay ) for iter in range(training_times_input): print "Training", iter+1,"times" self.trainer.trainEpochs(1) trn_error = self._net_performance(self.network, self.trndata) tst_error = self._net_performance(self.network, self.tstdata) print "the trn error is: ", trn_error print "the test error is: ",tst_error '''prediction on all data:'''
def trainNetwork(inData, numOfSamples, numOfPoints, epochs): # Build the dataset alldata = createRGBdataSet(inData, numOfSamples, numOfPoints) # Split into test and training data trndata, tstdata = splitData(alldata) # Report stats 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] # Build and train the network fnn = buildNetwork( trndata.indim, 256, trndata.outdim, outclass=SoftmaxLayer ) trainer = BackpropTrainer( fnn, dataset=trndata, momentum=0.001, verbose=True, weightdecay=0.001) #trainer.trainEpochs( epochs ) trainer.trainUntilConvergence(maxEpochs=epochs) # Report results trnresult = percentError( trainer.testOnClassData(), trndata['class'] ) tstresult = percentError( trainer.testOnClassData( dataset=tstdata ), tstdata['class'] ) print "epoch: %4d" % trainer.totalepochs, \ " train error: %5.2f%%" % trnresult, \ " test error: %5.2f%%" % tstresult # Report results of final network checkNeuralNet(trainer, alldata, numOfSamples) return fnn
def parse_and_train(self): f = open(self.file,'r') learn_lines = [] for line in f: if line.strip() != '': learn_lines.append(line) i = 0 f.close() while i < len(learn_lines): ins, outs = self.convert_to_tuple(learn_lines[i],learn_lines[i+1]) i += 2 self.ds.addSample(ins,outs) self.nn = buildNetwork(self.ios,self.hns,25,self.ios) #self.train_dat, self.test_dat = self.ds.splitWithProportion(0.75) self.train_dat = self.ds trnr = BackpropTrainer(self.nn,dataset=self.train_dat,momentum=0.1,verbose=False,weightdecay=0.01) i = 150 trnr.trainEpochs(150) while i < self.epochs: trnr.trainEpochs(50) i += 50 print 'For epoch ' + str(i) print 'For train:' self.print_current_error() #print 'For test:' #self.print_validation() self.nn.sortModules()
from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised.trainers import BackpropTrainer from librosa import core from scipy import fft import csv import math import os # SESSAO TREINAMENTO VERSAO = "48000-100-100-10-5-5" NETWORK = buildNetwork(48000, 100, 100, 10, 5, 5) # SESSAO TESTES # VERSAO = "48000-100-100-10-5-TESTE-AUDIO-JOAS" # NETWORK = NetworkReader.readFrom('resultado/48000-100-100-10-5/network.xml'); # OUTROS CAMINHO_RESULTADO = "resultado/" + VERSAO + "/" EXTENSAO_ARQUIVO_AUDIO = ".ogg" NOME_DOS_CAMPOS_VALIDACAO = [ "Nome do arquivo", "Segundo", "Valor esperado 1", "Valor obtido 1", "Erro 1", "Valor esperado 2", "Valor obtido 2", "Erro 2", "Valor esperado 3", "Valor obtido 3", "Erro 3", "Valor esperado 4", "Valor obtido 4", "Erro 4", "Valor esperado 5", "Valor obtido 5", "Erro 5", "Erro quadrático médio" ]
print train ## DataSet ds = SupervisedDataSet(11, 1) for i in train.values: #print [i[1],i[6],i[34],i[35],i[36]] #ds.addSample(tuple(i[1:-1]), i[-1]) ds.addSample([ i[1], i[5], i[6], i[10], i[12], i[15], i[17], i[21], i[25], i[26], i[32] ], i[-1]) ## Build neural net net = buildNetwork( 11, 30, # number of hidden units 1, bias=True, hiddenclass=SigmoidLayer, outclass=LinearLayer) trainer = BackpropTrainer(net, ds, verbose=True, momentum=0.1, weightdecay=0.01) trainer.trainUntilConvergence(verbose=True, validationProportion=0.2, maxEpochs=200, continueEpochs=10) # modval = ModuleValidator() # for i in range(100): # trainer.trainEpochs(1)
for i in range(0, 115, 1): trainingSet.addSample((normalized_data[i], normalized_data[i+1], normalized_data[i+2], normalized_data[i+3]), (normalized_data[i+4]))#116 tuples # print "trainginSet" # for inpt, target in trainingSet: # print inpt, target ds = SupervisedDataSet(4, 1) for i in range(119, 162, 1): ds.addSample((normalized_data[i], normalized_data[i+1], normalized_data[i+2], normalized_data[i+3]), (normalized_data[i+4]))#44 tuples # print "dataset" # for inpt, target in ds: # print inpt, target net = buildNetwork(4, 2, 1, bias = True, hiddenclass = SigmoidLayer) # net = buildNetwork(3, 4, 1, bias = True, hiddenclass = TanhLayer) trainer = BackpropTrainer(net, ds, learningrate = 0.001, momentum = 0.99) print "entrenando hasta converger..." print "training until the Convergence: ", trainer.trainUntilConvergence(verbose=True, trainingData=trainingSet, validationData=ds, maxEpochs=100) print "predicting the next month: 0.28733060532417387" y = net.activate([0.12897219396266188, 0.10031611360730924, 0.13198268361816343, 0.239516498322237]) print y print "des normalizando" #((y - d1) * (x_max - x_min) / (d2 - d1)) + x_min= x
file = open(path, "r") data = [] for linha in file: # obtem cada linha do arquivo linha = linha.rstrip() # remove caracteres de controle, \n digitos = linha.split(" ") # pega os dígitos for numero in digitos: # para cada número da linha data.append(numero) # add ao vetor de dados file.close() return data # configurando a rede neural artificial e o dataSet de treinamento network = buildNetwork(45, 1000, 1000, 1) # define network dataSet = SupervisedDataSet(45, 1) # define dataSet ''' arquivos = ['1.txt', '1a.txt', '1b.txt', '1c.txt', '1d.txt', '1e.txt', '1f.txt'] ''' arquivos = ['1.txt'] # a resposta do número resposta = [[1]] #resposta = [[1], [1], [1], [1], [1], [1], [1]] i = 0 for arquivo in arquivos: # para cada arquivo de treinamento data = getData(arquivo) # pegue os dados do arquivo dataSet.addSample(data, resposta[i]) # add dados no dataSet i = i + 1
# Our dataset is divided, with 80% as training data and # 20% as test data tstdata_temp, trndata_temp = alldata.splitWithProportion(0.2) tstdata = ClassificationDataSet(1600, 1, nb_classes=2) for n in xrange(0, tstdata_temp.getLength()): tstdata.addSample( tstdata_temp.getSample(n)[0], tstdata_temp.getSample(n)[1] ) trndata = ClassificationDataSet(1600, 1, nb_classes=2) for n in xrange(0, trndata_temp.getLength()): trndata.addSample( trndata_temp.getSample(n)[0], trndata_temp.getSample(n)[1] ) trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) fnn = buildNetwork( trndata.indim,120,trndata.outdim, outclass=SoftmaxLayer ) trainer = BackpropTrainer(fnn, dataset=trndata, momentum=0.1, verbose=True, weightdecay=0.00001) modval = ModuleValidator() # We define the number of iterations we want to train our model. for i in range(100): trainer.trainEpochs(1) trnresult = percentError(trainer.testOnClassData(dataset=trndata),trndata['class']) print "epoch : " , trainer.totalepochs," train error: " , trnresult # We validate our model by applying the n-folds technique and check the Mean Square Error cv = CrossValidator( trainer, trndata, n_folds=5, valfunc=modval.MSE ) print "MSE %f at loop %i"%(cv.validate(),i) # Finally we test our data on the model we built perror = percentError(trainer.testOnClassData(dataset=tstdata),tstdata['class'])
def run(args): manual_validated_file = args.manual_validated_file # 'JHotDraw54b1_clones.xml.clones2' save_target_name = args.save_target_name #'newTrainedModel' print 'Training the Model. Please wait ...' manual_validation_data = pd.read_csv('manual_validator/input_clone_pairs/'+manual_validated_file) inputDim = 6 alldata = ClassificationDataSet(inputDim, 1, nb_classes=2) txlHelper = TXLHelper() for i in range(0, len(manual_validation_data)): #print manual_validation_data.iloc[i][3], manual_validation_data.iloc[i][4] #print manual_validation_data.iloc[i][2] cloneFragment_1_path, cloneFragment_1_start, cloneFragment_1_end = manual_validation_data.iloc[i][3].split()[0], \ manual_validation_data.iloc[i][3].split()[1], \ manual_validation_data.iloc[i][3].split()[2] cloneFragment_2_path, cloneFragment_2_start, cloneFragment_2_end = manual_validation_data.iloc[i][4].split()[0], \ manual_validation_data.iloc[i][4].split()[1], \ manual_validation_data.iloc[i][4].split()[2] cloneFragment_1 = read_file_in_line_range(filePath='manual_validator/input_clone_pairs/'+cloneFragment_1_path, \ startLine=cloneFragment_1_start, endLine=cloneFragment_1_end) cloneFragment_2 = read_file_in_line_range(filePath='manual_validator/input_clone_pairs/' + cloneFragment_2_path, startLine=cloneFragment_2_start, endLine=cloneFragment_2_end) type1sim_by_line, type2sim_by_line, type3sim_by_line = txlHelper.app_code_clone_similaritiesNormalizedByLine(cloneFragment_1, cloneFragment_2, 'java') type1sim_by_token, type2sim_by_token, type3sim_by_token = txlHelper.app_code_clone_similaritiesNormalizedByToken(cloneFragment_1, cloneFragment_2, 'java') label = manual_validation_data.iloc[i][2] if label == 'true': label = 1 else: label = 0 input = np.array([type1sim_by_token, type2sim_by_line, type3sim_by_line, type1sim_by_token, type2sim_by_token, type3sim_by_token]) alldata.addSample(input, int(label)) # # np.nan_to_num(alldata) # # alldata = alldata[~np.isnan(alldata)] # #alldata.fillna(0) # np.set_printoptions(precision=3) # print alldata # # def load_training_dataSet(fileName): # data = pd.read_csv(fileName, sep=',', header=None) # #data.columns = ["state", "outcome"] # return data # # myclones_data = load_training_dataSet('Datasets/new_dataset_with_new_features.csv') # myclones_data = myclones_data.values # # # inputDim = 6 # # # means = [(-1,0),(2,4),(3,1)] # cov = [diag([1,1]), diag([0.5,1.2]), diag([1.5,0.7])] # alldata = ClassificationDataSet(inputDim, 1, nb_classes=2) # # # #input = np.array([ myclones_data[n][16], myclones_data[n][17], myclones_data[n][18], myclones_data[n][15],myclones_data[n][11],myclones_data[n][12], myclones_data[n][26], myclones_data[n][27]] ) # # for n in xrange(len(myclones_data)): # #for klass in range(3): # input = np.array( # [myclones_data[n][11], myclones_data[n][17], myclones_data[n][12], myclones_data[n][15], myclones_data[n][18], # myclones_data[n][16]]) # #print (n, "-->", input) # alldata.addSample(input, int(myclones_data[n][35])) # # tstdata, trndata = alldata.splitWithProportion( 0.25 ) #print(tstdata) tstdata_new = ClassificationDataSet(inputDim, 1, nb_classes=2) for n in xrange(0, tstdata.getLength()): tstdata_new.addSample( tstdata.getSample(n)[0], tstdata.getSample(n)[1] ) trndata_new = ClassificationDataSet(inputDim, 1, nb_classes=2) for n in xrange(0, trndata.getLength()): trndata_new.addSample( trndata.getSample(n)[0], trndata.getSample(n)[1]) trndata = trndata_new tstdata = tstdata_new #print("Before --> ", trndata) trndata._convertToOneOfMany( ) tstdata._convertToOneOfMany( ) fnn = buildNetwork( trndata.indim, 107, trndata.outdim, outclass=SoftmaxLayer ) trainer = BackpropTrainer( fnn, dataset=trndata, momentum=0.1,learningrate=0.05 , verbose=True, weightdecay=0.001) #print "Printing Non-Trained Network..." """ ticks = arange(-3.,6.,0.2) X, Y = meshgrid(ticks, ticks) # need column vectors in dataset, not arrays griddata = ClassificationDataSet(7,1, nb_classes=2) for i in xrange(X.size): griddata.addSample([X.ravel()[i],Y.ravel()[i]], [0]) griddata._convertToOneOfMany() # this is still needed to make the fnn feel comfy """ #trainer.trainEpochs(1) #trainer.testOnData(verbose=True) #print(np.array([fnn.activate(x) for x, _ in tstdata])) for i in range(1): trainer.trainEpochs(10) trnresult = percentError(trainer.testOnClassData(), trndata['class']) tstresult = percentError(trainer.testOnClassData( dataset=tstdata), tstdata['class']) #print "epoch: %4d" % trainer.totalepochs, \ # " train error: %5.2f%%" % trnresult, \ # " test error: %5.2f%%" % tstresult #print "Printing Trained Network..." #print fnn.params print "Saving the trined Model at : ", 'pybrain/'+save_target_name #saving the trained network... import pickle fileObject = open('pybrain/'+save_target_name, 'w') pickle.dump(fnn, fileObject) fileObject.close() # # fileObject = open('trainedNetwork79', 'r') # loaded_fnn = pickle.load(fileObject) # # # print "Printing the result prediction..." # # print loaded_fnn.activate([0.2,0.5,0.6,0.1,0.3,0.7]) # # print fnn.activate([0.2,0.5,0.6,0.1,0.3,0.7]) # #out = fnn.activateOnDataset(griddata) #out = out.argmax(axis=1) # the highest output activation gives the class #out = out.reshape(X.shape) """
def predict_class(self, _x, _y, test_file, epochs, steps): print("Iniciando funcao predict_class() .............") traindata = self.ReadTrainFile(_x, _y) #testdata = self.ReadTestFile( test_file, len(_x[0]) ) print( "____________________________________________________________________________" ) print("A matrix de treino tem ", len(traindata), "linhas de dados") print("Dimensoes de Input e Output : ", traindata.indim, traindata.outdim) print( "____________________________________________________________________________\n" ) print("convertendo arquivos .................") traindata._convertToOneOfMany() #testdata._convertToOneOfMany( ) import os.path if os.path.exists('rede_animal.xml'): print( " Carregando a rede de treinos do arquivo rede_animal.xml *************** " ) fnn = NetworkReader.readFrom('rede_animal.xml') else: print( " Criando rede de treinos no arquivo rede_animal.xml *************** " ) fnn = buildNetwork(traindata.indim, 5, traindata.outdim, outclass=SoftmaxLayer) trainer = BackpropTrainer(fnn, dataset=traindata, momentum=0.1, verbose=True, weightdecay=0.01) print("Treinando .............") for i in range(epochs): print("Treinando epoca ", i) trainer.trainEpochs(steps) NetworkWriter.writeToFile(fnn, 'rede_animal.xml') print(" Rede salva em rede_animal.xml (Ok) ") print("Lendo arquivo de teste e classificando ..........") print("Gerando resultados em ANIMAL_OUTPUT.CSV ..........") output = open('animal_output.csv', 'wb') i = 1 output.write("ID,Adoption,Died,Euthanasia,Return_to_owner,Transfer\n") for line in open(test_file, 'r'): x = ast.literal_eval(line) output.write("{},{},{},{},{},{} \n".format(i, fnn.activate(x)[0], fnn.activate(x)[1], fnn.activate(x)[2], fnn.activate(x)[3], fnn.activate(x)[4])) i = i + 1 print("Concluido")
from pybrain.tools.shortcuts import buildNetwork from pybrain.datasets import SupervisedDataSet from pybrain.supervised.trainers import BackpropTrainer rede = buildNetwork(2, 3, 1) # 2 neuronios na camada de entrada; # 3 na camada oculta; # 1 na camada de saída. dados = SupervisedDataSet(2, 1) # (quantidade de atributos, quantidade classes) dados.addSample((0, 0), (0, )) dados.addSample((0, 1), (1, )) dados.addSample((1, 1), (0, )) dados.addSample((1, 0), (1, )) treinamento = BackpropTrainer(rede, dados, momentum=0.06) for i in range(30000): erro = treinamento.train() if i % 1000 == 0: print("Erro:", erro) print(rede.activate([0, 0])) # predicao print(rede.activate([0, 1])) # predicao print(rede.activate([1, 1])) # predicao
if scale_data == 1: scalizer = preprocessing.StandardScaler().fit(dataX) dataX = scalizer.transform(dataX) if normalize_data == 1: normalizer = preprocessing.Normalizer().fit(dataX) dataX = normalizer.transform(dataX) # / scalarization && normalization # training dataset construction for i in range(0, len(dataX)): ds.addSample(dataX[i], dataY[i]) # / training dataset construction # nn && trainer construction net = buildNetwork(ds.indim, (ds.indim + ds.outdim) / 2, ds.outdim, bias=True, outclass=SoftmaxLayer) # building the n trainer = BackpropTrainer(net, ds, learningrate=0.3, momentum=0, verbose=False) # building the trainer # / nn && trainer construction # training trainer.trainUntilConvergence(maxEpochs=maxEpk) # Train, until convergence # for epoch in range(0,1000): # trainer.train() # / training # cross validation
from pybrain.optimization import FEM from pybrain.rl.experiments import EpisodicExperiment batch = 2 #number of samples per learning step prnts = 100 #number of learning steps after results are printed epis = int(4000 / batch / prnts) #number of roleouts numbExp = 10 #number of experiments et = ExTools(batch, prnts) #tool for printing and plotting for runs in range(numbExp): # create environment env = CartPoleEnvironment() # create task task = BalanceTask(env, 200, desiredValue=None) # create controller network net = buildNetwork(4, 1, bias=False) # create agent with controller and learner (and its options) agent = OptimizationAgent(net, FEM(storeAllEvaluations=True)) et.agent = agent # create the experiment experiment = EpisodicExperiment(task, agent) #Do the experiment for updates in range(epis): for i in range(prnts): experiment.doEpisodes(batch) #print "Epsilon : ", agent.learner.sigma et.printResults((agent.learner._allEvaluations)[-50:-1], runs, updates) et.addExps() et.showExps()
pl.xlim(np.min(entrada),1.2*np.max(entrada)) pl.ylim(1.2*np.min(salida),1.2*np.max(salida)) pl.grid() pl.legend(loc='lower right',ncol=2,fontsize=fsize) pl.title('Target range = [0,1]',fontsize=fsize) epochs = 2500#numero de iteraciones de la red size = MPI.COMM_WORLD.Get_size() rank = MPI.COMM_WORLD.Get_rank() name = MPI.Get_processor_name() sys.stdout.write("Hello, World! I am process %d of %d on %s.\n"% (rank, size, name)) comm = MPI.COMM_WORLD np.random.seed(0) net = pybrain_tools.buildNetwork(1, 40, 1)#ajusta la red a i entradas,j capas ocultas,k salidas net.randomize()#ajusta aleatoriamente los parametros de la red print 'entrenando red standard' data=init_sin_dataset() trainer = pybrain_rprop.RPropMinusTrainer(net, dataset=data)#red, datos de entrenamiento trainer.trainEpochs(epochs)#numero de iteraciones entrada = data['input'] salida = data['target'] L = len(entrada) out = np.zeros(L) aux3 = np.zeros(L) aux4 = np.zeros(L) for c in range(L): out[c] = net.activate([entrada[c]]) #chart_original_output(data,net)#graficar dataset
start_time=time.time() #our data set has 14 input parameters and 50 classes ds = SupervisedDataSet(14,50) #tf.csv has been modifies such that the csv file has 64 values on each line separated by a comma. The first 14 values are input values and the rest 50 are outputs. tf=open('tf.csv','r') for line in tf.readlines(): data = [float(x) for x in line.strip().split(',') if x != ''] indata = tuple(data[:14]) outdata = tuple(data[14:]) 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. #buiding the network sucg that is has 14 input neurons, 2 hidden layers of 14 neurons each and output layer of 50 neurons. #change the hidden layer neurons to maximise the accuracy n = buildNetwork(ds.indim,14,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"
hiddenUnits = 10 loadNet = False saveNet = False saveName = "grasp.wgt" numbExp = 1 #number of experiments for runs in range(numbExp): # create environment #Options: XML-Model, Bool(OpenGL), Bool(Realtime simu. while client is connected), ServerIP(default:localhost), Port(default:21560) env = CCRLEnvironment() # create task task = CCRLGlasVarTask(env) # create controller network net = buildNetwork(len(task.getObservation()), hiddenUnits, env.actLen, outclass=TanhLayer) # create agent with controller and learner agent = FiniteDifferenceAgent(net, SPLA()) # learning options agent.learner.gd.alpha = 0.2 #step size of \mu adaption agent.learner.gdSig.alpha = 0.085 #step size of \sigma adaption agent.learner.gd.momentum = 0.0 #Loading weights if loadNet: agent.learner.original = loadWeights("grasp.wgt") agent.learner.gd.init(agent.learner.original) agent.learner.epsilon = 0.2 agent.learner.initSigmas()
# coding=utf-8 from pybrain.optimization.hillclimber import HillClimber from pybrain.rl.agents.optimization import OptimizationAgent from pybrain.rl.environments.cartpole.balancetask import BalanceTask from pybrain.rl.experiments.episodic import EpisodicExperiment from pybrain.tools.shortcuts import buildNetwork task = BalanceTask() net = buildNetwork(task.outdim, 3, task.indim) agent = OptimizationAgent(net, HillClimber()) exp = EpisodicExperiment(task, agent) exp.doEpisodes(100) print(exp)
def buildNet_deep_mnist(n_input, n_output): return buildNetwork(n_input, 40, 30, 20, n_output, hiddenclass=TanhLayer, outclass=SoftmaxLayer, bias=True)
for k in xrange(0, test_t.getLength()): test.addSample(test_t.getSample(k)[0], test_t.getSample(k)[1]) for k in xrange(0, training_t.getLength()): training.addSample(training_t.getSample(k)[0], training_t.getSample(k)[1]) print(training.getLength()) print(test.getLength()) print(test.indim) print(test.outdim) print(training.indim) print(training.outdim) fnn = buildNetwork(training.indim, 64, training.outdim, outclass=SoftmaxLayer) trainer = BackpropTrainer(fnn, dataset=training, momentum=0.1, learningrate=0.01, verbose=True, weightdecay=0.01) trainer.trainEpochs(10) print(percentError(trainer.testOnClassData(), training['class'])) print(percentError(trainer.testOnClassData(dataset=test), test['class'])) plt.imshow(digits.images[0], cmap=plt.cm.gray_r, interpolation='nearest') plt.show() for i in range(0, 10):
def buildNet_perceptron(n_input, n_output): return buildNetwork(n_input, n_output, hiddenclass=TanhLayer, outclass=SoftmaxLayer, bias=True)
# Esse projeto tem como dependências códigos de terceiros com livre distribuição: # # python-numpy - Para integração com algebra linear # python-scipy - integração e otimização numérica # python-matplotlib - Plotagens # ipython - parallel and distributed computing (SPMD/MPMD)** # python-pandas - Analise e modelagem de dados # python-sympy - algebra** # pybrain - Rotinas para criações de redes neorais artificiais e treinamentos # Criando rede neoral from pybrain.tools.shortcuts import buildNetwork net = buildNetwork(2, 3, 1, bias=True) # Construindo tipo de entrada from pybrain.datasets import SupervisedDataSet ds = SupervisedDataSet(2, 1) # Imputando valores para serem reconhecidos (XOR) ds.addSample((0, 0), (0, )) ds.addSample((0, 1), (1, )) ds.addSample((1, 0), (1, )) ds.addSample((1, 1), (0, )) # Treinando from pybrain.supervised.trainers import BackpropTrainer trainer = BackpropTrainer(net, ds) #Iniciando trainer.train()
#********************NN With GA*************************** def fitFunction(net, dataset=training_data, targetClass=training_data['class']): error = percentError(testOnClassData_custom(net, dataset=training_data), targetClass) return error stepSize = [.05, .5, 1] for s in stepSize: fnn_ga = buildNetwork(training_data.indim, 2, training_data.outdim, bias=True, outclass=SoftmaxLayer) domain = [(-1, 1)] * len(fnn_ga.params) #print domain epochs = 20 epoch_v = [] trnerr_ga = [] tsterr_ga = [] iteration = 5 for i in xrange(epochs): winner = geneticoptimize(iteration, domain, fnn_ga, fitFunction,
from pybrain.tools.shortcuts import buildNetwork import rospy net = buildNetwork(2, 3, 1) print(net)
if y[i] != 0: train_data.addSample(X_new[i,], [target[i]]) for i in xrange(N_train+1, N_test_end): if y[i] != 0: test_data.addSample(X_new[i,], [target[i]]) for i in xrange(X_new.shape[0]): all_data.addSample(X_new[i,], [target[i]]) train_data._convertToOneOfMany() test_data._convertToOneOfMany() all_data._convertToOneOfMany() print("building") fnn = buildNetwork( train_data.indim, 5, train_data.outdim, fast=True, outclass = SoftmaxLayer) trainer = BackpropTrainer( fnn, dataset=train_data, momentum=0.2, verbose=True, learningrate=0.05, lrdecay=1.0) # trainer = RPropMinusTrainer( fnn, dataset=train_data, momentum=0.1, verbose=True, learningrate=0.01, lrdecay=1.0) # trainer.trainUntilConvergence() best = fnn.copy() best_test = 1 for i in range(5): print("training") trainer.trainEpochs(1) print("testing") trnresult = trainer.testOnData() tstresult = trainer.testOnData( dataset=test_data )
rules[49] = 6 rules[50] = '3' rules[51] = '3' rules[52] = '5' rules[53] = '2' rules[54] = 'killSprite' rules[55] = 'killSprite' rules[56] = 'killBoth' rules[57] = 0.8 setRule(rules) #certainGame #start certainInitial() net = buildNetwork(336, 10, 8, hiddenclass=SigmoidLayer) from pybrain.optimization import SNES from pybrain.optimization import OriginalNES from pybrain.optimization import GA from numpy import ndarray best = 0 print "SNES starting......" algo = SNES(lambda x: evaluate(x), net, verbose=True) #algo = GA(lambda x: evaluate(x), net, verbose=True) #algo = OriginalNES(lambda x: evaluate(x), net, verbose=True, desiredEvaluation=0.85) episodesPerStep = 10 for i in range(99999): algo.learn(episodesPerStep) print net.params if isinstance(algo.bestEvaluable, ndarray):
def main(): # the existing lyrics you've filled the text document with if word_by_word == 0: lyrics = open(filename).read().split("\n") elif word_by_word == 1: lyrics = markov(filename).split("\n") # the (now empty) song the neural network is going to write song = [] # all of the possible rhymes based on the contents of the stuff you fed it if training == 1: all_possible_rhymes = rhymeindex(lyrics) elif training == 0: all_possible_rhymes = opennetwork(epoch)[1] rhymes_in_lyrics = rhymeindex(lyrics) for rhyme in rhymes_in_lyrics: if rhyme not in all_possible_rhymes: all_possible_rhymes.append(rhyme) print all_possible_rhymes if training == 1: net = buildNetwork(4, 8, 8, 8, 8, 8, 8, 8, 8, 4, recurrent=True, hiddenclass=TanhLayer) t = BackpropTrainer(net, learningrate=0.05, momentum=0.5, verbose=True) # This loads a neural network that has already been trained on an actual rap song - so it knows how the rhymes and syllables should fit together if training == 0: rapdict = [] rhyme_list_generator(lyrics, rapdict, all_possible_rhymes) net = opennetwork(epoch)[0] t = BackpropTrainer(net, learningrate=0.01, momentum=0.5, verbose=True) # debug stuff... print "\n\nAlright, here are all of the possible rhymes from the lyrics it can draw from." print all_possible_rhymes if training == 1: # rapdict is just the list containing smaller lists as follows; # [the text of the line, the number of syllables in the line, the number of the rhyme scheme of the line] rapdict = [] rhyme_list_generator(lyrics, rapdict, all_possible_rhymes) print "\n\nAlright, here's the information it will be working with - in the form of lyric, syllables, and rhyming scheme" print rapdict # makes a dataset ds = SupervisedDataSet(4,4) # the dataset is in the form of the amount of syllables and rhyme scheme of TWO lines that are next to each other in the song. for i in rapdict[:-3]: if i != "" and rapdict[rapdict.index(i) + 1] != "" and rapdict[rapdict.index(i) + 2] != "" and rapdict[rapdict.index(i) + 3] != "": # twobars is just a list containing the aspects of two lines in a row twobars = [i[1], i[2], rapdict[rapdict.index(i) + 1][1], rapdict[rapdict.index(i) + 1][2], rapdict[rapdict.index(i) + 2][1], rapdict[rapdict.index(i) + 2][2], rapdict[rapdict.index(i) + 3][1], rapdict[rapdict.index(i) + 3][2]] # twobars gets formatted into floating point values between 0 and 1 so it can be entered into the dataset ds.addSample((twobars[0] / float(20), int(twobars[1]) / float(len(all_possible_rhymes)), twobars[2] / float(20), int(twobars[3]) / float(len(all_possible_rhymes))), (twobars[4] / float(20), int(twobars[5]) / float(len(all_possible_rhymes)), twobars[6] / float(20), int(twobars[7]) / float(len(all_possible_rhymes)))) # printing the dataset print "\n\nAlright, here is the dataset." print ds #just to make sure it doesn't keep using the same lyric over and over lyricsused = [] trainingcount = 0 # The part that actually writes a rap. final_song = open("neural_rap.txt", "r+") # The number 3 at the end of this line can be tweaked- it's just so things don't get too repetitive/drawn out. # for example; if i had 30 lines to draw from, I wouldn't want to try and rearrange them into a song with 30 lines. # it would be much better if i only tried to take 10 rhyming lines and make a song with those. if training == 0: while len(song) < len(lyrics) / 3 and len(song) < 50: verse = writearap([(random.choice(range(1,20))) / 20.0 , (random.choice(range(1, len(all_possible_rhymes)))) / float(len(all_possible_rhymes)), (random.choice(range(1, 20))) / 20.0, (random.choice(range(1, len(all_possible_rhymes)))) / float(len(all_possible_rhymes))], net, rapdict, all_possible_rhymes, lyricsused, song) if len(verse) > 3: # this number can be adjusted - usually the short verses it generates are low quality. for line in lyricsused: final_song.write(str(line) + "\n") # actually write the line to the song song.append(line) final_song.write("\n...\n") print "Just wrote a verse to the file... - " + str(lyricsused) lyricsused = [] if training == 1: while True: epochs_per_iteration = 100 trainingcount += epochs_per_iteration t.trainOnDataset(ds, epochs_per_iteration) print "just wrote " + str(trainingcount) + "/" + "..." savenetwork(net, all_possible_rhymes, trainingcount)
iris = datasets.load_iris() x, y = iris.data, iris.target dataset = ClassificationDataSet(4, 1, nb_classes=3) # add amostra for i in range(len(x)): dataset.addSample(x[i], y[i]) # dados para treinamento train_data, part_data = dataset.splitWithProportion(0.6) print("Quantidade para treino: %d" % len(train_data)) # 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)) net = buildNetwork(dataset.indim, 3, dataset.outdim) trainer = BackpropTrainer(net, dataset=train_data, learningrate=0.01, momentum=0.1, verbose=True) train_errors, val_errors = trainer.trainUntilConvergence(dataset=train_data, maxEpochs=1000) plt.plot(train_errors, 'b', val_errors, 'r') plt.show()
from pybrain.tools.shortcuts import buildNetwork from pybrain.datasets import SupervisedDataSet from pybrain.supervised.trainers import BackpropTrainer from pybrain.structure.modules import SoftmaxLayer from pybrain.structure.modules import SigmoidLayer '''rede = buildNetwork(2, 3, 1, outclass = SoftmaxLayer, hiddenclass = SigmoidLayer, bias = False) print(rede['in']) print(rede['hidden0']) print(rede['out']) print(rede['bias'])''' rede = buildNetwork(2, 3, 1) base = SupervisedDataSet(2, 1) base.addSample((0, 0), (0, )) base.addSample((0, 1), (1, )) base.addSample((1, 0), (1, )) base.addSample((1, 1), (0, )) #print(base['input']) #print(base['target']) treinamento = BackpropTrainer(rede, dataset=base, learningrate=0.01, momentum=0.06) for i in range(1, 30000): erro = treinamento.train() if i % 1000 == 0: print("Erro: %s" % erro)
def main(): #prefix = '/media/wtluo/8A6C28646C284CEF/w2/' #pointing = 'w2m0m0/step1/' prefix = '../' pointing = 'step1/' exposure = '831549' chipid = '_01' allgalfits = prefix + pointing + 'gal_' + exposure + chipid + '.fits' allstarfits = prefix + pointing + 'star_' + exposure + chipid + '.fits' galcat = prefix + pointing + 'gal_info' + exposure + chipid + '.dat' starcat = prefix + pointing + 'star_info' + exposure + chipid + '.dat' #hdr = pf.open(allgalfits) sky = 2653.10250279776 galim = pf.getdata(allgalfits) starim = pf.getdata(allstarfits) galdat = np.loadtxt(galcat, unpack=True, skiprows=1) stardat = np.loadtxt(starcat, unpack=True, skiprows=1) ra_gal = galdat[0][:] dec_gal = galdat[1][:] e1_lf = galdat[4][:] e2_lf = galdat[5][:] w_lf = galdat[6][:] m = galdat[10][:] c = galdat[11][:] xgal = galdat[17][:] ygal = galdat[18][:] snrgal = galdat[19][:] ngal = np.size(ra_gal) xstar = stardat[1][:] ystar = stardat[2][:] ra_st = stardat[3][:] dec_st = stardat[4][:] snrst = stardat[5][:] nstar = np.size(ra_st) xmax_gal = np.size(galim[:][0]) ymax_gal = np.size(galim[0][:]) xmax_str = np.size(starim[:][0]) ymax_str = np.size(starim[0][:]) #print xmax_str/48.,ymax_str/48. #---test image extraction--- nx = int(xmax_str / 48.0) ny = int(ymax_str / 48.0) imstar_3d = np.zeros([nstar, 48 * 48]) imstars = np.zeros([nstar, 48 * 48]) ellipstar = np.zeros([nstar, 2]) Rstar = np.zeros(nstar) for i in range(nx): for j in range(ny): i_min = i * 48 i_max = (i + 1) * 48 j_min = j * 48 j_max = (j + 1) * 48 slc_i = slice(i_min, i_max) slc_j = slice(j_min, j_max) #galsub= galim[slc_i,slc_j] if j + i * nx < nstar: starsub = starim[slc_i, slc_j] mnstr = moments(starsub) cen_star = mnstr['centroid'] mxx, mxy, myy = mnstr['moments'] ellipstar[j + i * nx][0] = (mxx - myy) / (mxx + myy) ellipstar[j + i * nx][1] = (2. * mxy) / (mxx + myy) Rstar[j + i * nx] = mxx + myy cen_ini = np.array([24, 24]) offset = np.array([int(round(cen_star[0]-cen_ini[0])),\ int(round(cen_star[1]-cen_ini[1]))]) shift_im = shiftcen(starsub, offset) #imstar_3d[j+i*nx][:] = shift_im.reshape(48*48)/np.sum(starsub) imstar_3d[j + i * nx][:] = starsub.reshape( 48 * 48) / np.sum(starsub) imstars[j + i * nx][:] = starsub.reshape(48 * 48) pcstr = pcaimages(imstar_3d) coeffs_ini = [1., 1., 1., 1.] ind = np.random.randint(low=0, high=100, size=100) idx = np.unique(ind) ntrain = len(idx) comatrix = np.zeros((ntrain, 4)) trainsample = np.zeros((ntrain, 4)) for ix in range(len(idx)): i = idx[ix] chi2 = lambda *args: -lnlike(*args) constraints= opt.minimize(chi2,coeffs_ini,\ args=(imstars[i][:]/np.sum(imstars[i][:]),pcstr)) comatrix[ix][:] = constraints["x"] trainsample[ix][0] = xstar[i] - np.mean(xstar) trainsample[ix][1] = ystar[i] - np.mean(ystar) trainsample[ix][2] = ellipstar[i][0] trainsample[ix][3] = ellipstar[i][1] from mpl_toolkits.mplot3d import Axes3D """fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter(xstar[idx]-np.mean(xstar),ystar[idx]-np.mean(ystar),comatrix[:,3], c='r', marker='o') ax.set_xlabel('xccd-center') ax.set_ylabel('yccd-center') ax.set_zlabel('Coeff_4') plt.show()""" # ANN learning as interpolation---------------------- from pybrain.tools.shortcuts import buildNetwork from pybrain.structure import SigmoidLayer, LinearLayer from pybrain.datasets import SupervisedDataSet from pybrain.supervised.trainers import BackpropTrainer net = buildNetwork(2,3,3,4,bias=True,hiddenclass=SigmoidLayer,\ outclass=LinearLayer) ds = SupervisedDataSet(2, 4) for iy in range(len(idx)): i = idx[iy] ds.addSample((xstar[i]-np.mean(xstar),ystar[i]-np.mean(ystar)),\ (comatrix[iy][0],comatrix[iy][1],comatrix[iy][2],comatrix[iy][3])) trainer = BackpropTrainer(net, ds) trainer.trainUntilConvergence() nout = nstar - len(idx) pos = np.zeros([nout, 2]) for j in range(nout): if j != idx[j]: pos[j][0] = xstar[j] - np.mean(xstar) pos[j][1] = ystar[j] - np.mean(ystar) outmatrix = net.activate( [xstar[j] - np.mean(xstar), ystar[j] - np.mean(ystar)]) psfim = psfmodel(outmatrix, pcstr) #print psfim.shape mnpsf = moments(psfim.reshape(48, 48)) mxx, mxy, myy = mnpsf['moments'] Rpsf = mxx + myy e1psf = (mxx - myy) / (mxx + myy) e2psf = (2. * mxy) / (mxx + myy) print Rstar[j],ellipstar[j][0],ellipstar[j][1],\ Rpsf,e1psf,e2psf """fig = plt.figure()
trndata.appendLinked( trndata_temp.getSample(n)[0], trndata_temp.getSample(n)[1]) trndata._convertToOneOfMany() tstdata._convertToOneOfMany() ''' implementation of BP network ''' from pybrain.tools.shortcuts import buildNetwork # for building network raw model from pybrain.structure import SoftmaxLayer # for output layer activation function from pybrain.supervised.trainers import BackpropTrainer # for model trainer # network structure n_h = 5 # hidden layer nodes number net = buildNetwork(19, n_h, 2, outclass=SoftmaxLayer) # 1.1 model training, using standard BP algorithm trainer = BackpropTrainer(net, trndata) trainer.trainEpochs(1) # training for once # 1.2 model training, using accumulative BP algorithm # trainer = BackpropTrainer(net, trndata, batchlearning=True) # trainer.trainEpochs(50) # err_train, err_valid = trainer.trainUntilConvergence(maxEpochs=50) # convergence curve for accumulative BP algorithm process # import matplotlib.pyplot as plt # plt.plot(err_train,'b',err_valid,'r') # plt.title('BP network classification') # plt.ylabel('accuracy')
We now build an equivalent network to the one before, but with a more concise syntax: """ n2 = RecurrentNetwork(name='net2') n2.addInputModule(LinearLayer(2, name='in')) n2.addModule(SigmoidLayer(3, name='h')) n2.addOutputModule(LinearLayer(1, name='out')) n2.addConnection(FullConnection(n2['in'], n2['h'], name='c1')) n2.addConnection(FullConnection(n2['h'], n2['out'], name='c2')) n2.sortModules() """ Printouts look more concise and readable: """ print n2 """ There is an even quicker way to build networks though, as long as their structure is nothing more fancy than a stack of fully connected layers: """ n3 = buildNetwork(2, 3, 1, bias=False) """ Recurrent networks are working in the same way, except that the recurrent connections need to be explicitly declared upon construction. We can modify our existing network 'net2' and add a recurrent connection on the hidden layer: """ n2.addRecurrentConnection(FullConnection(n2['h'], n2['h'], name='rec')) """ After every structural modification, if we want ot use the network, we call 'sortModules()' again""" n2.sortModules() print n2 """ As the network is now recurrent, successive activations produce different outputs: """ print n2.activate([1, 2]), print n2.activate([1, 2]), print n2.activate([1, 2])
def build_network(self): self.neural_network = buildNetwork( self.train.indim, 7, self.train.outdim, outclass=SoftmaxLayer) # feed forward network
def net_class(ustraining_set, train_set_labels, usvalidation_set=None, validation_set_labels=None, pre=True): # print (validation_set_labels - 1) if pre: # ltraining_set = gabor_filter(ustraining_set) ltraining_set = standard_data(ustraining_set) else: ltraining_set = ustraining_set if not usvalidation_set == None: if pre: # lvalidation_set = gabor_filter(usvalidation_set) lvalidation_set = standard_data(usvalidation_set) else: lvalidation_set = usvalidation_set vds = ClassificationDataSet(1024, 7, nb_classes=7) for vd, vt in zip(lvalidation_set, validation_set_labels): vtarr = [int(i == vt - 1) for i in range(0, 7)] vds.addSample(vd, vtarr) # net = buildNetwork(1024, 100, 8,outclass=SoftmaxLayer) ds = ClassificationDataSet(1024, 7, nb_classes=7) for d, t in zip(ltraining_set, train_set_labels): tarr = [int(i == t - 1) for i in range(0, 7)] ds.addSample(d, tarr) tot_min_err = 100.0 best_l = 0.0 best_w = 0.0 obest_e = 0 for l in [0.005]: for w in [0.01]: net = buildNetwork(1024, 320, 7, outclass=SoftmaxLayer, hiddenclass=SigmoidLayer) net.sortModules() trainer = BackpropTrainer(net, ds, learningrate=l, momentum=0, weightdecay=w, batchlearning=False, verbose=True) cmin_err = 100.0 flag = True best_e = 0 e = 0 flag = False trnresult = 100.0 tstresult = 100.0 for i in range(10): e += 1 trainer.trainEpochs(1) trnresult = percentError(trainer.testOnClassData(), train_set_labels - 1) if not usvalidation_set == None: tstresult = percentError( trainer.testOnClassData(dataset=vds), validation_set_labels - 1) if cmin_err >= tstresult: cmin_err = tstresult print "copt err ", tstresult best_e = e flag = True if tot_min_err > cmin_err: tot_min_err = cmin_err best_l = l best_w = w obest_e = best_e print "new opt err:{}, for LR: {}, WD:{}, NE:{} ".format( tot_min_err, best_l, best_w, obest_e) net.sorted = False net.sortModules() res_f = open('net.dump', 'w') pickle.dump(net, res_f) res_f.close() return net