reseaubp.java

application som kohonen , pour une classification de couleur et voir l application de l algorithme

package neuronespack;

/**
 * Package Neurones
 * Fonctionalit閟 de base des r閟eaux neuronaux.
 * R閟eaux Neauronaux, Vuibert 2006.
 * Jean-Philippe Rennard
 * version 1.0, 17/3/2006
 */

/**
 * <p>Title: R閟eau backprop</p>
 * <p>Description: Gestion des r閟eaux backprop.</p>
 */
public class ReseauBP extends ReseauFF {

  /** Moment */
  private double momentum;

  /**
   * Constructeur du r閟eau
   * @param nbC int : Nombre de couches
   */
  public ReseauBP(int nbC) {
    super(nbC);
    setEta(1.0D);
    momentum = 0.0D;
  }

  /**
   * Construit un r閟eau BP selon param鑤res
   * @param paramReseau int[] : Nombre de neurones pour chaque couche
   * @param fonction int : Fonction de transfert
   * @param paramFT double[] : Param鑤res de la fonction de transfert
   */
  public void construitReseau(int paramReseau[], int fonction,
                              double paramFT[]) {
    construitLesCouches(paramReseau, fonction, paramFT);
    construitLesConnexions();
  }

  /**
   * Construit un r閟eau BP selon param鑤res
   * @param paramReseau int[] : Nombre de neurones pour chaque couche
   * @param fonction int : Fonction de transfert
   * @param paramFT double[] : Param鑤res de la fonction de transfert
   * @param vb double[][] : Valeurs des biais (seuils) par couche et par neurone
   */
  public void construitReseau(int paramReseau[], int fonction,
                              double paramFT[], double vb[][]) {
    construitLesCouches(paramReseau, fonction, paramFT);
    construitConnexionsBiais(vb);
    construitLesConnexions();
  }

  /**
   * Construit les couches
   * @param paramReseau int[] : Nombre de neurones pour chaque couche
   * @param fonction int : Fonction de transfert
   * @param paramFT double[]Param鑤res de la fonction de transfert
   */
  private void construitLesCouches(int paramReseau[], int fonction,
                                   double paramFT[]) {
    double paramFL[] = new double[1];
    paramFL[0] = 1.0D;
    ajouteCouche(paramReseau[0], FonctionTransfert.F_LINEAIRE, paramFL);
    for(int i=1; i<getNbCouches(); i++) {
      ajouteCouche(paramReseau[i], fonction, paramFT);
    }
  }

  /** Construit les connexions */
  private void construitLesConnexions() {
    construitConnexionsEntreesDirectes();
    for(int i=1; i<getNbCouches(); i++) {
      construitConnexionsCouchesComplete((GroupeUnites) getCouche(i-1),
                                 (GroupeUnites) getCouche(i));
    }
    construitConnexionsSortiesDirectes();
  }

  /**
   * Apprentissage d'un exemple
   * @return double : Erreur totale sur la couche de sortie
   */
  public double apprend() {
    double erreurTotale;
    propagation();
    erreurTotale = calcErreurSortie(((CoucheFF) getCouche(getNbCouches()-1)));
    for(int j=getNbCouches()-2; j>0; j--) {
      calcErreurCachee(((CoucheFF) getCouche(j)));
    }
    corrigePoids();
    return erreurTotale;
  }

  /**
   * Calcul des signaux d'erreurs sur la couche de sortie
   * @param couche CoucheFF : couche