J'essaie de faire de la reconnaissance d'écriture manuscrite avec une seule couche de perceptrons, en utilisant la base de données MNIST en Java. Chaque perceptron est assigné à reconnaître un chiffre (donc 10 perceptrons). Ils sont chacun formés au hasard sur chacun des 50 000 échantillons pour un certain nombre d'époques. Lors du test, le perceptron ayant le taux le plus élevé est sélectionné (c'est-à-dire celui qui est le plus confiant qu'il est correct).L'algorithme d'apprentissage pour l'échec de Perceptron sigmoïde - Reconnaissance de l'écriture manuscrite
En utilisant cette méthode, j'obtiens systématiquement une précision de 93,5%. Cependant, je pense que pour améliorer je devrai ajouter des calques cachés, et implémenter une backpropogation. Lorsque j'utilise la fonction Sigmoid (squashing) pour calculer le passage avant de mon réseau monocouche, cela fonctionne à merveille. Cependant, quand je change ma fonction de passe en arrière (apprentissage) pour correspondre à la rétro-propagation, j'obtiens une précision de ~ 70%. Quelqu'un peut-il vérifier mes algorithmes pour s'assurer que c'est correct?
J'ai obtenu l'algorithme de quelques endroits, et je pense que c'est la même chose. Par exemple celui-ci: http://www.webpages.ttu.edu/dleverin/neural_network/neural_networks.html
Remarque Je traite le dernier poids comme un biais. L '«erreur» introduite dans la fonction d'apprentissage est juste le résultat souhaité moins le résultat réel. exemple est le même tableau que l'entrée - l'échelle de gris de chaque pixel du chiffre.
Forward pass:
public final double apply(double[] input) {
double ret = 0;
for (int i=0; i<wei.length-1; i++){
ret = ret + input[i]*wei[i];
}
ret+=wei[wei.length-1];
//apply squashing function
ret = 1/(1+Math.exp(-ret));
return ret;
}
Learning Function (backwards Pass)
public final void learn(double error, double result, double[] example, double alpha) {
for (int i=0; i<wei.length-1; i++){
//wei[i] = wei[i] + alpha*error*example[i]; //This was original learning function - it gives 93.5% accuracy
wei[i]=wei[i]+ alpha* error * example[i]*result*(1-result); //This line gives ~70% accuracy
}
//wei[wei.length-1] += alpha*error; //this line works for bias
wei[wei.length-1]=wei[wei.length-1]+ alpha* error * 1*result*(1-result); //again, this makes results inaccurate
}