Sujet Précédent Sujet Suivant

Optimisation(minimisation) par les réseaux de neurones

yokohama2 Messages postés 1 Date d'inscription lundi 23 janvier 2006 Statut Membre Dernière intervention 23 janvier 2006 - 23 janv. 2006 à 17:15
lavidato Messages postés 1 Date d'inscription lundi 3 janvier 2011 Statut Membre Dernière intervention 3 janvier 2011 - 3 janv. 2011 à 20:26
salut je travaille dans le domaine d'optimisation de la fonction de coût d'énergie électrique sous des contraintes en utilisant les reseau de neurones, c'est une fonction quadretique.
j'aimerai bien avoir une aide dans soit un algorithme ou un programme qui utilise les reseaux de neurones pour minimiser une fonction de coût.
merci.

2 réponses

Réponse 1 / 2
ptitjib Messages postés 7 Date d'inscription samedi 9 mai 2009 Statut Membre Dernière intervention 12 mai 2009
24 oct. 2008 à 02:56
bonsoir,


Regardes peut être à ça, c'est un réseau de neurone à apprentissage par rétropopagation du gradient d'erreur.


unit uRNA1;


interface


Uses Windows,Math, SysUtils;


Const
 KA = 0.746;  // pour l'instant cette constante est au pif a ameliorer
 µ = 1;
 GainCorrection = 1;
 dEta = (0.9);
 dAlpha = (0.9);


Type TModeCalcule = (FctSigmoide,FctLineaire);
Type TDoubleArray = Array of Double;


Type
TSortieChangeEvent = Procedure(Sender : TObject; aSortie : Double; aModeCalcule: TModeCalcule) of Object;
TEntreeChangeEvent = Procedure(Sender : TObject; aEntrees : Double) of Object;
TPoidsChangeEvent = Procedure(Sender : TObject; aCoef : Double) of Object;




type TPoids = class(Tobject)
    Private
     FPoids : Double;
     FValue2 : Double;
     FPoidsChange : TPoidsChangeEvent;
     Procedure SetPoids(aPoids : Double);
     Procedure SetValue2(aValue2 : Double);
    Public
     Numero,
     NumeroNeurone,
     NumeroCouche : integer;
     Constructor Create(aNumero, aNumeroNeurone, aNumeroCouche : integer);
    Published
     Property Poids : Double read FPoids write SetPoids;
     Property Value2 : Double read FValue2 write SetValue2;
     Property OnPoidsChange : TPoidsChangeEvent read FPoidsChange write FPoidsChange;
end;


Type TArrayPoids = Array of TPoids;


Type TEntree = class(TObject)
    Private
     FEntree : Double;
     FEntreeChange : TEntreeChangeEvent;
     Procedure SetEntree(aEntree : Double);
    Public
     Numero,
     NumeroNeurone,
     NumeroCouche : integer;
     Constructor Create(aNumero, aNumeroNeurone, aNumeroCouche : integer);
    Published
     Property Entree : Double read FEntree write SetEntree;
     Property OnEntreeChange : TEntreeChangeEvent read FEntreeChange write FEntreeChange;
end;


Type TArrayEntrees = Array of TEntree;


Type


