Sciences mathématique et informatique

Projet Tutoré
Semestre S6

Mémoire

Classification des vidéos

Avec Deep Learning

Présenté par :
EL AMARTI MOAD
ZDA ALI YASSIR

Encadré par :
Pr : Fatima EL HAOUSSI
Pr : Hanane CHERGUI HALI

Soutenu le ———– devant le jury constitué de :

Pr. Abdellatif EL ABDERRAHMANI FSDM Fès

Pr. Hassan SATORI FSDM Fès
Pr. Fatima EL HAOUSSI FSDM Fès
Pr. Hanane CHERGUI HALI Ministère de l’éducation national Fès

Année Universitaire : 2021/2022

Dédicaces

À nous chers parents qui nous ont soutenus et encadrés tout au long de notre
cursus.
A nos frères et soeurs.
A nos enseignants.
A nos amies.
A tous ceux qui nous ont soutenus.

1
Remerciement

En premier lieu, on profite de remercier chaleureusement Mme Fatima El Haoussi pour

l’encadrement sérieux dont elle a fait preuve et sur les meilleures conseils qu’elle nous a
donner.

Nous tenons ainsi à adresser nos vifs remerciements à Mme Hanane Chergui Hali pour
son suivie et son énorme soutien qu’elle n’a cessé de nous prodiguer tout au long de cette
période.

Nous tenons ainsi à adresser nos remerciements aux membres du jury pour m’avoir ho-
noré en acceptant d’évaluer ce travail et d’être présents dans de telles conditions.

Et Finalement, nous exprimons nos profondes gratitudes à tout le personnel que nous
avons contacté, auprès desquels on a trouvé l’accueil chaleureux, l’aide et l’assistance.

2
Resumé

Nul doute que ces dernières décennies on a un recours sans précédent à l’intelligence
artificielle AI qui se présente comme étant un outil très puissant capable essentiellement de
trouver des solutions sophistiquées à nos problématiques existentielles, Cependant.
ce progrès a créé une nouvelle révolution technologique fournies un ensemble de moyens
pour arriver dans un premier lieu à l’intégration de l’être humain avec la machine dans le but
de moderniser le monde au meilleur.
Et l’une des branches qui fait partie de cette technologie, on trouve le Deep Learning qui
fera l’objet de notre projet en se plongeant impérativement sur le traitement des vidéos et
l’extraction de l’information via le décryptage de la séquence image vidéo afin de classifier
les caractéristiques de celle-ci.
Mots clés : AI, Deep Learning, révolution technologique, traitement de vidéos, séquence,
image, classification.

3
Abstract

There is no doubt that in the last decades there has been an unprecedented recourse to
artificial intelligence AI, which presents itself as a very powerful tool capable of finding
sophisticated solutions to our existential problems. However, this progress has created a new
technological revolution providing a set of means to integrate the human being with the
machine in order to modernize the world to the best. And one of the branches that is part of
this technology, we find the deep learning that will be the subject of our project by diving
imperatively on the processing of videos and the extraction of information via the decoding
of the video image sequence in order to classify the characteristics of it.
Keywords : AI, Deep learning, technological revolution, video processing, sequence, image,
classification.

4
Table des matières

Dédicaces 1

Remerciement 2

Resumé 3

Abstract 4

Introduction Générale 10

1 État de l’art 12
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.2 Traitement de données vidéo . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.2.1 Qu’est-ce qu’une vidéo numérique ? . . . . . . . . . . . . . . . . . 12
1.2.2 Les formats de fichiers vidéo . . . . . . . . . . . . . . . . . . . . . 13
1.3 Les caractéristiques de vidéo . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.3.1 Représentation d’image . . . . . . . . . . . . . . . . . . . . . . . 13
1.3.2 Pixel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.3.3 Échantillonnage vidéo . . . . . . . . . . . . . . . . . . . . . . . . 14
1.3.4 Principes de la compression vidéo . . . . . . . . . . . . . . . . . . 14
1.4 Classification des vidéos . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.4.1 Histoire de AI/Deep Learning . . . . . . . . . . . . . . . . . . . . 15
1.4.2 L’apprentissage Automatique . . . . . . . . . . . . . . . . . . . . 17
1.4.3 Deep Learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.4.4 Types d’apprentissage automatique . . . . . . . . . . . . . . . . . 19
1.4.4.1 L’apprentissage supervisé . . . . . . . . . . . . . . . . . 19
1.4.4.2 L’apprentissage non-supervisé . . . . . . . . . . . . . . 20
1.4.4.3 L’apprentissage semi supervisé . . . . . . . . . . . . . . 20
1.4.4.4 L’apprentissage par renforcement . . . . . . . . . . . . 21
1.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

5
 TABLE DES MATIÈRES

2 Les réseaux de neurones 23

2.1 Les neurones biologiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.2 Le réseau neurone artificiel . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.3 Les réseaux de neurones convolutifs . . . . . . . . . . . . . . . . . . . . . 26
2.3.1 Architecture de CNN . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.3.2 La couche de convolution . . . . . . . . . . . . . . . . . . . . . . 27
2.3.3 La parite Max-Pooling . . . . . . . . . . . . . . . . . . . . . . . . 27
2.3.4 La couche Flattening Fully Connected . . . . . . . . . . . . . . . . 28
2.4 Les modèles CNN pré-entraînés . . . . . . . . . . . . . . . . . . . . . . . 29
2.4.1 ResNet50 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.4.2 VGG 16 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.4.3 Inceptionv3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.5 Les réseaux de neurones récurrents . . . . . . . . . . . . . . . . . . . . . . 31
2.5.1 Architecture de RNN . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.5.2 Problème de la disparition du gradient . . . . . . . . . . . . . . . . 32
2.6 La cellule LSTM (long-short-term-memory) . . . . . . . . . . . . . . . . . 33
2.6.1 L’architecture d’une cellule LSTM . . . . . . . . . . . . . . . . . . 33
2.6.2 Le principe de fonctionnement . . . . . . . . . . . . . . . . . . . . 34
2.7 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

3 Classification des vidéos avec Deep Learning 37

3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.2 Environnement logiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.3 Présentation des bibliothèques utilisées en DL . . . . . . . . . . . . . . . . 38
3.3.1 TensorFlow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.3.2 Keras 2.8.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.3.3 OpenCV 4.3.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.3.4 NumPy 1.19.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.3.5 Matplotlib 3,2,2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.3.6 Scikit-learn 0.23.1 . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.3.7 Imutils 0.5.4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.4 Transfer Learning et fine tuning . . . . . . . . . . . . . . . . . . . . . . . 40
3.5 L’approche du réseau CNN pour la classification vidéo . . . . . . . . . . . 41
3.5.1 Réseau CNN basé sur ResNet50 . . . . . . . . . . . . . . . . . . . 41
3.5.2 Résultats d’entrainement . . . . . . . . . . . . . . . . . . . . . . . 46
3.5.3 Classification vidéo avec le modèle formé . . . . . . . . . . . . . . 48
3.5.4 Résultats de la classification vidéo . . . . . . . . . . . . . . . . . . 51
3.6 Classification vidéo avec des modèles hybrides CNN-LSTM . . . . . . . . 52
3.6.1 Classification avec ResNet50 . . . . . . . . . . . . . . . . . . . . . 52

6
 TABLE DES MATIÈRES

3.6.2 Classification avec VGG16 . . . . . . . . . . . . . . . . . . . . . . 56

3.6.3 Classification avec Inceptionv3 . . . . . . . . . . . . . . . . . . . . 59
3.6.4 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
3.7 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

Conclusion Générale et Perspectives 63

Bibliographies 64

7
Table des figures

1.1 Modèle luminance chrominance . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.2 Modèle de compression vidéo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.3 Quantité de données dans les différentes plateformes du monde. . . . . . . . . . . . . 17
1.4 Historique de AI. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.5 Représentation des composantes de AI. . . . . . . . . . . . . . . . . . . . . . . . 19
1.6 Représentation graphique d’apprentissage non supervisé. . . . . . . . . . . . . . . . 20
1.7 Les grandes classes d’apprentissage automatique. . . . . . . . . . . . . . . . . . . 21
1.8 Schéma descriptif de l’apprentissage par renforcement . . . . . . . . . . . . . . . . . 22

2.1 Schéma d’un neurone biologique humaine. . . . . . . . . . . . . . . . . . . . . . 23

2.2 Mise en correspondance neurone biologique /neurone artificiel. . . . . . . . . . . . . 25
2.3 Le fonctionnement d’un simple neuron. . . . . . . . . . . . . . . . . . . . . . . . 25
2.4 Schéma représentant l’architecture d’un CNN. . . . . . . . . . . . . . . . . . . . . 26
2.5 L’operation du convolution. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.6 Processus de Max-Pooling. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.7 La couche Flattening et Fully connected . . . . . . . . . . . . . . . . . . . . . . . 28
2.8 Une illustration du réseau ResNet50. . . . . . . . . . . . . . . . . . . . . . . . . 29
2.9 Une illustration du réseau VGG16. . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.10 Une illustration du réseau Inceptionv3. . . . . . . . . . . . . . . . . . . . . . . . 31
2.11 L’architecture de réseau RNN. . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.12 Passage de l’état interne d’un RNN. . . . . . . . . . . . . . . . . . . . . . . . . 32
2.13 La cellule LSTM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.14 Le LSTM dispose de 4 matrices de poids (avec leurs biais) contrôlant ses portes. . . . . 35

3.1 Approche traditionnelle vs. Approche de Transfert Learning. . . . . . . . . . . . . . 41

3.2 Le résultat d’entrainement. . . . . .. . . . . . . . . . . . . . . . . . . . . . . 47
3.3 L’évaluation de modèle formé. . . . .. . . . . . . . . . . . . . . . . . . . . . . 48
3.4 Graphe précision/perte. . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . 49
3.5 La vidéo output. . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . 52
3.6 L’architecture du modèle ResNet50-LSTM . . . . . . . . . . . . . . . . . . . . . . 55

8
 TABLE DES FIGURES

3.7 L’entrainement de modèle formé. . . . . . . . . . . . . . . . . . . . . . . . . . . 55

3.8 Graphe précision/perte du modèle ResNet50-LSTM. . . . . . . . . . . . . 56
3.9 La prédiction pour les données de validation . . . . . . . . . . . . . . . . . . . . . 56
3.10 Architecture du modèle VGG16-LSTM. . . . . . . . . . . . . . . . . . . . . . . . 57
3.11 Graphe de précision/perte du modèle VGG16-LSTM. . . . . . . . . . . . . 58
3.12 Prédiction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3.13 Architecture du modèle Inceptionv3-LSTM. . . . . . . . . . . . . . . . . . . . . . 60
3.14 Graphe de précision/perte du modèle Inceptionv3-LSTM. . . . . . . . . . . 60
3.15 Prédiction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

9
Introduction Générale

Les nouvelles technologies ont bouleversés d’une manière invraisemblable le domaine de

l’informatique avec un rythme trop élevé qui répond essentiellement aux exigences de nos
jours, l’utilité de ces nouvelles technologies qu’ils sont capables de prendre en charge les
divers perspectives de la complexité algorithmique issue d’une grande quantité des données
éparpillés dans les différentes plateformes d’hébergements.
Dans le même contexte, on trouve notamment un nombre incomptable des données vidéos
qui sont difficiles à traiter et leurs analyse prennent beaucoup trop du temps. De ce fait que
l’imposition d’une analyse vidéo intelligente devient exigeante pour qu’on puisse filtrer les
données inutiles, suivre les objets en mouvement, et déchiffrer le contenu de données,etc.

La technologie Deep Learning vient en quelque sorte pour remédier à une telle problé-
matique puisqu’elle repose sur un ensemble des théories et des techniques afin de permettre
à la machine de pouvoir analyser chaque données reçue de la décoder sous forme d’une in-
formation et de l’interpréter en comparaison avec les autres données stockées, ce qui leur
permettra d’apprendre à travers une séquence d’exemples.
A cet égard, une analyse vidéo intelligente vient nous offrir véritablement une alternative aux
anciens méthodes de détection, cette approche manipule des algorithmes visant la détection
automatique de personnes, véhicules, toutes sortes d’objets à travers l’extraction d’images
vidéo à partir desquels on peut détecter le mouvement, l’apparition et la disparition d’objet
avec une traçabilité trop optimisée.
Ce travail est réparti comme suit :
Dans un premier lieu, nous définissons les caractéristiques d’une vidéo numérique et l’intêret
d’une classification vidéo, ainsi nous avons mis en accent les différents type d’apprentissage.

Dans un second lieu, nous avons abordé le principe de fonctionnement d’un réseau de neu-
ronne en traitant les architectures CNN et LSTM, et leurs rôles qui jouent dans l’extraction
des caractéristiques spatiales et temporelles d’une image vidéo, de plus, on a discuté quelque
modèles pré entrainés tel que Resnet50, VGG16....

Et dans la troisième chapitre, on a opté à l’implémentation et l’expérimentation de la classi-

10
 INTRODUCTION GÉNÉRALE

