il y à de ça 3 mois j'ai codé un truc pour tester mes connaissances de cours pour un cours de modélisation avancée avec des réseaux de neurones.
Ca ne fonctionne pas super, et l'apprentissage n'est pas forcé d'arriver à un résultat mais voila :
En gros tu créés ta base d'exemple a apprendre, ensuite tu définies la taille du réseau de neurone, puis tu effectues l'apprentissage jusqu'à ce que les résultats soient acceptables.
En fin de compte tu peux dégrader les exemples de la base d'apprentissage et regarder si le réseau les reconstruit correctement... Ce n'est pas vraiment de l'ocr, mais plutôt un début.
Un des problèmes des ces techniques d'ocr consiste à isolé les caractères pour les soumettre à l’algorithme de reconnaissance.
C'est complexe, et il faut plein d'hypothèse sur la position des caractères etc... Il y a un paquet de théorie à maitriser avant.
Code : Tout sélectionner
UsePNGImageDecoder()
UsePNGImageEncoder()
;{ structure
CompilerIf #PB_Compiler_OS <> #PB_OS_Windows
#White = 16777215
CompilerEndIf
Structure BaseApprentissage_Exemple
List Entree.l()
EndStructure
Structure BaseApprentissage
List Exemple.BaseApprentissage_Exemple()
NombreEntree.l
IS_Memory.b
EndStructure
Structure Neurone
List PoidsEntree.d()
Seuil.d
IS_Memory.b
EndStructure
Structure MemoireAssociative
List Neurone.Neurone()
IS_Memory.b
EndStructure
;}
;{ variables
Global WD_Window_0
Global GD_ListIcon_0
Global GD_Image_0, GD_Image_1
Global GD_Text_0, GD_Text_1, GD_Text_2, GD_Text_3, GD_Text_4, GD_Text_5, GD_Text_6, GD_Text_7, GD_Text_8, GD_Text_9
Global GD_Frame3D_0, GD_Frame3D_1, GD_Frame3D_2
Global GD_Button_0, GD_Button_1, GD_Button_2, GD_Button_3, GD_Button_4, GD_Button_5, GD_Button_6
Global GD_String_0, GD_String_1, GD_String_2, GD_String_3, GD_String_4, GD_String_5, GD_String_6
Global GD_Canvas_0
Global GD_Editor_0
Global IMG_canvas.l, Canvas_RATIO.d, Canvas_W, Canvas_H
;}
;{ macro générale
Macro Message(Message)
AddGadgetItem(GD_Editor_0, 0, "[" + FormatDate("%hh:%ii:%ss", Date()) + "] - " + Message)
EndMacro
;}
;{ procedures neuronales
EnableExplicit
Procedure.i CreationBaseApprentissage(NombreEntree.l, *NouvelleBase.BaseApprentissage = 0)
Protected IS_memory.b
If *NouvelleBase = 0
*NouvelleBase = AllocateMemory(SizeOf(BaseApprentissage))
IS_memory = #True
EndIf
InitializeStructure(*NouvelleBase, BaseApprentissage)
*NouvelleBase\IS_Memory = IS_memory
*NouvelleBase\NombreEntree = NombreEntree
ProcedureReturn *NouvelleBase
EndProcedure
Procedure FreeBaseApprentissage(*Base.BaseApprentissage)
ForEach *base\Exemple()
FreeList(*Base\Exemple()\Entree())
Next
FreeList(*Base\Exemple())
If *Base\IS_Memory
FreeMemory(*Base)
EndIf
EndProcedure
Procedure Ajout_Exemple_Apprentissage(*Base.BaseApprentissage, Image)
Protected x.l, y.l
If IsImage(Image) = 0
Message("ERREUR Ajout Exemple d'apprentissage : l'image n'est pas correctement initialisée")
ProcedureReturn #False
EndIf
If *Base\NombreEntree <> ImageWidth(Image) * ImageHeight(Image)
Message("ERREUR Ajout Exemple d'apprentissage : Le nb d'entrée est différent du produit W*H de l'image")
ProcedureReturn #False
EndIf
AddElement(*Base\Exemple())
InitializeStructure(*Base\Exemple(), BaseApprentissage_Exemple)
If StartDrawing(ImageOutput(Image))
For x = 0 To ImageWidth(Image) - 1
For y = 0 To ImageHeight(Image) - 1
AddElement(*Base\Exemple()\Entree())
If Point(x, y) = 0 ; noir
*Base\Exemple()\Entree() = -1
Else
*Base\Exemple()\Entree() = 1
EndIf
Next
Next
StopDrawing()
EndIf
ProcedureReturn #True
EndProcedure
Procedure.i CreationNeurone(NombreEntree.l, Seuil.d, Hazard.b, *NouveauNeurone.Neurone = 0)
Protected i, IS_memory.b
If *NouveauNeurone = 0
*NouveauNeurone = AllocateMemory(SizeOf(Neurone))
IS_memory = #True
EndIf
InitializeStructure(*NouveauNeurone, Neurone)
*NouveauNeurone\Seuil = Seuil
*NouveauNeurone\IS_Memory = IS_memory
For i = 1 To NombreEntree
AddElement(*NouveauNeurone\PoidsEntree())
If Hazard
*NouveauNeurone\PoidsEntree() = (Random(20) - 10) / 10
EndIf
Next
ProcedureReturn *NouveauNeurone
EndProcedure
Procedure FreeNeurone(*Neurone.Neurone)
FreeList(*Neurone\PoidsEntree())
If *Neurone\IS_Memory
FreeMemory(*Neurone)
EndIf
EndProcedure
;{ Mono Neurone
; Procedure Apprentissage_MonoNeurone(*Neurone.Neurone, *Base.BaseApprentissage, correcteur_nu.d, IterationMaximum.l = 100)
; Protected PasdErreur.b, SortieObtenue.d, x.b, Iteration.l
;
; Repeat
; PasdErreur = #True
;
; ForEach *Base\Exemple()
; SortieObtenue = - *Neurone\Seuil
;
; If ListSize(*Neurone\PoidsEntree()) <> ListSize(*Base\Exemple()\Entree())
; Debug "ERREUR : Nombre d'entrée différents du nombre de poids"
; ProcedureReturn #False
; EndIf
;
; ResetList(*Neurone\PoidsEntree())
; ForEach *Base\Exemple()\Entree()
; NextElement(*Neurone\PoidsEntree())
; SortieObtenue = SortieObtenue + *Neurone\PoidsEntree() * *base\Exemple()\Entree()
; Next
;
; If SortieObtenue > 0
; x = 1
; Else
; x = -1
; EndIf
;
; Debug "Exemple " + Str(ListIndex(*base\Exemple()) + 1) + " : x = " + Str(x) + " Sortie désirée = " + *base\Exemple()\Sortie_desiree + " Obtenue = " + SortieObtenue
;
; If x <> *Base\Exemple()\Sortie_desiree
; ; modification des poids
; PasdErreur = #False
;
; Debug "Modification des poids :"
;
; ResetList(*Base\Exemple()\Entree())
; ForEach *Neurone\PoidsEntree()
; NextElement(*Base\Exemple()\Entree())
; *Neurone\PoidsEntree() = *Neurone\PoidsEntree() + correcteur_nu * *Base\Exemple()\Entree() * (*base\Exemple()\Sortie_desiree - x)
;
; Debug "w" + Str(ListIndex(*Neurone\PoidsEntree())+1) + " = " + *Neurone\PoidsEntree()
; Next
; ; correction du seuil pour une convergence plus rapide
; *Neurone\Seuil = *Neurone\Seuil - correcteur_nu * (*base\Exemple()\Sortie_desiree - x)
; Debug "Seuil = " + *Neurone\Seuil
;
; Else
; ; rien, on passe à l'exemple suivant !
; EndIf
;
; Next
;
; Iteration + 1
; Until PasdErreur = #True Or Iteration >= IterationMaximum
;
; ProcedureReturn PasdErreur
; EndProcedure
;
; Procedure Reponse_MonoNeurone(*Neurone.Neurone, Sequence$)
; Protected SortieObtenue.d, Nb.l
;
; Nb = CountString(Sequence$, ",")
;
; If Nb + 1 <> ListSize(*Neurone\PoidsEntree())
; ProcedureReturn 0 ; pas de calcul
; EndIf
;
; SortieObtenue = - *Neurone\Seuil
; ForEach *Neurone\PoidsEntree()
; SortieObtenue = SortieObtenue + *Neurone\PoidsEntree() * Val(StringField(Sequence$, ListIndex(*Neurone\PoidsEntree()) + 1, ","))
; Next
;
; If SortieObtenue > 0
; ProcedureReturn 1
; Else
; ProcedureReturn -1
; EndIf
; EndProcedure
;
;}
Procedure.i CreationMemoireAssociative(NombreNeurones, NombreEntreeParNeurone, *NouvelleMemoireAssociative.MemoireAssociative = 0)
Protected i, IS_memory.b
If *NouvelleMemoireAssociative = 0
*NouvelleMemoireAssociative = AllocateMemory(SizeOf(MemoireAssociative))
IS_memory = #True
EndIf
InitializeStructure(*NouvelleMemoireAssociative, MemoireAssociative)
*NouvelleMemoireAssociative\IS_Memory = IS_memory
For i = 1 To NombreNeurones
AddElement(*NouvelleMemoireAssociative\Neurone())
CreationNeurone(NombreEntreeParNeurone, 0, #False, *NouvelleMemoireAssociative\Neurone())
Next
Message("Memoire Associative Créée - " + Str(NombreNeurones) + " Neurones à " + Str(NombreEntreeParNeurone) + " Entrées")
ProcedureReturn *NouvelleMemoireAssociative
EndProcedure
Procedure FreeMemoireAssociative(*MemoireAssociative.MemoireAssociative)
ForEach *MemoireAssociative\Neurone()
FreeNeurone(*MemoireAssociative\Neurone())
Next
FreeList(*MemoireAssociative\Neurone())
If *MemoireAssociative\IS_Memory
FreeMemory(*MemoireAssociative)
EndIf
EndProcedure
Procedure Apprentissage_MemoireAssociative(*MemoireAssociative.MemoireAssociative, *Base.BaseApprentissage, Pas_ModificationPoids.d = 0.2, CycleOut = 100)
Protected Erreur, Resultat.d, x_bool.b, entre_bool.b, Cycle.l, time, text$
Protected res.l ;, avant.d
FirstElement(*MemoireAssociative\Neurone())
If ListSize(*MemoireAssociative\Neurone()\PoidsEntree()) <> *base\NombreEntree
Message("ERREUR : Le nombre des entrées de la Base d'apprentissage n'est pas celui prévu pour cette mémoire.")
ProcedureReturn -1
EndIf
; initialisation des poids
ForEach *MemoireAssociative\Neurone()
ForEach *MemoireAssociative\Neurone()\PoidsEntree()
*MemoireAssociative\Neurone()\PoidsEntree() = 0 ; (-Random(20) + 10) / 100
Next
*MemoireAssociative\Neurone()\Seuil = 2
Next
Message("######## Début de l'apprentissage")
time = ElapsedMilliseconds()
Protected NewList erreur()
Repeat
Erreur = #False
Cycle + 1
If ElapsedMilliseconds() - time > 500
While WindowEvent() : Wend
time = ElapsedMilliseconds()
EndIf
Message("## Cycle : " + Str(Cycle))
ForEach *Base\Exemple()
Message("## # Exemple : " + Str(ListIndex(*Base\Exemple())))
ClearList(erreur())
ForEach *MemoireAssociative\Neurone()
; Message("## # # Neurone : " + Str(ListIndex(*MemoireAssociative\Neurone())))
Resultat = - *MemoireAssociative\Neurone()\Seuil
ResetList(*Base\Exemple()\Entree())
ForEach *MemoireAssociative\Neurone()\PoidsEntree()
NextElement(*Base\Exemple()\Entree())
Resultat = Resultat + *Base\Exemple()\Entree() * *MemoireAssociative\Neurone()\PoidsEntree()
Next
If Resultat > 0
x_bool = 1
Else
x_bool = -1
EndIf
; test du résultat par rapport à l'état voulu :
SelectElement(*base\Exemple()\Entree(), ListIndex(*MemoireAssociative\Neurone())) ; correspondance Neurone / Entrée
; Message("Etat = " + Str(x_bool) + " Sortie désirée = " + Str(entre_bool))
If x_bool <> *base\Exemple()\Entree() ; Erreur, on procède à la correction de la valeur des Poids
Erreur = #True
; Message("Correction")
AddElement(erreur())
erreur() = ListIndex(*MemoireAssociative\Neurone())
ResetList(*base\Exemple()\Entree())
ForEach *MemoireAssociative\Neurone()\PoidsEntree()
NextElement(*Base\Exemple()\Entree())
*MemoireAssociative\Neurone()\PoidsEntree() = *MemoireAssociative\Neurone()\PoidsEntree() - Pas_ModificationPoids * *Base\Exemple()\Entree() * x_bool
Next
EndIf
Next
text$ = ""
ForEach erreur()
text$ = text$ + ", " + Str(erreur())
Next
Message("Neurones corrigés : " + Mid(text$, 3, Len(text$)))
Next
Until Erreur = #False Or Cycle >= CycleOut
Message("######## Fin de l'apprentissage")
If erreur = #False
ProcedureReturn 0
EndIf
ProcedureReturn Cycle
EndProcedure
Procedure CalculReponse(*MemoireAssociative.MemoireAssociative, Image)
Protected x.l, y.l, Resultat.d, x_bool.b, Image_res
If IsImage(Image) = 0
Message("ERREUR Calcul Réponse : l'image n'est pas correctement initialisée")
ProcedureReturn -1
EndIf
FirstElement(*MemoireAssociative\Neurone())
If ListSize(*MemoireAssociative\Neurone()\PoidsEntree()) <> ImageWidth(Image) * ImageHeight(Image)
Message("ERREUR Calcul Réponse : Le nb d'entrée est différent du produit W*H de l'image")
ProcedureReturn -1
EndIf
Protected NewList Image()
If StartDrawing(ImageOutput(Image))
For x = 0 To ImageWidth(Image) - 1
For y = 0 To ImageHeight(Image) - 1
AddElement(Image())
If Point(x, y) = 0 ; noir
Image() = -1
Else
Image() = 1
EndIf
Next
Next
StopDrawing()
EndIf
Protected NewList Image_res()
ForEach *MemoireAssociative\Neurone()
; Message("## # # Neurone : " + Str(ListIndex(*MemoireAssociative\Neurone())))
Resultat = - *MemoireAssociative\Neurone()\Seuil
ResetList(Image())
ForEach *MemoireAssociative\Neurone()\PoidsEntree()
NextElement(Image())
Resultat = Resultat + Image() * *MemoireAssociative\Neurone()\PoidsEntree()
Next
If Resultat > 0
x_bool = 1
Else
x_bool = -1
EndIf
AddElement(Image_res())
Image_res() = x_bool
Next
Image_res = CreateImage(#PB_Any, ImageWidth(Image), ImageHeight(Image))
ResetList(Image_res())
StartDrawing(ImageOutput(Image_res))
For x = 0 To ImageWidth(Image) - 1
For y = 0 To ImageHeight(Image) - 1
NextElement(Image_res())
If Image_res() = -1 ; noir
Plot(x, y, 0)
Else
Plot(x, y, #White)
EndIf
Next
Next
StopDrawing()
ProcedureReturn Image_res
EndProcedure
;}
;{ procedure interface
Procedure ChargementImageDATA(file$); retourne le nb d'images chargées
Protected file_ID, nb, erreur, i, taille, *mem, img_ID, Nom$
file_ID = OpenFile(#PB_Any, file$)
If file_ID = 0
MessageRequester("Chargement des données Image", "Le fichier " + file$ + " n'a pu être ouvert." + #CR$ + "Rien n'a été chargé")
ProcedureReturn #False
EndIf
ClearGadgetItems(GD_ListIcon_0)
nb = ReadLong(file_ID)
For i = 1 To nb
taille = ReadLong(file_ID)
If taille = 0
erreur + 1
Else
*mem = AllocateMemory(taille, #PB_Memory_NoClear)
If *mem = 0
erreur + 1
Else
Nom$ = ReadString(file_ID)
ReadData(file_ID, *mem, taille)
img_ID = CatchImage(#PB_Any, *mem)
FreeMemory(*mem)
If img_ID = 0
erreur + 1
Else
AddGadgetItem(GD_ListIcon_0, -1, Nom$, ImageID(img_ID))
SetGadgetItemData(GD_ListIcon_0, CountGadgetItems(GD_ListIcon_0) - 1, img_ID)
EndIf
EndIf
EndIf
Next
CloseFile(file_ID)
ProcedureReturn nb - erreur
EndProcedure
Procedure SauvegardeImageDATA(file$)
Protected nb, file_ID, i, *mem, erreur, img
file_ID = CreateFile(#PB_Any, file$)
If file_ID = 0
MessageRequester("Sauvegarde des Données Images", "Impossible de créer le fichier" + #CR$ + file$)
ProcedureReturn #False
EndIf
; écriture du nb d'image
nb = CountGadgetItems(GD_ListIcon_0) - 1
WriteLong(file_ID, nb + 1)
For i = 0 To nb
img = GetGadgetItemData(GD_ListIcon_0, i)
If IsImage(img) = 0
erreur + 1
Else
*mem = EncodeImage(img, #PB_ImagePlugin_PNG)
If *mem = 0
erreur + 1
Else
WriteLong(file_ID, MemorySize(*mem))
WriteStringN(file_ID, GetGadgetItemText(GD_ListIcon_0, i))
WriteData(file_ID, *mem, MemorySize(*mem))
EndIf
EndIf
Next
; on tient compte des erreurs de sauvegarde possibles
FileSeek(file_ID, 0)
WriteLong(file_ID, nb + 1 - erreur)
CloseFile(file_ID)
ProcedureReturn nb + 1 - erreur
EndProcedure
Procedure MiseAJour_TailleCanvas(NePasToucherImage = #False)
Protected w, h, ratio.d, Canvas_0_w, Canvas_0_h
;{ taille et protections
w = Val(GetGadgetText(gd_string_2))
h = Val(GetGadgetText(GD_String_3))
If IsImage(IMG_canvas)
If w = Canvas_W And h = Canvas_H
ProcedureReturn #False
EndIf
EndIf
If w < 1 : w = 1 : EndIf
If h < 1 : h = 1 : EndIf
If w > 100 : w = 100 : EndIf
If h > 100 : h = 100 : EndIf
SetGadgetText(GD_String_2, Str(w))
SetGadgetText(GD_String_3, Str(h))
;}
ratio = w / h
Canvas_W = w
Canvas_H = h
If ratio > 1
Canvas_0_w = 220
Canvas_0_h = 220 / ratio
Else
Canvas_0_h = 220
Canvas_0_w = 220 * ratio
EndIf
Canvas_RATIO = Canvas_0_w / w
ResizeGadget(GD_Canvas_0, 340 + 110 - Canvas_0_w / 2, 50 + 110 - Canvas_0_h / 2, Canvas_0_w, Canvas_0_h)
If NePasToucherImage = #False
If IsImage(IMG_canvas)
FreeImage(IMG_canvas)
EndIf
IMG_canvas = CreateImage(#PB_Any, w, h)
StartDrawing(ImageOutput(IMG_canvas))
Box(0, 0, w, h, #White)
StopDrawing()
StartDrawing(CanvasOutput(GD_Canvas_0))
Box(0, 0, Canvas_0_w, Canvas_0_h, #White)
StopDrawing()
EndIf
EndProcedure
Procedure MiseAJour_ImageCanvas(image)
Protected x, y
If IsImage(image) = 0
ProcedureReturn #False
EndIf
SetGadgetText(GD_String_2, Str(ImageWidth(IMG_canvas)))
SetGadgetText(GD_String_3, Str(ImageHeight(IMG_canvas)))
MiseAJour_TailleCanvas(#True)
Protected Dim tableau(ImageWidth(image) - 1, ImageHeight(image) - 1)
StartDrawing(ImageOutput(image))
For x = 0 To ImageWidth(image) - 1
For y = 0 To ImageHeight(image) - 1
tableau(x, y) = Point(x, y)
Next
Next
StopDrawing()
StartDrawing(CanvasOutput(GD_Canvas_0))
For x = 0 To ImageWidth(image) - 1
For y = 0 To ImageHeight(image) - 1
Box(x * Canvas_RATIO, y * Canvas_RATIO, Round(Canvas_RATIO, #PB_Round_Up), Round(Canvas_RATIO, #PB_Round_Up), tableau(x, y))
Next
Next
StopDrawing()
EndProcedure
Procedure MiseAJour_DessinCanvas()
Protected mouse.POINT, color
If IsImage(IMG_canvas) = 0
MiseAJour_TailleCanvas()
EndIf
If GetGadgetAttribute(GD_Canvas_0, #PB_Canvas_Buttons) & #PB_Canvas_LeftButton = #PB_Canvas_LeftButton
color = 0
ElseIf GetGadgetAttribute(GD_Canvas_0, #PB_Canvas_Buttons) & #PB_Canvas_RightButton = #PB_Canvas_RightButton
color = #White
Else
ProcedureReturn #False
EndIf
mouse\x = GetGadgetAttribute(GD_Canvas_0, #PB_Canvas_MouseX)
mouse\y = GetGadgetAttribute(GD_Canvas_0, #PB_Canvas_MouseY)
; If mouse\x < 0 : mouse\x = 0 : EndIf
; If mouse\y < 0 : mouse\y = 0 : EndIf
; If mouse\x > GadgetWidth(GD_Canvas_0) : mouse\x = GadgetWidth(GD_Canvas_0) : EndIf
; If mouse\y > GadgetHeight(GD_Canvas_0) : mouse\y = GadgetHeight(GD_Canvas_0) : EndIf
mouse\x = Round(mouse\x / Canvas_RATIO, #PB_Round_Down)
mouse\y = Round(mouse\y / Canvas_RATIO, #PB_Round_Down)
If mouse\x >= ImageWidth(IMG_canvas) : mouse\x = ImageWidth(IMG_canvas) - 1: EndIf
If mouse\y >= ImageHeight(IMG_canvas) : mouse\y = ImageHeight(IMG_canvas) - 1 : EndIf
If StartDrawing(ImageOutput(IMG_canvas))
Plot(mouse\x, mouse\y, color)
StopDrawing()
EndIf
If StartDrawing(CanvasOutput(GD_Canvas_0))
Box(mouse\x * Canvas_RATIO, mouse\y * Canvas_RATIO, Round(Canvas_RATIO, #PB_Round_Up), Round(Canvas_RATIO, #PB_Round_Up), color)
; DrawImage(ImageID(IMG_canvas), 0, 0)
StopDrawing()
EndIf
ProcedureReturn #True
EndProcedure
Procedure MiseAJour_Image(Gadget, image, pos_x, pos_y, largeur_cote)
Protected x, y, image_old, ratio.d, Image_w, Image_h, RATIO_petit_grand.d
If IsImage(image) = 0
ProcedureReturn #False
EndIf
image_old = GetGadgetData(Gadget)
If IsImage(image_old)
FreeImage(image_old)
EndIf
Protected Dim tableau(ImageWidth(image) - 1, ImageHeight(image) - 1)
StartDrawing(ImageOutput(image))
For x = 0 To ImageWidth(image) - 1
For y = 0 To ImageHeight(image) - 1
tableau(x, y) = Point(x, y)
Next
Next
StopDrawing()
ratio = ImageWidth(image) / ImageHeight(image)
If ratio > 1
Image_w = largeur_cote
Image_h = largeur_cote / ratio
Else
Image_h = largeur_cote
Image_w = largeur_cote * ratio
EndIf
RATIO_petit_grand = Image_w / ImageWidth(image)
image_old = CreateImage(#PB_Any, Image_w, Image_h)
StartDrawing(ImageOutput(image_old))
For x = 0 To ImageWidth(image) - 1
For y = 0 To ImageHeight(image) - 1
Box(x * RATIO_petit_grand, y * RATIO_petit_grand, Round(RATIO_petit_grand, #PB_Round_Up), Round(RATIO_petit_grand, #PB_Round_Up), tableau(x, y))
Next
Next
StopDrawing()
SetGadgetData(Gadget, image_old)
SetGadgetState(Gadget, ImageID(image_old))
ResizeGadget(Gadget, pos_x + (largeur_cote - image_w) / 2, pos_y + (largeur_cote - image_h) / 2, #PB_Ignore, #PB_Ignore)
EndProcedure
DisableExplicit
;{ Fenêtre
Procedure OpenWD_Window_0()
WD_Window_0 = OpenWindow(#PB_Any, 0, 0, 690, 550, "Memoire Associative", #PB_Window_ScreenCentered | #PB_Window_SystemMenu)
GD_ListIcon_0 = ListIconGadget(#PB_Any, 10, 10, 110, 270, "Images", 50, #PB_ListIcon_AlwaysShowSelection)
GD_Frame3D_0 = Frame3DGadget(#PB_Any, 130, 0, 190, 140, "")
GD_Text_0 = TextGadget(#PB_Any, 140, 20, 90, 20, "Image soumise :")
GD_Image_0 = ImageGadget(#PB_Any, 260, 20, 50, 50, 0, #PB_Image_Border)
GD_Text_1 = TextGadget(#PB_Any, 140, 80, 90, 20, "Résultat :")
GD_Image_1 = ImageGadget(#PB_Any, 260, 80, 50, 50, 0, #PB_Image_Border)
GD_Frame3D_1 = Frame3DGadget(#PB_Any, 130, 140, 190, 140, "")
GD_Text_2 = TextGadget(#PB_Any, 140, 150, 170, 20, "Taille de l'info de sortie :")
GD_Text_3 = TextGadget(#PB_Any, 140, 173, 50, 20, "W x H =")
GD_String_0 = StringGadget(#PB_Any, 200, 170, 30, 20, "5", #PB_String_Numeric)
GD_Text_4 = TextGadget(#PB_Any, 240, 173, 10, 20, "x")
GD_String_1 = StringGadget(#PB_Any, 260, 170, 30, 20, "7", #PB_String_Numeric)
GD_Text_8 = TextGadget(#PB_Any, 140, 198, 50, 20, "Cycle Out")
GD_String_5 = StringGadget(#PB_Any, 200, 195, 30, 20, "20", #PB_String_Numeric)
GD_Text_9 = TextGadget(#PB_Any, 240, 198, 10, 20, "µ")
GD_String_6 = StringGadget(#PB_Any, 260, 195, 30, 20, "0.2")
GD_Button_0 = ButtonGadget(#PB_Any, 140, 250, 170, 20, "Effectuer l'apprentissage")
GD_Button_1 = ButtonGadget(#PB_Any, 140, 220, 170, 20, "Redéfinir les neurones")
GD_Frame3D_2 = Frame3DGadget(#PB_Any, 330, 0, 350, 280, "")
GD_Text_7 = TextGadget(#PB_Any, 340, 20, 40, 20, "Nom :")
GD_String_4 = StringGadget(#PB_Any, 390, 20, 50, 20, "")
GD_Canvas_0 = CanvasGadget(#PB_Any, 340, 50, 220, 220, #PB_Canvas_ClipMouse)
GD_Text_5 = TextGadget(#PB_Any, 520, 20, 50, 20, "W x H =")
GD_String_2 = StringGadget(#PB_Any, 580, 20, 30, 20, "5", #PB_String_Numeric)
GD_Text_6 = TextGadget(#PB_Any, 620, 20, 10, 20, "x")
GD_String_3 = StringGadget(#PB_Any, 640, 20, 30, 20, "7", #PB_String_Numeric)
GD_Button_2 = ButtonGadget(#PB_Any, 570, 50, 100, 20, "Soumettre")
GD_Button_3 = ButtonGadget(#PB_Any, 570, 80, 100, 40, "Enregistrer une nouvelle Image", #PB_Button_MultiLine)
GD_Button_4 = ButtonGadget(#PB_Any, 570, 130, 100, 50, "Enregistrer sur l'image sélectionnée", #PB_Button_MultiLine)
GD_Button_5 = ButtonGadget(#PB_Any, 570, 190, 100, 40, "Supprimer l'image sélectionnée", #PB_Button_MultiLine)
GD_Button_6 = ButtonGadget(#PB_Any, 570, 240, 100, 30, "Chargement auto", #PB_Button_MultiLine | #PB_Button_Toggle)
GD_Editor_0 = EditorGadget(#PB_Any, 10, 290, 670, WindowHeight(WD_Window_0) - 300)
AddKeyboardShortcut(WD_Window_0, #PB_Shortcut_Escape, 0)
AddKeyboardShortcut(WD_Window_0, #PB_Shortcut_Return, 1)
SetGadgetAttribute(GD_ListIcon_0, #PB_ListIcon_DisplayMode, #PB_ListIcon_DisplayMode)
SetGadgetState(GD_Button_6, #True)
MiseAJour_TailleCanvas()
EndProcedure
OpenWD_Window_0()
;}
;}
;{ chargement de la base de donnée des images
ChargementImageDATA("Image_DATA.img")
Nb = Val(GetGadgetText(GD_String_0)) * Val(GetGadgetText(GD_String_1))
*Memoire.MemoireAssociative = CreationMemoireAssociative(Nb, Nb)
;}
Repeat
event = WaitWindowEvent()
;{ gestion évènements
Select event
Case #PB_Event_Menu
;{ menus
Select EventMenu()
Case 0 ; Key_escape
event = #PB_Event_CloseWindow
Case 1 ; Key_Return
If GetActiveGadget() = GD_String_2 Or GetActiveGadget() = GD_String_3
MiseAJour_TailleCanvas()
EndIf
EndSelect
;}
;{ Gadgets
Case #PB_Event_Gadget
Select EventGadget()
Case GD_Button_3
;{ enregistrer une nouvelle image
If IsImage(IMG_canvas)
AddGadgetItem(GD_ListIcon_0, -1, GetGadgetText(GD_String_4), ImageID(IMG_canvas))
SetGadgetItemData(GD_ListIcon_0, CountGadgetItems(GD_ListIcon_0) - 1, IMG_canvas)
IMG_canvas = 0
MiseAJour_TailleCanvas()
EndIf
;}
Case GD_Button_4
;{ enregistrer sur l'image sélectionnée, l'ancienne image est perdue
elem_selc = GetGadgetState(GD_ListIcon_0)
If elem_selc <> -1 And IsImage(IMG_canvas)
IMG_suppr = GetGadgetItemData(GD_ListIcon_0, elem_selc)
If IsImage(IMG_suppr)
FreeImage(IMG_suppr)
EndIf
SetGadgetItemText(GD_ListIcon_0, elem_selc, GetGadgetText(GD_ListIcon_0))
SetGadgetItemImage(GD_ListIcon_0, elem_selc, ImageID(IMG_canvas))
SetGadgetItemData(GD_ListIcon_0, elem_selc, IMG_canvas)
IMG_canvas = 0
MiseAJour_TailleCanvas()
EndIf
;}
Case GD_Button_5
;{ supprimer l'image sélectionnée
elem_selc = GetGadgetState(GD_ListIcon_0)
If elem_selc <> -1
IMG_suppr = GetGadgetItemData(GD_ListIcon_0, elem_selc)
If IsImage(img_suppr)
FreeImage(IMG_suppr)
EndIf
RemoveGadgetItem(GD_ListIcon_0, elem_selc)
EndIf
;}
Case GD_ListIcon_0
;{ Chargement d'une image par clic sur la ListIcon
If GetGadgetState(GD_Button_6) = #True
; chargement dans le panneau de modification
elem_selc = GetGadgetState(GD_ListIcon_0)
If elem_selc <> -1
If IsImage(IMG_canvas)
FreeImage(IMG_canvas)
EndIf
IMG_canvas = GetGadgetItemData(GD_ListIcon_0, elem_selc)
IMG_canvas = CopyImage(IMG_canvas, #PB_Any)
SetGadgetText(GD_String_4, GetGadgetItemText(GD_ListIcon_0, elem_selc))
; dessin de l'image dans le canvas
MiseAJour_ImageCanvas(IMG_canvas)
EndIf
EndIf
;}
Case GD_String_2, GD_String_3
;{ Modification de la taille du canvas
If EventType() = #PB_EventType_LostFocus
MiseAJour_TailleCanvas()
EndIf
;}
Case GD_Canvas_0
;{ dessin sur le canvas
MiseAJour_DessinCanvas()
;}
Case GD_Button_1
;{ Redéfinir les neurones
If *Memoire
FreeMemoireAssociative(*Memoire)
EndIf
Nb = Val(GetGadgetText(GD_String_0)) * Val(GetGadgetText(GD_String_1))
*Memoire = CreationMemoireAssociative(Nb, Nb)
;}
Case GD_Button_0
;{ Effectuer l'apprentissage
If CountGadgetItems(GD_ListIcon_0) = 0
MessageRequester("Attention", "Base d'Image vide")
Else
IMG_premierItem = GetGadgetItemData(GD_ListIcon_0, 0)
If IsImage(IMG_premierItem)
; création de la base d'apprentissage
*Base.BaseApprentissage = CreationBaseApprentissage(ImageWidth(IMG_premierItem) * ImageHeight(IMG_premierItem))
Message("Base d'apprentissage créée")
; ajout des exemples, ils doivent avoir la même dimension que la première image, sinon, ils ne seront pas ajoutés
image_ajoutee = 0
For i = 0 To CountGadgetItems(GD_ListIcon_0) - 1
IMG_select = GetGadgetItemData(GD_ListIcon_0, i)
If IsImage(IMG_select) And ImageWidth(IMG_premierItem) = ImageWidth(IMG_select) And ImageHeight(IMG_premierItem) = ImageHeight(IMG_select) And Ajout_Exemple_Apprentissage(*Base, IMG_select)
image_ajoutee + 1
EndIf
Next
Message(Str(image_ajoutee) + " images de " + Str(ImageWidth(IMG_premierItem)) + " x "+ Str(ImageHeight(IMG_premierItem)) + " ajoutées à la Base d'apprentissage")
; Lancement de l'apprentissage :
CycleOut = Val(GetGadgetText(GD_String_5))
Mu.d = ValD(GetGadgetText(GD_String_6))
If Mu = 0 : Mu = 0.2 : SetGadgetText(GD_String_6, StrD(Mu)) : EndIf
res = Apprentissage_MemoireAssociative(*Memoire, *Base, Mu, CycleOut)
Select res
Case -1
Message("Apprentissage Echoué - Non correspondance entre le nombre d'entrée de la base et de la mémoire")
Case 0
Message("Apprentissage Réussi")
Default
Message("Apprentissage Impossible - " + Str(res) + " Cycles")
EndSelect
FreeBaseApprentissage(*Base)
Message("Base d'apprentissage libérée")
EndIf
EndIf
;}
Case GD_Button_2
;{ Soumettre une image
If IsImage(IMG_resultat)
FreeImage(IMG_resultat)
EndIf
If IsImage(IMG_canvas)
Message("Nouvelle image soumise à la mémoire")
MiseAJour_Image(GD_Image_0, IMG_canvas, 260, 20, 50)
IMG_resultat = CalculReponse(*Memoire, IMG_canvas)
If IsImage(IMG_resultat)
MiseAJour_Image(GD_Image_1, IMG_resultat, 260, 80, 50)
EndIf
EndIf
;}
EndSelect
;}
EndSelect
;}
Until event = #PB_Event_CloseWindow
;{ sauvegarde des données images
SauvegardeImageDATA("Image_DATA.img")
;}
End
; Début du test
;{ Test 1
; ; création de la base d'exemple
; *Base.BaseApprentissage = CreationBaseApprentissage(4)
;
; ; ajout des exemples dans la base :
; Ajout_Exemple_Apprentissage(*Base, "1,-1,1,-1,1")
; Ajout_Exemple_Apprentissage(*Base, "1,1,1,1,1")
; Ajout_Exemple_Apprentissage(*Base, "1,1,1,-1,-1")
; Ajout_Exemple_Apprentissage(*Base, "1,-1,-1,1,-1")
;
;
; ; création du neurone
; *Neurone.Neurone = CreationNeurone(4, 0.1, #False)
;
; ; Apprentissage
; If Apprentissage(*Neurone, *Base, 0.1) = #False
; Debug ""
; Debug "Aucune solution n'a été trouvée."
; EndIf
;
;
; ; Affichage des résultats (poids) :
; Debug ""
; Debug "Résultats"
; ForEach *Neurone\PoidsEntree()
; Debug "w" + Str(ListIndex(*Neurone\PoidsEntree())+1) + " = " + *Neurone\PoidsEntree()
; Next
; Debug "Seuil = " + *Neurone\Seuil
;}