TErreurChangeEvent = Procedure(Sender : TObject; aErreur : Double) of Object;
TNbCalculesChangeEvent = Procedure(Sender : TObject; aNbCalcules : Integer) of Object;
TNbRetroCalculesChangeEvent = Procedure(Sender : TObject; aNbCalcules : Integer) of Object;
TNeurone = class(TObject)
        Private
         FModeCalcule : TModeCalcule;  // Set onCreate
         FStochastique : boolean; // Set onCreate
         FEntrees : TArrayEntrees;
         FCoefs : TArrayPoids;
         FSortie : Double;
         FOnSortieChange : TSortieChangeEvent;
         FErreur : double; // Pour la rétropropagation
         FOnErreurChange : TErreurChangeEvent;
         FNbCalcules : Integer;
         FOnNbCalculesChange : TNbCalculesChangeEvent;
         FNbRetroCalcules : Integer;
         FOnNbRetroCalculesChange : TNbRetroCalculesChangeEvent;
          Procedure SetSortie(aSortie : Double); // Pour la retropropagation
          Procedure SetErreur(aErreur : Double);
          Procedure SetNbCalcules(aNbCalcules : integer);
          Procedure SetNbRetroCalcules(aNbRetroCalcules : integer);
          Procedure CalculeSortieSigmoideSommePonderee;
          Procedure CalculeSortieLineaireSommePonderee;


        Public
          Numero : integer;    //pour info
          NumeroCouche : integer;  // pour info seulement pas d'insertion
          Procedure Calcule;
          Constructor Create(aNumeroCouche,aNumero, aNbSynapse : Integer; aModeCalcule : TModeCalcule; aStochastique : Boolean);




  published
    { Published declarations }
    Property Sortie: Double read FSortie write SetSortie;
    Property Entrees : TArrayEntrees read FEntrees write FEntrees;
    Property Coefs : TArrayPoids read FCoefs write FCoefs;
    Property Erreur : Double read FErreur write SetErreur;
    Property NbCalcules : Integer read FNbCalcules write SetNbCalcules;
    Property NbRetroCalcules : Integer read FNbRetroCalcules write SetNbRetroCalcules;
    Property OnSortieChange : TSortieChangeEvent read FOnSortieChange write FOnSortieChange;
    Property OnErreurChange : TErreurChangeEvent read FOnErreurChange write FOnErreurChange;
    Property OnNbCalculesChange : TNbCalculesChangeEvent read FOnNbCalculesChange write FOnNbCalculesChange;
    Property OnNbRetroCalculesChange : TNbRetroCalculesChangeEvent read FOnNbRetroCalculesChange write FOnNbRetroCalculesChange;


end;


Type TCoucheNeurone = class(TObject)
    Public
     Numero : integer;
     Neurones : Array of TNeurone;
     SortieNeurones : TDoubleArray;
     Procedure Calcule;
     Procedure AssignesEntrees(aEntrees : Array of Double);
     Constructor Create(aNumero, aNb_Neurones, aNbEntreesParNeurone : integer; aModeCalcule : TModeCalcule);


end;


Type TOnCalculeSortieEvent = Procedure(Sender : TObject; aSortie : Double) of Object;


Type TRNA = class(TObject)
  Private
     FSortie: Double;
     FSortieChange : TOnCalculeSortieEvent;
     Procedure SetSortie(aSortie : Double);
  Public
     Numero : integer;
     dMSE, dMAE : Double; //Erreur Quadratique moyenne et Absolue Moyenne
     CoucheNeurones : Array of TCoucheNeurone;
     Temps : String; //ms
     Procedure Calcule;
     Procedure Apprends(aEntrees, aSortiesVoulues : Array of Double);
     Procedure SaveCoefs(aFileName : String);
     Procedure LoadCoefs(aFileName : String);
     Constructor Create(aNumero, aNbCouches, aNbEntrees : integer; aNbNeuronesParCouche : Array of integer; aModesCalcules : Array of TModeCalcule);
   Published
     Property Sortie : Double read FSortie write SetSortie;
     Property OnSortieCalculed : TOnCalculeSortieEvent read FSortieChange write FSortieChange;
end;


implementation


{ TNeurone }


procedure TNeurone.Calcule;
begin
case FModeCalcule of
  FctSigmoide: CalculeSortieSigmoideSommePonderee;
  FctLineaire: CalculeSortieLineaireSommePonderee;
end;


SetNbCalcules(FNbCalcules+1);
end;


procedure TNeurone.CalculeSortieLineaireSommePonderee;
var
 i : integer;
 sortie : Double;
begin
for i := 0 to Length(FEntrees) - 1 do
  Sortie := Sortie + FEntrees[i].Entree*Coefs[i].Poids;
SetSortie(Sortie);
end;


procedure TNeurone.CalculeSortieSigmoideSommePonderee;
var
 i : integer;
 sortie : Double;
begin
sortie:=0;
for i := 0 to Length(FEntrees) - 1 do
  Sortie := Sortie + FEntrees[i].Entree*Coefs[i].Poids;
Sortie := 1/(1+exp(-KA*Sortie ));
SetSortie(Sortie);
end;