fication vidéo à travers le concept Deep learning, pour ce faire, on a travaillé sur la classifi-
cation des activités sportives en incluant l’architeture ResNet50 pour voir l’intêret de passer
à une classification d’image et la mettre au service d’une classification vidéo, à partir de
cette classification on a pu mettre en exergue une combinaison entre CNN et LSTM qui sert
principalement à la classifiction des données séquentielles lieés à la dimension temporelle.
et par la suite on a opté pour une comparaison entre trois architectures à savoir ResNet50-
LSTM et VGG16-LSTM et Inceptionv3-LSTM pour en conclure finalement l’approche la
plus optimale.

11
Chapitre 1

État de l’art

"...What we want is machine that can learn from experience."

— Alan Turin

1.1 Introduction
Dans ce chapitre, nous allons présenter les caractéristiques de la donnée vidéo en met-
tant l’accent sur ses dimensions spatiales et temporelles. Ainsi,nous avons traité le principe
de la classification vidéo qui réside sur les algorithmes d’apprentissages en se focalisant sur
l’intérêt de Deep Learning.

1.2 Traitement de données vidéo

1.2.1 Qu’est-ce qu’une vidéo numérique ?
Une vidéo numérique est une succession d’images à une certaine cadence, leur principe
consiste en premier lieu à sous diviser chaque image vidéo selon une résolution donnée nor-
malement (720*486) pixels pour une image vidéo ordinaire, ensuite il s’associe à chacun des
éléments une valeur numérique qui forment la couleur de ce pixel (YUV/RGB) à base d’une
table de conversion de couleurs. En revanche, les systèmes vidéo se distinguent en résolution
d’affichage, rapport (hauteur/largeur), taux de rafraichissement, capacités de couleur, et elle
s’était rendue possible grâce au codage transformée cosinus discrète (DCT), un processus de
compression avec perte développé au début des années 1970, le codage DCT qui était adapté
en compression vidéo compensée en mouvement DCT à la fin des années 1980.[6]

12
 1.3. LES CARACTÉRISTIQUES DE VIDÉO

1.2.2 Les formats de fichiers vidéo

Dernièrement, les fichiers vidéo deviennent volumineux en terme de stockage et de par-
tage, pour cette raison qu’on trouve une panoplie de programmes servent à compresser les
données pour un rapport dâéquilibre entre qualité et simplicité dâusage.
AVI
Le format AVI (Audio VideoInterleave) fonctionne avec pratiquement tous les navigateurs
web sous Windows, Mac et Linux. Développé par Microsoft, il offre la meilleure qualité,
mais produit aussi les fichiers les plus volumineux. Pris en charge par YouTube, ce format
est parfaitement adapté à la diffusion télévisuelle.
AVCHD
Le format Advanced VideoCoding High Definition s’adresse spécifiquement à la vidéo haute
définition. Mis au point pour les caméscopes numériques Panasonic et Sony, ce format com-
presse vos fichiers pour simplifier leur stockage, sans perte de définition. FLV, F4V et SWF
Les formats vidéo Flash FLV, F4V et SWF (Shockwave Flash) sont conçus pour Flash Player
mais couramment utilisés en streaming vidéo sur YouTube.
MKV
Développé en Russie, le format MatroskaMultimedia Container est gratuit et disponible
en open source. Compatible avec presque tous les codecs, il n’est cependant pas pris en
charge par de nombreux programmes. Le format MKV est un choix judicieux pour les vi-
déos destiné.[7]
Gif
Un GIF (Graphical Interchange Format) est un format d’image inventé en 1987 par Steve
Wilhite, un auteur de logiciels américain qui cherchait un moyen d’animer des images dans
la plus petite taille de fichier. En bref, les GIF sont une série d’images ou de vidéos sans son
qui tournent en boucle en continu et ne nécessitent personne d’appuyer sur lecture.

1.3 Les caractéristiques de vidéo

1.3.1 Représentation d’image
L’image est définie comme étant une fonction f(x, y) à deux dimensions, où x et y sont
les coordonnées spatiales, et l’amplitude à tous points f(x, y) correspondant à l’intensité ou
au niveau de gris. Lorsque les points (x, y) et l’amplitude sont discrétisés, on parle dâimage
numérique ou digitale. Dans ce dernier cas la fonction f est remplacée par la lettre I et le
couple (x, y) par le couple (i, j), et parmi les images numériques on trouve limages binaire
qui se présentent comme étant une matrice rectangulaire dont les éléments prennent la valeur
de 0 ou de 1.[8]

13
 1.3. LES CARACTÉRISTIQUES DE VIDÉO

1.3.2 Pixel
Le pixel désigne le petit élément constitutif d’une image numérique, chaque pixel dans
une image vidéo conserve une quantité d’information qui crée une différence par rapport à
ses contigus. De plus, étant donné que cette dernière se présente sous forme d’une matrice à
savoir les valeurs de pixels, nombre de colonnes multiplié par le nombre de ligne donne le
nombre total de pixels dans l’image.

En prenant à titre d’exemple une image de 620*400 en couleur ce qui va nous produire
un nombre de pixel égal à (640*480=248 000) avec un poids de chaque pixel (3 octets), alors
on peut estimer le poids de lâimage dans sa globalité (248 000*3=744 000 octets) dans les
alentours de 700ko.
Dans le même sens, pour coder une image vidéo généralement on la code via le codage dite
RVB, chaque couleur est codée sur 8bits (1 octet) et chaque pixel sur 3 octets rouge R [0-
255], vert V [0-255], bleu B [0-255]. Le principe est dâadditionné les couleurs pour obtenir
les différentes couleurs possibles [256*256*256=16 777 216] couleurs différents.

1.3.3 Échantillonnage vidéo

Le regroupement de toutes les composantes qui forment un élément de codage de l’image
se base sur un algorithme de MPEG qui se repose essentiellement sur la luminance puisque
l’oeil est plus sensible à la luminance qu’aux chrominances (Cb rouge et vert) et (Cr vert et
bleu).
En vidéo, on utilise le codage YUV qui tient en compte les caractéristiques de la vision
humaine pour un meilleur rendu et une plus grande efficacité, et les quatre échantillonnages
utilisés dans les vidéos, on trouve format 4 :1 :1, format 4 :2 :0, format 4 :2 :2 et format
4 :4 :4
On prend cette format a : b : c pour représenter l’échantillonnage de la couleur en vidéo
a représente le nombre de pixels sur chaque ligne.
b représente le nombre de pixels sur la première ligne qui possèdent leurs propres valeurs de
chrominance et de luminance.
c représente le nombre de pixels sur la deuxième ligne qui possèdent leurs propres valeurs
de chrominance et de luminance.

1.3.4 Principes de la compression vidéo

On peut désigner un système de compression vidéo comme ce qui représente la figure [2]
par 3 modèles de bases, le modèle temporel qui s’appuie sur la notion du temps, le modèle

14
 1.4. CLASSIFICATION DES VIDÉOS

F IGURE 1.1 – Modèle luminance chrominance .

spatial qui repose sur les redondances spatiales et le codage entropique. [9]
La première chose dans la compression consiste d’abord à prendre en charge le modèle
temporel de prédire l’image courante à coder en utilisant une des images de références ti-1,
en contrepartie, on trouve la prédiction spatiale qui permet de diviser l’image en plusieurs
blocs de façon à ce que on obtient la différence entre ces blocs. Et le codage entropique vient
pour exploiter la redondance statique afin de représenter chacun d’eux par une série de bits
de sorte à minimiser la taille globale.

1.4 Classification des vidéos

1.4.1 Histoire de AI/Deep Learning
Une masse gigantesque de données représente aujourd’hui un problème pour l’exploiter,
trier et l’indexer de façon à ce qu’on peut avoir des données bien structurées et classifiées. La
Data est en train de s’intensifier d’une manière inflationniste ces derniers temps, ce qui nous
la démontre bien le site Data Never Sleep [10], nous donne approximativement les quantités
de données consommées habituellement dans le monde et ce qui est illustrées dans la figure
ci-dessous.
Le terme Intelligence Artificielle cache derrière lui une idée qui s’est devenu réalité,

15
 1.4. CLASSIFICATION DES VIDÉOS

F IGURE 1.2 – Modèle de compression vidéo .

comme disait Steve jobs « innovation, c’est une situation qu’on choisit parce qu’on a une
passion brulante pour quelque chose », l’idée de la machine pensante a abordée dans un pre-
mier temps divers interrogations, à savoir :

Comment simuler la pensée et le langage à travers des règles formelles ?

Comment faire penser un réseau de neurones ?
Comment doter une machine d’une capacité d’apprentissage automatique ?
Et finalement, comment doter une telle machine à la créativité ?
Dès le milieu des années 60, la recherche autour de cette technologie était principalement
financée par le département de la défense en Amérique. Certains experts prédisaient que les
machines seront capables d’ici 20 ans de faire le travail que toute personne puisse faire.[11]
A vrai dire, le concept de Deep Learning n’est pas une nouveauté mais un cumul de
plusieurs expériences qui s’est concrétisé depuis les années 2000. Ce concept est directe-
ment inspiré du neurone biologique, ce modèle qui a été proposé en 1943, et juste après, le
perceptron s’est mis en application comme un petit réseau neuronal formel jusqu’à 1986 où
il a venu le concept de perceptrons multicouches MLP qui avait pour objectif principal de
classer les données plus complexe que celles classées par un perceptron. Et avec l’arrivée
de l’année 2010, qui a connu un progrès révolutionnaire lié à la puissance des ordinateurs
qui ne cessent d’augmenter et qui permet la création et l’entrainement de réseaux neuro-

16
 1.4. CLASSIFICATION DES VIDÉOS

F IGURE 1.3 – Quantité de données dans les différentes plateformes du monde.

naux avec des dizaines de couches cachées ce qui a fait normalement l’émergence de Deep
Learning.[12]

1.4.2 L’apprentissage Automatique

D’après Mit Chill [13], l’apprentissage Automatique peut être défini comme étant un
programme informatique capable d’apprendre à partir d’une expérience E dans le respect
d’une classe de tache T avec la mesure de performance P s’il accomplit la tache T, mesurée
par P et améliorée par l’expérience E (modèle statistique ou modèle d’apprentissage). Ce
modèle est vu comme une boite noire capable de prendre en entrée des données (Images,
trafic réseauâ) et renvoyer une sortie (prise de décision de l’IA, description dâune imageâ).

1.4.3 Deep Learning

L’apprentissage profond fait partie d’une famille de méthodes d’apprentissage automa-
tique fondées sur l’apprentissage de modèles de données. Une observation (une image, p.
ex.) peut être représentée de différentes façons par un vecteur, une matrice ou un tenseur de
données décrivant la scène observée, notamment en fonction de :
— L’intensité des pixels dont elle est constituée .
— Ses différentes régions, aux formes particulières.

17
 1.4. CLASSIFICATION DES VIDÉOS

F IGURE 1.4 – Historique de AI.

Une des perspectives des techniques de l’apprentissage profond est le remplacement de cer-
tains travaux encore relativement laborieux, par des modèles algorithmiques d’apprentissage
supervisé, non supervisé (c’est-à-dire ne prenant pas en compte pas des connaissances spé-
cifiques du domaine étudié) ou encore par des techniques d’extraction hiérarchique des ca-
ractéristiques. Les recherches dans ce domaine s’efforcent de construire de meilleures repré-
sentations du réel et de créer des modèles capables d’apprendre ces représentations à partir
de données non labellisées à grande échelle. Certaines de ces représentations s’inspirent des
dernières avancées en neuroscience. Il s’agit d’interprétations du traitement de l’information
et des modèles de communication du système nerveux.
Les différentes architectures d’apprentissage profond telles que les réseaux de neurones pro-
fonds, les réseaux neuronaux convolutifs « convolutional deep neural networks », et les ré-
seaux de croyance profonde ont plusieurs champs d’application :
— La vision par ordinateur (reconnaissance de formes) ;
— La reconnaissance automatique de la parole ;
— Le traitement automatique du langage naturel ;
— La reconnaissance audio et la bio-informatique.
[14]

18
 1.4. CLASSIFICATION DES VIDÉOS

F IGURE 1.5 – Représentation des composantes de AI.

1.4.4 Types d’apprentissage automatique

Dans une part, la notion d’apprentissage désigne une simple mémorisation, or les ma-
chines contemporains avec leurs mémoires puissantes n’ont pas la difficulté à mémoriser
toute une encyclopédie y compris sons et images.

Dans une autre part, l’apprentissage se différencie au premier qu’il fait appel à la généra-
lisation en identifiant plus à l’apprentissage de lecture la manière dont le mot est écrit.[15]

Les algorithmes d’apprentissages se catégorisent comme suit :

1.4.4.1 L’apprentissage supervisé

Le système apprend à classer selon un modèle de classement, alors on parle d’apprentis-

sage supervisé le modèle doit préalablement étiqueter les composantes d’une classe ce qui
va permettre à l’apprenant de trouver ou approximer la fonction d’affectation de la bonne
étiquette,parfois il est préférable d’associer une donnée non pas à une classe unique, mais
une probabilité d’appartenance à chacune des classes prédéterminées, on parle justement
d’apprentissage supervisé probabiliste. A titre d’exemple, en fonction de points communs

