Verwenden Sie mehr Trainingsmethoden einen ANN mit Encog

Question

trainieren würde ich gerne wissen, ob ein Feed-Forward-neuronales Netz mit genetischen Algorithmen, Particle Swarm Optimization Ausbildung und simuliertem Ausglühen vor elastischem Ausbreitungstraining mit dem Ergebnis nicht verbessert. Hier

ist der Code, ich verwende:

    CalculateScore score = new TrainingSetScore(trainingSet); 
        StopTrainingStrategy stop = new StopTrainingStrategy(); 
        StopTrainingStrategy stopGA = new StopTrainingStrategy(); 
        StopTrainingStrategy stopSIM = new StopTrainingStrategy(); 
        StopTrainingStrategy stopPSO = new StopTrainingStrategy(); 

        Randomizer randomizer = new NguyenWidrowRandomizer(); 
        //Backpropagation train = new Backpropagation((BasicNetwork) network, trainingSet, 0.2, 0.1); 
        // LevenbergMarquardtTraining train = new LevenbergMarquardtTraining((BasicNetwork) network, trainingSet); 
        int population = 500; 
        MLTrain trainGA = new MLMethodGeneticAlgorithm(new MethodFactory(){ 
         @Override 
         public MLMethod factor() { 
          final BasicNetwork result = createNetwork(); 
          ((MLResettable)result).reset(); 
          return result; 
         }}, score,population); 


        Date dStart = new Date(); 

        int epochGA = 0; 
        trainGA.addStrategy(stopGA); 
        do{ 
         trainGA.iteration(); 
         if(writeOnStdOut) 
          System.out.println("Epoch GenetiC#" + epochGA + " Error:" + trainGA.getError()); 
         epochGA++;//0000001 
         previousError = trainGA.getError(); 
         Date dtemp = new Date(); 
         totsecs = ((double)(dtemp.getTime()-dStart.getTime())/1000); 
        } while(previousError > maximumAcceptedErrorTreshold && epochGA < (maxIterations/5) && !stopGA.shouldStop() && totsecs < (secs/3)); 

        NeuralPSO trainPSO = new NeuralPSO((BasicNetwork) network, randomizer, score, 100); 

        int epochPSO = 0; 
        trainPSO.addStrategy(stopPSO); 
        dStart = new Date(); 
        do{ 
         trainPSO.iteration(); 
         if(writeOnStdOut) 
          System.out.println("Epoch Particle Swarm #" + epochPSO + " Error:" + trainPSO.getError()); 
         epochPSO++;//0000001 
         previousError = trainPSO.getError(); 
         Date dtemp = new Date(); 
         totsecs = ((double)(dtemp.getTime()-dStart.getTime())/1000); 
        } while(previousError > maximumAcceptedErrorTreshold && epochPSO < (maxIterations/5) && !stopPSO.shouldStop() && totsecs < (secs/3)); 

        MLTrain trainSIM = new NeuralSimulatedAnnealing((MLEncodable) network, score, startTemperature, stopTemperature, cycles); 

        int epochSA = 0; 
        trainSIM.addStrategy(stopSIM); 
        dStart = new Date(); 
        do{ 
         trainSIM.iteration(); 
         if(writeOnStdOut) 
          System.out.println("Epoch Simulated Annealing #" + epochSA + " Error:" + trainSIM.getError()); 
         epochSA++;//0000001 
         previousError = trainSIM.getError(); 
         Date dtemp = new Date(); 
         totsecs = ((double)(dtemp.getTime()-dStart.getTime())/1000); 
        } while(previousError > maximumAcceptedErrorTreshold && epochSA < (maxIterations/5) && !stopSIM.shouldStop() && totsecs < (secs/3)); 




        previousError = 0; 
        BasicTraining train = getTraining(method,(BasicNetwork) network, trainingSet); 


        //train.addStrategy(new Greedy()); 
        //trainAlt.addStrategy(new Greedy()); 
        HybridStrategy strAnneal = new HybridStrategy(trainSIM); 

        train.addStrategy(strAnneal); 
        //train.addStrategy(strGenetic); 
        //train.addStrategy(strPSO); 

        train.addStrategy(stop); 
        // 
        // Backpropagation train = new Backpropagation((ContainsFlat) network, trainingSet, 0.7, 0.3); 
        dStart = new Date(); 

        int epoch = 1; 

        do { 
         train.iteration(); 
         if(writeOnStdOut) 
          System.out.println("Epoch #" + epoch + " Error:" + train.getError()); 
         epoch++;//0000001 
         if(Math.abs(train.getError()-previousError)<0.0000001) iterationWithoutImprovement++; else iterationWithoutImprovement = 0; 
         previousError = train.getError(); 

         Date dtemp = new Date(); 
         totsecs = ((double)(dtemp.getTime()-dStart.getTime())/1000); 
        } while(previousError > maximumAcceptedErrorTreshold && epoch < maxIterations && !stop.shouldStop() && totsecs < secs);//&& iterationWithoutImprovement < maxiter); 

Wie Sie sehen können eine Folge von Trainingsalgorithmen ist, die die allgemeine Ausbildung verbessern sollte.

Bitte lassen Sie mich wissen, ob es Sinn macht und ob der Code korrekt ist. Es scheint zu funktionieren, aber ich will sicher sein, denn manchmal sehe ich, dass die Fortschritte von GA von PSO zurückgesetzt werden.

Dank

Answer 1

Es scheint logisch, aber es wird nicht funktionieren.

mit den Standardparametern des RPROP, wird diese Sequenz nicht wahrscheinlich Arbeit. Der Grund dafür ist, dass nach dem vorherigen Training die Gewichte des neuronalen Netzwerks in der Nähe eines lokalen Optimums liegen. Wegen der Nähe zu einem lokalen Optimum bewegen sich nur kleine Änderungen an den Gewichten näher an das Optimum (verringern die Fehlerrate). Standardmäßig verwendet RPROP einen initialUpdate-Wert von 0,1 über die Gewichtsmatrix. Dies ist ein großer Wert für ein Netzwerk, das so nahe an einem Optimum liegt. Sie "entfesseln einen Stier in einem Porzellanladen an diesem Punkt". Die erste Iteration wird das Netzwerk weit vom Optimum wegbewegen und im Wesentlichen eine neue globale Suche beginnen.

Senken des InitialUpdate-Werts SOLLTE helfen. Ich bin mir nicht sicher, wie viel. Vielleicht möchten Sie sich die durchschnittlichen RPROP-Gewichtsaktualisierungswerte für einen Zug mit Ihren Daten ansehen, um eine Vorstellung zu bekommen. Oder versuchen Sie es sehr klein und arbeiten Sie sich wieder hoch.