Ministère de l'enseignement supérieur

et de la recherche Scientifique
Université de Gabes Département Génie Electrique -Automatique
Ecole Nationale d'Ingénieurs de Gabès
Année universitaire : 2022-2023

Rapport de projet tutoré

Présenté par:

L’Ecole Nationale d'Ingénieurs de Gabès

Département Génie Electrique -Automatique

Réalisé par :

Kouraichi Zeineb
Saad Ghada
GEA 2 A

Reconnaissance de chiffres à l’aide de CNN pour l’ensemble

de données MNIST

photovoltaïques

photovoltaïques Encadrant :
Ms Zaied Mourad
photovoltaïques
1
 REMERCIEMENT

A travers ces lignes, nous tenons à remercier tous les employés, cadres et dirigeants de l'école National
d'Ingénieur de Gabes pour leur assistance et encadrement durant ce projet. Nous profitons cette occasion
aussi pour reconnaître les efforts de ceux qui nous ont aidé à effectuer notre rapport de projet dans la
bonne condition : Notre encadreur Ms Zaied Mourad qui nous a beaucoup soutenu. Ainsi que tous les
responsables qui nous ont supporté durant cette période

2
 Résumé

La reconnaissance de chiffres manuscrits présente un défi très grand et joue un rôle

très important dans le monde actuel pour rendre les machines capables de connaitre
comme un homme et capable de résoudre des problèmes complexes tel que la
reconnaissance de chiffres du (chèque bancaire, relevé des compteurs d’électricité,
gaz et eau, etc.…). Les travaux de ce mémoire s’inscrivent dans le cadre de la
reconnaissance automatique des chiffres manuscrits. L’approche proposée consiste à
utiliser un CNN pour reconnaitre les chiffres en utilisant la base MNIST. Notre
modèle a été entrainé avec succès avec un taux de reconnaissance qui vaut 98,83%.

Mots clés : Reconnaissance de chiffres, CNN, Python, Apprentissage profond.

3
 Abstract

Recognition of handwritten digits presents a very big challenge and plays a very
important role in today's world to make machines able to know like a man and able to
solve complex problems such as the recognition of digits from (bank check, statement
of electricity, gas and water …). The work of this thesis is part of the automatic
recognition of handwritten digits. The proposed approach consists of using the CNN
to recognize digits using the MNIST database. our model has been successfully
trained with an accuracy rate of 98,83%.

Keywords: digit recognition, CNN, Python, deep learning

i
 Sommaire

Introduction générale …………………………………………………………………………6

I. Introductions et définitions …………………………………………………………..6

1) Présentation du projet …………………………………………………………7
2) Objectifs ………………………………………………………………………..7
3) Description de l’ensemble de données MNIST ……………………………….7
4) CNN ………………………………………………………………………….8
5) Justification du choix de CNN ………………………………………………...8
II. Implémentation et résultats expérimentaux ………………………………………….9
1) Language de programmation uitlisées ………………….……………………..9
2) Importation des bibliothèques nécéssaires ……………………………………9
3) Importation des données de l’entrainement et de test et préparation des données 11
4) Création du modèle et résultats expérimentales ……………………………….15
III. Interface graphique ……………………………………………………………………..20
Conclusion générale …………………………………………………………………......23
Bibliographie …………………………………………………………………………….24

5
 Introduction générale
Depuis la fin des années soixante, des travaux intensifs sont été accomplis dans le domaine de la
reconnaissance de l’écriture. En effet, des systèmes commerciaux sont aujourd’hui indisponibles,
particulièrement pour la poste (lecture les chiffres des chèques, tri postale) et dans les banques (traitement
des chèques, des factures).

À l’heure actuelle, les recherches s’orientent vers l’interprétation de l’écriture manuscrite.