19
 1.4. CLASSIFICATION DES VIDÉOS

des symptômes de différents patients le système peut catégoriser les patients en vu de leurs
analyses médicales en risque de développer telle ou telle maladie.

1.4.4.2 L’apprentissage non-supervisé

Quand le système ne dispose que d’exemples mais que le nombre de classes et leurs
natures n’ont pas été prédéterminés, on parle justement d’apprentissage non supervisé (ou
clustering). L’algorithme doit découvrir par lui-même la structure plus ou moins cachée des
données, ainsi le système a le devoir de cibler les données selon leurs attributs afin de les
classer en groupe homogènes. La similarité est généralement calculée selon la fonction de
distance entre paires d’exemples. A titre dâexemple, un épidémiologiste veut tenter à partir
d’un ensemble assez large de victimes de cancers du foie faire émerger des hypothèses expli-
catives, le système peuvent différencier différents groupes, (leur provenance géographique,
génétiqueâ).

F IGURE 1.6 – Représentation graphique d’apprentissage non supervisé.

1.4.4.3 L’apprentissage semi supervisé

Il s’agit d’une combinaison entre l’apprentissage supervisé et non supervisé en utilisant

des données étiquetées et non étiquetées pour le même ensemble de données.

L’intérêt d’utiliser cette approche réside dans le fait que l’étiquetage de données prend sou-
vent beaucoup de temps, dans ce cas l’inclusion d’un grand nombre de données non étique-
tées au cours du processus dâentrainement a tendance à améliorer la performance du modèle
final tout en réduisant le temps et les coûts consacrés à sa construction.

20
 1.5. CONCLUSION

F IGURE 1.7 – Les grandes classes d’apprentissage automatique.

1.4.4.4 L’apprentissage par renforcement

L’apprentissage se fait sans supervision, par interaction avec l’environnement (principe

dâessai / erreur) et en observant le résultat des actions prises. Chaque action de la séquence
est associée à une récompense. Le but est de déterminer la stratégie comportementale opti-
male afin de maximiser la récompense totale. Pour cela, un simple retour des résultats est
nécessaire pour apprendre comment la machine doit agir. Ceci est appelé le signal de ren-
forcement. Il peut être très avantageux pour la prévision financière à haute fréquence où
l’environnement est dynamique et en conséquence, il est difficile de trouver ou dâautomati-
ser manuellement des stratégies efficaces.[16]

1.5 Conclusion
Dans ce chapitre, nous avons donné des concepts de base concernant les données vi-
déos, de plus nous avons traité de manière générale quelques types d’apprentissage tels que
apprentissage supervisé, apprentissage non supervisé ,semi-supervisé et par renforcement.
Notre objectif dans le chapitre suivant sera basé sur des algorithmes d’apprentissage super-
visé dédié à la classification de CNN et LSTM.

21
 1.5. CONCLUSION

F IGURE 1.8 – Schéma descriptif de l’apprentissage par renforcement .

22
Chapitre 2

Les réseaux de neurones

2.1 Les neurones biologiques

Un neurone, ou une cellule nerveuse, est une cellule excitable constituant l’unité fonc-
tionnelle de la base du système nerveux humaine.
Le système nerveux est composé de milliards de cellules : c’est un réseau de neurones bio-
logiques. En effet, les neurones ne sont pas indépendants les uns des autres, ils établissent
entre eux des liaisons et forment des réseaux plus complexes.
Le neurone biologique est composé de trois parties principales :
— Le corps cellulaire composé du centre de contrôle traitant les informations reçues par
les dendrites.
— Les dendrites sont les principaux fils conducteurs par lesquels transitent l’information
venue de l’extérieur.
— L’axone est fil conducteur qui conduit le signal de sortie du corps cellulaire vers
d’autres neurones.

F IGURE 2.1 – Schéma d’un neurone biologique humaine.

23
 2.2. LE RÉSEAU NEURONE ARTIFICIEL

Le principe de fonctionnement :
Les neurones biologiques disposent d’un centre de contrôle (appelé cellule somatique) fai-
sant la somme des informations recueillies par les dendrites. Ensuite, le centre de contrôle
retourne un potentiel d’action en suivant les règles suivantes :
— la somme en entrée ne dépasse pas le seuil d’excitation : pas de message nerveux via
l’axone.
— Si la somme en entrée dépasse le seuil d’excitation : un message nerveux est émis via
l’axone.

2.2 Le réseau neurone artificiel

En 1943, le neurophysiologiste Warren McCulloch et le mathématicien Walter Pitts ont
écrit un article sur le fonctionnement des neurones. Afin de décrire comment les neurones
du cerveau pourraient fonctionner, ils ont modélisé un simple réseau de neurones à l’aide de
circuits électriques.[4]
Un réseau de neurones est un modèle informatique dont la structure en couches est simi-
laire à la structure en réseau des neurones du cerveau, avec des couches de noeuds connectés
ce reseau peut apprendre à partir des données ; il peut ainsi être entraîné à reconnaître des
tendances, classer des données et prévoir des événements à venir.La mise à jour des pondéra-
tions (weights en anglais) est le moyen principal permettant le réseau de neurones à apprend
de nouvelles informations.
La figure 2.2 montre la structure d’un neurone artificiel. Chaque neurone artificiel est un
processeur élémentaire. Il reçoit un nombre variable d’entrées en provenance de neurones
amonts.a chacune de ces entrées est associée un poids w abréviation de weight représentatif
de la force de la connexion. Chaque processeur élémentaire est doté d’une sortie unique, qui
se ramifie ensuite pour alimenter un nombre variable de neurones avals. a chaque connexion
est associée un poid.
perceptron avec les éléments constitutifs des neurones biologiques.
— Les synapses/dendrites : pondération de chaque élément en entrée wi xi
— Corps cellulaires : application d’une fonction d’activation f à la somme des entrées
pondérées
— Axone : sortie de notre modèle
— Le vecteur w porte le nom de vecteur de poids (qui s’ajuste lors de l’entraînement).
— Le vecteur x porte le nom de vecteur d’entrée.
— f porte le nom de fonction d’activation
Le principe de fonctionnement :
Le fonctionnement est inspiré de fonction de neurone biologique Les entres xi seront mul-
tiplier avec les poids wi et la somme wi·xi sera l’entres de de fonction d’activation f qui va
représenter un seuil pour les entres et la sortie sera soit 0 soit 1 et sera connecté a un autre

24
 2.2. LE RÉSEAU NEURONE ARTIFICIEL

F IGURE 2.2 – Mise en correspondance neurone biologique /neurone artificiel.

F IGURE 2.3 – Le fonctionnement d’un simple neuron.

réseau(voir figure 2.3)

Cette algorithme est utilisé pour la classification des images et la reconnaissance des
formes...etc. L’inconvénient de ce système tient dans l’impossibilité de travailler sur des
données complexes et en grande nombre. Le modèle d’apprentissage basé sur le perceptron
monocouche reste basique et limité dans ses applications, car la séparation des classes n’est
effective que de manière linière. Pour entourer ce problème on il y’ se quand appelé un per-
ceptron multicouches est un modèle des réseau de neurone artificiels ,qui comprend plusieurs
couche cachées, et permet de produire un séparateur non linière il est constitué de plusieurs
entrées et sorties on dépasse alors le machine Learning pour entre dans le Deep Learning
avec des système d’apprentissage pouvant traiter des données en profondeur donc on parle
ici sur les réseaux de neurone convolutés profond c’est le réseau de neurone convolutive en
anglais CNN(Convolutional Neural Network)

25
 2.3. LES RÉSEAUX DE NEURONES CONVOLUTIFS

F IGURE 2.4 – Schéma représentant l’architecture d’un CNN.

2.3 Les réseaux de neurones convolutifs

Les CNN désignent une sous-catégorie de réseaux de neurones, dans lequel le motif de
connexion entre les neurones est inspiré par le cortex visuel des animaux. ils consistent en
un empilage multicouche de perceptrons, dont le but est de prétraiter de petites quantités
d’informations.
Les réseaux neuronaux convolutés ont de larges applications dans la reconnaissance d’image
et vidéo qui est une partie de notre travaille, les systèmes de recommandation et le traitement
du langage naturel NLP (Natural Language,Processe).

2.3.1 Architecture de CNN

L’architecture du la CNN dispose en amont d’une partie convolutive et comporte par
conséquent deux parties bien distinctes :

— Une partie convolutive : Son objectif final est d’extraire des caractéristiques propres
à chaque image en les compressant de façon à réduire leur taille initiale. En résumé,
l’image fournie en entrée passe à travers une succession de filtres, créant par la même
occasion de nouvelles images appelées cartes de convolutions. Enfin, les cartes de
convolutions obtenues sont concaténées dans un vecteur de caractéristiques appelé
code CNN.
— Une partie classification : Le code CNN obtenu en sortie de la partie convolutive
est fourni en entrée dans une deuxième partie, constituée de couches entièrement
connectées appelées perceptron multicouche (MLP pour Multi Layers Perceptron).
Le rôle de cette partie est de combiner les caractéristiques du code CNN afin de
classer l’image.

26
 2.3. LES RÉSEAUX DE NEURONES CONVOLUTIFS

F IGURE 2.5 – L’operation du convolution.

2.3.2 La couche de convolution

Le nom réseau convolutif renvoit à un terme mathématique : le produit de convolution. En
termes simples, l’idée est qu’on applique un filtre à l’image d’entrée, les paramètres du filtre
seront appris au fur et à mesure de l’apprentissage. Un filtre appris permettra par exemple
de détecter les angles dans une image si les angles servent à classifier au mieux l’image. La
fenêtre de filtre représentant la feature, se déplace progressivement de la gauche vers la droite
d’un certain nombre de cases défini au préalable (le pas) jusqu à arriver au bout de l’image.
chaque portion d’image rencontrée, un calcul de convolution s’effectue permettant d’obtenir
en sortie une carte d’activation ou feature map qui indique où est localisées les features dans
l’image (i.e. les caractéristiques de l’image)

2.3.3 La parite Max-Pooling

Le Max-Pooling est un processus de discrétisation basé sur des échantillons. Son objectif
est de sous-échantillonner une représentation d’entrée (image, matrice de sortie de couche
cachée, etc.) en réduisant sa dimension. De plus, son intérêt est qu’il réduit le coût de cal-
cul en réduisant le nombre de paramètres à apprendre et fournit une invariance par petites
translations (si une petite translation ne modifie pas le maximum de la région balayée, le
maximum de chaque région restera le même et donc la nouvelle matrice créée restera iden-
tique).
Pour rendre plus concret l’action du Max-Pooling, voici un exemple : imaginons que nous
avons une matrice 4 représentant notre entrée initiale et un filtre d’une fenêtre de taille 2
que nous appliquerons sur notre entrée. Pour chacune des régions balayées par le filtre, le
max-pooling prendra le maximum, créant ainsi par la même occasion une nouvelle matrice
de sortie où chaque élément correspondra aux maximums de chaque région rencontrée, la
fenêtre de filtre se déplace de deux pixels vers la droite (stride/pas = 2) et récupère à chaque

27
 2.3. LES RÉSEAUX DE NEURONES CONVOLUTIFS

F IGURE 2.6 – Processus de Max-Pooling.

F IGURE 2.7 – La couche Flattening et Fully connected .

pas l’ rgmax correspondant à la valeur la plus grande parmi les 4 valeurs de pixels.. (voir
figure 1.6 )

2.3.4 La couche Flattening Fully Connected

Le flatening consiste à convertit les donnes en un tableau d’une dimension pour les saisir
dans la couche suivante nous aplatissons la sortie des couches de consolatives pour crée un
vecteur de feature et il est connecté au modèle de classification final appelé couche entière-
ment connecté en anglais Fully Connected (voire figure 1.7).
Ces couches sont placées en fin d’architecture de CNN et sont entièrement connectées à tous
les neurones de sorties (d’où le terme fully-connected).
Après avoir reçu un vecteur en entrée, la couche FC applique successivement une combinai-
son linéaire puis une fonction d’activation dont l’intérêt est de rendre le modèle non linéaire
et de ce fait plus complexe, a fin de classifier l’input image (voir schéma suivant). Elle ren-

28
 2.4. LES MODÈLES CNN PRÉ-ENTRAÎNÉS

F IGURE 2.8 – Une illustration du réseau ResNet50.

voie enfin en sortie un vecteur de taille d correspondant au nombre de classes dans lequel
chaque composante représente la probabilité pour l’input image d’appartenir à une classe.
Finalement, le principe de fonctionnement d’un CNN est assez facile à comprendre mais
le faite de créer un nouveau réseaux de neurones convolutés est couteaux en terme d’ex-
pertise,de matériel et de quantité de données annotées nécessaire ,il s’agit d’abord de fixer
l’architecture de réseau c’est-à-dire le nombre de couches ,leur tailles et les opérations matri-
cielles qui les connectent ,ainsi l’entrainement d’un réseau peut prendre plusieurs semaines
pour une meilleur CNN , Pour pallier à ces obstacles, Python , offre la possibilité d’exploiter
des modèles CNN pré-entraînés performants tels que ResNet50,VGG16, Inceptionv3.

2.4 Les modèles CNN pré-entraînés

