interface graphique, réseau de neurones

**korp69** · 10/11/2006, 22h48

Bonjour à tous
Je suis étudiant en sciences cognitives et l'informatique n'est à vrai dire pas ma spécialité.
Je suis actuellement sur la réalisation d'un réseau de neurones simple pour la reconnaissance de chiffre. Pour cela j'ai besoin de représenter une grille de 6*6. Chaque case ayant une valeur binaire (noir ou blanc), être numérotée, et reliée à un neurone d'entrée.
Comment puis je réaliser cette simple manip ?
Merci de m'aider c'est assez urgent.

**millie** · 10/11/2006, 22h58

Il te faut créer une structure pour chaque case :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
struct Fautluitrouverunnom
{
  bool couleur;
  int numero;
  Neurone* neurone; //le neurone auquel il est relié
};
 
//Si tu es sûr que ça sera toujours de taille 6,6
//Tu déclares 
 
Fautluitrouverunom grille[6][6];
grille[0][1].couleur = true; //accès aux champs

Tu peux également utiliser std::vector pour faire le tableau.

PS : j'ai fait une version assez simple puisque tu n'as peut être pas le temps d'apprendre des choses complexes en C++

**korp69** · 10/11/2006, 23h09

merci pour cette reponse rapide
ça me fait chaud au coeur

Comment puis je à partir de ces structures representer cette grille ?
genre dessin de grille, avec des cases, des lignes et tout et tout. Et que quand je change la valeur du bool ça change graphiquement la couleur ?

**millie** · 10/11/2006, 23h17

La, c'est un peu plus compliqué, il faut trouver une bibliothèque graphique pour faire cela.