Dans ce mémoire, nous nous intéressées à la reconnaissance des chiffres manuscrits avec le CNN qui reste
aujourd'hui un thème de recherche ouvert. En effet, bien que le nombre de classes naturel les soit très réduit
(chiffres '0' à '9'), on trouve à l'intérieur de chacune d'entre elles, une très grande de variabilité de l'écriture,
de plus, les conditions souvent relativement précaires dans les quelles sont écrits les chiffres (chèques écrits
rapidement sur un coin de table) et la variabilité du matériel utilisé (utilisation de divers stylos, de
différentes qualités de papier) tendent à compliquer la reconnaissance.

Un réseau de neurone convolutifs (ou réseau de neurones à convolution, ou CNN ou ConvNet) est un type
de réseau de neurones artificiels acycliques dans lequel le motif de connexion entre les neurones est
inspiré par le cortex visuel des animaux. Les neurones de cette région du cerveau sont arrangés de sorte à
ce qu'ils correspondent à des régions qui se chevauchent lors du pavage du champ visuel. Leur
fonctionnement est inspiré par les processus biologiques, ils consistent en un empilage multi couche de
perceptrons, dont le but est de prétraiter de petites quantités d'informations.

Les réseaux neuronaux convolutifs ont de larges applications dans la reconnaissance d'image et vidéo, les
systèmes de recommandation et le traitement du langage naturel. Dans un réseau de neurones convolutif
CNN), les couches sont disposées dans une matrice 3D (coordonnée sur l'axe des X, coordonnée sur l'axe

6
des Y et couleur). En conséquence, un nœud de la couche cachée ne serait connecté qu'à une petite région
située au voisinage de la couche d'entrée correspondante, ce qui rendrait le processus beaucoup plus
efficace qu'un réseau de neurones traditionnel.

Nous allons utiliser la base de données MNIST de chiffres . Nous allons former les données sur le kit
d’entraînement (données d’apprentissage) et valider les résultats en fonction des données de test.

I.Introduction et definitions :
1. Presentation du projet :

En partant de la reconnaissance de formes qui est une branche de l’intelligence artificielle qui fait appel

aux techniques d’apprentissage automatique et à diverses techniques mathématiques. Elle peut être définie
comme un ensemble de méthodes visant à identifier des objets à partir de données brutes caractérisées ou
des paramètres.

Dans ce context , la reconnaissance de chiffres est une tâche essentielle dans le domaine de la vision par
ordinateur. Elle trouve des applications dans divers domaines tels que la numérisation de documents, la
lecture automatique de chèques, la classification d'écriture manuscrite, etc. Dans ce projet, nous nous
concentrons sur la reconnaissance de chiffres à l'aide de réseaux de neurones convolutifs (CNN), une
approche puissante et largement utilisée pour le traitement des images. Notre objectif est d'explorer
l'ensemble de données MNIST, un jeu de données classique largement utilisé dans la communauté de
l'apprentissage automatique, afin de développer un modèle de CNN performant pour la reconnaissance
précise des chiffres.

2. Objectifs :
 Comprendre comment l'apprentissage profond peut résoudre des problèmes que les méthodes de
programmation traditionnelles ne peuvent pas.
 En savoir plus sur le jeu de données de chiffres manuscrits MNIST
 Utilisez l'API Keras pour charger le jeu de données MNIST et le préparer pour la formation.
 Créer un réseau neuronal simple pour effectuer la prediction des chiffres.
 Entraînez le réseau neuronal en utilisant le jeu de données MNIST prepare
 Observer la performance du réseau neuronal formé.

3. Description de l'ensemble de données MNIST:

7
 L'ensemble de données MNIST (La base de données MNIST pour Modified ou Mixed National
Institute of Standards and Technology), est une base de données de chiffres écrits à la main. C'est un jeu de
données très utilisé en apprentissage automatique),c’est une collection d'images de chiffres manuscrits en
noir et blanc, avec des étiquettes correspondantes, largement utilisée
pour l'évaluation et le développement d'algorithmes de
reconnaissance de chiffres. Il comprend 60 000 images
d'apprentissage et 10 000 images de test, chacune de taille 28x28
pixels. Les chiffres vont de 0 à 9, ce qui donne 10 classes au total.
L'ensemble de données est réparti de manière équilibrée avec 6 000
Figure1 : une image de MNIST dataset