2.4.1 ResNet50
Le ResNet50 est un réseau neuronal convolutif qui a une profondeur de 50 couches. Il
a été construit et formé par Microsoft en 2015[1] . Ce modèle est également formé sur plus
d’un million d’images de la base de données ImageNet.Il peut classer jusqu’à 1000 objets et
le réseau a été formé sur des images colorées de 224x224 pixels. Voici de brèves informations
sur sa taille et ses performances :
— Taille : 98 Mo
— Top-1 : Précision : 80.4%
— Top 5 : Précision : 92,1%
— Nombre de paramètres : 25 636 712

29
 2.4. LES MODÈLES CNN PRÉ-ENTRAÎNÉS

F IGURE 2.9 – Une illustration du réseau VGG16.

2.4.2 VGG 16
VGG16 est un modèle de réseau de neurones à convolution qui a une profondeur de
16,conçu par K. Simonyan et A. Zisserman[2].Ce modèle est également formé Pendant 3
semaines sur 14 millions d’images appartenant à 1000 classes. Voici de brèves informations
sur sa taille et ses performances.
— Taille : 528 MB
— Top-1 : Précision : 74.4%
— Top 5 : Précision : 90,1%
— Nombre de paramètres : 138 357 544

2.4.3 Inceptionv3
Inceptionv3 est un réseau neuronal convolutif de reconnaissance d’images qui a une pro-
fondeur de 50 couches,(voire la figure 2.10). Il a été construit par Google,la version pré-
entraînée d’Inceptionv3 avec les poids ImageNet,Voici de brèves informations sur sa taille et
ses performances :
— Taille : : 92 MB
— Top-1 : Précision : 78,95%
— Top 5 : Précision : 94.49%
— Nombre de paramètres : 23 851 784
— Profondeur : 159

30
 2.5. LES RÉSEAUX DE NEURONES RÉCURRENTS

F IGURE 2.10 – Une illustration du réseau Inceptionv3.

2.5 Les réseaux de neurones récurrents

Les réseaux de neurones récurrents (en anglais recurrent neural networks), aussi appe-
lés RNNs, sont une classe de réseaux de neurones qui permettent d’analyser les données
temporelle ils sont utilisé en reconnaissance des formes et les videos et aussi de la parole.

2.5.1 Architecture de RNN

sur chaque neurone bleu, on a une boucle :
— on a une donnée t (3 valeurs, une pour chaque neurone jaune) qui arrive dans le ré-
seau
— celles-ci se propagent dans le réseau
— sauf que chaque neurone bleu, en plus de recevoir les sorties pondérées des neurones
précédents, reçoit également la valeur qui sortait de lui-même pour la donnée t-1
— la valeur de sortie de chaque neurone bleu est conservée et servira pour la donnée t+1
,voire la figure 2.12.
Les données en entrée sont sous la forme d’un vecteur, par exemple (0.7, 0.4, 0.9) et
chaque coordonnée du vecteur est envoyée à un neurone jaune ci-dessous Ensuite, les 3 va-
leurs vont avancer dans le réseau couche par couche (1ère bleue puis 2nde bleue puis orange
qui est la sortie). Les couches bleues sont dites cachées et l’orange dite couche de sortie. Pour
avancer, entre chaque neurone il y a un trait qui les relie : ce trait est associé à une va-leur
dite le poids (par exemple 0.3 entre le 1er neurone jaune et le 1er bleu) qui va pondérer la
valeur entrante (i.e. on aura 0.7*0.3 = nouvelle valeur qui arrive dans le 1er neurone bleu).
Toutes les valeurs entrantes (et pondérées) sont additionnées à l’entrée d’un neurone puis
on applique une certaine fonction au résultat, ce qui donne une valeur de sortie pour chaque
neurone. Ces valeurs sont ensuite propagées à la couche suivante et ainsi de suite.

31
 2.5. LES RÉSEAUX DE NEURONES RÉCURRENTS

F IGURE 2.11 – L’architecture de réseau RNN.

F IGURE 2.12 – Passage de l’état interne d’un RNN.

Pour chaque entres de données dans le RNN, la sortie, notée ht pour l’entre prétendante est
ajoutée en entrée avec le nouveau entre. Cette sortie est appelée l’ état caché (hidden state
en anglais).
Les donnees traversant la RNN dans le figure 2.12 sont mises bout-à-bout c’est-à-dire conca-
ténées puis passent dans la fonction mathématique tanh pour ’éviter que les sorties des
neurones ne deviennent trop grandes valeurs en des nouvelles valeurs entre -1 et 1,car cela
demanderait alors plus de temps de calculs et de mémoire d’ordinateur avant de devenir la
nouvelle sortie notée ht .

2.5.2 Problème de la disparition du gradient

La Descendent de Gradiant algorithme pour entraîner un réseau de neurones, consistant à
mettre à jour les poids de chaque neurone de la dernière couche vers la première. Elle vise à
corriger les erreurs selon l’importance de la contribution de chaque élément à celles-ci. Dans

32
 2.6. LA CELLULE LSTM (LONG-SHORT-TERM-MEMORY)

le cas des réseaux de neurones, les poids synaptiques qui contribuent plus à une erreur seront
modifiés de manière plus importante que les poids qui provoquent une erreur marginale.
Selon la formule suivante :
w(t + 1) = w(t) − α · F w
avec :
— w un poids du réseau
— α la vitesse d’apprentissage du réseau
— Fw le gradient du réseau par rapport au poids
L’algorithme du gradient a pour but de converger de manière itérative vers une configuration
optimale des poids synaptiques. Cet état peut être le minimum global la fonction,d’optimaistaion
de probleme cest à dire le point où se trouve le meilleur modèle , C’est grâce à cet algorithme
que le reseau apprend.
Alors ici Le RNN souffre du problème c’est que le faite de la mise à jour des poids se fait
de droite à gauche. Au fur et a mesure que l’on avance vers la gauche, a travers l’algorithme
de descendante Gardiane , le produit α · F w devient très petit et les poids des premières
couches de neurones qui ne sont quasiment pas modifiés ! Ainsi, ces couches n’apprennent
strictement rien.
Et par conséquent, le RNN peut facilement oublier des données appris des premières couches
lors de la phase d’apprentissage donc on dit que sa mémoire est courte et c’est la raison lequel
on doit voir autre architecture de réseau neurone plus performantes comme LSTM.

2.6 La cellule LSTM (long-short-term-memory)

Le réseau LSTM a été proposé par Sepp Hochreiter et Jrgen Schmidhuber en 1997 [5]
réseau de neurones récurrents la plus utilisée en pratique qui permet de répondre au problème
de disparition de gradient.
Le LSTM à base de la RNN qui permettant de gérer efficacement la mémoire à court et
long terme grâce à leurs systèmes de portes. Sont encore très largement utilisées dans les
meilleurs modèles de Deep Learning pour le traitement automatique du langage naturel, ce
qui a trait à la reconnaissance vocale, la classification des vidéos ainsi pour la génération de
texte ...etc.

2.6.1 L’architecture d’une cellule LSTM

Le LSTM, est une cellule composée de trois portes : ce sont des zones de calculs qui
régulent le flot d’informations (en réalisant des actions spécifiques). On a également deux
types de sorties (nommées états).Figure 2.13
— porte d’oubli (Forget gate)

33
 2.6. LA CELLULE LSTM (LONG-SHORT-TERM-MEMORY)

F IGURE 2.13 – La cellule LSTM.

— porte d’entrée(Input gate)

— porte de sortie (Output gate)
— état caché (Hidden state)
— état de la cellule (Cell state)
À l’intérieur d’une cellule LSTM on trouve plusieurs opération et fonction tels que la fonc-
tion Sigmoid et tanh représenter respectivement en rouge et bleu ainsi des addition et des
multiplication et aussi la concaténation bout-a-bout des vecteur de l’entrées . Ces opérations
dans les portes permettent au LSTM de conserver ou supprimer des informa-tions qu’il a en
mémoire.
Les données stockées dans la mémoire du réseau sont en fait un vecteur noté ct : l’état de la
cellule. Comme cet état dépend de l’état précédent c( t − 1), qui lui-même dépend d’états en-
core précédents, le réseau peut conserver des informations qu’il a vu longtemps auparavant
(contrairement au RNN classique).

2.6.2 Le principe de fonctionnement

Les entrées de chaque porte sont pondérées par des poids liés aux portes ainsi que par un
biais. On a 4 matrices de poids (leurs dimensions dépendent des dimensions de des entrés
h( t − 1) ,xt )
— Wf : pondère l’entrée de la porte d’oubli (forget gate)
— Wi : pondère l’entrée de la porte d’entrée (input gate)
— WC : pondère les données qui vont se combiner à la porte d’entrée pour mettre à jour
l’état de la cellule (cell state)
— Wo : pondère l’entrée de la porte de sortie (output gate)
Détaillons à présent ce que fait chaque porte, en gardant en mémoire que les données sont
pondérées par les poids W auxquels on ajoute un biais qui dépend de la porte et qui est aussi

34
 2.6. LA CELLULE LSTM (LONG-SHORT-TERM-MEMORY)

F IGURE 2.14 – Le LSTM dispose de 4 matrices de poids (avec leurs biais) contrôlant ses portes.

mis à jour dans la phase d’apprentissage.

Porte d’oubli (forget gate) La porte d’entrée a pour rôle d’extraire l’information de
la donnée courante on va appliquer en parallèle sigmoïde aux deux données concaténées (cf
porte précédente) et une tanh
Le Sigmoïde deva renvoyer un vecteur pour lequel une coordonnée proche de 0 si-
gnifie que la coordonnée en position équivalente dans le vecteur concaténé n’est pas
importante. A l’inverse, une coordonnée proche de 1 sera jugée importante (i.e. utile
pour la prédiction que cherche à faire le LSTM).

Le tanh va simplement normaliser les valeurs (les écraser) entre -1 et 1 pour éviter les
problèmes de surcharge de l’ordinateur en calculs.

Le produit des deux permettra donc de ne garder que les informations importantes, les
autres étant quasiment remplacées par 0

Etat de la cellule (cell state) On parle de l’état de la cellule avant d’aborder la dernière
porte (porte de sortie), car la valeur calculée ici est utilisée dedans. L’état de la cellule se
calcule assez simplement à partir de la porte d’oubli et de la porte d’entrée : d’abord on
multiplie coordonnée à coordonnée la sortie de l’oubli ft avec l’ancien état de la cellule
c( t − 1). Cela permet d’oublier certaines informations de l’état précédent qui ne servent pas
pour la nouvelle prédiction à faire. Ensuite, on additionne le tout (coordonnée à coordonnée)
avec la sortie de la porte d’entrée it · ċ, ce qui permet d’enregistrer dans l’état de la cellule ce
que le LSTM (parmi les entrées et l’état caché précédent) a jugé pertinent, tout en respectant
l’equation suivante :
ct = ft · c( t − 1) + it · ċ (2.1)

35
 2.7. CONCLUSION

Porte de sortie (output gate) Dernière étape : la porte de sortie doit décider de quel
sera le prochain état caché, qui contient des informations sur les entrées précédentes du ré-
seau et sert aux prédictions.
Pour ce faire, le nouvel état de la cellule calculé juste avant est normalisé entre -1 et 1 grâce
à tanh Le vecteur concaténé de l’entrée courante avec l’état caché précédent passe, pour
sa part, dans une fonction sigmoïde dont le but est de décider des informations à conserver
(proche de 0 signifie que l’on oublie, et proche de 1 que l’on va conserver cette coordonnée
de l’état de la cellule).
Tout cela peut sembler magique en ce sens où on dirait que le réseau doit deviner ce qu’il doit
retenir dans un vecteur à la volée, mais rappelons bien qu’une matrice de poids est appliquée
en entrée. C’est cette matrice qui va, concrètement, stocker le fait que telle information est
importante ou non à partir des milliers d’exemples qu’aura vu le réseau !

2.7 Conclusion
Les architectures CNN sont des réseaux de neurones à propagation avant, feed-forward
en anglais dont l’information ne se déplace que dans une seule direction, vers l’avant,à partir
des noeuds d’entrée, en passant par les couches cachées (le cas échéant) et vers les noeuds de
sortie ainsi les connexions ne forment pas de cycles, ce qui est insuffisant pour l’étiquetage
de la séquence. Pour mieux explorer l’information temporelle des données séquentielles, des
réseaux récurrents (RNNs) ont été introduits, ils autorisent des connexions cycliques ce qui
active une "mémoire" des entrées précédentes pour persister dans l’état interne du réseau .
Le problème avec les RNNs est qu’ils ne sont pas bien capables de modéliser à longue dis-
tance les dépendances et de stocker des informations sur les entrées passées pour une longue
période. Pour résoudre ces problèmes, les chercheurs ont introduit les réseaux récurrents de
longue mémoire à court terme(LSTM) qui est une variante de RNNs conçue pour stocker et
accéder à l’information dans une séquence de longue durée. Comparés aux RNNs standards,
des portes multiplicatives non linéaires et une cellule de mémoire sont introduites.
Ces portes, y compris l’entrée, la sortie et la porte d’oubli, régissent l’information circu-
lée à l’intérieur et l’extérieur de la cellule de mémoire. Avec ces unités, LSTM est capable
d’exploiter la mémoire temporelle à longue distance et évite les problèmes de disparition de
gradients et explosion.