constructor TNeurone.Create(aNumeroCouche, aNumero, aNbSynapse : Integer; aModeCalcule: TModeCalcule; aStochastique: Boolean);
var i : integer;
begin
  Randomize;
  Numero:=aNumero;
  NumeroCouche:=aNumeroCouche;
  FModeCalcule := aModeCalcule;
  FStochastique := aStochastique;
  FNbCalcules := 0;
  FNbRetroCalcules := 0;


  SetLength(FCoefs,aNbSynapse);
  SetLength(FEntrees,aNbSynapse);
  //init de coefs au hazard
  for i := 0 to aNbSynapse - 1 do
   begin
    Coefs[i] := Tpoids.Create(i,Numero,NumeroCouche);
    Entrees[i] := TEntree.Create(i,Numero,NumeroCouche);
   end;
end;


procedure TNeurone.SetErreur(aErreur: Double);
begin
if FErreur <> aErreur then
 FErreur := aErreur;
If assigned(FOnErreurChange) then
 FOnErreurChange(self,FErreur) ;
end;


procedure TNeurone.SetNbCalcules(aNbCalcules: integer);
begin
if FNbCalcules <> aNbCalcules then
 begin
  FNbCalcules:=aNbCalcules;
  if assigned(FOnNbCalculesChange) then
    FOnNbCalculesChange(self,FNbCalcules);
 end;
end;


procedure TNeurone.SetNbRetroCalcules(aNbRetroCalcules: integer);
begin
if FNbRetroCalcules <> aNbRetroCalcules then
 begin
  FNbRetroCalcules:=aNbRetroCalcules;
  if assigned(FOnNbRetroCalculesChange) then
    FOnNbRetroCalculesChange(self,FNbRetroCalcules);
 end;
end;


procedure TNeurone.SetSortie(aSortie: Double);
begin
if FSortie <> aSortie then
begin
  FSortie := aSortie;
end;
  If assigned(FOnSortieChange) then
   FOnSortieChange(self,FSortie,FModeCalcule);
end;


{ TCoucheNeurone }


procedure TCoucheNeurone.AssignesEntrees(aEntrees: Array of Double);
var i,k : integer;
begin
 for i := 0 to Length(Neurones) - 1 do
  for k := 0 to Length(aEntrees) - 1 do
   Neurones[i].Entrees[k].Entree:=aEntrees[k];
end;


procedure TCoucheNeurone.Calcule;
var i : integer;
begin
for i := 0 to Length(Neurones) - 1 do
 begin
  Neurones[i].Calcule;
  SortieNeurones[i]:=Neurones[i].Sortie;
 end;
end;




constructor TCoucheNeurone.Create(aNumero, aNb_Neurones, aNbEntreesParNeurone: integer; aModeCalcule: TModeCalcule);
var i : integer;
begin
Numero:=aNumero;
SetLength(Neurones,aNb_Neurones);
for i := 0 to Length(Neurones) - 1 do
 Neurones[i] := TNeurone.Create(Numero,i,aNbEntreesParNeurone, aModeCalcule, false);
SetLength(SortieNeurones, Length(Neurones));
end;


{ TRNA }


procedure TRNA.Apprends(aEntrees, aSortiesVoulues: Array of Double);
var
 i,j,k : integer;
 Delta : Double;
 TableauSortie : TDoubleArray;
begin
SetLength(TableauSortie, Length(aSortiesVoulues));
  for I := 0 to Length(aSortiesVoulues) - 1 do
     TableauSortie[i]:=aSortiesVoulues[i];


// on assigne les entrees du reseau
CoucheNeurones[0].AssignesEntrees(aEntrees);


// on Calcule la sortie du reseau
Calcule;


//Calcule erreurs de la derniere couche
dMSE := 0; dMAE := 0;
for i := 0 to Length(CoucheNeurones[Length(CoucheNeurones)-1].Neurones) - 1 do
 begin
  CoucheNeurones[Length(CoucheNeurones)-1].Neurones[i].Erreur:=µ * CoucheNeurones[Length(CoucheNeurones)-1].Neurones[i].Sortie * (1-CoucheNeurones[Length(CoucheNeurones)-1].Neurones[i].Sortie)*(TableauSortie[i]-CoucheNeurones[Length(CoucheNeurones)-1].Neurones[i].Sortie);
  dMSE := dMSE + sqr(TableauSortie[i]-CoucheNeurones[Length(CoucheNeurones)-1].Neurones[i].Sortie);
  dMAE := dMAE + abs(dMAE);
 end;
  dMSE := dMSE / Length(CoucheNeurones[Length(CoucheNeurones)-1].Neurones);
  dMAE := dMAE / Length(CoucheNeurones[Length(CoucheNeurones)-1].Neurones);