images par classe dans l'ensemble d'apprentissage et 1 000 images par classe dans l'ensemble de test.

MNIST est populaire en raison de sa taille gérable, de sa simplicité et de son utilisation comme référence
pour la classification d'images, en particulier les réseaux de neurones convolutifs (CNN). Il est largement
disponible et utilisé dans la communauté de l'apprentissage automatique. [1]

Figure2 : tableau de la répartition de MNIST pour les chiffres

Figure3 : exemple de numéro 8 dans la base MNIST

8
 4. CNN (Convolutional Neural Networks):

Les réseaux de neurones convolutifs (CNN) sont une classe d'architectures de réseaux neuronaux utilisées
principalement pour le traitement d'images. Ils sont caractérisés par l'utilisation de couches de convolution
qui permettent d'extraire automatiquement des caractéristiques pertinentes à partir des données d'entrée.
Les CNN sont capables de capturer les motifs locaux et les relations spatiales dans une image, ce qui les
rend particulièrement efficaces pour des tâches telles que la reconnaissance d'objets, la détection de visages
et la segmentation d'images. Les couches de convolution sont souvent suivies de couches de pooling pour
réduire la dimensionnalité et de couches entièrement connectées pour la classification. Les CNN ont
révolutionné le domaine de la vision par ordinateur et ont obtenu des performances remarquables dans de
nombreuses applications. [2]

5. Justification du choix des CNN:

Les réseaux de neurones convolutifs (CNN) se sont révélés extrêmement efficaces dans le domaine de la
vision par ordinateur, notamment dans la reconnaissance d'images. Leur capacité à extraire
automatiquement des caractéristiques pertinentes à partir des données brutes en fait une approche idéale
pour la reconnaissance de chiffres. Les CNN sont capables de capturer des motifs complexes et de
modéliser les relations spatiales entre les pixels, ce qui est essentiel pour identifier et distinguer les chiffres
manuscrits.

II. Implémentation et résultats expérimentaux :

1) Langage de programmation utilisées :

Python :
Python est un langage de programmation de haut niveau utilisé pour la programmation générale.
Créé par Guido van Rossum et sorti en 1991, Python a une philosophie de conception qui met
l’accent sur la lisibilité du code, notamment en utilisant des espaces importants. Il combine un
pouvoir remarquable avec une syntaxe très claire. Il comporte des modules, des classes, des
exceptions, des types de données dynamiques de très haut niveau et le typage dynamique. Il existe
des interfaces vers de nombreux appels systèmes et bibliothèques, ainsi que vers différents systèmes
de fenêtrage. Les nouveaux modules intégrés sont faciles à écrire en C ou C ++ (ou dans d'autres
langages, selon l'implémentation choisie). Python est également utilisable comme langage
d'extension pour les applications écrites dans d'autres langages nécessitant des interfaces de script
ou d'automatisation facile à utiliser.

9
2) Importation des bibliothèques nécéssaires :

Les bibliothèques utilisées :

Python dispose de plusieurs bibliothèques et chaque bibliothèque a un travail spécifique, ce qui lui
rend un language très riche et très utilisé. Les bibliothèques utilisées dans ce travail sont :
Tensorflow, Keras. Numpy.

Tensorflow : Est une bibliothèque logicielle open source pour le calcul numérique de haute
performance. Son architecture flexible permet un déploiement facile du calcul sur diverses plates-
formes (CPUs, GPUs, TPUs), et des ordinateurs de bureau aux clusters de serveurs, aux
périphériques mobiles. Initialement développé par des chercheurs et des ingénieurs de l’équipe de
Google Brain au sein de l’organisation de l’IA de Google, il s’appuie sur l’apprentissage
automatique et l’apprentissage en profondeur.

Keras : C’est l’outil le plus utilisé en Python dans le monde pour l’apprentissage profond (Deep
Learning). Cette librairie open-source, créée par François Chollet, Permet de créer facilement et
rapidement des réseaux de neurones, en se basant sur les principaux frameWorks (Tensorflow,
Pytorch). Keras permet de diminuer de 30% le temps de développement d’un prototype de réseaux
de neurones).