36
Chapitre 3

Classification des vidéos avec Deep

Learning

3.1 Introduction
Ce chapitre comprend deux parties essentielles de classification :

— la classification des vidéos en utilisant le modèle pré-entrainée de CNN ResNet50.

— La classification des vidéos en utilisant trois modèles prés-entraines de CNN fusionné
avec LSTM.

3.2 Environnement logiciel

ANACONDA[19] :est une distribution libre et open source des langages de programma-
tion Python et R appliqué au développement d’applications dédiées à la science des données
et à l’apprentissage automatique (traitement de données à grande échelle, analyse prédictive,
calcul scientifique), qui vise à simplifier la gestion des paquets et de déploiement. Les ver-
sions de paquetages sont gérées par le système de gestion de paquets conda. En outre, la
distribution Anaconda est utilisée par plus de 6 millions d’utilisateurs. La version d’installa-
tion comprend plus de 250 paquets populaires en science des données adaptés pour Windows,
Linux et MacOS, et plus de 7 500 paquets open-source supplémentaires peuvent être instal-
lés à partir de PyPI ainsi que du gestionnaire de paquets et d’environnements virtuels conda.
Et pour permettre aux utilisateurs de lancer des applications et gérer les librairies conda, on
trouve une interface graphique (GUI) qui s’appelle navigateur Anaconda qui est une incluse
dans la distribution Anaconda
JUPYTER[20] : est une application web utilisée pour programmer dans plus de 40 lan-
gages de programmation, dont Python, Julia, Ruby, R, ou encore Scala2. C’est un projet

37
 3.3. PRÉSENTATION DES BIBLIOTHÈQUES UTILISÉES EN DL

communautaire dont l’objectif est de développer des logiciels libres, des formats ouverts
et des services pour l’informatique interactive. Jupyter est une évolution du projet IPython.
Ainsi il permet de réaliser des programmes contenant à la fois du texte en markdown et du
code. Ces calepins sont utilisés en science des données pour explorer et analyser des don-
nées.
Jupyter Notebook se caractérise par un environnement de programmation interactif basé sur
le Web permettant de créer des documents Jupyter Notebook. Un document Jupyter Note-
book est un document JSON. Il suit un schéma contenant une liste ordonnée de cellules
d’entrée/sortie. Celles-ci peuvent contenir du code, du texte (à l’aide de Markdown), des
formules mathématiques, des graphiques et des médias interactifs. Ce document se termine
généralement par l’extension ".ipynb".
PYTHON[21] : est un langage de programmation interprété, multi-paradigme et multiplate-
formes. Il favorise la programmation impérative structurée, fonctionnelle et orientée objet. Il
est doté d’un typage dynamique fort, d’une gestion automatique de la mémoire par ramasse-
miettes et d’un système de gestion d’exceptions ; il est ainsi similaire à Perl, Ruby, Scheme,
Smalltalk et Tcl.
Le langage Python est placé sous une licence libre proche de la licence BSD et fonctionne
sur la plupart des plates-formes informatiques, des smartphones aux ordinateurs centraux, de
Windows à Unix avec notamment GNU/Linux en passant par macOS, ou encore Android,
iOS, et peut aussi être traduit en Java ou .NET. Il est conçu pour optimiser la productivité des
programmeurs en offrant des outils de haut niveau et une syntaxe simple à utiliser. Il est éga-
lement apprécié par certains pédagogues qui y trouvent un langage où la syntaxe, clairement
séparée des mécanismes de bas niveau, permet une initiation aisée aux concepts de base de
la programmation.

3.3 Présentation des bibliothèques utilisées en DL

Avant de commencer par le processus du classification de vidéos par des modèles de
Deep learning. On va présenter les principles bibliothèques de Deep Learning.

3.3.1 TensorFlow
Il s’agit d’une bibliothèque Open Source de calcul numérique et de Machine Learning
compatible avec le langage Python. Elle simplifie le processus d’acquisition de données,
d’entraînement des modèles de Machine Learning, de génération de prédictions et de raffi-
nement des résultats futurs. TensorFlow regroupe des modèles et des algorithmes de Machine
Learning et de Deep Learning. Le langage Python offre une API front-end pratique et confor-
table pour créer des applications à l’aide de ce framework. Ces applications peuvent ensuite

38
 3.3. PRÉSENTATION DES BIBLIOTHÈQUES UTILISÉES EN DL

être exécutées en C++. Il est possible de se servir de ce framework pour entraîner et exé-
cuter des réseaux de neurones profonds pour la classification de chiffres manuscrits, pour
la reconnaissance d’image, pour le plongement lexical, pour les réseaux de neurones récur-
rents, pour les modèles "sequenceto-sequence" de traduction automatique, pour le traitement
naturel du langage, et pour les simulations basées sur les équations aux dérivées partielles.
Son nom s’inspire notamment du fait que les opérations actuelles des réseaux de neurones
s’effectuent principalement via une table multidimensionnelle de données, appelée Tenseurs
(Tensor) qui est l’équivalent d’une matrice. Aujourd’hui, ce framework est utilisé par les
grandes entreprises [22] comme Intel, Twitter, Lenovo, Nvidia, etc...

3.3.2 Keras 2.8.0

Keras [23] est une bibliothèque open source écrite en Python (sous licence MIT) basée
principalement sur les travaux du développeur de Google François Chollet dans le cadre
du projet ONEIROS (Open-ended Neuro-Electronic Intelligent Robot Operating System).
Une première version du logiciel multiplateforme a été publiée le 28 mars 2015. Le but
de cette bibliothèque est de permettre la constitution rapide de réseaux neuronaux. Dans ce
cadre, Keras ne fonctionne pas comme un framework propre mais comme une interface de
programmation applicative (API) pour l’accès et la programmation de différents frameworks
d’apprentissage automatique. Theano, Microsoft Cognitive Toolkit (anciennement CNTK) et
TensorFlow font notamment partie des frameworks pris en charge par Keras. Un autre outil
permettrait de donner plus de sens à la transformation vectorielle d’un texte et permettrait
aussi une meilleure classification.

3.3.3 OpenCV 4.3.0

OpenCV [24] une interface GPU basée sur OpenCL, OpenCV (Open Source Computer
Vision Library) est une bibliothèque de logiciels open source de vision par ordinateur et d’ap-
prentissage automatique. OpenCV a été conçu pour fournir une infrastructure commune pour
les applications de vision par ordinateur et pour accélérer l’utilisation de la perception par
machine dans les produits commerciaux. La bibliothèque contient plus de 2500 algorithmes
optimisés, qui comprennent un ensemble complet d’algorithmes de vision par ordinateur et
d’apprentissage automatique classiques et à la pointe de la technologie.

3.3.4 NumPy 1.19.0

NumPy [25] est une bibliothèque pour le langage de programmation Python, ajoutant
la prise en charge de grands tableaux et matrices multidimensionnels, ainsi qu’une grande
collection de fonctions mathématiques de haut niveau pour opérer sur ces tableaux.

39
 3.4. TRANSFER LEARNING ET FINE TUNING

3.3.5 Matplotlib 3,2,2

Matplotlib [26] est une bibliothèque de traçage pour le langage de programmation Python
et son extension de mathématiques numériques NumPy.

3.3.6 Scikit-learn 0.23.1

Il s’agit d’une bibliothèque d’apprentissage automatique gratuite [27] pour Python. Il
comporte divers algorithmes tels que la machine à vecteurs de support, les forêts aléatoires
et les k-voisins, et il prend également en charge les bibliothèques numériques et scientifiques
Python telles que NumPy et SciPy.

3.3.7 Imutils 0.5.4

Une série de fonctions pratiques [28] pour rendre les fonctions de traitement d’image de
base telles que la traduction, la rotation, le redimensionnement, la squelettisation, l’affichage
d’images Matplotlib, le tri des contours, la détection des contours et bien plus facilement
avec OpenCV et Python 2.7 et Python 3.

3.4 Transfer Learning et fine tuning

Avant de commencer par le processus de classification et puisque nous travaillons sur une
approche de transfert de connaissances d’un modèle à un autre. Dans ce cas, on doit définir
le concept de l’apprentissage.
Qu’est ce qu’un Transfer Learning ?
L’apprentissage par transfert Transfer Learning en anglais , désigne l’ensemble des méthodes
qui permettent de transférer les connaissances acquises à partir de la résolution de problèmes
donnés pour traiter un autre problème.
Le Transfer Learning a connu un grand succès avec l’essor du Deep Learning. En effet, bien
souvent, les modèles utilisés dans ce domaine nécessitent des temps de calcul élevés et des
ressources importantes. Or, en utilisant des modèles pré-entraînés comme point de départ,
le Transfer Learning permet de développer rapidement des modèles performants et résoudre
efficacement des problèmes complexes dans la vision par ordinateur. Qu’est ce qu’un fine
tunning ?
Le fine tuning consiste à prendre des poids d’un réseau de neurones pré-entrainées et l’uti-
liser comme des poids initiales pour un nouveau modèle formé à travers l’apprentissage par
transfert.
il peut contenir plusieurs étapes comme suite :
— L’élimination des noeuds entièrement connectés à l’extrémité du réseau (c.-à-d, lorsque
des prédictions de classe réelle sont faites).

40
 3.5. L’APPROCHE DU RÉSEAU CNN POUR LA CLASSIFICATION VIDÉO

F IGURE 3.1 – Approche traditionnelle vs. Approche de Transfert Learning.

— Le remplacement des noeuds entièrement connectés par des noeuds fraîchement ini-
tialisés.
— Congélation des couches de convolution précédentes au début du réseau (veiller à
ce que toutes les fonctions robustes précédemment apprises par CNN ne soient pas
détruites).
— L’entraînement uniquement les têtes (head) de couches entièrement connectées
Il est utilisé pour :
— Accélérer l’entrainement
— Les petites taille de données

3.5 L’approche du réseau CNN pour la classification vidéo

3.5.1 Réseau CNN basé sur ResNet50
Le modèle que nous venons d’implémenter dans cette section est un réseau CNN pour en
donner un premier aperçu sur la classification.Or, ce modèle contient deux couches convolu-
tionnelles, et deux couches entièrement connecté et une couche sous-échantillonnage.
Les vidéos peuvent être définies comme une série d’images individuelles. Le Deep learning
vient pour traiter rapidement ces types de classification. Cependant, la classification vidéo
est plus qu’une simple classification d’images car avec la vidéo on est censé d’adopter les
deux dimensions spatiales et temporelles.
Notre approche tente d’appliquer une classification d’image à la classification vidéo.Pour
cette raison,l’algorithme que nous proposons est :
— Boucler sur toutes les images du fichier vidéo
— Pour chaque frame, passez la frame à travers le CNN
— Obtenir les prédictions du CNN

41
 3.5. L’APPROCHE DU RÉSEAU CNN POUR LA CLASSIFICATION VIDÉO

— Maintenir une liste des dernières K prédictions

— Calculer la moyenne prédictions et choisir l’étiquette avec la plus grande probabilité
correspondante
— choisir l’étiquette qui a la plus grande probabilité et qu’elle soit affecté à la sortie de
ce traitement
l’ensemble de données de la classification L’ensemble de données que nous avons traité
concerne particulièrement la classification des activités sportives :(Swimming ,Badminton
,Wrestling, Olympic Shooting ,Cricket,Football ,Tennis ,Hockey ,Ice Hockey ,Kabaddi ,WWE
wrestling ,Gymnasiumn ,Weight lifting ,Volleyball ,Table tennis ,Baseball ,Formula 1 ,Moto
GP ,Chess ,Boxing ,Fencing ,Basketball).[17] Pour ce fait, que nos données d’images d’en-
trainement on les a organisé par classe dans le répertoire sporttypeclassifier.Et d’autre part,
nos fichiers de classification se trouvent dans le répertoire videoclassificationmodel.
Nous nous sommes concentrés sur les scripts Python suivants :
train.py un script Keras qui saisit les images de classe des données qui nous intéressent,par
la suite charge le CNN ResNet50 et applique l’apprentissage par l’ajustement des poids Ima-
geNet pour former notre modèle.
Le script d’entraînement génère trois fichiers :
Un classificateur basé sur ResNet50 pour la reconnaissance des sports.
Un fichier binaire se compose d’étiquettes de chacun de nos classes.
Une vidéo d’entrée qui permet de procéder à la classification vidéo.
Au début de notre programme on va importer les libraires nécessaire pour implémenter notre
réseau.
1 import matplotlib
2 from keras.preprocessing.image import ImageDataGenerator
3 from keras.layers.pooling import AveragePooling2D
4 from tensorflow.keras.applications import ResNet50
5 from keras.layers.core import Dropout
6 from keras.layers.core import Flatten
7 from keras.layers.core import Dense
8 from keras.layers import Input
9 from keras.models import Model
10 from tensorflow.keras.optimizers import SGD
11 from sklearn.preprocessing import LabelBinarizer
12 from sklearn.model_selection import train_test_split
13 from sklearn.metrics import classification_report
14 from imutils import paths
15 import matplotlib.pyplot as plt
16 import numpy as np
17 import argparse
18 import pickle
19 import cv2
20 import os

