neural network - Usa múltiples métodos de entrenamiento para entrenar una ANN con Encog

neural-network genetic-algorithm

Question

Me gustaría saber si el entrenamiento de una red neuronal de retroalimentación con Algoritmos Genéticos, Optimización de Enjambre de Partículas y Recocido Simulado antes de usar entrenamiento de propagación resistente mejora el resultado.

Aquí está el código que estoy usando:

 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);

Como puede ver, hay una secuencia de algoritmos de entrenamiento que deberían mejorar el entrenamiento general.

Por favor, avíseme si tiene sentido y si el código es correcto. Parece que funciona, pero quiero estar seguro porque a veces veo que el progreso realizado por GA se restablece desde PSO.

Gracias

Answer 1

Parece lógico, sin embargo, no funcionará.

Con los parámetros predeterminados de RPROP, esta secuencia probablemente no funcionará. La razón por la cual es que después de su entrenamiento previo, los pesos de la red neuronal estarán cerca de un óptimo local. Debido a la proximidad a un óptimo local, solo los PEQUEÑOS cambios en los pesos se acercarán al óptimo (menor la tasa de error). Por defecto, RPROP usa un valor de actualización inicial de 0.1 en la matriz de ponderación. Este es un gran valor para una red tan cerca de un óptimo. Estás "desatando un toro en una tienda de porcelana en este momento". La primera iteración moverá la red lejos del óptimo y esencialmente comenzará una nueva búsqueda global.

Bajar el valor de actualización inicial DEBERÍA ayudar. No estoy seguro de cuánto. Es posible que desee ver los valores promedio de actualización de peso RPROP para un tren con sus datos para tener una idea. O intente configurarlo realmente pequeño y volver a subir.