Numpy: Est une bibliothèque permettant d’effectuer des calculs numériques avec Python. Elle
introduit une gestion facilitée des tableaux de nombres, des fonctions sophistiquées (diffusion), on
peut aussi l’intégrer le code C / C ++ et Fortran.[3]
Première étape (importation des bibliothèques):
- La première des choses à faire consiste tout d’abord à 10ossible10 l’environnement et installer
toutes les bibliothèques puis Importer les bibliothèques installées.
- Ensuite, nous allons importer le type de modèle 10ossible10s de Keras.
Il s’agit simplement d’un empilement linéaire de couches de réseaux de 10ossibl. Nous
importerons aussi les couches “principales” de Keras :
Dense : régulateur de couche, chaque couche reçoit une entré de chaque neurone de la couche
précédente.

10
“import numpy as np” : Cette ligne importe la bibliothèque NumPy, qui fournit des fonctionnalités
avancées pour la manipulation de tableaux multidimensionnels et des outils mathématiques.

“import pandas as pd” : Cette ligne importe la bibliothèque Pandas, qui 11ossi des structures de données
et des outils d’analyse de données 11ossible. Elle est souvent utilisée pour manipuler et analyser des
ensembles de données tabulaires.

“from sklearn import metrics” : Cette ligne importe le module “metrics” de la bibliothèque scikit-learn
(sklearn). Scikit-learn est une bibliothèque populaire d’apprentissage automatique qui fournit des outils
pour le prétraitement des données, la construction de modèles et l’évaluation des performances. Le module
“metrics” contient diverses 11ossible et métriques d’évaluation de modèle.

“import matplotlib.pyplot as plt” : Cette ligne importe la bibliothèque Matplotlib, qui est utilisée pour la
11ossible de graphiques et la 11ossible11s11on des données. La syntaxe “as plt” permet d’utiliser “plt”
comme un alias pour la bibliothèque, ce qui facilite l’appel des fonctions de Matplotlib.

“%matplotlib inline” : Cette ligne spécifie que les graphiques Matplotlib doivent être affichés directement
dans le notebook ou l’environnement de travail actuel, plutôt que dans une fenêtre externe. Cela permet
d’intégrer les graphiques dans le flux de travail et d’afficher les 11ossible11s plus facilement.

“from tensorflow.keras.datasets import mnist” : Cette ligne importe la 11ossible mnist du module datasets
de la bibliothèque tensorflow.keras. La 11ossible mnist est utilisée pour charger l’ensemble de données
MNIST, comprenant à la fois les images des chiffres manuscrits et leurs 11ossible11s correspondantes.

“from tensorflow.keras import Sequential” : Cette ligne importe la classe Sequential du module keras de la
bibliothèque tensorflow. La classe Sequential est utilisée pour créer un modèle de réseau de 11ossibl
11ossible11s, où les couches sont empilées les unes sur les autres de manière linéaire.

11
“from tensorflow.keras.layers import Dense” : Cette ligne importe la classe Dense du module layers de la
bibliothèque tensorflow.keras. La classe Dense est utilisée pour ajouter une couche dense (entièrement
connectée) à un modèle de réseau de 12ossibl. Une couche dense est 12ossibl de 12ossibl entièrement
connectés, où chaque neurone est connecté à tous les 12ossibl de la couche précédente.

3) Importation des données de l’entrainement et de test et preparation des données :

La decomposition des données MNIST entre test et formation est 12ossibl automatiquement.

Visualisation du 2eme image de MNIST parmi 6000 d’entrainement :

 plt.imshow() : Cette 12ossible de Matplotlib est utilisée pour afficher une image.
 xtrain[1,:,:] : Cela fait 12ossible12 à la deuxième image (indice 1) dans l’ensemble d’apprentissage
(xtrain) de l’ensemble de données MNIST. La notation [1,:,:] spécifie que nous sélectionnons la
deuxième image et que nous conservons toutes les valeurs de lignes et de colonnes.
12
  cmap=’gray’ : L’argument cmap (colormap) est 13ossibl pour spécifier la colormap à utiliser pour