42
 3.5. L’APPROCHE DU RÉSEAU CNN POUR LA CLASSIFICATION VIDÉO

Dans ce script, nous avons spécifié le chemin d’accès aux données d’entrée, le chemin vers
le fichier de modèle keras en sortie, le chemin d’accès au fichier pickle d’étiquettes de sortie,
et le nombre d’époques pour entrainer notre réseau, on a choisi dans cet état 25 époques.
1 datapath = r"C:\Users\PC\Desktop\AI\sport_type_classifier\data"
2 outputmodel =r"C:\Users\PC\Desktop\AI\sport_type_classifier\
video_classification_model\videoclassificationModel"
3 outpulablbinarizer = r"C:\Users\PC\Desktop\AI\sport_type_classifier\
video_classification_model\videoclassificationbinarizer"
4 epoch=25

L’ensemble des classes contenant dans LABELS (Linges 1-2) à partir de laquelle il sera
compose notre ensemble de données. Et toutes étiquettes non présents dans cet ensemble
seront exclues.
1 Sport_Labels = set([’boxing’,’swimming’,’table_tennis’])
2 print("Images is being loaded.......")
3 pathToImages = list(paths.list_images(datapath))
4 data = []
5 labels= []
6 for images in pathToImages:
7 label = images.split(os.path.sep)[-2]
8 if label not in Sport_Labels:
9 continue
10 image = cv2.imread(images)
11 image = cv2.cvtColor(image,cv2.COLOR_BGR2RGB)
12 image = cv2.resize(image,(244,244))
13 data.append(image)
14 labels.append(label)

Ensuite, on fait intervenir l’ensemble de données imagePaths.

On initialise les données étiquetées,à partir de là, nous commençons à boucler sur tous les
données ImagePath.
Et par la suite, on charge et on pré-traite un image. Le pré-traitement comprend l’échange de
canaux de couleur pour la compatibilité OpenCV vers Keras et le redimensionnement à 224
24px. L’image et l’étiquette sont ensuite ajoutées aux listes de données et d’étiquettes.
1 data = np.array(data)
2 labels = np.array(labels)
3 lb = LabelBinarizer()
4 labels = lb.fit_transform(labels)
5 (X_train, X_test, Y_train, Y_test) = train_test_split(data,labels,
test_size=0.25, stratify=labels, random_state=42)

On convertit la liste de données et les étiquettes en tableau Numpy après on les code de façon
à ce que une étiquette de classe peut se présenter à partir des éléments de tableau binaire. Par
exemple, "football" peut être un tableau ([1, 0, 0]) tandis que "Baseball" peut être un tableau
([0, 0, 1]). Puis, on subdivise nos données en fractions d’entrainement et de test en utilisant

43
 3.5. L’APPROCHE DU RÉSEAU CNN POUR LA CLASSIFICATION VIDÉO

75 % des données pour l’entraînement et les 25 % restants pour les tests.

Augmentation des données avec la classe ImageDataGenerator de Keras
Dans ce script on a introduit une classe ImageDataGenerator de Keras qui fonctionne en fait
par :
— Accepter un ensemble d’images utilisées pour l’entrainement.
— Prendre cet ensemble et appliquer une série de transformations aléatoires à chaque
image de l’ensemble, notamment la rotation aléatoire, le redimensionnement, etc.
— Remplacement de l’ensemble d’images original avec le nouvel ensemble d’images
transformées aléatoirement.
— Former le CNN sur cet ensemble transformé de manière aléatoire (c’est-à-dire que
les données d’origine elles-mêmes ne sont pas utilisées pour l’entrainement)
Généralement, ImageDataGenerator accepte les données originales, les transforme aléatoire-
ment et ne retourne que les données récemment transformées.L’objectif lors de l’application
de l’augmentation des données est d’augmenter la généralisation du modèle.
Un modèle formé sur ces données modifiées et augmentées est plus susceptible de se géné-
raliser à des exemples de données non inclus dans l’ensemble des données d’entraînement.
La ligne 13 sert à définir la valeur moyenne mean est la somme des valeurs de pixels divisées
par le nombre total de valeurs de pixels d’une image,et sert à la normalisation des entités de
données pendant l’augmentation.
Les 14-15 lignes définissent l’attribut de moyenne mean pour trainAug et valAug afin que la
valeur de moyenne soit effectuée au fur et à mesure que les images sont générées pendant
l’entraînement/l’évaluation.

1 # initialisation un objet trainAug pour l’augmantation des donneés d’

entrainment
2 trainAug = ImageDataGenerator(
3 rotation_range=30,
4 zoom_range=0.15,
5 width_shift_range=0.2,
6 height_shift_range=0.2,
7 shear_range=0.15,
8 horizontal_flip=True,
9 fill_mode="nearest")
10 # initialiser l’objet valAug d’augmentation des données de validation/
test
11 valAug = ImageDataGenerator()
12 # définir la valeur moyenne mean est la somme des valeurs de pixels
divisées par le nombre total de valeurs de pixels d’un image pour
chacune des augmentations de données
13 mean = np.array([123.68, 116.779, 103.939], dtype="float32")
14 trainAug.mean = mean
15 valAug.mean = mean

44
 3.5. L’APPROCHE DU RÉSEAU CNN POUR LA CLASSIFICATION VIDÉO

Construction de notre modèle