//---------------


// Retropropagation de l'erreur de chaques sorties
// pour chaque couche en partant de l'avant derniere
for i := Length(CoucheNeurones)-2 downto 0 do
 begin
//pour chaque neurone
   for j := Length(CoucheNeurones[i].Neurones)-1 downto 0 do
    begin
     Delta := 0;
     //Pour chaque coef
     for k := Length(CoucheNeurones[i+1].Neurones)-1 downto 0 do
       Delta := Delta + CoucheNeurones[i+1].Neurones[k].Coefs[j].Poids * CoucheNeurones[i+1].Neurones[k].Erreur;


     CoucheNeurones[i].Neurones[j].Erreur :=  µ * CoucheNeurones[i].Neurones[j].Sortie * (1 - CoucheNeurones[i].Neurones[j].Sortie) * Delta;
    end;
 end;
//---------------------------------------------------


//Ajustement des poids


  // --- la boucle commence à l'avant derniere couche
  for i:=Length(CoucheNeurones)-1 downto 1 do
     for j:=Length(CoucheNeurones[i].Neurones)-1 downto 0 do
     for k:=Length(CoucheNeurones[i-1].Neurones)-1 downto 0 do
       begin
       CoucheNeurones[i].Neurones[j].Coefs[k].Poids := CoucheNeurones[i].Neurones[j].Coefs[k].Poids + dEta * CoucheNeurones[i-1].Neurones[k].sortie * CoucheNeurones[i].Neurones[j].Erreur + dAlpha * CoucheNeurones[i].Neurones[j].Coefs[k].Value2;
       CoucheNeurones[i].Neurones[j].Coefs[k].Value2 := dEta * CoucheNeurones[i-1].Neurones[k].sortie * CoucheNeurones[i].Neurones[j].Erreur;
       end;


//---------------------
end;


procedure TRNA.Calcule;
var
 i : integer;
 freq,deb,fin : int64;
begin
QueryPerformanceFrequency(freq);
QueryPerformanceCounter(deb);


for i := 0 to Length(CoucheNeurones) - 1 do
 begin
  CoucheNeurones[i].Calcule;
  if i<>Length(CoucheNeurones) - 1 then
    CoucheNeurones[i+1].AssignesEntrees(CoucheNeurones[i].SortieNeurones);
 end;
 Sortie:=CoucheNeurones[Length(CoucheNeurones)-1].Neurones[Length(CoucheNeurones[Length(CoucheNeurones)-1].Neurones)-1].Sortie;


QueryPerformanceCounter(fin);
Temps := FormatFloat('0.000000 ms', (fin-deb)/freq*1000);
end;


constructor TRNA.Create(aNumero, aNbCouches, aNbEntrees: integer; aNbNeuronesParCouche: array of integer; aModesCalcules : Array of TModeCalcule);
var
 i : integer;
begin
Numero:=aNumero;
  SetLength(CoucheNeurones,aNbCouches);
  for i := 0 to aNbCouches - 1 do
   if i = 0 then
    CoucheNeurones[i]:=TCoucheNeurone.Create(i,aNbNeuronesParCouche[i], aNbEntrees, aModesCalcules[i])
   else
    CoucheNeurones[i]:=TCoucheNeurone.Create(i,aNbNeuronesParCouche[i], aNbNeuronesParCouche[i-1], aModesCalcules[i]);
end;


procedure TRNA.LoadCoefs(aFileName: String);
var
i,j,k : integer;
T : TextFile;
Val : Double;
begin
AssignFile(T,AFileName);
Reset(T);
 for i := 0 to Length(CoucheNeurones) - 1 do
   for j := 0 to Length(CoucheNeurones[i].Neurones) - 1 do
    for k := 0 to Length(CoucheNeurones[i].Neurones[j].Coefs) - 1 do
     begin
       Read(T,Val);
       CoucheNeurones[i].Neurones[j].Coefs[k].Poids:=Val;
     end;
   
CloseFile(T);
end;


procedure TRNA.SaveCoefs(aFileName: String);
var
i,j,k : integer;
T : TextFile;
begin
AssignFile(T,AFileName);
ReWrite(T);
 for i := 0 to Length(CoucheNeurones) - 1 do
   for j := 0 to Length(CoucheNeurones[i].Neurones) - 1 do
    for k := 0 to Length(CoucheNeurones[i].Neurones[j].Coefs) - 1 do
     writeln(T,CoucheNeurones[i].Neurones[j].Coefs[k].Poids);