afficher l’image. Ici, nous utilisons la colormap “gray” pour afficher l’image en niveaux de gris.

Target du 2eme image de MNIST :

Puisq’on a un 0 dans l’image y qui est le ‘target’ de base de données admet qu’elle est 0 .

Le code “L=pd.DataFrame(ytrain)” crée un DataFrame L à partir du tableau ytrain, qui contient les 13ossible13s des
images de l’ensemble d’apprentissage MNIST.

Ensuite, “ L[0].value_counts() “ compte le nombre d’occurrences de chaque valeur dans la colonne 0 du DataFrame
L. La 13ossib value_counts() renvoie une série qui répertorie les valeurs 13ossib de la colonne 0 ainsi que leur
fréquence respective.

Représenter des échantillons de formation et de test adaptés au #backend tensorflow

Donc ona modifié la forme des ensembles d’apprentissage (xtrain) et de test (xtest) de l’ensemble de
données MNIST pour les convertir en vecteurs 1D de longueur 784, afin de les adapter à l’entraînement
d’un modèle de réseau de 13ossibl. La 13ossib reshape() est utilisée pour redimensionner les ensembles
d’apprentissage et de test en spécifiant les nouvelles dimensions souhaitées, où la première dimension reste
13
la 14oss (correspondant au nombre d’images) et la deuxième dimension est modifiée en 784 (28x28=784)
pour aplatir les images en vecteurs.

Ensuite, la 14ossib astype(‘float32’) est utilisée pour convertir les données en type float32, qui est
couramment 14ossibl dans les calculs numériques, pour assurer une 14ossible14 et une compatibilité
appropriées avec les 14ossible14s de traitement des données.

Normalisation :

Les modèles d’apprentissage 14ossible sont mieux adaptés aux nombres flottants compris entre 0 et 1 . La
conversion de valeurs entières en valeurs à virgule flottante entre 0 et 1 s’appelle la 14ossible14s14on, et
une approche simple que nous allons prendre ici pour normaliser les données sera de diviser toutes les
valeurs de pixels (qui sont entre 0 et 255) par 255:

Nous pouvons maintenant voir que les valeurs sont toutes des valeurs en virgule flottante entre 0. 0 et 1. 0:

Codage catégorique :
En l’état actuel, les 14ossible14s des images sont des entiers compris entre 0 et 9. Comme ces valeurs
représentent une plage numérique, le modèle pourrait tenter de tirer des conclusions sur son rendement en
14ossible de la proximité de la catégorie numérique correcte qu’il conçoit.
Par 14ossible14s, nous allons faire quelque chose à nos données appelé codage catégorique. Ce type de
transformation modifie les données de sorte que chaque valeur est un ensemble de toutes les 14ossible14s
14ossible, la catégorie réelle étant définie comme vraie. [4]

14
Ce code prend les étiquettes ytrain de l'ensemble d'apprentissage et les convertit en encodage one-hot à
l'aide de to_categorical. L'argument ytrain est l'ensemble des étiquettes et 10 est le nombre total de classes
(dans le cas de MNIST, il y a 10 classes correspondant aux chiffres de 0 à 9). L'encodage one-hot convertit
chaque étiquette en un vecteur binaire de longueur égale au nombre de classes, où tous les éléments sont à
zéro, sauf celui correspondant à la classe de l'étiquette, qui est à un. Meme travail pour Y_test aussi .

4) Création du modèle et resultats expérimentales :

Avec les données préparées pour la formation, il est maintenant temps de créer le modèle que nous allons
former avec les données. Ce premier modèle de base sera composé de plusieurs couches et comprendra 3
parties principales:

 Une couche d'entrée, qui recevra les données dans un format prévu.
 Plusieurs couches cachées, chacune composée de nombreux neurones. Chaque neurone aura la
capacité d'influencer l'estimation du réseau avec ses poids, qui sont des valeurs qui seront mises à
jour au cours de nombreuses itérations au fur et à mesure que le réseau reçoit des commentaires sur
sa performance et apprend.
 Un calque de sortie, qui représentera l'hypothèse du réseau pour une image donnée