Dans les lignes 2-3 ,on charge ResNet50 qui formé avec les poids d’ImagNet,et par la suite
on construit un headModel qui sera basé sur ResNet50 en lui ajoutant après des couches de
convolution,Ensuite on va congeler la base du modèle baseModel de façon à ce qu’elle ne soit
pas entrainée par rétropropagation du gradient.à savoir que la rétropropagation du gradient
permet de calculer le gradient de l’erreur pour chaque neurone, de la dernière couche vers la
première.
1 #charger le réseau ResNet-50, en s’assurant que les ensembles de couches
FC principaux sont laissés désactivé
2 baseModel = ResNet50(weights="imagenet", include_top=False,
3 input_tensor=Input(shape=(224, 224, 3)))
4 #construire la tête(le head) du modèle qui sera placée au-dessus du le
modèle de base
5 headModel = baseModel.output
6 headModel = AveragePooling2D(pool_size=(7, 7))(headModel)
7 headModel = Flatten(name="flatten")(headModel)
8 headModel = Dense(512, activation="relu")(headModel)
9 headModel = Dropout(0.5)(headModel)
10 headModel = Dense(len(lb.classes_), activation="softmax")(headModel)
11 #placer le modèle de tête FC au-dessus du modèle de base
12 model = Model(inputs=baseModel.input, outputs=headModel
13 #boucle sur tous les couches du modèle de base pour qu’ils ne pas être
mis à jour pendant le processus d’entrainment
14 for layer in baseModel.layers:
15 layer.trainable = False

Entrainement du modèle
Les lignes 4-5-6 compiler notre modèle avec l’optimiseur Stochastic Gradient Descent (SGD)
avec un taux d’apprentissage initial(lr=1e-4),et une désintégration du taux d’apprentissage
(decay=1e-4) pour commencer à entrainer le réseau avec un grand taux d’apprentissage, puis
à le réduire jusqu’à ce que les minima locaux soient obtenus.pour aider à l’optimisation et à
la généralisation de modèle formé.
Nous utilisons la perte "categorical_crossentropy" pour l’entraînement car on a plusieurs
classes de donnés.Après on fait Un appel à la fonction fit_generator sur notre modèle (Lignes
11-16) pour entrainer notre réseau avec les données augmentées.
ant donné que notre modèle de base ResNet50 est gelé et que nous ne formons que la tête i.e
le headModel. C’est ce qu’on appelle le fine-tuning ou le réglage à fin.

1 #compiler notre modèle formé après avoir défini notrecouches à être non
entraînable
2 print("[INFO] compiling model...")
3 opt = SGD(lr=0.0001, momentum=0.9, decay=1e-4 /epoch)
4 model.compile(loss="categorical_crossentropy", optimizer=opt,

45
 3.5. L’APPROCHE DU RÉSEAU CNN POUR LA CLASSIFICATION VIDÉO

5 metrics=["accuracy"])
6 print("[INFO] training head...")
7 H = model.fit_generator(
8 trainAug.flow(trainX, trainY, batch_size=32),
9 steps_per_epoch=len(trainX) // 32,
10 validation_data=valAug.flow(testX, testY),
11 validation_steps=len(testX) // 32,
12 epochs=epoch )

Les métriques d’évaluation du réseau

Dans ce script, nous avons fait l’évaluation de nos réseaux sur l’ensemble de données et le
traçage des graphes de précision/perte.
1 #évaluer le réseau
2 print("[INFO] evaluating network...")
3 predictions = model.predict(testX, batch_size=32)
4 print(classification_report(testY.argmax(axis=1),
5 predictions.argmax(axis=1), target_names=lb.classes_))
6 #traçage la perte d’entraînement et la précision loss et accuracy
7 N = epoch
8 plt.style.use("ggplot")
9 plt.figure()
10 plt.plot(np.arange(0, N), H.history["loss"], label="train_loss")
11 plt.plot(np.arange(0, N), H.history["val_loss"], label="val_loss")
12 plt.plot(np.arange(0, N), H.history["accuracy"], label="train_acc")
13 plt.plot(np.arange(0, N), H.history["val_accuracy"], label="val_accuracy"
)
14 plt.title("Training Loss and Accuracy on Dataset")
15 plt.xlabel("Epoch")
16 plt.ylabel("Loss/Accuracy")
17 plt.legend(loc="lower left")
18 plt.savefig("plot")

Dans ce script on enregistre notre modèle et fichier binaire d’étiquettes des classes de don-
nées.
1 # serializing the model to disk
2 print("[INFO] serializing network...")
3 model.save(outputmodel)
4 lbinarizer=open(r"C:\Users\moad\PFE\Input\binarizer.pickle","wb")
5 lbinarizer.write(pickle.dumps(lb))
6 lbinarizer.close()

3.5.2 Résultats d’entrainement

Avant de pouvoir classer les images d’une vidéo avec notre CNN,nous devons d’abord
entrainer le modèle.(Voir Figure 3.2).

46
3.5. L’APPROCHE DU RÉSEAU CNN POUR LA CLASSIFICATION VIDÉO

F IGURE 3.2 – Le résultat d’entrainement.

47
 3.5. L’APPROCHE DU RÉSEAU CNN POUR LA CLASSIFICATION VIDÉO

F IGURE 3.3 – L’évaluation de modèle formé.

Nous avons obtenu une précision de 92% après l’entraînement de notre ensemble de données
sportives (Voir la Figure 3.3)
La Figure 3.4 montre :
— La perte fait référence à la valeur de perte sur les données d’entraînement après
chaque époque. C’est ce que le processus d’optimisation essaie de minimiser avec
l’entrainement,donc, plus c’est bas,plus c’est mieux.
— La précision fait référence au rapport entre les prédictions correctes et le nombre total
de prédictions dans les données d’entraînement. Plus c’est élevé,plus c’est mieux.Ceci
est normalement inversement corrélé avec la perte
Remarque Dans la Figure 3.4 On remarque que les deux courbes Bleu charrette,Gris de
Payne qui font référence à la valeur de précision sur les données d’entraînement et de va-
lidation ont convergé après chaque époque vers des grandes valeurs jusqu’à atteindre une
précision de 92%.
Par contre, les deux courbes rouge, bleu qui font référence à la valeur de perte sur les données
d’entraînement et de validation ont convergé après chaque époque vers des petites valeurs
proches de zéros.

3.5.3 Classification vidéo avec le modèle formé

Après avoir enregistré nos modèles, formés et labels de fichiers binaires de classes de
données.On a pu introduire les deux fichiers dans un autre programme qui sert à la classifi-
cation vidéo, il prend comme input le modèle formé et le fichier binaire pour aider le modèle
attribut une classe avec plus grande confiance au moment de la prédiction.
En général, le programme effectue le traitement sur la vidéo d’entrée et renvoie à la sortie de
la vidéo classifiée.

48
 3.5. L’APPROCHE DU RÉSEAU CNN POUR LA CLASSIFICATION VIDÉO

F IGURE 3.4 – Graphe précision/perte.

Dans ce script, nous avons chargé les paquets et modules nécessaires.En particulier,nous uti-
lisons deque du module collections de Python pour faciliter le calcule de moyenne mobile
ou moyenne glissante ; qui est une moyenne statistique utilisée pour analyser des séries or-
données de données, le plus souvent des séries temporelles, en supprimant les fluctuations
transitoires de façon à en souligner les tendances à plus long terme.
Cette moyenne est dite mobile parce qu’elle est recalculée de façon continue, en utilisant à
chaque calcul un sous-ensemble d’éléments dans lequel un nouvel élément remplace le plus
ancien ou s’ajoute au sous-ensemble.
1 from keras.models import load_model
2 from collections import deque
3 import numpy as np
4 import argparse
5 import pickle
6 import cv2

Importation du modèle et le fichier binaire d’étiquettes

Dans ce script, on a chargé le modèle et le fichier binaire, après on initialise la valeur
moyenne qui sers à la normalisation des entités de données et le modèle de collection de
Python deque pour faciliter le calcul de moyenne.
1 # charger le modèle formé et le binariseur d’étiquettes
2 print("[INFO] loading model and label binarizer...")
3 model = load_model(r"C:\Users\moad\Downloads\Nouveau dossier\model")
4 lb = pickle.loads(open(r"C:\Users\moad\Downloads\Nouveau dossier\Input\
binarizer.pickle", "rb").read())
5 #initialiser la moyenne de l’image pour la soustraction moyenne avec la
6 #file d’attente des prédictions
7 mean = np.array([123.68, 116.779, 103.939][::1], dtype="float32")
8 Q= deque(maxlen=128)

49
 3.5. L’APPROCHE DU RÉSEAU CNN POUR LA CLASSIFICATION VIDÉO

La lecture de la vidéo d’entrée

Le script suivant va lire la vidéo d’entrée image par image.
1 # initialiser le flux vidéo, pointeur vers le fichier vidéo de sortie, et
2 dimensions du frame
3 vs = cv2.VideoCapture(r"C:\Users\moad\Downloads\Nouveau dossier\Input\
demo_video.mp4")
4 writer = None
5 (W, H) = (None, None)
6 # boucle sur les images du flux de fichiers vidéo
7 while True:
8 # lire le frame suivante de fichier
9 (grabbed, frame) = vs.read()
10 #si le frame n’a pas été saisi, alors nous avons atteint la fin
11 du flux de fichiers vidéo
12 if not grabbed:
13 break
14 # si les dimensions du frame sont vides, saisissez-les
15 if W is None or H is None:
16 (H, W) = frame.shape[:2]

Traitement de frame
Dans le script suivant, nous effectuons une série d’opérations sur chaque image particulière. :
— Permutation des canaux de couleur (Ligne 5)
— Redimensionnement à 22424px (Ligne 6)
— Soustraction moyenne (Ligne 7)
Remarque : La soustraction moyenne est soustraite de toute image d’entrée que nous avions
fournissez au réseau de neurones. L’intérêt est d’avoir des entrées qui sont (en moyenne)
centrées autour de zéro. Le pixel moyenne (mean) est simplement la moyenne de tous les
pixels de l’image
1 # clonez l’image de sortie, puis convertissez-la de BGR en RVB
2 # ordonnez, redimensionnez le frame à un 224x224 fixe, puis
3 # effectuer une soustraction moyenne
4 output = frame.copy()
5 frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
6 frame = cv2.resize(frame, (224, 224)).astype("float32")
7 frame -= mean

Calcul de prédictions
Concernant la ligne 2 on fait des calculs de prédictions sur l’image actuelle. Les résultats de
la prédiction sont ajoutés au Q via la ligne 3. partir de là, les lignes 5 à 8 effectuent une
moyenne de prédiction sur Q, ce qui donne une étiquette de classe pour la moyenne mo-
bile. en général ces lignes trouvent l’étiquette avec la plus grande probabilité correspondante
parmi les prédictions moyennes.

50
 3.5. L’APPROCHE DU RÉSEAU CNN POUR LA CLASSIFICATION VIDÉO

1 # faire des prédictions sur le frame, puis mettre à jour les prédictions
file d’attente
2 preds = model.predict(np.expand_dims(frame, axis=0))[0]
3 Q.append(preds)
4 # effectuer une moyenne de prédiction
5 results = np.array(Q).mean(axis=0)
6 i = np.argmax(results)
7 label = lb.classes_[i]

Génération de vidéo classé

Dans le script suivant on fait l’affichage des étiquettes trouver dans le variable label sous
forme de texte sur la vidéo en sortie pour afficher la classe de celui-ci
1 #dessiner l’activité sur le frame de sortie
2 text = "activity: {}".format(label)
3 cv2.putText(output, text, (35, 50), cv2.FONT_HERSHEY_SIMPLEX,1.25, (0,
255, 0), 5)
4 #vérifiez si lecriture de la vidéo est null
5 if writer is None:
6 # initialize our video writer
7 fourcc = cv2.VideoWriter_fourcc(*"MJPG")
8 writer = cv2.VideoWriter(r"C:\Users\moad\Downloads\Nouveau dossier\
outvideo.avi", fourcc, 30,
9 (W, H), True)
10 # écrire la frame de sortie sur l’output
11 writer.write(output)
12 # afficher l’image de sortie
13 cv2.imshow("Output", output)
14 key = cv2.waitKey(1) & 0xFF
15 if key == ord("q"):
16 break
17 # libérer les pointeurs de fichier
18 print("[INFO] cleaning up...")
19 writer.release()
20 vs.release()

3.5.4 Résultats de la classification vidéo

Par conséquent, nous pouvons voir que la vidéo d’entrée est correctement classée (Voir
la Figure 3.5).

51
 3.6. CLASSIFICATION VIDÉO AVEC DES MODÈLES HYBRIDES CNN-LSTM

F IGURE 3.5 – La vidéo output.

3.6 Classification vidéo avec des modèles hybrides CNN-

LSTM
Les réseaux de neurones conventionnels (CNN) sont efficaces pour les données d’image
tandis que les réseaux de mémoire à terme long (LSTM) sont excellents pour un traitement
de données séquentiel à travers leurs dimensions temporelles telles que la donnée vidéo.
De ce fait, que la combinaison entre ces deux approches va nous permettre d’obtenir un
meilleur résultat notamment pour la classification vidéo. Dans cette section, on va opter pour
une implémentation de la classification des images animées à l’aide d’un réseau neuronal
conventionnel combiné avec un réseau de mémoire à terme long, nous utilisons des diffé-
rentes architectures dans Tensorflow qui vont nous apporter une meilleure performance au
niveau de la prédiction, qu’on va citer : ResNet50 qu’on a traité dans la section précédente,
on doit l’associer au LSTM afin de mettre en exergue le rôle de LSTM dans la mémorisa-
tion de séquences. De la même façon, on opte après à l’utilisation de VGG-16 associé au
LSTM, et par la suite l’utilisation d’Inceptionv3 avec le LSTM. Pour en conclure par la suite
l’approche la plus performante avec la précision la plus optimale.

3.6.1 Classification avec ResNet50

importation des libraires nécessaire pour le programme :
1 import os, glob
2 import imageio
3 import itertools

52
 3.6. CLASSIFICATION VIDÉO AVEC DES MODÈLES HYBRIDES CNN-LSTM

4 import math
5 import numpy as np
6 import pandas as pd
7 import tensorflow as tf
8 import matplotlib.pyplot as plt
9 from tensorflow.keras.models import Model, Sequential
10 from tensorflow.keras.layers import Dense, Activation, Dropout, Flatten,
TimeDistributed, LSTM, Input, BatchNormalization, Conv2D, MaxPooling2D
, Reshape, Conv1D, GlobalAveragePooling1D, MaxPooling1D, Lambda
11 from tensorflow.keras.utils import to_categorical
12 from tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau
, EarlyStopping
13 from tensorflow.keras.preprocessing.image import ImageDataGenerator
14 import matplotlib.pyplot as plt

Dans le script suivant on a crée une fonction read\_gif qui va prendre comme paramètre le
fichier d’image animée va lire le fichier frame par frame et redimensionner puis convertir en
RGB tous les frames de fichier stocker tous les frames d’un tableau.
1 from PIL import Image, ImageSequence
2 import numpy as np
3 def read_gif(filename):
4 max_frames = 50
5 im = Image.open(filename)
6 frames = []
7 for frame in ImageSequence.Iterator(im):
8 #print(frame.size)
9 resized_frame = np.array(frame.convert(’RGB’).resize((200,200)))
10 frames.append(resized_frame)
11 frames = frames*max_frames
12 return np.asarray(frames[:max_frames])

Construction de modèle CNN-LSTM

Les entrées de notre modèle ont une dimension de (frames, channels ; rows, columns) et que
les sorties ont une dimension (nombre de classes) et puis on récupère les entités de la dernière
couche de pooling dans le modèle pré-entraîné ResNet50 et transmet les caractéristiques
obtenues au réseau LSTM.
1

2 """ IMAGE_HEIGHT = 200

3 IMAGE_WIDTH = 200
4 IMAGE_CHANNEL = 3
5 NUM_FRAMES = 50
6 NUM_CLASSES = 2
7 """
8 def build(self):
9 video =Input(shape=(self.frames_n,self.img_w, self.img_h, IMAGE_CHANNEL))

53
 3.6. CLASSIFICATION VIDÉO AVEC DES MODÈLES HYBRIDES CNN-LSTM

10 cnn_base = ResNet50(weights="imagenet", include_top=False,input_tensor=

Input(shape=(200, 200, 3)))
11 cnn_out = GlobalAveragePooling2D()(cnn_base.output)
12 cnn = Model(cnn_base.input, cnn_out)
13 cnn.trainable = False
14 encoded_frames = TimeDistributed(cnn)(video)
15 encoded_sequence = LSTM(256)(encoded_frames)
16 hidden_layer = Dense(1024, activation="relu")(encoded_sequence)
17 outputs = Dense(NUM_CLASSES, activation="softmax")(hidden_layer)
18 self.model = Model([video], outputs)
19 def summary(self):
20 #Résume l’architecture du modèle.
21 #:return: : renvoie le résumé de l’architecture du modèle
22 return self.model.summary()

l’architecture du modèle.
Le modèle est composé de :
— Le modèle pré-entrainé de CNN Res Net50 avec 25 636 712 paramètres
— Une couche time_distributede avec 23587712 paramètres, cette couche permettant d’ap-
pliquer un flux de convolutions à plusieurs entrées(ie frames) et il produit une sortie par
entrée pour obtenir le résultat à tempset aussi d’éviter le faite passé un seul frame à un
bloc de convolution car ceci génère un entraînement très long avec plusieurs erreurs
— Une couche LSTM avec 256 unités et 25636712 paramètres.
— Deux couches Denses qui permettent de chaque neurone de connecter à tous les neurones
de la couche précédente.
La génération des données d’entrainement et de validation
Dans le script suivant on fait la génération 40 fichiers des images animés des données entrai-
nement et 10 fichiers pour la validation[18]à l’aide de méthode Generate Dataset().
1 gen = GenerateDataset(’data/train/’, ’’, 40)
2 datasets = gen.generator()
3 num_samples = gen.get_sample_size()
4 steps_per_epoch = 5
5 # validation
6 val_gen = GenerateDataset(’data/val/’, ’’, 10)
7 val_datasets = val_gen.generator()
8 num_valid_samples = val_gen.get_sample_size()
9 steps_per_valid_epoch = 5
10 num_samples

L’entrainement
1 def train(self, generator,steps_per_epoch=None, epochs=1,
validation_data=None, validation_steps=None):
2 early_stopping_monitor = EarlyStopping(patience=3)
3 callbacks_list = [early_stopping_monitor]
4 print(’Training...’)

54
 3.6. CLASSIFICATION VIDÉO AVEC DES MODÈLES HYBRIDES CNN-LSTM

F IGURE 3.6 – L’architecture du modèle ResNet50-LSTM .

F IGURE 3.7 – L’entrainement de modèle formé.

Visualisation de la précision/perte d’entrainment et de test de modèle

Remarque :
Pour le graphe de précision de notre modèle nous pouvons estimer que les courbes d’orange,
bleu respectivement de test et d’entraînement,ils fluctuent entre les valeurs de 1 et 0,mais à
partir de l’époque 37 les deux convergent vers de grande valeur selon les époques de façons
croissantes.
Pour le graphe de perte de notre modèle nous pouvons estimer que les courbes d’orange, bleu
respectivement de test et d’entraînement,Au début d’entraînement ont des grandes valeurs et
pendant l’apprentissage,les valeurs se diminuent. à l’exclue de l’époque 35,et à partir 37,5
les deux convergent vers des valeurs proches de 0.Concernant ce modèle on peut en résulte

55
 3.6. CLASSIFICATION VIDÉO AVEC DES MODÈLES HYBRIDES CNN-LSTM

F IGURE 3.8 – Graphe précision/perte du modèle ResNet50-LSTM.

F IGURE 3.9 – La prédiction pour les données de validation .

qu’il est moins ajustés(Voir la Figure 3.8).

La prédiction
Dans ce scripte on a fait appelle a la méthode predict_genrator() qui prend comme paramètres
les données générer au début de programme et le nombre de donnée de validation qui est 20
fichier animé, après la méthode renvoie une matrice de prédiction pour chaque fichiers.(Voire
Figure 3.9)
1 model.predict_generator(val_datasets,num_valid_samples)

3.6.2 Classification avec VGG16

Dans la deuxième méthode, nous avons proposé un modèle d’apprentissage basé sur une
architecture VGG-16 associé à un LSTM. Le modèle que nous proposons ci-dessous est
un empilement de couches VGG16 qui servit comme entré à la couche LSTM d’une
taille de 256 avec une couche Dense pour en modifier les dimensions des paramètres à

56
3.6. CLASSIFICATION VIDÉO AVEC DES MODÈLES HYBRIDES CNN-LSTM

F IGURE 3.10 – Architecture du modèle VGG16-LSTM.

travers sa fonction d’activation “Softmax”.

1 def build(self):
2 #video = Input(shape=(frames, channels,rows, columns))
3 video =Input(shape=(self.frames_n,self.img_w, self.img_h,
IMAGE_CHANNEL)) # input shape
4 #input_shape=(channels,rows,columns)
5 cnn_base = VGG16(weights=’imagenet’, input_shape=(200, 200, 3),
include_top=False)
6 cnn_out = GlobalAveragePooling2D()(cnn_base.output)
7 cnn = Model(cnn_base.input, cnn_out)
8 cnn.trainable = False
9 encoded_frames = TimeDistributed(cnn)(video)
10 encoded_sequence = LSTM(256)(encoded_frames)
11 hidden_layer = Dense(1024, activation="relu")(encoded_sequence)
12 outputs = Dense(NUM_CLASSES, activation="softmax")(hidden_layer)
13 self.model = Model([video], outputs)

Architecture de ce modèle
Dans la figure 3.10 ci-dessous montre un résumé sur le modèle hybride VGG16-LSTM
qui accepte un total de paramètres égal à 15 767 362
Visualisation de la précision/perte d’entrainement et de test de modèle
Remarque :
Pour le graphe de précision de notre modèle nous pouvons voir que les courbes d’orange,
bleu respectivement de test et d’entraînement, Au début d’entraînement ont pris des va-

57
3.6. CLASSIFICATION VIDÉO AVEC DES MODÈLES HYBRIDES CNN-LSTM

F IGURE 3.11 – Graphe de précision/perte du modèle VGG16-LSTM.

leurs croissantes, à de l’époque 19, la précision et la perte ont pris des valeurs plus bas
et à partir d’époque 35 les deux ont convergé vers de grande valeur selon les époques de
façons croissantes.
Par contre pour le graphe de perte de notre modèle nous pouvons estimer que les courbes
d’orange, bleu respectivement de test et d’entraînement,au début ils ont des grandes va-
leurs ce qui est normal car notre modèle dans son début d’apprentissage, et plus qu’on
s’approche à l’époque 40 plus les valeurs des deux courbes s’amoindrissent. ce qui
montre que notre modèle a bien appris.(Voir la Figure 3.11).
Prédiction
Dans cette étape, on a trouvé un taux entre 91% et 99% ce qui montre très bien l’apparte-
nance de notre modèle VGG16-LSTM que l’approche dont on a utilisé hybride Resnet50
et LSTM,(Voire la Figure 3.12)

F IGURE 3.12 – Prédiction.

58
3.6. CLASSIFICATION VIDÉO AVEC DES MODÈLES HYBRIDES CNN-LSTM

3.6.3 Classification avec Inceptionv3

Dans la deuxième méthode, nous avons proposé un modèle d’apprentissage basé sur
une architecture Inceptionv3 associés à un LSTM. Le modèle que nous proposons ci-
dessous est un empilement de couches Inceptionv3 qui servit comme entré à la couche
LSTM d’une taille de 256 avec une couche Dense pour en modifier les dimensions des
paramètres à travers sa fonction d’activation “Softmax”.
1 def build(self):
2 #video = Input(shape=(frames, channels,rows, columns))
3 video =Input(shape=(self.frames_n,self.img_w, self.img_h,
IMAGE_CHANNEL)) # input shape
4 #input_shape=(channels,rows,columns)
5 cnn_base = InceptionV3(weights=’imagenet’, input_shape=(200, 200, 3)
, include_top=False)
6 cnn_out = GlobalAveragePooling2D()(cnn_base.output)
7 cnn = Model(cnn_base.input, cnn_out)
8 cnn.trainable = False
9 encoded_frames = TimeDistributed(cnn)(video)
10 encoded_sequence = LSTM(256)(encoded_frames)
11 hidden_layer = Dense(1024, activation="relu")(encoded_sequence)
12 outputs = Dense(NUM_CLASSES, activation="softmax")(hidden_layer)
13 self.model = Model([video], outputs)

Architecture de ce modèle
Dans la figure 3.13 montre un résumé sur le modèle hybride Inceptionv3 et LSTM qui
accepte un total de paramètres égal à 24 428 322.
Visualisation du résultat
Remarque :
Pour le graphe de précision de notre modèle nous pouvons voir que les courbes d’orange,
bleu respectivement de test et d’entraînement, au début de ce dernier ont pris des valeurs
croissantes, à partir de l’époque 5, la précision et la perte ont pris des valeurs plus proches
de 1 (0.99) et constantes tout au long d’entraînement ce qui montre que le modèle d’hy-
bride Inceptionv3-LSTM est capable d’apprendre plus vite et avec plus de performance .
Par contre, pour le graphe de perte de notre modèle nous pouvons voir que les courbes
d’orange, bleu respectivement de test et d’entraînement, au début d’entrainement ont des
grandes valeurs et c’est normal, car notre système est dans son début d’apprentissage,
et une fois, on dépasse l’époque 5 on voit la décroissance de leurs valeurs tout au long
d’entraînement.Ce qui montre que notre modèle est capable d’apprendre plus vite d’être
plus prédictif avec une grande performance en comparant avec les autres modèles. En
général on voit bien que la précision et la perte dans les deux graphes ont des valeurs
inversées.(Voir la Figure 3.14).
Prédiction
Dans cette étape, on a trouvé une moyenne de prédiction de 99% qui est très élevés par

59
3.6. CLASSIFICATION VIDÉO AVEC DES MODÈLES HYBRIDES CNN-LSTM

F IGURE 3.13 – Architecture du modèle Inceptionv3-LSTM.

F IGURE 3.14 – Graphe de précision/perte du modèle Inceptionv3-LSTM.

60
3.6. CLASSIFICATION VIDÉO AVEC DES MODÈLES HYBRIDES CNN-LSTM

rapport à l’approche dont on a utilisé hybride Resnet50-LSTM. 3.15)