CloseFile(T);


end;


procedure TRNA.SetSortie(aSortie: Double);
begin
if FSortie <> aSortie then
  begin
   FSortie:= ASortie;
   if assigned(FSortieChange) then
    FSortieChange(Self,FSortie);
  end;
end;


{ TPoids }


constructor TPoids.Create(aNumero, aNumeroNeurone, aNumeroCouche : integer);
begin
Numero:=aNumero;
NumeroNeurone:=aNumeroNeurone;
NumeroCouche:=aNumeroCouche;
Randomize;
Self.FPoids := 1 - random(1000)/1000;
FValue2:=0;
end;


procedure TPoids.SetPoids(aPoids: Double);
begin
 if Self.FPoids <> aPoids then
   begin
     Self.FPoids := aPoids;
     if Assigned(FPoidsChange) then
       FPoidsChange(Self,FPoids);
   end;
end;


procedure TPoids.SetValue2(aValue2: Double);
begin
  if Self.FValue2 <> aValue2 then
   begin
     Self.FValue2 := aValue2;
     //if Assigned(FValue2Change) then
       //FValue2Change(Self,FValue2);
   end;
end;


{ TEntree }


constructor TEntree.Create(aNumero, aNumeroNeurone, aNumeroCouche: integer);
begin
Numero:=aNumero;
NumeroNeurone:=aNumeroNeurone;
NumeroCouche:=aNumeroCouche;
end;


procedure TEntree.SetEntree(aEntree: Double);
begin
 if Self.FEntree <> aEntree then
   begin
     Self.FEntree := aEntree;
     if Assigned(FEntreeChange) then
       FEntreeChange(Self,FEntree);
   end;
end;


end.

// UTILISATION ------------------------
Var rna : TRNA;
rna := TRNA.Create(0,4,2,[4,3,2,1],[FctSigmoide, FctSigmoide, FctSigmoide, FctSigmoide]);

//On assigne les évenements pour des statistiques sur le réseau
for i := 0 to Length(rna.CoucheNeurones) - 1 do
 for j := 0 to Length(rna.CoucheNeurones[i].Neurones) - 1 do
 for k := 0 to Length(rna.CoucheNeurones[i].Neurones[j].Coefs) - 1 do
  begin
   rna.CoucheNeurones[i].Neurones[j].Entrees[k].OnEntreeChange:=affiche_e;
   rna.CoucheNeurones[i].Neurones[j].Coefs[k].OnPoidsChange:=Affiche_c;
   rna.CoucheNeurones[i].Neurones[j].OnSortieChange:=Affiche_s;
   rna.CoucheNeurones[i].Neurones[j].OnErreurChange:=Affiche_er;
   rna.CoucheNeurones[i].Neurones[j].OnNbCalculesChange:=Affiche_NbCalcs;
   rna.CoucheNeurones[i].Neurones[j].OnNbRetroCalculesChange:=Affiche_NbRetroCalcs;
  end;
//Attribution des entrées
 rna.CoucheNeurones[0].AssignesEntrees(entrees);
// on charge les poids des synapses
rna.LoadCoefs('Coefs.txt');
rna.Calcule;
rna.Apprends([0,1],[1]);
rna.SaveCoefs('Coefs.txt');

Ceci est une transcription du vb à delphi, dites moi ce que vous en pensez.

A Bienôt.
0
Réponse 2 / 2
lavidato Messages postés 1 Date d'inscription lundi 3 janvier 2011 Statut Membre Dernière intervention 3 janvier 2011
3 janv. 2011 à 20:26
BONJOUR;

SVP ptitjip , d'ou tu as copie ce programme et par quelle version de delphi peut etre compile, moi j'ai essaye par delphi 7 mais il y a des erreurs!!?? SVP c'est urgent!!


Merci pour l'aide

-------------------------------
0

Discussions similaires

Bonton plat
Dorgendubal -
krakoss -

3 réponses
Lister les ordinateurs du réseau
arnaud2006 -
arnaud2006 -

2 réponses
reseaux de neurones
manu222 -
manu222 -

3 réponses
connexion vb6 avec access sur un reseau distant
valeryht -
valeryht -

4 réponses
réseau
zerouti -
fbalien -

1 réponse
Rejoignez-nous