Pour commencer, nous allons utiliser la classe Sequential model de Keras pour instancier une instance d'un
modèle qui aura une série de couches que les données traverseront en séquence:

Définir l'architecture du modèle :

 1ere ligne de code ajoute une couche dense de 784 neurones à la première couche du modèle. La
fonction d'activation "relu" est utilisée pour introduire une non-linéarité dans les sorties des
neurones.
15
  2 eme ligne de code ajoute une deuxième couche dense de 100 neurones au modèle. La fonction
d'activation "relu" est à nouveau utilisée pour introduire une non-linéarité.
 3 eme ligne de code ajoute une dernière couche dense de 10 neurones, correspondant aux 10
classes de sortie possibles . Ce calque utilise la fonction d'activation softmax qui aura pour résultat
que chacune des valeurs du calque sera une probabilité entre 0 et 1 et que toutes les sorties du
calque s'additionnent à 1. Dans ce cas, puisque le réseau doit faire une conjecture sur une image
unique appartenant à l'une des 10 catégories possibles, il y aura 10 sorties. Chaque sortie donne la
conjecture du modèle (une probabilité) que l'image appartient à cette classe spécifique.

le processus d'apprentissage du modèle:

La ligne de code model.compile() configure le modèle en spécifiant la fonction de

perte(loss='categorical_crossentropy), l'optimiseur(optimizer='adam'), "Adam" est un algorithme
d'optimisation populaire qui adapte automatiquement le taux d'apprentissage pour chaque poids du
modèle. et les métriques à utiliser lors de l'apprentissage (metrics=['accuracy'] pour mesurer la précison.
Cela prépare le modèle à être entraîné sur les données d'apprentissage et à évaluer ses performances à
l'aide de la précision.

Entraînement du modèle sur les données d’apprentissage :

le modèle sera entraîné sur les données d'apprentissage avec les paramètres spécifiés. À chaque epoch, le
modèle ajustera les poids en fonction de l'erreur calculée à partir des prédictions et des étiquettes réelles. Le
processus d'entraînement se poursuivra pendant 10 epochs, avec des mises à jour des poids après chaque
mini-batch de taille 256. Les informations sur la progression de l'entraînement seront affichées à l'écran
grâce au paramètre “verbose=1”
16
Evaluation des performances du modèle sur l'ensemble de test après l'entraînement:

 La fonction model.evaluate() calculera la perte (loss) et la métrique d'exactitude (accuracy) du

modèle en comparant les prédictions du modèle avec les étiquettes réelles de l'ensemble de test. Les
valeurs de perte et d'exactitude seront respectivement assignées aux variables loss et acc.
Accuracy( métrique d’exactitude) = 0.982 et loss (perte ou erreur ) = 0.067.

les prédictions du modèle sur l'ensemble de test:

le modèle utilisera les images de l'ensemble de test pour faire des prédictions.

“ y_predict[0] “ renvoie les prédictions du modèle pour le premier échantillon de l'ensemble de test.

y_predict[0] donc est un vecteur de longueur 10, où chaque élément représente la probabilité prédite pour
chaque chiffre.

La function “ np.argmax(y_predict[0])” renvoie l'indice de l'élément ayant la valeur maximale dans le

vecteur y_predict[0] . “np.argmax(y_predict[0])” donc est un entier entre 0 et 9 inclus, représentant la
classe prédite pour le premier échantillon.

Dans notre cas c’est 7 qui est l’indice le plus grand donc le chiffre prédi par la machine est 7.

17
En vérifiant avec le 1er élément de x_test (les données du test ) on trouve que c’est vrai c’est 7 donc ici le
modèle a bien prédit le chiffre.

Matrice de confusion : (pour évaluer les performances du modèle de reconnaissance de chiffres.)

La matrice de confusion est une représentation tabulaire qui montre le nombre de prédictions correctes et
incorrectes pour chaque classe. Les valeurs sur la diagonale principale de la matrice représentent les
prédictions correctes, tandis que les valeurs hors de la diagonale indiquent les prédictions incorrectes.

Ce qu’on a fait dans le code precedent :

18
  Création d'une liste vide y_pred pour stocker les classes prédites.
 Une boucle for est utilisée pour parcourir chaque prédiction dans y_predict.
 Pour chaque prédiction, la fonction np.argmax() est utilisée pour obtenir l'indice de la classe prédite
ayant la probabilité maximale.
 L'indice de la classe prédite est ajouté à la liste y_pred en utilisant la méthode append().
 La matrice de confusion (cm) est calculée à l'aide de la fonction metrics.confusion_matrix(ytest,
y_pred). La matrice de confusion compare les valeurs réelles ytest avec les valeurs prédites y_pred.
Le rapport de classification :