Pour faire des tracer de droite, de point, je connais Glut (mais va te demander malheureusement un peu d'apprentissage). Il existe peut être des bibliothèques encore plus simple pour faire des choses tout simple, mais je ne connais pas

Si tu ne souhaites pas quelque chose en temps réel (par exemple si ce n'est qu'une image) que tu souhaites visualiser. Tu peux exporter directement ce que tu souhaites au format PGM (format de dessin très simple à utiliser qui se gère pixel par pixel). Mais je pense que tu souhaites tout de même gérer du temps réel.

**millie** · 10/11/2006, 23h19

Au format PGM, tu peux avoir quelque chose du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
ofstream filePGM("fichier.ppm");
 
filePGM << "P2" << endl <<6 << " " << 6 << endl << "255 " << endl;
 
  for(int i=0;i<6;i++)
   for(int j=0;j<6;j++)
    {
      if(grille[i][j].couleur)
    	 filePGM << 255 << " ";
      else
         filePGM << 0 << " ";
   } 
  filePGM.close();

Mais ce n'est pas temps réel

**korp69** · 10/11/2006, 23h30

Dans ce cas précis pas necessairement besoin de temps réél. Sinon problème de rafraichissement du réseau delicate surtout dans un réseau bouclé
mais quelle rapidité !

ofstream filePGM("fichier.ppm");

filePGM << "P2" << endl <<6 << " " << 6 << endl << "255 " << endl;

c'est quoi ces deux lignes ?

**korp69** · 10/11/2006, 23h38

merci pour ces pistes je crois que j'ai de quoi bien commencer

**millie** · 11/11/2006, 10h27

Je me sens l'ame généreuse aujourd'hui :

Envoyé par korp69

ofstream filePGM("fichier.ppm");

filePGM << "P2" << endl <<6 << " " << 6 << endl << "255 " << endl;

c'est quoi ces deux lignes ?

Je te le dis pour ta culture générale, mais je vais te proposer une autre méthode avec GLUT qui te permettra de faire du temps réel.

P2, c'est dans l'entête du fichier, cela correspond à une image noir et blanc en mode ASCII de type PGM.
6 c'est la largeur puis la longueur et 255 c'est le maximum de couleur (donc 255=blanc)

Je te propose un code avec GLUT pour faire cela, cherches un peu des tutoriels dessus si tu ne comprends pas tout.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
 
#include <GL/glut.h>
 
////// Ta grille doit être définit quelque part, elle se nommera grille
 
using namespace std;
 
static int win_x = 60; //taille de ta fenetre horizontale
static int win_y = 60; //taille verticale
 
 
float booltofloat(bool b)
{
 if(b)
  return 1.0f;
 else
  return 0.0f;
}
 
static void dessineGrille ()
{
	int i, j;
	float x, y, d00, d01, d10, d11;
 
        float N = 6.0f; //taille du tableau hor
        float M = 6.0f; //vert
	float hx = 1.0f/6.0f;
	float hy = 1.0f/6.0f;
 
   //on commence le dessin
 //il y a peut être d'autre moyen que d'utiliser GL_QUADS, mais je ne connais pas énormement
	glBegin ( GL_QUADS );
 
		for ( i=0 ; i<6 ; i++ ) {
			x = (i-0.5f)*hx;
			for ( j=0 ; j<6 ; j++ ) {
				y = (j-0.5f)*hy;
 
				d00 = booltofloat(grille[i][j].couleur);//pour avoir quelque chose d'uniforme
				d01 = booltofloat(grille[i][j].couleur);
				d10 = booltofloat(grille[i][j].couleur);
				d11 = booltofloat(grille[i][j].couleur);
 
				glColor3f ( d00, d00, d00 ); 
                                 glVertex2f ( x, y );
				glColor3f ( d10, d10, d10 ); 
                                 glVertex2f ( x+hx, y );
				glColor3f ( d11, d11, d11 ); 
                                 glVertex2f ( x+hx, y+hy );
				glColor3f ( d01/2, d01/2, d01 ); 
                                 glVertex2f ( x, y+hy );
			}
		}
 
	glEnd ();
}
 
static void getMouvement ()
{
 
}
 
 
 
static void affichageCommence ( void )
{
	glViewport ( 0, 0, win_x, win_y );
	glMatrixMode ( GL_PROJECTION );
	glLoadIdentity ();
	gluOrtho2D ( 0.0, 1.0, 0.0, 1.0 );
	glClearColor ( 0.0f, 0.0f, 0.0f, 1.0f );
	glClear ( GL_COLOR_BUFFER_BIT );
}
 
static void affichageTermine ( void )
{
	glutSwapBuffers ();
}
 
 
 
 
 
static void floglutClavier (unsigned char key, int x, int y )
{
 
	switch ( key )
	{
 
		case 'q':
		case 'Q':
 
			exit ( 0 );
			break;
 
	}
}
 
static void floglutMouse ( int button, int state, int x, int y )
{
	omx = mx = x;
	omx = my = y;
 
	mouse_down[button] = state == GLUT_DOWN;
}
 
static void floglutMouvementSouris ( int x, int y )
{
	mx = x;
	my = y;
}
 
static void floglutRedimensionnement ( int width, int height )
{
	glutSetWindow ( win_id );
	glutReshapeWindow ( width, height );
 
	win_x = width;
	win_y = height;
}
 
 
 
 
 
 
static void floglutPrincipal ()
{
	getMouvement ();
 
	glutSetWindow ( win_id );
	glutPostRedisplay ();
}
 
static void floglutAffiche ()
{
	affichageCommence();
 
       dessineGrille();
 
 
	affichageTermine ();
}
 
 
 
void fonctionalancer ()
{
 
 
	glutInitDisplayMode ( GLUT_RGBA | GLUT_DOUBLE);
 
	glutInitWindowPosition ( 0, 0 );
	glutInitWindowSize ( win_x, win_y );
	win_id = glutCreateWindow ( "millie" );
 
	glClearColor ( 0.0f, 0.0f, 0.0f, 1.0f );
	glClear ( GL_COLOR_BUFFER_BIT );
	glutSwapBuffers ();
	glClear ( GL_COLOR_BUFFER_BIT );
	glutSwapBuffers ();
 
 
	glutKeyboardFunc ( floglutClavier );
	glutMouseFunc ( floglutMouse );
	glutMotionFunc ( floglutMouvementSouris );
	glutReshapeFunc ( floglutRedimensionnement );
	glutIdleFunc ( floglutPrincipal );
	glutDisplayFunc ( floglutAffiche );
}

Bon, j'ai un peu fait ça vite fait. Mais ça te donner une idée de la chose. C'est plus complexe avec GLUT.

EDIT : Si tu n'es pas très bon en informatique et que tu souhaites avoir des résultats rapide, peut être qu'il te sera plus pratique de prendre un autre langage

**korp69** · 11/11/2006, 11h03

MERCI, même si franchement ta demonstration sort nettement de mon domaine de competence, je suppose à priori que la clé de mes soucis ce situe par là. Je vais donc creuser dans cette direction. Il me reste encore quelques temps pour approfondir la théorie. Je vais donc m'atteler à comprendre Glut ou openGL, je suppose que c'est pareil, et à l'utiliser. En tout cas merci. Maintenant je vais devoir apprendre à incorporer cette bibliothèque dans mon vieux devCpp, puis à l'utiliser.
Merci pour tes reponses. A bientôt

**korp69** · 11/11/2006, 11h08

En parlant d'autre langage
mon prof m'a filé matlab
il me dit que c'est tres bien et tout et tout.
Mais des tutoriels sur matlab, genre matlab pour les nuls, y'en a pas des masses. Du coup je pensais le faire en C ou C++, le langage que je manie le mieux.

**Matthieu Brucher** · 11/11/2006, 11h34

Envoyé par korp69

merci pour cette reponse rapide
ça me fait chaud au coeur

Comment puis je à partir de ces structures representer cette grille ?
genre dessin de grille, avec des cases, des lignes et tout et tout. Et que quand je change la valeur du bool ça change graphiquement la couleur ?

Si tu es débutant etq ue tu n'as pas le temps, tu n'y arriveras pas. Gérer une bibliothèque graphique, ça prend beaucoup de temps.

Envoyé par korp69

MERCI, même si franchement ta demonstration sort nettement de mon domaine de competence, je suppose à priori que la clé de mes soucis ce situe par là. Je vais donc creuser dans cette direction. Il me reste encore quelques temps pour approfondir la théorie. Je vais donc m'atteler à comprendre Glut ou openGL, je suppose que c'est pareil, et à l'utiliser. En tout cas merci. Maintenant je vais devoir apprendre à incorporer cette bibliothèque dans mon vieux devCpp, puis à l'utiliser.
Merci pour tes reponses. A bientôt

Glut est une surcouche d'OpenGL.

Envoyé par korp69

En parlant d'autre langage
mon prof m'a filé matlab
il me dit que c'est tres bien et tout et tout.
Mais des tutoriels sur matlab, genre matlab pour les nuls, y'en a pas des masses. Du coup je pensais le faire en C ou C++, le langage que je manie le mieux.

Ouh là... Si tu manies aussi bien le C ou le C++ que ça, tu vas avoir du mal.
Franchement, garde MatLab, en plus il y a des ToolBox gratuites pour les réseaux de neurones.

**JolyLoic** · 11/11/2006, 11h37

Les deux ne sont pas au même niveau. Matlab est très bien pour prototyper des calculs, et livré (si on achète les 100 000 packs supplémentaires disponibles) avec des bibliothèque couvrant tous les domaines des maths numériques et de la physique (et par exemple... les réseaux de neurone, http://www.mathworks.com/products/neuralnet/), et a une syntaxe où tout est fait pour simplifier l'utilisation des matrices.

Le C++ est un langage plus générique, très bien pour réaliser des applications complètes, conçu pour être capable de gérer de grosses applications.

**dedesite** · 11/11/2006, 14h50

Salut tout le monde,

J'aide un peu korp69 a faire son programme car on est dans la même classe et vu ce qu'il doit faire, je pense que l'utilisation de fichiers PGM est recommendable. Comme ça il ne se perdera pas avec du code inutile d'interface, puis c'est peut-être plus facile de faire des "figure" avec un logiciel de type paint ou autre que dans un programme fait main.

J'ai donc regarder le code que tu as fournis Miles :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
ofstream filePGM("fichier.ppm");
 
filePGM << "P2" << endl <<6 << " " << 6 << endl << "255 " << endl;
 
  for(int i=0;i<6;i++)
   for(int j=0;j<6;j++)
    {
      if(grille[i][j])
    	 filePGM << 255 << " ";
      else
         filePGM << 0 << " ";
   } 
  filePGM.close();

Et je dois que je comprend pas bien ce que tu veux lui faire faire.
Il faut savoir que c'est l'image .pgm qui va renseigner les données de la grilles, donc déjà on ne peux pas faire if(grille[i][j].couleur) s'il y'a rien dedans.
En fait il faudrait pouvoir lire chaque chiffres du fichier pgm et si c'est 255 on met true à la couleur correspondante dans la grille, si c'est 0 on met false.

J'y arriverai sans problème si on avait un tableau, mais je dois dire que je ne suis pas du tout famillier avec les lecture de fichier et l'utilisation du "<<". Je sais c'est du C++, je devrais connaitre ça... Moi j'aime tout ce qui est simple et haut-niveau donc je connais pas très bien désolé.

Si quelqu'un pouvait expliquez comment faire? merci.

Sinon je crois qu'on va se débrouillé avec des tableaux de 1 et de 0 (remplit a la mano) pour si peux de case...

Merci, A+
dede

Invité · 11/11/2006, 15h17

Le code de millie ne sert pas à lire la grille depuis un fichier mais à l'y écrire. S'il s'agit de lecture, il faut utiliser std::ifstream et non std::ofstream, et l'opérateur >> à la place de << dans l'autre ligne.
Tu peux faire un truc de ce genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include <fstream>
 
class CGrille {
    class CCase {
    public:
        bool m_bEtat;
    };
 
    CCase *m_Cases;
    int m_iX, m_iY;
 
public:
    CGrille(int x, int y)
      : m_iX(x), m_iY(y)
    {
        m_Cases = new CCase[x*y];
    }
 
    void setCase(int x, int y, bool bEtat)
    {
        m_Cases[y*m_iX + x].m_bEtat = bEtat;
    }
 
    bool getCase(int x, int y)
    {
        return m_Cases[y*m_iX + x].m_bEtat;
    }
};
 
int main()
{
    std::ifstream fichier("entree.txt", std::ios::in);
 
    CGrille grille(6, 6);
 
    int y, x;
    for(y = 0; y < 6; y++)
    {
        for(x = 0; x < 6; x++)
        {
            int nb;
            fichier>>nb;
            if(nb)
                grille.setCase(x, y, true);
            else
                grille.setCase(x, y, false);
        }
    }
 
    // Traitement de la grille
 
    fichier.close();
 
    return 0;
}

**dedesite** · 11/11/2006, 15h32

Oué merci remram44, j'ai finalement fait un truc dans ce genre

.
A+
dede

**millie** · 11/11/2006, 15h47

Envoyé par dedesite

J'ai donc regarder le code que tu as fournis Miles :

Heu, c'était moi

, enfin, bref.

Effectivement, remram44 avait raison, j'ai donné une possibilité pour écrire dans un fichier son tableau. Je n'ai jamais dit que c'était pour une lecture... La méthode de remram44 est bonne pour la lecture en tout cas, et fournit une classe. (je n'avais mis qu'une structure car je ne savais pas quel était votre niveau)

**korp69** · 11/11/2006, 17h31

Merci à tous pour vos reponses
je ne sais toujours pas comment faire
mais je cherche

Invité · 11/11/2006, 18h11

Envoyé par korp69

je ne sais toujours pas comment faire

Hmm dedesite dit qu'il travaille avec toi et qu'il a "fait un truc dans le genre".

Qu'est-ce que tu ne comprends pas plus précisément ? N'hésite pas à demander

**dedesite** · 12/11/2006, 15h24

Hmm dedesite dit qu'il travaille avec toi et qu'il a "fait un truc dans le genre".

Qu'est-ce que tu ne comprends pas plus précisément ? N'hésite pas à demander

En effet, j'avais fait un truc dans le genre mais sans les classes car j'essayais de faire quelquechose de pas trop complexe vu que la complexité de ce genre de programme se situe plutot dans le reseau de neuronne.
J'ai bossé avec lui par internet mais j'ai pas eu le temps de bien faire malheureusement.

Mais korp, ce que je t'ai donné marchait pas? T'arrivais pas a ouvrir le fichier texte comme moi?

A+

dede

**korp69** · 13/11/2006, 13h44

J'ai essayé de me mettre à openGl pour me faire une grille mais c'est chaud, en plus mon dev c++, il est bien pourri et la compilation marche une fois sur 2, et encore.
Du coup je vais pas m'emmerder, je vais le faire avec des tableaux et tant pis pour l'interface. Néanmoins si quelqu'un est motiver pour me pondre une grille 6*6 en openGl avec quand on clique dans une case elle change de couleur (blanc vers noir) et la valeur bool passe de false à true. ça serait nikel.
Merci à tous. A bientôt

interface graphique, réseau de neurones

C++

Discussions similaires

Partager

Partager