F IGURE 3.15 – Prédiction.

3.6.4 Discussion
Le choix de la meilleure architecture était basé sur 4 métriques :
Précision : est la métrique utilisée pour évaluer les modèles de classification, elle repré-
sente notamment le nombre de prédictions vrais obtenues par le modèle.
la perte : est la pénalité pour les mauvaises prédictions, décrivant à quel point la prédic-
tion est mauvaise ou éloignée de sa valeur réelle.
Précision de la validation : qui représente la précision calculée pendant l’entrainement
mais sur les données qui ne sont pas utilisées pour l’entrainement. Elle est utilisée surtout
pour valider le degré de généralisation de notre modèle sur les données.
la perte de validation : Calculée de la même manière que la perte d’apprentissage mais
n’est pas utilisée pour mettre à jour les poids, elle sert uniquement à voir les pertes géné-
ralisées.
A partir des graphes, on a pu comparer entre les trois architectures, on a trouvé Incep-
tionv3 est une architecture qui fonctionne très bien dans de nombreux problèmes, ce que
nous pouvons voir clairement dans le nôtre parce que il atteint une précision décente en
l’associant avec le LSTM avec une bonne généralisation.
Voici une table comparative entre les trois architectures :
la perte la précision la perte de test la précision de test
ResNet50-LSTM 0,291 0,602 0,451 0,983
VGG16-LSTM 0,154 0,981 0,101 0,992
Inceptionv3-LSTM 0,092 1,013 0,093 1,014

61
 3.7. CONCLUSION

3.7 Conclusion
Dans ce chapitre, nous avons appris à effectuer une classification vidéo avec Keras, un
algorithme de classification vidéo CNN consisterait à traiter chaque image d’une vidéo
individuellement indépendamment des autres. Ce type de mise en oeuvre entraînera un
problème lequel les frames de vidéo sont des séquences temporelles dépendent que ne
doivent pas traiter individuellement.
Des réseaux de neurones plus avancés, y compris les LSTM plus généraux, peuvent aider
à lutter contre ce problème et conduire à une précision beaucoup plus élevée grâce à ses
caractéristiques de traitement des séquences temporelles et de sa capacité d’accéder à
l’information dans une séquence de longue durée.
Dans la deuxième partie, nous avons fusionné les architectures CNN à savoir ResNet50,
VGG16 et Inceptionv3 avec le LSTM pour pouvoir arriver à la combinaison la plus per-
formante en matière de la précision, pour ce faire on a tenté d’utiliser une approche
comparative qui compare les degrés de la précision et de perte pour chaque architecture
et en déduire par la suite le modèle le plus prédictif.

62
Conclusion Générale et Perspectives

L’objectif de ce travail était d’étudier l’ensemble des techniques permettant une bonne
classification vidéo vu son importance dans la détection des caractéristiques liés à l’image
vidéo. Ce travail consiste au début une collecte d’informations qui va nous servir de vi-
sualiser les différentes approches permettant une classification vidéo et en choisir la plus
déterminante en terme de la précision. En effet, on a opté dans un premier temps de
mettre en application le modèle CNN dédié notamment à la classification des images au
service d’une Classification vidéo dont on a utilisé une classification des activités spor-
tives comme outil de l’expérimentation afin d’extraire les caractéristiques de celle-ci et
d’en connaitre l’avantage qu’il apporte au niveau de la performance. Ensuite, on a pu
passer à une classification en adoptant le choix d’hybride CNN associé avec le LSTM
pour qu’on puisse savoir l’utilité de la mémorisation des séquences dans les vidéos du
plus longue durée. De telle manière, nous avons choisi une approche comparative entre
trois architectures de CNN en l’associant avec le LSTM pour en conclure la meilleur
démarche au niveau de la précision. À vrai dire, les obstacles que nous avons retrouvé
durant la réalisation de ce projet précisément au niveau de quantités de ressources que
nos ordinateurs consomment qui nous a limités en quelques sorte de bien approfondir
nos connaissances d’une telle sujet intéressant. En guise de conclusion, nous trouvons
que ce projet est une vrai démarche pour mettre en relief cette étude avec ce qui existe
dans le milieu professionnel puisque ça va nous permettre d’étudier des problématiques
existentielles dans les différentes domaines en adoptant ces algorithmes qui vont nous
permettre de bien instrumentaliser les données.
Pour les travaux futurs, nous pouvons citer :
— La classification des vidéos avec des modèles plus complexes tels que Inception-
v4.
— La classification des vidéos audiovisuelles.
— L’étude d’autres concepts permettant de former des modèles afin d’interpréter des
données dans le domaine médical.

63
Bibliographie

[1] https ://www.arxiv.org/abs/1512.03385,Auteurs :Kaiming He, Xiangyu Zhang,

Shaoqing Ren, Jian Sun
[2] https ://www.arxiv.org/pdf/1409.1556.pdf,Auteurs :Karen Simonyan et Andrew
Zisserman
[3] https ://www.arxiv.org/pdf/1409.4842.pdf,Auteurs :Christian Szegedy,Christian
Szegedy,Christian Szegedy,Pierre Sermanet.
[4] https ://www.cs.stanford.edu/people/eroberts/courses/soco/projects/neural-
networks/History
[5] Hochreiter, Sepp et Schmidhuber, Jürgen, « Long Short-Term Memory », Neural
Computation, vol. 9,n° 8,1997, p. 1735-1780
[6] http ://www.univ-bejaia.dz/xmlui/bitstream/handle/123456789/9623/Optimisation
[7] http ://www.univ-bejaia.dz/xmlui/bitstream/handle/123456789/9623/Optimisation
[8] https ://www.domo.com/learn/infographic/data-never-sleeps-8
[9] https ://www.natural-solutions.eu/blog/histoire-du-deep-learning : :text=La
[10] https ://www.domo.com/learn/infographic/data-never-sleeps-8
[11] https ://www.natural-solutions.eu/blog/histoire-du-deep-learning : :text=La
[12] https ://www.datascientest.com/deep-learning-definition
[13] https ://www.tel.archives-ouvertes.fr/tel-02284916/document
[14] http ://www.eprints.univ-batna2.dz/624/1/sce
[15] http ://www.eprints.univ-batna2.dz/624/1/sce
[16] https ://espace.etsmtl.ca/id/eprint/2422/1/MIFDAL_Rachid_.pdf,Auteur :Rachid
Mifdal, 2019
[17] https ://www.github.com/jurjsorinliviu/Sports-Type-Classifier/tree/master/data
[18] https ://www.github.com/moadelamarti/Deep-learnig-for-video-classification-
using-CNN-and-LSTM/tree/main/data
[19] https ://www.fr.wikipedia.org/wiki/Anaconda

64
 BIBLIOGRAPHIE

[20] https ://www.fr.wikipedia.org/wiki/Jupyter

[21] https ://www.docs.python.org/3/
[22] https ://www.tensorflow.org/
[23] "Keras Documentation", sur keras.io,consulté le 13 Avril 2022.
[24] https ://www.opencv.org/,consulté le 02 Mai 2022.
[25] https ://www.numpy.org/doc/stable/,consulté le 02 Mai 2022.
[26] https ://www.matplotlib.org/,consulté le 02 Mai 2022.
[27] https ://www.scikit-learn.org/stable/,consulté le 02 Mai 2022.
[28] https ://www.pypi.org/project/imutils/,consulté le 02 Mai 2022.

65