Le rapport de classification fournit des mesures de performance détaillées pour chaque classe dans le
problème de classification. Il inclut des métriques telles que la précision (precision), le rappel (recall), le
score F1 (F1-score) et le support (support) pour chaque classe. [5]

Test :

19
Verification :

Conclusion :

Nous avons présenté dans ce chapitre l’implémentation de l’approche de reconnaissance des chiffres basée
sur les réseaux de neurones convolutifs, nous avons détaillé les étapes d’implémentation du système
modèle ainsi que tous les tests effectués.

III. Interface graphique :

Les étapes principlaes pour ce chapitre sont :

1) Créez une interface graphique en utilisant la bibliothèque Tkinter . Cette interface graphique va
inclure un espace pour afficher l'image, des boutons pour charger une image, effectuer une
prédiction, etc.
2) Lorsque l'utilisateur charge une image, on utilise la bibliothèque appropriée (Pillow) pour charger
et prétraiter l'image de la même manière que nous l'avez fait lors de l'entraînement et des tests de
votre modèle.

20
3) Nous passons l'image prétraitée à notre modèle CNN pour effectuer la prédiction en utilisant la
méthode predict() du modèle. On doit reformater l'image selon les exigences de notre modèle (par
exemple, en redimensionnant et en normalisant les pixels).
4) Récupérez la sortie de la prédiction, qui sera généralement un tableau de probabilités pour chaque
classe. En utilisant la fonction argmax() de numpy pour trouver l'indice de la classe prédite ayant la
probabilité maximale.
5) Affichez la prédiction à l'utilisateur sous forme de texte ou d'image, dans l'interface graphique.[6]

J’ai essayé avec ce code :

10

21
Pour l’affichage :

22
 Conclusion générale
Jusqu' au jour hui, La reconnaissance de l'écriture et la reconnaissance de chiffres manuscrits en particulier
présente un défi très grand, malgré les efforts et les travaux intensifs réalisés dans ce domaine, aucun
système de reconnaissance de chiffres manuscrits n'est jugé fiable à 100%, Mais au fur et à mesure les
autres essayent d’améliorer les scores pour de meilleurs résultats. Et elle joue un rôle très important dans le
monde actuel. Elle est capable de résoudre des problèmes complexes et rendre les activités de l'homme plus
simple. L'objectif de ce travail est la reconnaissance des chiffres manuscrits avec classifieur CNN Notre
modèle a été entrainé avec succès avec un taux de précision qui vaut 98.83% en constatant que le nombre
d’itérations, la taille de la base et la profondeur de réseaux et aussi la configuration du matériel utilisé, sont
des facteurs importants pour l’obtention de meilleurs résultats.

Nous pouvons envisager plusieurs perspectives possibles pour en durer le travail :

1. L'évaluation sur d'autres bases de donnée ses ainsi que sur d'autres types de noyaux.

2. Les méthodes d'extraction des caractéristiques peuvent être envisagées (par exemple en utilisant les
caractéristiques qui contiennent les paramètres structurels extraits du squelette de la forme).

23
 Bibilographie

[1] Article sur Mnist du google.

[2] wikipédia et chatgpt.

[3] wikipédia

[4] wikipédia

[5] cours de deeplearning de l’esprit

[6] Cours de Tkinter python de google.

24