Inspection Des Pylône Avec Un Drone Software

République Tunisienne
Ministère de l’Enseignement Supérieur

et de la Recherche Scientifique
Université de Carthage
Institut Supérieur des Technologies de
l’Information et de la Communication
Rapport de Projet de Fin d’Etude

Présenté en vue de l’obtention de la
Licence en Technologie de l’information et de la
communication
Spécialité : Telecommunication
Inspection des pylône avec un drone

intelligent
Par Alaeddine Bouabid et Oussama Cherni
Réalisé au sein de
Encadrant Professionel :Ben Mna Mourad
Période De Stage : 01/02/2023 - 30/04/2023
Année Universitaire : 2022 - 2023

République Tunisienne
Ministère de l’Enseignement Supérieur
et de la Recherche Scientifique
Université de Carthage
Institut Supérieur des Technologies de
l’Information et de la Communication
Rapport de Projet de Fin d’Etudes

Présenté en vue de l’obtention de la
Licence en Technologie de l’information et de la
communication
Spécialité : Telecommunication
Inspection des pylône avec un drone

intelligent
Par Bouabid Alaeddine

Cherni Oussama
Réalisé au sein de Sotetel
Autorisation de dépôt du rapport de Projet de Fin d’Etudes :
Encadrant professionnel :Ben Mna Encadrant académique :Attia

Mourad Dhouha
Le : Le :
Signature : Signature :
Dédicaces
Je dédie ce travail
À mes chers parents, Anouar et Najet, je vous suis infiniment
reconnaissant pour votre amour inconditionnel, votre soutien
indéfectible et les sacrifices que vous avez consentis pour mon
éducation. Votre présence et vos encouragements constants ont
été des sources de force et de motivation qui m’ont permis
d’atteindre mes objectifs.
À mes frères, Mohamed et Maissa, je vous adresse également
mes plus sincères remerciements. Votre soutien, vos
encouragements et votre complicité ont joué un rôle essentiel
dans ma vie. Vous êtes de véritables piliers sur lesquels je peux
toujours compter.
À mes amis, Khalil, Anis, Hamza, Fahmi et tous les autres, je
suis reconnaissant de vous avoir à mes côtés. Votre amitié, vos
encouragements et les moments partagés ensemble ont été
précieux pour moi. Vous avez été là pour m’écouter, me soutenir
et me divertir, et je vous en suis vraiment reconnaissant.
Enfin, je tiens à exprimer ma gratitude envers tous mes autres
amis. Que ce soit pour les moments passés ensemble, les
échanges chaleureux ou les soutiens mutuels, votre présence a
été significative dans ma vie. Je suis reconnaissant d’avoir pu
partager ces expériences et ces souvenirs avec vous.
En somme, je voulais vous dire à tous un immense merci. Votre
soutien, votre amitié et votre présence ont eu un impact positif
sur ma vie, et je vous suis profondément reconnaissant d’être là
pour moi.
Avec une gratitude sincère,
Bouabid Alaeddine
i
Dédicaces
Il est un moment dans la vie où nous arrivons à un carrefour, un

carrefour où nous réalisons que nous n’aurions pas pu arriver là où nous
sommes sans l’appui inconditionnel de ceux qui nous entourent.
Aujourd’hui, je tiens à exprimer ma gratitude à ceux qui ont rendu
possible mon voyage jusqu’à ce point.
À mes chers parents, mon père Adel Cherni et ma mère Bouthaina
Derbali, ma gratitude envers vous ne connaît aucune limite. Je suis le
fruit de votre amour, de votre patience et de votre soutien indéfectible. À
chaque moment de doute, à chaque défi, vous étiez là, une présence
constante qui me guidait et m’encourageait à persévérer. Vous êtes la
source de ma force et mon inspiration. Vous avez non seulement fait
naître mes rêves, mais vous m’avez aussi montré comment les réaliser.
Pour cela, je vous suis éternellement reconnaissant.
Je voudrais remercier du fond du cœur Madame Dhia Attia, mon
encadrante universitaire. Votre sagesse, votre dévouement et votre
passion pour l’enseignement ont éclairé mon parcours académique. Vous
avez su insuffler la rigueur et l’excellence dans mon travail, me
permettant ainsi de grandir en tant qu’étudiant et professionnel.
Je tiens également à exprimer ma gratitude à Messieurs Mourad Bn Mna
et Faouzi Saidi, mes encadrants professionnels. Vos conseils avisés et
votre expertise ont été précieux tout au long de ce projet. Vous m’avez
montré comment mettre en pratique les connaissances acquises et m’avez
donné l’opportunité de contribuer à des projets concrets. Merci pour
votre temps, votre patience et votre engagement à faire de moi un
meilleur professionnel.
À mon équipe, Amira Karoui, Chayma Zaouali, et mon binôme Bouabid
Ala Eddine, je vous remercie pour votre soutien, votre camaraderie et
votre travail acharné. Ce voyage n’aurait pas été le même sans vous. Nous
avons partagé des moments de doutes et de joie, et je suis honoré d’avoir
travaillé à vos côtés.
ii
En cette occasion spéciale, je tenais à te remercier du fond du cœur pour
ton soutien infini. Tu as joué un rôle indispensable dans ma vie et tu as
toujours été là pour moi. Je suis extrêmement reconnaissant de t’avoir à
mes côtés.
Ta présence constante et ton dévouement ont été une source d’inspiration
inestimable pour moi. Tu as cru en moi lorsque je doutais de moi-même
et tu m’as encouragé à persévérer dans les moments difficiles. Grâce à toi,
j’ai pu surmonter des obstacles et accomplir des choses que je n’aurais
jamais cru possibles.
Tu es bien plus qu’une personne spéciale dans ma vie. Tu es mon soutien
le plus solide, mon amie la plus chère et mon confident le plus fidèle. Tu
m’as montré ce que signifie être aimé inconditionnellement et je ne
pourrai jamais te remercier assez pour cela.
Ton amour et ta générosité ont illuminé ma vie d’une manière que je
n’aurais jamais pu imaginer. Tu es un exemple de force, de grâce et de
bonté. Chaque jour, tu me inspires à devenir une meilleure personne et à
apprécier les merveilles de la vie.
Je suis béni de t’avoir comme partenaire, mais surtout comme amie. Tu
es la personne sur qui je peux compter en tout temps et en toutes
circonstances. Ma vie est infiniment meilleure grâce à toi.
En ce jour spécial, je tiens à te rappeler combien je t’aime et combien je
suis reconnaissant de t’avoir à mes côtés. Ta présence dans ma vie est un
cadeau précieux et je ferai tout mon possible pour mériter ton amour et
ton soutien.
Merci, Amira, pour tout ce que tu as fait pour moi. Je suis honoré d’avoir
une personne aussi exceptionnelle à mes côtés.
À mes amis, votre amitié a été une source constante de soutien et de
motivation. Vous avez partagé avec moi des moments de rires et de
larmes, d’espoirs et de peines. Vous avez cru en moi, même dans les
moments où je doutais de moi-même. Pour votre amitié sincère et pour
tout ce que nous avons partagé, je vous remercie.
Je suis également reconnaissant à l’ISTIC, l’Institut Supérieur des
Technologies de l’Information et des Communications, qui m’a donné une
éducation de qualité et l’opportunité de croître tant sur le plan personnel
que professionnel.
Enfin, je remercie la société SOTETEL, qui m’a ouvert ses portes et m’a
permis d’acquérir une expérience précieuse dans le domaine professionnel.
Vous avez su instiller en moi le respect des normes et des valeurs
professionnelles.
iii
Je reste humble devant l’immense soutien que j’ai reçu et je suis fier de ce
que nous avons accompli ensemble. Merci du fond du cœur à tous.
Cherni Oussema
iv
Remerciement
Cher enseignant, famille, amis et encadrants,

Nous souhaitons profiter de cette occasion pour exprimer notre sincère reconnaissance
envers chacun d’entre vous. Votre soutien constant tout au long de notre parcours a été
inestimable, et nous vous sommes profondément reconnaissants d’avoir été présents à nos
côtés.
À nos enseignants, nous vous remercions pour votre passion, votre dévouement et
votre patience. Votre expertise et vos conseils précieux ont grandement contribué à notre
développement académique et personnel.
À notre famille, nous tenons à exprimer notre gratitude pour votre amour incondition-
nel, votre soutien indéfectible et les sacrifices que vous avez consentis pour nous permettre
d’atteindre nos objectifs.
À nos amis, vous avez été des compagnons de route précieux. Vos encouragements
et votre présence ont été des sources d’énergie et de motivation qui nous ont aidés à
surmonter les défis rencontrés.
Enfin, à nos encadrants, nous vous remercions pour votre guidance et votre disponi-
bilité. Votre encadrement précieux a joué un rôle déterminant dans notre réussite.
En résumé, nous tenons à vous exprimer notre profonde reconnaissance. Votre soutien,
vos conseils et votre présence ont été essentiels dans notre parcours. Nous vous en sommes
sincèrement reconnaissants.
Avec nos plus chaleureux remerciements.
v
Table des matières
Introduction générale 1
1 Contexte du projet 3
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Présentation de l’organisme d’accueil . . . . . . . . . . . . . . . . . . . . . 4
1.2.1 Organisme d’accueil : . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.2 Domaines d’activités . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Présentation du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.1 Cadre du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.2 Problématique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3.3 Etude de l’existant . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.4 Solution proposée . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4 Méthodologie de travail et planification . . . . . . . . . . . . . . . . . . . . 8
1.4.1 Définition de la méthodologie . . . . . . . . . . . . . . . . . . . . . 8
1.4.2 Choix de Scrum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4.3 Jira . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.5 Sprints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.6 Synopsis global . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.7 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
I Conception 15
2 Conception d’intelligence artificielle 16
2.8 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.9 Machine learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.10 Deep learning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.11 Modèles disponibles et choix de YOLO . . . . . . . . . . . . . . . . . . . . 18
2.12 Analyse des besoins fonctionnels . . . . . . . . . . . . . . . . . . . . . . . 19
2.13 Analyse des besoins non fonctionnels . . . . . . . . . . . . . . . . . . . . . 19
2.14 Méthodologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.15 Bibliothèques Python utilisées par YOLO . . . . . . . . . . . . . . . . . . 20
2.15.1 OpenCV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.15.2 NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.15.3 Keras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.15.4 TensorFlow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.15.5 Darknet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.16 Paramètres et hyperparamètres du modèle YOLO . . . . . . . . . . . . . . 21
2.16.1 Taille de l’image d’entrée (INP) . . . . . . . . . . . . . . . . . . . . 22
vi
Table des matières Table des matières
2.16.2 Nombre de cartes de probabilité (NB) . . . . . . . . . . . . . . . . . 22

2.16.3 Nombre de boîtes d’ancrage (NA) . . . . . . . . . . . . . . . . . . . 22
2.16.4 Seuil de confiance (SC) . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.16.5 Score IOU (IOU) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.17 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3 Conception web 23
3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.2 Conception Django . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.2.1 Présentation de Django . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.2.2 Pourquoi choisir Django . . . . . . . . . . . . . . . . . . . . . . . . 24
3.2.3 Architecture et Structure de Django . . . . . . . . . . . . . . . . . . 25
3.2.4 Conception des modèles Django . . . . . . . . . . . . . . . . . . . . 26
3.2.5 Conception des vues Django . . . . . . . . . . . . . . . . . . . . . . 27
3.2.6 Routage URL dans Django . . . . . . . . . . . . . . . . . . . . . . . 28
3.2.7 Conception des templates Django . . . . . . . . . . . . . . . . . . . 28
3.2.8 Formulaires dans Django . . . . . . . . . . . . . . . . . . . . . . . . 29
3.2.9 Gestion des données avec l’ORM Django . . . . . . . . . . . . . . . 29
3.2.10 Sécurité dans Django . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.2.11 Test et débogage dans Django . . . . . . . . . . . . . . . . . . . . . 30
3.3 Conception web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.3.1 Présentation de HTML . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.3.2 Présentation de CSS . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.3.3 Présentation de JavaScript . . . . . . . . . . . . . . . . . . . . . . . 31
3.3.4 Présentation de Spline . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.3.5 Concrétisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.3.6 Conception de la Page d’Authentification et d’Inscription . . . . . . 32
3.3.7 Conception de la Page de Formulaire . . . . . . . . . . . . . . . . . 32
3.3.8 Conception de la Page d’Affichage des Résultats de Détection . . . 32
3.3.9 Conception de la Page de Tableau de Bord . . . . . . . . . . . . . . 33
3.3.10 Utilisation de Spline . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4 Conception drone 34
4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.2 Spécifications fonctionnelles du drone . . . . . . . . . . . . . . . . . . . . . 34
4.3 Choix des composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.3.1 Châssis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.3.2 Moteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.3.3 ESC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.3.4 Hélices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.3.5 Batteries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.4 Conception mécanique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.4.1 Design de la structure du drone . . . . . . . . . . . . . . . . . . . . 39
4.4.2 Modélisation 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.5 Conception électronique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.6 Conception logicielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.7 conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
vii
II Réalisation 43
5 Réalisation Drone 44
5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
5.2 Assemblage du drone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
5.2.1 Fixation du châssis . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
5.2.2 Installation des moteurs . . . . . . . . . . . . . . . . . . . . . . . . 45
5.2.3 Connexion des ESC . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.2.4 Fixation des hélices . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.2.5 Connexion de la batterie . . . . . . . . . . . . . . . . . . . . . . . . 46
5.3 Configuration et calibrage . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.4 Essais de vols . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
6 Réalisation IA 50
6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
6.2 Collecte d’images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
6.2.1 Méthode de collecte . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
6.2.2 Sécurité et équipement . . . . . . . . . . . . . . . . . . . . . . . . . 52
6.3 Étiquetage manuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
6.3.1 Avantages de l’utilisation de LabelImg . . . . . . . . . . . . . . . . 52
6.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.5 Étiquetage automatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.5.1 Préparation du modèle YOLOv5s pour l’étiquetage automatique . . 53
6.5.2 Étiquetage automatique . . . . . . . . . . . . . . . . . . . . . . . . 58
6.5.3 Vérification et correction manuelle . . . . . . . . . . . . . . . . . . . 58
6.5.4 Consolidation des images étiquetées . . . . . . . . . . . . . . . . . . 58
6.5.5 Conclusion sur l’étiquetage des images . . . . . . . . . . . . . . . . 58
6.6 Étape 5 : Sélection d’une Configuration Modèle . . . . . . . . . . . . . . . 58
6.6.1 Choix du Modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
6.6.2 Architecture du modèle YOLOv5m . . . . . . . . . . . . . . . . . . 59
6.6.3 Mise en œuvre du modèle de détection d’objets YOLOv5m . . . . . 60
6.6.4 Organisation de la structure des images . . . . . . . . . . . . . . . . 60
6.6.5 Étape 3 : Organisation des données . . . . . . . . . . . . . . . . . . 60
6.6.6 Préparation du fichier dataset.yaml . . . . . . . . . . . . . . . . . . 61
6.7 Transformation des Annotations YOLO en CSV . . . . . . . . . . . . . . . 62
6.8 Formats d’annotation des boîtes englobantes . . . . . . . . . . . . . . . . . 62
6.8.1 Indice de classe de l’objet . . . . . . . . . . . . . . . . . . . . . . . 62
6.8.2 Position de la boîte englobante . . . . . . . . . . . . . . . . . . . . 62
6.9 Génération d’Ancres Personnalisées à l’Aide de la Méthode K-Means . . . 63
6.9.1 Paramétrage du modèle . . . . . . . . . . . . . . . . . . . . . . . . 66
6.10 Étape 6 : Apprentissage du modèle . . . . . . . . . . . . . . . . . . . . . . 67
6.10.1 Évaluation du modèle . . . . . . . . . . . . . . . . . . . . . . . . . 70
6.10.2 Interprétation des Résultats d’Entraînement du Modèle YOLO V
pour la Détection d’Antennes . . . . . . . . . . . . . . . . . . . . . 70
6.10.3 Analyse des performances du modèle . . . . . . . . . . . . . . . . . 76
6.10.4 Test des performances du modèle . . . . . . . . . . . . . . . . . . . 76
viii
7 Réalisation détection de texte 79

7.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
7.2 Amélioration de la qualité de l’image . . . . . . . . . . . . . . . . . . . . . 79
7.3 Utilisation de Tesseract OCR pour la reconnaissance de texte sur les images
traitées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
7.4 Intégration du processus de détection et de reconnaissance de texte dans
un serveur Django . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
7.5 Enregistrement du texte dans une base de données SQLite . . . . . . . . . 83
7.5.1 Étape 1 : Création du modèle OCRResult dans models.py pour
stocker les résultats OCR . . . . . . . . . . . . . . . . . . . . . . . 85
7.5.2 Étape 2 : Création et application d’une nouvelle migration pour les
modifications de la base de données SQLite : . . . . . . . . . . . . . 86
7.5.3 Étape 3 : Modification de la vue ‘ocr_results‘ pour enregistrer les
résultats OCR dans la base de données : . . . . . . . . . . . . . . . 86
7.5.4 Étape 4 : affichage des résultats stockés dans la base de données . . 87
7.6 Migration de la base de données de SQLite vers PostgreSQL . . . . . . . . 88
7.6.1 Étape 1 : Installation de PostgreSQL sur Windows et configuration
du mot de passe de l’utilisateur "postgres" . . . . . . . . . . . . . . 88
7.6.2 Étape 2 : Création d’une base de données et d’un utilisateur . . . . 89
7.6.3 Étape 3 : Attribution des privilèges à l’utilisateur sur la base de
données PostgreSQL . . . . . . . . . . . . . . . . . . . . . . . . . . 90
7.6.4 Étape 4 : Configuration de Django pour utiliser la nouvelle base de
données PostgreSQL dans ‘settings.py‘ . . . . . . . . . . . . . . . . 90
7.6.5 Étape 5 : Application de la migration : . . . . . . . . . . . . . . . . 91
7.6.6 Étape 6 : Extraction d’informations à partir du texte détecté et les
enregistrer dans PostgreSQL . . . . . . . . . . . . . . . . . . . . . . 92
7.7 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
8 Réalisation Django 95
8.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
8.2 Étape 1 : Installation de Django . . . . . . . . . . . . . . . . . . . . . . . . 95
8.3 Étape 2 : Créer un nouveau projet Django . . . . . . . . . . . . . . . . . . 95
8.3.1 Le fichier manage.py . . . . . . . . . . . . . . . . . . . . . . . . . . 95
8.3.2 La base de données et les modèles de données . . . . . . . . . . . . 96
8.3.3 Structure des fichiers dans un projet Django . . . . . . . . . . . . . 96
8.3.4 Le dossier de configuration . . . . . . . . . . . . . . . . . . . . . . . 97
8.3.5 Le dossier des applications . . . . . . . . . . . . . . . . . . . . . . . 97
8.3.6 Les fichiers statiques . . . . . . . . . . . . . . . . . . . . . . . . . . 97
8.3.7 Les templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
8.3.8 Les fichiers de migration . . . . . . . . . . . . . . . . . . . . . . . . 98
8.4 Étape 3 : Configuration du projet Django . . . . . . . . . . . . . . . . . . . 98
8.5 Étape 4 : Création d’une application Django . . . . . . . . . . . . . . . . . 99
8.6 Étape 5 : Modèles et bases de données . . . . . . . . . . . . . . . . . . . . 100
8.7 Étape 6 : Vues et logique de l’application . . . . . . . . . . . . . . . . . . . 101
8.8 Étape 7 : URLs et routage . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
8.9 Étape 8 : Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
8.10 Étape 9 : Static files and media files . . . . . . . . . . . . . . . . . . . . . . 103
8.11 Étape 10 : Formulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
ix
8.12 Étape 11 : Exécution du serveur de développement . . . . . . . . . . . . . 104

8.13 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
9 Réalisation web 106

9.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
9.2 HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
9.3 CSS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
9.4 JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
9.5 Django Frontend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
9.6 Spline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
9.7 Authentification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
9.8 Inscription . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
9.9 Formulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
9.10 Formulaire de Soumission . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
9.11 Affichage des Résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
9.12 Tableau de Bord . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
9.13 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Conclusion Générale 113
Bibliographie 115
x
Table des figures
1.1 Logo de sotetel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.2 Capture d’écran Scrum 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.6 Capture d’écran de Jira . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.7 Capture d’écran du sprint 1 . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.10 Synopsis global du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.11 Le processus de Machine Learning . . . . . . . . . . . . . . . . . . . . . . . 17
2.12 Le processus de Deep Learning . . . . . . . . . . . . . . . . . . . . . . . . 18
4.13 Image d’un châssis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.14 Exemple d’un moteur de drone. . . . . . . . . . . . . . . . . . . . . . . . . 36
4.15 Un exemple d’un esc 30A . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.16 Les helice 1045 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.17 Exemple de batterie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.18 Conception mécanique du drone . . . . . . . . . . . . . . . . . . . . . . . . 39
4.19 Structure du drone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.20 Modélisation 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.21 Modélisation 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.22 Modélisation 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.23 Simulation du circuit du drone . . . . . . . . . . . . . . . . . . . . . . . . 41
5.24 Composant du drone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
5.25 Fixation schématisée du châssis . . . . . . . . . . . . . . . . . . . . . . . . 45
5.26 Fixation réelle du châssis . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.27 Installation schématisée des moteurs . . . . . . . . . . . . . . . . . . . . . 45
5.28 Installation réelle des moteurs . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.29 ESC 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.30 ESC 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.31 Fixation schématisée des hélices . . . . . . . . . . . . . . . . . . . . . . . . 46
5.32 Fixation réelle des hélices . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.33 Batterie type 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.34 Batterie type 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.35 Configuration et calibrage . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.36 Vue du drone prêt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.37 Premier test de vol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.38 Deuxième test de vol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.39 Troisième test de vol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
xi
Table des figures Table des figures
6.40 Base de données Sotetel . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

6.41 Visite du site Sotetel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.42 Capture d’écran de l’application LabelImg. . . . . . . . . . . . . . . . . . . 52
6.43 capture d’ecran d’entrainement du model . . . . . . . . . . . . . . . . . . . 54
6.44 Capture d’écran d’une courbe F1-Confidence. . . . . . . . . . . . . . . . . 56
6.45 Exemple de courbe Rappel-Confiance . . . . . . . . . . . . . . . . . . . . . 56
6.46 Exemple de courbe Précision-Confiance . . . . . . . . . . . . . . . . . . . . 57
6.47 Exemple de courbe Précision-Rappel-Confiance . . . . . . . . . . . . . . . 57
6.48 Capture d’écran du de differentes versions du modèle YOLOv5 . . . . . . . 59
6.49 Capture d’écran du fichier YAML pour la configuration du modèle YOLOv5 61
6.50 Capture d’écran du fichier de transformation vers CSV . . . . . . . . . . . 62
6.51 Coordonnées variables de la boîte englobante . . . . . . . . . . . . . . . . . 63
6.52 Intersction over Union . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
6.53 Image illustrant les ancres optimisées pour YOLOv5 personnalisé. . . . . . 67
6.54 capture d’ecran d’entainement du model . . . . . . . . . . . . . . . . . . . 68
6.55 capture d’ecran results.csv . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
6.56 Capture d’écran d’un labels correlogramme. . . . . . . . . . . . . . . . . . 71
6.57 Capture d’écran d’une courbe F1-Confidence. . . . . . . . . . . . . . . . . 72
6.58 Exemple de courbe Rappel-Confiance . . . . . . . . . . . . . . . . . . . . . 73
6.59 Exemple de courbe Précision-Confiance . . . . . . . . . . . . . . . . . . . . 74
6.60 Exemple de courbe Précision-Rappel-Confiance . . . . . . . . . . . . . . . 75
6.61 Résultat de détection 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
6.62 Résultat de détection 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
7.63 Image originale avant traitement . . . . . . . . . . . . . . . . . . . . . . . . 80
7.64 Amélioration de la qualité de l’image . . . . . . . . . . . . . . . . . . . . . 81
7.65 Résultat de la détection de texte à partir de l’image traitée . . . . . . . . . 82
7.66 Création de l’application ’ocr_app’ dans le serveur Django . . . . . . . . . 83
7.67 Code extrait de views.py . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
7.68 Résultats de l’OCR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
7.69 Création de l’application ’ocr_app’ dans le serveur Django . . . . . . . . . 85
7.70 Création et application d’une migration SQLite . . . . . . . . . . . . . . . 86
7.71 Modification de la fonction ’ocr_results . . . . . . . . . . . . . . . . . . . . 86
7.72 Création de la fonction ’ocr_results_list’ . . . . . . . . . . . . . . . . . . . 87
7.73 Ajout de l’URL dans le fichier urls.py . . . . . . . . . . . . . . . . . . . . 87
7.74 Création du fichier ocr_results_list.html . . . . . . . . . . . . . . . . . 88
7.75 Affichage de la liste des résultats OCR . . . . . . . . . . . . . . . . . . . . 88
7.76 Installation et configuration de PostgreSQL . . . . . . . . . . . . . . . . . 89
7.77 Connexion à PostgreSQL en tant qu’utilisateur "postgres" . . . . . . . . . . 89
7.78 Création d’une base de données PostgreSQL . . . . . . . . . . . . . . . . . 90
7.79 Création d’un utilisateur dans PostgreSQL . . . . . . . . . . . . . . . . . . 90
7.80 Attribution des privilèges à l’utilisateur . . . . . . . . . . . . . . . . . . . . 90
7.81 Configuration de la base de données PostgreSQL dans settings.py . . . . 91
7.82 Application d’une migration dans PostgreSQL . . . . . . . . . . . . . . . . 91
7.83 Fonction extract_antenna_string() - Extraction de sous-chaîne . . . . . . . 92
7.84 Fonction extract_antenna_info() - Extraction d’informations spécifiques 93
7.85 Stockage d’informations dans un dictionnaire . . . . . . . . . . . . . . . . . 93
7.86 Enregistrement des valeurs extraites dans la base de données PostgreSQL . 93
8.87 Structure des fichiers dans un projet Django . . . . . . . . . . . . . . . . . 96
xii
Table des figures Table des figures
9.88 Capture d’écran du tableau de bord réalisé avec Spline . . . . . . . . . . . 108

9.89 Capture d’écran de la page d’authentification . . . . . . . . . . . . . . . . 108
9.90 Page d’inscription . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
9.91 Capture d’écran du formulaire de soumission . . . . . . . . . . . . . . . . . 110
9.92 Capture d’écran du formulaire de soumission . . . . . . . . . . . . . . . . . 110
9.93 Capture d’écran de la page des résultats . . . . . . . . . . . . . . . . . . . 111
9.94 Capture d’écran du tableau de bord . . . . . . . . . . . . . . . . . . . . . . 111
xiii
Liste des tableaux
4.1 Le tableau de caractéristiques du drone. . . . . . . . . . . . . . . . . . . . 34

6.2 Comparaison des modèles YOLOv5 . . . . . . . . . . . . . . . . . . . . . . 59
xiv
Introduction générale
Dans un monde en constante évolution, les avancées technologiques offrent de nouvelles

possibilités dans de nombreux domaines, y compris l’inspection des pylônes. L’inspection
traditionnelle des pylônes peut être coûteuse, dangereuse et nécessiter beaucoup de temps.
Cependant, grâce à l’utilisation de caméras alimentées par l’intelligence artificielle (IA)
montées sur des drones, il est désormais possible de réaliser des inspections plus efficaces,
sûres et précises.
Ce projet ambitieux vise à développer un système d’inspection de pylônes basé sur
l’utilisation de drones équipés de caméras IA. L’idée est d’utiliser la puissance de l’IA pour
analyser les images capturées par les caméras des drones, détecter les défauts potentiels,
évaluer l’état des pylônes et générer des rapports d’inspection détaillés. Pour gérer les
données collectées et fournir une interface conviviale pour les utilisateurs, un serveur
Django sera mis en place pour transférer les données vers un tableau de bord en ligne.
Le système d’inspection de pylônes avec caméra IA sur un drone offre de nombreux
avantages par rapport aux méthodes d’inspection traditionnelles. Tout d’abord, l’utilisa-
tion de drones permet d’accéder facilement aux pylônes, même dans des endroits difficiles
d’accès ou dangereux pour les humains. Cela réduit les risques liés à l’inspection manuelle
et garantit la sécurité des opérateurs. De plus, les caméras IA sont capables de captu-
rer des images haute résolution et de les analyser instantanément, permettant ainsi une
détection rapide et précise des défauts potentiels. Cela permet d’économiser du temps et
des ressources, tout en assurant une meilleure qualité d’inspection.
Le serveur Django joue un rôle central dans ce projet. Il sert de plateforme pour gérer
les données collectées par les drones lors des inspections de pylônes. Le serveur Django
est responsable de la réception des données provenant des drones, de leur stockage dans
une base de données, de leur traitement à l’aide de modèles d’IA et de la génération
de rapports d’inspection détaillés. De plus, le serveur Django est également responsable
du transfert des données vers un tableau de bord en ligne, offrant ainsi une interface
utilisateur conviviale pour visualiser et analyser les résultats des inspections.
Le tableau de bord en ligne constitue une composante essentielle de ce projet. Il offre
une interface intuitive et conviviale pour les utilisateurs, leur permettant de visualiser les
rapports d’inspection, de suivre l’état des pylônes, d’analyser les données collectées et de
prendre des décisions éclairées. Le tableau de bord peut afficher des données en temps réel,
des graphiques, des images et d’autres informations pertinentes, offrant ainsi une vision
globale de l’état des pylônes et des recommandations pour les opérations de maintenance.
En résumé, ce projet d’inspection de pylônes avec caméra IA sur un drone et serveur
Django offre une approche novatrice et efficace pour l’inspection des pylônes. Grâce à
l’utilisation de drones équipés de caméras IA, il est possible de réaliser des inspections
plus sûres, plus
rapides et plus précises. Le serveur Django joue un rôle central dans la gestion des
données d’inspection, leur traitement et la génération de rapports détaillés. Le tableau
1
Introduction générale
de bord en ligne offre une interface conviviale pour visualiser et analyser les résultats des
inspections. Ce projet représente une avancée majeure dans le domaine de l’inspection des
pylônes et ouvre de nouvelles perspectives pour des opérations d’inspection plus efficaces
et fiables.
Au cours de ce rapport, nous explorerons en détail chaque composante de ce projet,
en mettant l’accent sur les aspects techniques, les défis rencontrés et les résultats obtenus.
Nous discuterons également des perspectives d’avenir et des améliorations possibles pour
rendre ce système d’inspection encore plus performant et adapté aux besoins spécifiques
des opérations de maintenance des pylônes.
2
Chapitre 1
Contexte du projet
1.1 Introduction
L’utilisation de la technologie mobile a connu une croissance exponentielle
en Tunisie ces dernières années, entraînant l’installation d’un grand nombre
d’antennes sur tout le territoire pour assurer une couverture de qualité pour
les utilisateurs. Toutefois, cette croissance rapide a également engendré des
risques importants pour les pylonistes, qui sont chargés de l’installation et
de la maintenance de ces antennes.
Les risques auxquels sont confrontés les pylonistes sont multiples, allant
des chutes de hauteur aux expositions aux ondes électromagnétiques, en pas-
sant par les risques d’électrocution et d’électrisation lors de l’utilisation d’ou-
tils électriques à proximité de pièces sous tension. Ces risques peuvent mettre
en danger la vie des travailleurs, d’autant plus que les pylônes peuvent être
très hauts et difficilement accessibles.
C’est dans ce contexte que l’utilisation de drones pour remplacer les pylo-
nistes a été proposée. Les drones équipés de caméras haute résolution et de
capteurs sophistiqués peuvent effectuer des inspections précises et complètes
des antennes en un temps record, ce qui réduit les risques pour les travailleurs
et améliore l’efficacité de la maintenance.
L’inspection par drone permet également d’accéder facilement aux zones
difficiles d’accès et aux endroits dangereux, comme les sommets des pylônes,
ce qui réduit le risque de chute pour les travailleurs. Les drones sont également
capables de fournir des données en temps réel, ce qui permet de diagnostiquer
rapidement les problèmes et de prendre les mesures nécessaires pour résoudre
les anomalies détectées.
Les données collectées par les drones peuvent être traitées par des al-
gorithmes de machine learning pour améliorer la précision et l’efficacité de
l’inspection. Les informations collectées peuvent également être stockées dans
une base de données centralisée pour un suivi et une analyse ultérieurs.
En conclusion, l’inspection par drone offre une solution innovante pour
résoudre les défis auxquels sont confrontées les méthodes d’inspection tradi-
3
Chapitre 1 1.2. Présentation de l’organisme d’accueil
tionnelles. En utilisant cette technologie, les opérateurs de télécommunica-

tion peuvent effectuer des inspections plus rapides, plus précises et plus sûres,
tout en réduisant les coûts et les risques pour les travailleurs. L’adoption de
cette technologie en Tunisie peut également stimuler le développement de la
technologie drone dans le pays et créer de nouvelles opportunités pour les
professionnels de l’inspection et de la maintenance.Introduction...
1.2 Présentation de l’organisme d’accueil

1.2.1 Organisme d’accueil :
SOTETEL est une entreprise tunisienne de télécommunication créée en
1984. Elle est spécialisée dans la conception, la réalisation et la maintenance
de réseaux de télécommunication ainsi que dans la fourniture de services de
communication.
SOTETEL est une entreprise leader dans le domaine de la télécommuni-
cation en Tunisie. Elle offre une large gamme de services de communication
pour les entreprises et les particuliers, tels que la téléphonie fixe et mobile,
l’accès à internet haut débit, les services de données et de télévision. SOTE-
TEL est un partenaire fiable pour les opérateurs de télécommunication et les
entreprises qui cherchent à améliorer leur infrastructure de communication.
SOTETEL dispose d’un personnel qualifié et compétent, composé d’in-
génieurs, de techniciens et d’experts en télécommunication, qui travaillent
en étroite collaboration pour garantir la qualité et la fiabilité des services
proposés. Elle dispose également d’une infrastructure de pointe, équipée des
dernières technologies de communication, qui lui permet d’offrir des services
innovants et adaptés aux besoins de ses clients.
En tant qu’entreprise engagée dans le développement durable, SOTETEL
s’efforce de minimiser l’impact environnemental de ses activités. Elle utilise
des technologies respectueuses de l’environnement et met en œuvre des pra-
tiques de gestion durable pour minimiser la consommation d’énergie et la
production de déchets.
SOTETEL (ayant le logo illustré dans la figure 1.1) est également engagée
dans la responsabilité sociale en contribuant au développement économique
et social de la Tunisie. Elle soutient des projets communautaires dans les
domaines de la santé, de l’éducation et de l’environnement, en s’associant.
1.2.2 Domaines d’activités

Le domaine d’activité de SOTETEL est très vaste et couvre l’ensemble des
services de télécommunication. L’entreprise est spécialisée dans la conception,
la réalisation et la maintenance de réseaux de télécommunication, ainsi que
4
Chapitre 1 1.3. Présentation du projet
Figure 1.1 – Logo de sotetel
dans la fourniture de services de communication pour les entreprises et les

particuliers.
SOTETEL fournit des solutions pour la téléphonie fixe et mobile, l’accès
à internet haut débit, les services de données, la télévision et les réseaux de
transmission. Elle est également impliquée dans des projets de déploiement
de réseaux 4G et 5G, pour offrir une connectivité plus rapide et plus fiable à
ses clients.
SOTETEL propose également des solutions pour les entreprises, telles que
des solutions de communication unifiée, de cloud computing, de sécurité et de
surveillance des réseaux. L’entreprise offre également des services de conseil et
d’assistance technique pour aider ses clients à améliorer leurs infrastructures
de communication.
En résumé, SOTETEL est une entreprise qui offre une large gamme de
services de télécommunication pour répondre aux besoins des particuliers et
des entreprises. Elle est spécialisée dans la conception, la réalisation et la
maintenance de réseaux de télécommunication, ainsi que dans la fourniture
de services de communication innovant et adaptés aux besoins de ses clients.
1.3 Présentation du projet

Dans cette section, nous introduisons le cadre général du projet ainsi que
la problématique
1.3.1 Cadre du projet

Contexte général du projet
Le projet vise à utiliser un drone équipé d’une intelligence artificielle pour

l’inspection des pylônes de télécommunication, ce qui permettrait de réaliser
des inspections plus rapides, plus précises et plus sûres.
Objectifs du projet
Le projet a pour objectif de proposer une méthode d’inspection facile à

mettre en œuvre, peu coûteuse et efficace pour aider les entreprises de pylônes
5
à réaliser des inspections régulières, tout en minimisant les risques pour les
travailleurs et en améliorant l’efficacité de la maintenance.
Bénéficiaires du projet
Les entreprises de pylônes de télécommunication sont les bénéficiaires di-

rects du projet, mais il peut également bénéficier aux fournisseurs de services
de télécommunication et à toute autre partie prenante impliquée dans la
maintenance des infrastructures de télécommunication.
Contraintes et limites du projet
Bien que les contraintes et les limites du projet puissent varier en fonction
des besoins spécifiques de chaque entreprise de pylônes, certaines limites et
contraintes communes peuvent être identifiées, comme des limitations tech-
niques ou financières.
Méthodes et outils utilisés
Le projet utilise un drone équipé d’une caméra haute résolution et d’un

système d’intelligence artificielle pour la détection d’objets. Les données col-
lectées par le drone seront transférées par l’Internet des objets (IoT) vers
un tableau de bord web et mobile pour une analyse ultérieure. Le tableau
de bord permettra aux opérateurs de télécommunication de visualiser les in-
formations collectées en temps réel et de prendre des décisions éclairées en
matière de maintenance.
1.3.2 Problématique
Introduction
Contexte de la problématique
Le contexte général de la problématique est l’utilisation des pylônes pour

les infrastructures de télécommunication. Les pylônes sont utilisés pour sup-
porter les antennes et les équipements nécessaires à la transmission de signaux
de communication, y compris les signaux mobiles et Internet. Les pylônes
peuvent être très hauts et difficiles d’accès, ce qui rend l’inspection manuelle
dangereuse et coûteuse.
Problématique de l’inspection des pylônes de télécommunication
La problématique spécifique à l’inspection des pylônes de télécommuni-

cation est la nécessité d’effectuer des inspections régulières pour assurer la
qualité et la sécurité des réseaux de communication, tout en minimisant les
6
risques pour les travailleurs et en réduisant les coûts associés à l’inspection.

Les pylônes peuvent être très hauts et difficiles d’accès, ce qui rend l’inspec-
tion manuelle dangereuse et coûteuse.
Les défis et les risques liés à l’inspection manuelle des pylônes de télécommu-
nication
Les défis et les risques associés à l’inspection manuelle des pylônes de

télécommunication comprennent les risques d’électrocution et de chutes de
hauteur pour les travailleurs, ainsi que les coûts élevés associés à l’utilisation
d’équipements de levage et à l’inspection manuelle.
Les avantages potentiels de l’inspection par drone pour l’industrie des télé-
communications
L’utilisation de drones pour l’inspection des pylônes de télécommunication

présente plusieurs avantages potentiels, notamment la réduction des risques
pour les travailleurs, la réduction des coûts associés à l’inspection et la pos-
sibilité de collecter des données plus précises et plus complètes. Les drones
équipés de caméras haute résolution peuvent fournir des images détaillées des
pylônes et détecter les anomalies plus rapidement et plus efficacement que
l’inspection manuelle.
En conclusion, la problématique de l’inspection des pylônes de télécom-
munication est un enjeu important pour l’industrie des télécommunications.
L’utilisation de drones pour l’inspection présente des avantages potentiels
significatifs, notamment la réduction des risques pour les travailleurs et la
réduction des coûts associés à l’inspection. Cependant, il existe également
des défis et des limites à l’utilisation de drones pour l’inspection des pylônes,
notamment
1.3.3 Etude de l’existant

Actuellement, l’inspection des pylônes de télécommunication est générale-
ment effectuée manuellement, ce qui peut être coûteux et dangereux pour les
travailleurs. Toutefois, l’utilisation de drones pour l’inspection des pylônes
commence à être explorée comme une alternative plus sûre, moins coûteuse
et plus efficace à l’inspection manuelle. Les drones équipés de caméras haute
résolution peuvent fournir des images détaillées des pylônes et détecter les
anomalies plus rapidement et plus efficacement que l’inspection manuelle.
Cependant, l’utilisation de drones pour l’inspection des pylônes de télé-
communication n’est pas encore largement répandue dans l’industrie. Les
défis liés à la fiabilité des drones, à la durée de vie de la batterie et à l’exac-
titude des données collectées doivent être résolus avant que cette technologie
puisse être pleinement adoptée. De plus, les réglementations et les normes de
7
Chapitre 1 1.4. Méthodologie de travail et planification
sécurité pour l’utilisation des drones dans l’industrie des télécommunications

doivent être développées et mises en place pour assurer la sécurité et la qua-
lité des inspections.
1.3.4 Solution proposée

La solution proposée consiste à utiliser des drones équipés de caméras
haute résolution et de capteurs sophistiqués pour l’inspection des pylônes de
télécommunication. Les drones peuvent être équipés d’intelligence artificielle
et d’algorithmes de détection d’objet pour détecter automatiquement les ano-
malies sur les images capturées, réduisant ainsi le temps et les coûts associés
à l’inspection. Les données collectées peuvent être transférées en temps réel
via l’IoT et stockées dans une base de données centralisée pour une analyse
ultérieure.
L’utilisation de drones pour l’inspection des pylônes de télécommunica-
tion peut réduire les coûts, améliorer la précision et réduire les risques pour
les travailleurs. De plus, cette technologie peut accéder facilement aux zones
difficiles d’accès, ce qui améliore l’efficacité de la maintenance. Cependant,
pour que cette solution soit pleinement adoptée, des défis tels que la fiabi-
lité des drones, la durée de vie de la batterie et l’exactitude des données
collectées doivent être résolus. Les réglementations et les normes de sécurité
pour l’utilisation des drones dans l’industrie des télécommunications doivent
également être développées et mises en place pour assurer la sécurité et la
qualité des inspections.
1.4 Méthodologie de travail et planification

Dans cette section, nous définissons notre méthologie de travail et les choix
effectués
1.4.1 Définition de la méthodologie

Une méthodologie est une approche systématique et structurée utilisée
pour organiser, planifier et exécuter un projet. Les méthodologies sont utili-
sées pour assurer la qualité, la cohérence et la transparence dans les projets,
tout en optimisant les ressources et en minimisant les risques.
SCRUM est une méthodologie de gestion de projet agile utilisée pour gérer
des projets complexes et évolutifs. Elle se concentre sur une approche itéra-
tive et incrémentale pour la planification, la conception, la construction et la
livraison de produits. SCRUM est basée sur des équipes auto-organisées et
pluridisciplinaires travaillant ensemble pour atteindre un objectif commun.
8
Elle se caractérise par une communication ouverte et transparente, une col-

laboration étroite avec les parties prenantes et une amélioration continue du
processus.
SCRUM utilise des sprints, qui sont des cycles de développement itéra-
tifs et courts, pour produire des livrables fonctionnels en peu de temps. À
chaque sprint, l’équipe se concentre sur la réalisation d’un ensemble de fonc-
tionnalités spécifiques. Des réunions régulières sont organisées pour suivre la
progression du projet, identifier les problèmes et ajuster le plan en consé-
quence.
SCRUM est un cadre de travail très flexible et adaptable, qui peut être
appliqué à une variété de projets, des projets de développement de logiciels
aux projets d’innovation et de recherche. Cette méthodologie est de plus en
plus utilisée dans les entreprises et les organisations qui cherchent à maximi-
ser l’efficacité, la qualité et la satisfaction des clients tout en minimisant les
risques et les coûts.
1.4.2 Choix de Scrum

Le choix de la méthode SCRUM pour la gestion de notre projet de dévelop-
pement de drone équipé d’intelligence artificielle pour l’inspection des pylônes
de télécommunication offre plusieurs avantages. SCRUM est une méthodo-
logie de gestion de projet flexible, qui permet d’adapter la planification et
l’exécution du projet en fonction des changements et des imprévus. SCRUM
utilise une approche itérative et incrémentale qui permet aux membres de
l’équipe de travailler sur des fonctionnalités spécifiques en cycles courts, ap-
pelés sprints, permettant ainsi une livraison rapide et fréquente de fonction-
nalités utiles aux utilisateurs.
De plus, SCRUM encourage la communication et la collaboration entre
les membres de l’équipe, ce qui facilite la résolution rapide des problèmes et
la prise de décision. Les réunions régulières, telles que les revues de sprint,
permettent une visibilité constante de l’état du projet et encouragent la par-
ticipation active des parties prenantes. Cela permet de garantir la transpa-
rence et l’implication de tous les acteurs du projet, y compris les clients et
les utilisateurs finaux.
En choisissant SCRUM pour notre projet, nous pouvons améliorer la qua-
lité et la cohérence du produit tout en optimisant les ressources et en mi-
nimisant les risques. SCRUM est une méthode efficace pour les projets de
développement de logiciels, les projets d’innovation et de recherche, ainsi que
pour les projets de toute taille et de toute complexité. Le choix de cette
méthode de gestion de projet s’aligne parfaitement avec notre vision de dé-
veloppement d’un produit de haute qualité, en mettant l’accent sur la colla-
boration, la transparence et la flexibilité.
9
Figure 1.2 – Capture d’écran Scrum 3
10
1.4.3 Jira
Jira est un outil de gestion de projets largement utilisé, conçu pour aider
les équipes à planifier, suivre et livrer leurs projets de manière efficace. Il
offre une gamme de fonctionnalités puissantes pour la gestion des tâches, la
collaboration, le suivi des problèmes, la gestion des versions, et bien plus
encore. J’ai choisi d’utiliser Jira pour notre projet Scrum en raison de ses
nombreux avantages.
Tout d’abord, Jira permet une organisation claire et structurée des tâches
et des activités du projet. Grâce à son tableau de bord intuitif, il est facile
de créer des tâches, de les attribuer aux membres de l’équipe, de suivre leur
progression et de définir les délais. Cela facilite la coordination entre les
membres de l’équipe et garantit que chacun sait ce qui doit être accompli.
De plus, Jira offre une visibilité en temps réel sur l’état du projet. Les
tableaux Kanban et les graphiques de suivi permettent de visualiser facile-
ment les tâches en cours, les tâches terminées et les problèmes rencontrés.
Cela aide à identifier les goulots d’étranglement, à hiérarchiser les tâches et
à prendre des décisions éclairées pour améliorer la productivité.
En outre, Jira favorise la collaboration au sein de l’équipe. Les membres
de l’équipe peuvent facilement communiquer, partager des informations et
collaborer sur les tâches. Les commentaires et les discussions associés à chaque
tâche permettent d’échanger des idées, de résoudre des problèmes et d’obtenir
des retours d’expérience.
Pour illustrer l’apparence de Jira, la figure 1.6 montre une capture d’écran
de l’interface utilisateur :
Figure 1.6 – Capture d’écran de Jira
Cette image représente l’interface conviviale et intuitive de Jira, avec ses

fonctionnalités clés accessibles à partir du tableau de bord principal.
11
Chapitre 1 1.5. Sprints
En conclusion, Jira a été un choix judicieux pour notre projet Scrum

en raison de sa facilité d’utilisation, de sa puissance et de sa capacité à
favoriser la collaboration et la transparence. Grâce à cet outil, nous avons pu
organiser efficacement notre travail, suivre notre progression et améliorer la
communication au sein de l’équipe.
1.5 Sprints
Figure 1.7 – Capture d’écran du sprint 1
12
Chapitre 1 1.6. Synopsis global
1.6 Synopsis global

Avant de conclure sur ce chapitre, nous présentons dans la figure 1.10, le
synopsis global de notre solution proposée avec tous les modules a developper.
Figure 1.10 – Synopsis global du projet
1.7 Conclusion
En conclusion, ce chapitre a permis de mettre en lumière les enjeux et
défis auxquels font face les opérateurs de télécommunication en Tunisie lors
de l’inspection des pylônes, ainsi que les risques encourus par les pylonistes.
Nous avons proposé une solution innovante basée sur l’utilisation d’un drone
équipé d’intelligence artificielle pour effectuer des inspections précises, ra-
pides et sûres.
En utilisant cette technologie, notre solution permettra de réduire les

risques pour les travailleurs et d’optimiser les coûts et le temps de main-
tenance. Les données collectées par le drone seront traitées à l’aide d’al-
gorithmes de machine learning pour améliorer la précision et l’efficacité de
l’inspection, permettant ainsi une meilleure prise de décision.
Nous avons également présenté la méthodologie SCRUM pour la gestion
de notre projet, qui offrira une gestion flexible et efficace grâce à une approche
itérative et incrémentale et une communication régulière entre les membres
de l’équipe.
Dans le prochain chapitre, nous détaillerons les spécifications techniques
du drone et les étapes de conception, d’implémentation et de test pour va-
lider notre solution. Nous sommes convaincus que notre approche innovante
13
Chapitre 1 1.7. Conclusion
et notre méthodologie de gestion de projet agile permettront de répondre

efficacement aux besoins des opérateurs de télécommunication en Tunisie.
14
Première partie
Conception
15
Chapitre 2
Intelligence Artificielle
2.8 Introduction
L’Intelligence Artificielle (IA) est une branche de l’informatique qui se concentre sur
le développement de technologies permettant aux machines de réaliser des tâches qui
nécessitent normalement une intervention humaine. L’IA s’appuie sur des algorithmes
et des modèles mathématiques sophistiqués pour analyser des données, apprendre de
nouvelles tâches et prendre des décisions.
L’histoire de l’IA remonte aux années 1950, lorsque les scientifiques ont commencé à
étudier la manière dont les machines peuvent imiter l’intelligence humaine. Depuis lors,
l’IA a connu des avancées significatives, notamment grâce aux algorithmes d’apprentissage
automatique (machine learning) qui permettent aux machines d’apprendre à partir de
données et de s’améliorer au fil du temps.
Aujourd’hui, l’IA est devenue un élément clé de nombreux secteurs, notamment la
santé, les finances, la fabrication, les transports et l’informatique. Elle est utilisée pour
résoudre des problèmes complexes, automatiser des processus et améliorer l’efficacité et la
précision dans de nombreuses tâches. Les applications de l’IA sont vastes et en constante
expansion, et elle est devenue un outil essentiel pour les entreprises, les gouvernements et
les particuliers.
Cependant, l’IA soulève également des préoccupations quant à son impact sur l’emploi,
la vie privée et l’éthique. Pour cette raison, il est important de comprendre les avantages
et les limites de l’IA, ainsi que les implications éthiques et sociales de son utilisation.
Dans ce projet, nous avons choisi d’utiliser le modèle de détection d’objets YOLO
(You Only Look Once) pour résoudre le problème de sécurité des travailleurs dans l’in-
dustrie des télécommunications. La croissance rapide de la technologie mobile en Tunisie
a entraîné l’installation d’un grand nombre d’antennes dans tout le pays, qui nécessitent
une maintenance et une inspection régulières. Cependant, ces tâches peuvent être dange-
reuses pour les travailleurs en raison des risques liés aux pylônes, notamment les chutes de
hauteur et l’exposition aux ondes électromagnétiques. La détection d’objets peut aider à
résoudre ces problèmes en utilisant des drones équipés de caméras et de capteurs sophis-
tiqués pour effectuer des inspections précises et complètes des antennes. Cette approche
réduit les risques pour les travailleurs tout en améliorant l’efficacité de la maintenance.
En outre, l’utilisation de l’apprentissage automatique pour traiter les données collectées
par les drones peut améliorer la précision et l’efficacité de l’inspection. L’adoption de
cette approche en Tunisie peut stimuler le développement de la technologie de détection
d’objets et créer de nouvelles opportunités pour les professionnels de l’inspection et de la
maintenance.
16
Chapitre 2 2.9. Machine learning
2.9 Machine learning

Le Machine Learning (apprentissage automatique) est une branche de l’intelligence
artificielle qui permet aux machines d’apprendre à partir de données et de s’améliorer
automatiquement sans être explicitement programmées. Il s’appuie sur des algorithmes
et des modèles statistiques pour analyser des données, trouver des motifs et des relations
cachées, et construire des modèles prédictifs ou des systèmes de recommandation [1]
Le processus de Machine Learning implique généralement les étapes suivantes (cf. fi-
gure 2.11) :
1. Collecte et préparation des données : cela implique la collecte de données pertinentes, le
nettoyage, la transformation et la normalisation des données pour les rendre exploitables.
2. Choix de l’algorithme : il existe plusieurs types d’algorithmes de Machine Learning
tels que les arbres de décision, les réseaux de neurones, les SVM, etc. Il est important de
sélectionner l’algorithme approprié pour répondre aux exigences spécifiques du problème
de Machine Learning.
3. Entraînement du modèle : cette étape consiste à utiliser des données d’entraînement
pour entraîner le modèle de Machine Learning.
4. Validation et optimisation du modèle : le modèle doit être évalué pour déterminer sa
performance et son efficacité, et doit être optimisé pour améliorer ses performances en
utilisant des techniques telles que la sélection de fonctionnalités, le réglage des hyperpa-
ramètres, etc.
5. Utilisation du modèle pour prédire de nouvelles données : une fois que le modèle est
entraîné et optimisé, il peut être utilisé pour prédire de nouvelles données.
Le Machine Learning est utilisé dans diverses applications, telles que la reconnaissance
vocale, la reconnaissance d’images, les systèmes de recommandation, la classification de
texte, la détection de fraude, etc. Les avantages du Machine Learning incluent l’automa-
tisation de tâches répétitives, la prise de décision plus rapide et plus précise, et la capacité
à traiter de grandes quantités de données.
Figure 2.11 – Le processus de Machine Learning

[2]
2.10 Deep learning

Le Deep Learning (apprentissage profond) est une branche de l’intelligence artificielle
qui utilise des réseaux de neurones artificiels pour apprendre à partir de données. Il s’agit
d’une méthode d’apprentissage automatique qui permet à un système de détecter des
motifs et des relations complexes dans les données en utilisant des couches de traitement
de l’information.
17
Chapitre 2 2.11. Modèles disponibles et choix de YOLO
Contrairement au Machine Learning traditionnel qui utilise des modèles linéaires pour
apprendre des données, le Deep Learning utilise des réseaux de neurones profonds pour ap-
prendre des données à plusieurs niveaux d’abstraction. Les réseaux de neurones profonds
sont constitués de plusieurs couches de neurones, chacune effectuant une transformation
non linéaire des données entrantes [3].
Le processus de Deep Learning implique généralement les étapes suivantes :
1. Collecte et préparation des données : cela implique la collecte de données perti-

nentes, le nettoyage, la transformation et la normalisation des données pour les rendre
exploitables.
2. Choix de l’architecture de réseau de neurones : il existe plusieurs types d’architec-

tures de réseaux de neurones profonds tels que les réseaux de neurones convolutifs, les
réseaux de neurones récurrents, etc. Il est important de sélectionner l’architecture appro-
priée pour répondre aux exigences spécifiques du problème de Deep Learning.
3. Entraînement du modèle : cette étape consiste à utiliser des données d’entraînement

pour entraîner le modèle de Deep Learning en ajustant les poids et les biais des neurones.
4. Validation et optimisation du modèle : le modèle doit être évalué pour déterminer

sa performance et son efficacité, et doit être optimisé pour améliorer ses performances en
utilisant des techniques telles que la régularisation, l’augmentation de données, etc.
5. Utilisation du modèle pour prédire de nouvelles données : une fois que le modèle est
entraîné et optimisé, il peut être utilisé pour prédire de nouvelles données.
Le Deep Learning est utilisé dans diverses applications telles que la reconnaissance
vocale, la reconnaissance d’image, la traduction automatique, la compréhension du langage
naturel, la classification de texte, etc. Les avantages du Deep Learning incluent la capacité
à traiter de grandes quantités de données, à identifier des motifs complexes et à améliorer
les performances du modèle à mesure que les données sont plus nombreuses.
Figure 2.12 – Le processus de Deep Learning

[2]
2.11 Modèles disponibles et choix de YOLO

Il existe de nombreux modèles de détection d’objets disponibles, tels que Faster R-
CNN, R-FCN, et SSD. Chacun de ces modèles a ses propres avantages et inconvénients,
18
Chapitre 2 2.12. Analyse des besoins fonctionnels
mais après avoir comparé ces différents modèles, nous avons choisi YOLO pour notre
projet de détection d’objets.
L’une des principales raisons pour lesquelles nous avons choisi YOLO est sa rapidité.
YOLO est capable de traiter des images en temps réel, ce qui est important pour la sécurité
des travailleurs lors de l’inspection des antennes. De plus, YOLO offre une précision élevée
pour la détection d’objets dans les images, avec une précision de détection supérieure à
90
En outre, YOLO est facilement personnalisable, ce qui nous permet de former notre
modèle de détection d’objets avec nos propres données de formation. De plus, il est opti-
misé pour les architectures de calcul modernes, ce qui facilite son exécution sur différents
types de matériel.
En comparaison, d’autres modèles de détection d’objets peuvent offrir une précision
légèrement plus élevée, mais cela se fait souvent au détriment de la rapidité de traitement.
De plus, certains de ces modèles sont plus complexes à mettre en œuvre et nécessitent
plus de ressources en termes de puissance de calcul et de mémoire.
En somme, nous avons choisi YOLO pour notre projet de détection d’objets en raison
de sa rapidité, de sa précision élevée, de sa facilité de personnalisation et de sa compa-
tibilité avec différentes architectures de calcul. Ces caractéristiques nous permettent de
développer un modèle de détection d’objets précis et efficace pour la sécurité des tra-
vailleurs lors de l’inspection des antennes.
2.12 Analyse des besoins fonctionnels

Pour un système de détection de pylônes utilisant YOLO, les besoins fonctionnels
incluent la capacité du système à détecter les différents composants des pylônes, tels
que les antennes, les faisceaux, les boulons et les boulons rouillés. Le système doit être
capable de fournir des résultats de détection en temps réel avec une précision élevée pour
permettre une maintenance préventive des pylônes. Le système doit également être capable
de détecter les composants des pylônes dans des conditions environnementales variables
telles que le vent, la pluie et le brouillard. Le système doit être en mesure de détecter
les pylônes à différentes distances et angles pour permettre une inspection complète des
pylônes.
2.13 Analyse des besoins non fonctionnels

Les besoins non fonctionnels pour un système de détection de pylônes incluent des
exigences de qualité, telles que la précision de la détection et la fiabilité du système dans
des conditions environnementales variables. Les exigences de performance comprennent
des délais de traitement rapides et une faible consommation de ressources pour permettre
une utilisation efficace du système. Les exigences de sécurité comprennent des protocoles
de sécurité pour garantir la confidentialité et l’intégrité des données collectées par le
système. Enfin, les exigences d’utilisabilité incluent une interface utilisateur conviviale
et intuitive pour faciliter l’utilisation du système par les opérateurs de maintenance des
pylônes. Le système doit également être évolutif pour permettre une mise à jour facile et
rapide en fonction des besoins futurs.
Pour répondre à ces besoins fonctionnels et non fonctionnels, le système de détection de
pylônes utilisera le modèle YOLO pour la détection des composants des pylônes. Le modèle
19
Chapitre 2 2.14. Méthodologie
sera entraîné sur un ensemble de données diversifié et représentatif pour améliorer la

précision de la détection. Le système sera également équipé de capteurs sophistiqués pour
collecter des données environnementales telles que la météo et l’humidité pour améliorer
la précision de la détection. Le système sera développé avec des outils de sécurité pour
garantir la confidentialité et l’intégrité des données collectées. Le système sera conçu
avec une interface utilisateur conviviale et intuitive pour faciliter son utilisation par les
opérateurs de maintenance des pylônes. Enfin, le système sera développé en utilisant des
technologies évolutives pour permettre une mise à jour facile et rapide en fonction des
besoins futurs.
2.14 Méthodologie
Pour notre projet de détection d’objets à l’aide de YOLO, nous avons suivi une mé-
thodologie en plusieurs étapes. Tout d’abord, nous avons collecté un ensemble de données
d’images d’antennes de télécommunication. Nous avons ensuite annoté les images en uti-
lisant des outils d’annotation d’images pour identifier les objets d’intérêt (les antennes)
et les délimiter avec une boîte englobante. Nous avons également étiqueté les images avec
la classe correspondante (dans notre cas, "antenne").
Nous avons ensuite divisé notre ensemble de données en un ensemble de formation
(pour entraîner le modèle) et un ensemble de test (pour évaluer la performance du modèle).
Nous avons utilisé l’architecture YOLOv3 et le framework de Deep Learning Keras pour
former notre modèle de détection d’objets.
Nous avons optimisé les paramètres de notre modèle de détection d’objets pour maxi-
miser sa précision et minimiser les faux positifs et les faux négatifs. Nous avons ajusté les
hyperparamètres tels que la taille de la grille de prédiction, le nombre d’ancres, le seuil de
confiance et le seuil de suppression non maximale pour améliorer la précision et la vitesse
de détection.
Nous avons également effectué des étapes de prétraitement des données pour aug-
menter notre ensemble de données et améliorer la performance du modèle. Nous avons
appliqué des techniques telles que le recadrage aléatoire, le changement d’échelle, le chan-
gement de couleur et le flou gaussien pour augmenter la variété des images d’entraînement
et améliorer la robustesse du modèle.
En conclusion, notre méthodologie pour implémenter YOLO pour la détection d’objets
a impliqué la collecte de données, l’annotation, la division des ensembles de données,
la formation et l’optimisation du modèle, ainsi que le prétraitement des données pour
augmenter la performance du modèle.
2.15 Bibliothèques Python utilisées par YOLO

YOLO [4] utilise plusieurs bibliothèques Python pour implémenter son architecture de
détection d’objets. Voici une liste des principales bibliothèques que nous avons utilisées
pour notre projet :
2.15.1 OpenCV
OpenCV[5] est une bibliothèque de traitement d’images en temps réel qui fournit des
fonctions pour la manipulation et l’analyse des images. Elle est utilisée pour la capture de
20
Chapitre 2 2.16. Paramètres et hyperparamètres du modèle YOLO
vidéos en direct, la lecture de vidéos préenregistrées, la lecture de fichiers d’images, ainsi

que pour la manipulation et la transformation des images. OpenCV fournit également des
fonctions pour la détection de contours, la correspondance de formes et la segmentation
d’images.
2.15.2 NumPy
NumPy[6] est une bibliothèque Python pour les calculs scientifiques qui fournit des
fonctions pour les tableaux multidimensionnels. Elle est utilisée pour la manipulation de
données en tableau, y compris les tableaux d’images. NumPy fournit des fonctions pour
la manipulation, la transformation et l’analyse de tableaux multidimensionnels, ainsi que
pour la création de tableaux à partir de données existantes.
2.15.3 Keras
Keras[7] est un framework de Deep Learning qui fournit une interface haut niveau
pour la construction et l’entraînement des réseaux de neurones. Elle est utilisée pour la
construction du modèle de détection d’objets, ainsi que pour l’entraînement et l’évaluation
du modèle. Keras fournit une interface conviviale pour la construction de modèles de
réseau de neurones en empilant des couches, ainsi que des fonctions pour l’optimisation
et la compilation du modèle.
2.15.4 TensorFlow
TensorFlow[8] est un framework de Deep Learning développé par Google qui fournit
des fonctions pour la construction et l’entraînement des réseaux de neurones. Elle est
utilisée pour la construction du modèle de détection d’objets, ainsi que pour l’entraînement
et l’évaluation du modèle. TensorFlow fournit des fonctions pour la création de graphes de
calcul pour la construction de modèles de réseau de neurones, ainsi que pour la propagation
en arrière et l’optimisation des poids du modèle.
2.15.5 Darknet
Darknet[9] est un framework de Deep Learning open source utilisé pour l’entraînement
de YOLO. Il fournit des fonctions pour la construction et l’entraînement de réseaux de
neurones, ainsi que pour la prédiction et la détection d’objets. Darknet utilise une archi-
tecture de réseau de neurones différente de celle de TensorFlow et de Keras, ce qui la rend
particulièrement adaptée pour l’entraînement de YOLO.
2.16 Paramètres et hyperparamètres du modèle YOLO

YOLO (You Only Look Once) est un modèle de détection d’objets qui utilise une ar-
chitecture de réseau de neurones convolutifs pour identifier et localiser des objets dans des
images. Le modèle YOLO est constitué de plusieurs couches de convolution, de regroupe-
ment et de normalisation, ainsi que d’une couche de prédiction qui produit des cartes de
probabilité pour la présence d’objets à différentes échelles.
Voici les principales valeurs et paramètres du modèle YOLO :
21
2.16.1 Taille de l’image d’entrée (INP)

La taille de l’image d’entrée (Input Size, INP) est un paramètre important pour le
modèle YOLO, car elle détermine la résolution spatiale de la carte de probabilité de l’objet.
Dans notre projet, nous avons utilisé une taille d’image d’entrée de 416x416 pixels (INP),
qui offre un bon compromis entre la précision de détection et la vitesse de traitement.
2.16.2 Nombre de cartes de probabilité (NB)

Le modèle YOLO produit plusieurs cartes de probabilité pour la présence d’objets à
différentes échelles spatiales. Dans notre projet, nous avons utilisé trois cartes de proba-
bilité de taille 13x13 (Number of Boxes, NB13), 26x26 (NB26) et 52x52 (NB52), chacune
correspondant à une résolution spatiale différente.
2.16.3 Nombre de boîtes d’ancrage (NA)

Les boîtes d’ancrage (Number of Anchors, NA) sont des régions prédéfinies de diffé-
rentes tailles et formes utilisées pour prédire la position et la taille des objets. Le modèle
YOLO utilise des boîtes d’ancrage pour prédire les coordonnées des boîtes englobantes
pour chaque objet détecté. Dans notre projet, nous avons utilisé 9 boîtes d’ancrage (NA9)
pour chaque carte de probabilité, pour un total de 27 boîtes d’ancrage.
2.16.4 Seuil de confiance (SC)

Le seuil de confiance (Confidence Score, SC) est un seuil de probabilité en dessous
duquel les prédictions du modèle sont rejetées. Dans notre projet, nous avons utilisé un
seuil de confiance de 0,5 (SC=0.5), ce qui signifie que seules les prédictions avec une
probabilité de présence d’objet supérieure à 50
2.16.5 Score IOU (IOU)

Le score IOU (Intersection over Union Score, IOU) est un score de similarité entre
deux boîtes englobantes qui mesure la proportion de pixels recouvrés par les deux boîtes.
Dans notre projet, nous avons utilisé un score IOU de 0,5 (IOU=0.5), ce qui signifie que
deux boîtes englobantes sont considérées comme correspondant au même objet si leur
score IOU est supérieur à 50
En utilisant ces valeurs et paramètres, nous avons pu entraîner efficacement le modèle
YOLO pour la détection d’objets dans nos images d’antennes de télécommunication.
2.17 Conclusion
En conclusion, la conception de l’intelligence artificielle (IA) est un domaine pas-
sionnant et complexe. Grâce à des techniques telles que l’apprentissage automatique, les
chercheurs ont réussi à créer des systèmes capables de réaliser des tâches complexes. Ce-
pendant, la conception d’une IA efficace nécessite une compréhension approfondie du
domaine, des données de qualité et une réflexion éthique. Il est important d’utiliser l’IA
de manière responsable pour le bien de l’humanité. Avec des efforts continus, l’IA a le
potentiel de transformer de nombreux aspects de notre société.
22
Chapitre 3
Conception web
3.1 Introduction
Django est un framework de développement web open-source, hautement performant
et puissant, qui permet de créer des applications web de manière efficace et structurée.
Il est écrit en Python et suit l’architecture du modèle MVC (Modèle-Vue-Contrôleur), ce
qui facilite la séparation des préoccupations et la gestion de la logique métier.
3.2 Conception Django

Dans cette section, nous nous intéressons à la conception Django
3.2.1 Présentation de Django

Django a été développé par une équipe de développeurs expérimentés dans le but de
simplifier et d’accélérer le processus de développement d’applications web. Il est conçu
pour être hautement extensible, ce qui permet aux développeurs d’ajouter facilement de
nouvelles fonctionnalités et de personnaliser le framework selon leurs besoins.
Les principales caractéristiques de Django comprennent :
— Architecture MTV : Django suit l’architecture du Modèle-Vue-Template (MTV),
qui est une variation du modèle MVC. Cela permet de séparer clairement la lo-
gique métier (Modèle), la présentation des données (Vue) et la gestion de l’interface
utilisateur (Template).
— ORM intégré : Django fournit un ORM (Object-Relational Mapping) intégré
qui facilite l’interaction avec la base de données. Cela permet aux développeurs de
travailler avec des objets Python plutôt qu’avec du SQL brut, ce qui simplifie le
processus de manipulation des données [10]
— Administration automatique : Django génère automatiquement une interface
d’administration basée sur les modèles de données définis. Cela permet aux admi-
nistrateurs de gérer facilement les données de l’application sans avoir à écrire de
code supplémentaire.
— Sécurité renforcée : Django intègre de nombreuses fonctionnalités de sécurité
pour protéger les applications contre les vulnérabilités courantes, telles que les
attaques par injection SQL, les attaques XSS (Cross-Site Scripting) et les atteintes
à la confidentialité des données.
23
Chapitre 3 3.2. Conception Django
— Internationalisation et localisation : Django prend en charge l’internationali-

sation et la localisation des applications, ce qui facilite le développement d’appli-
cations multilingues et adaptées à différentes régions.
— Large écosystème : Django bénéficie d’une communauté active et d’un vaste
écosystème d’extensions et de packages qui permettent d’ajouter des fonctionnalités
supplémentaires à l’application.
Django est largement utilisé par de nombreuses entreprises et organisations renom-
mées, ce qui en fait l’un des frameworks web les plus populaires et les plus fiables du
marché. Sa simplicité, sa flexibilité et sa robustesse en font un choix idéal pour dévelop-
per des applications web de toutes tailles et de toutes complexités.
3.2.2 Pourquoi choisir Django

Django est un framework de développement web de haut niveau écrit en Python qui
encourage un développement rapide et propre, avec une conception pragmatique. Voici
quelques raisons pour lesquelles Django est un excellent choix pour le développement web.
Principe DRY (Don’t Repeat Yourself)

L’un des principes fondamentaux de Django est le principe DRY. Cela signifie que
Django vise à minimiser la redondance dans le code, ce qui se traduit par un code plus
concis, plus maintenable et moins sujet aux erreurs.
Grande communauté et documentation riche

Django a une grande communauté de développeurs actifs, ce qui signifie que nous
avons trouver un grand nombre de ressources pédagogiques, de packages tiers, et obtenir
de l’aide lorsque nous avons besoin. La documentation officielle de Django est également
très complète et bien écrite.
ORM puissant
L’ORM de Django est l’un des points forts du framework. Il permet de manipuler la
base de données comme si elle était constituée d’objets Python, ce qui rend le code plus
lisible et facile à maintenir.
Sécurité
Django fournit plusieurs mécanismes de sécurité par défaut, comme la protection
contre les attaques CSRF, l’injection SQL et le Cross-Site Scripting (XSS). Cela rend
Django un choix sûr pour le développement web.
Rapidité de développement
Django a été conçu pour aider les développeurs à aller de l’idée au produit le plus
rapidement possible. Grâce à sa riche boîte à outils, les développeurs peuvent se concentrer
sur l’écriture de l’application sans avoir besoin de réinventer la roue.
24
Scalabilité
Django est conçu pour aider les développeurs à construire des applications qui peuvent
évoluer avec le temps. Il permet de commencer avec une petite application qui peut être
étendue et évoluer en une grande application avec des millions d’utilisateurs. “‘
3.2.3 Architecture et Structure de Django

L’architecture et la structure de Django sont conçues de manière à favoriser un dé-
veloppement web structuré et modulaire. Dans cette subsection, nous allons explorer les
principaux composants de l’architecture de Django et la structure générale d’une appli-
cation Django.
Modèle MVC (Modèle-Vue-Contrôleur)

Django suit le modèle de conception MVC (Modèle-Vue-Contrôleur), qui est un patron
de conception largement utilisé dans le développement web. Le modèle MVC sépare la
logique de l’application en trois composants distincts :
— Modèle : Le modèle représente les données et les règles métier de l’application. Il
interagit avec la base de données pour effectuer les opérations de lecture, d’écriture
et de mise à jour des données. Dans Django, les modèles sont définis à l’aide de
classes Python qui héritent de la classe de base django.db.models.Model.
— Vue : La vue gère la logique de présentation et l’interaction avec l’utilisateur.
Elle reçoit les requêtes HTTP, interroge les modèles pour récupérer les données
nécessaires et génère les réponses appropriées, telles que des pages HTML ou des
données JSON. Dans Django, les vues sont généralement des fonctions ou des
méthodes de classe qui sont associées à des URL spécifiques.
— Contrôleur : Le contrôleur fait le lien entre les modèles et les vues. Il reçoit les
requêtes de l’utilisateur, analyse les données de la requête et appelle les vues ap-
propriées pour générer les réponses. Dans Django, le contrôleur est principalement
géré par le framework lui-même, ce qui simplifie le développement.
Le modèle MVC permet de séparer clairement les responsabilités et favorise la réuti-
lisabilité du code.
Structure d’une Application Django

Une application Django suit une structure bien définie, qui facilite l’organisation et la
gestion du code. Voici les principaux composants d’une application Django :
— Répertoire du projet : C’est le répertoire racine de l’application Django. Il
contient les fichiers de configuration globaux, tels que settings.py qui définit les
paramètres de configuration de l’application, et urls.py qui gère les routes des
URL de l’application.
— Applications : Une application Django est un module indépendant qui regroupe
un ensemble de fonctionnalités spécifiques. Chaque application a sa propre struc-
ture interne, comprenant les modèles, les vues, les templates, les fichiers statiques,
etc. Les applications sont réutilisables et peuvent être utilisées dans différents pro-
jets Django.
— Modèles : Les modèles représentent les entités de l’application et définissent la
structure de la base de données. Ils sont généralement regroupés dans un répertoire
25
nommé models à l’intérieur de chaque application. Chaque modèle est défini dans
un fichier Python et correspond à une table dans la base de données.
— Vues : Les vues gèrent la logique de présentation et l’interaction avec l’utilisateur.
Elles sont généralement regroupées dans un répertoire nommé views à l’intérieur de
chaque application. Chaque vue est définie dans un fichier Python et est responsable
de la génération des réponses aux requêtes.
— Templates : Les templates sont des fichiers HTML qui définissent la structure et
la mise en page des pages web. Ils sont généralement stockés dans un répertoire
nommé templates à l’intérieur de chaque application. Les templates permettent
d’insérer dynamiquement les données récupérées des vues.
— Fichiers statiques : Les fichiers statiques, tels que les fichiers CSS, JavaScript, les
images, etc., sont stockés dans un répertoire nommé static à l’intérieur de chaque
application. Ils sont utilisés pour améliorer l’apparence et l’interactivité des pages
web.
Cette structure hiérarchique facilite la maintenance, le partage et la réutilisation du
code à travers différentes applications Django.
En résumé, l’architecture de Django suit le modèle MVC et offre une structure bien
définie pour organiser le code d’une application web. Cette approche facilite le dévelop-
pement, la maintenance et la collaboration entre les développeurs.
3.2.4 Conception des modèles Django

La conception des modèles Django est une étape cruciale dans le développement de
notre application web. Les modèles servent à représenter les entités et les relations de
données de notre système. Dans cette subsection, nous aborderons les principes et les
concepts clés de la conception des modèles Django.
Définition des classes de modèle

Dans Django, les classes de modèle sont utilisées pour représenter les entités de notre
application. Chaque classe de modèle hérite de la classe de base django.db.models.Model.
À l’intérieur de la classe de modèle, nous définissons les champs qui composent l’entité.
Les champs peuvent représenter des données telles que des chaînes de caractères, des
nombres, des dates, etc.
La définition des champs se fait en utilisant les différents types de champs fournis par
Django, tels que CharField, IntegerField, DateField, etc. Ces champs nous permettent
de définir les propriétés et les contraintes des données, telles que la longueur maximale
d’une chaîne de caractères ou la valeur minimale d’un nombre.
Relations entre les modèles

Les modèles Django permettent de définir des relations entre les entités. Ces relations
représentent les liens et les dépendances entre les différentes entités de notre système. Les
types de relations les plus courants sont les relations de clé étrangère (ForeignKey), les re-
lations Many-to-Many (ManyToManyField) et les relations One-to-One (OneToOneField).
Les relations de clé étrangère permettent d’établir des liens entre deux entités en
utilisant une référence à une clé primaire dans une autre table. Les relations Many-to-
Many permettent de représenter des relations multiples entre deux entités, tandis que les
relations One-to-One représentent une relation un-à-un entre deux entités.
26
Utilisation des fonctionnalités avancées

Django offre également des fonctionnalités avancées pour la conception des modèles,
telles que les modèles abstraits et l’héritage de modèles. Les modèles abstraits permettent
de définir des modèles génériques avec des champs communs, qui peuvent ensuite être éten-
dus par d’autres modèles. Cela permet de réutiliser du code et de simplifier la conception.
L’héritage de modèles permet de créer une hiérarchie de modèles, où un modèle en-
fant hérite des champs et des méthodes d’un modèle parent. Cette fonctionnalité est
utile lorsque nous avons des entités qui partagent des propriétés communes, mais qui ont
également des attributs spécifiques.
En utilisant ces fonctionnalités avancées, nous pouvons concevoir des modèles Django
flexibles et modulaires, qui reflètent de manière précise les entités et les relations de notre
application.
3.2.5 Conception des vues Django

Principe des vues dans Django
Dans Django, une vue est une fonction Python qui prend une requête Web et renvoie
une réponse Web. Chaque vue fonctionne comme un gestionnaire spécifique pour une
requête HTTP spécifique. Les vues sont généralement liées à une URL, qui est définie par
une expression régulière dans le système de routage d’URL de Django. La correspondance
entre l’URL et la vue est faite grâce à la structure de l’URL et non grâce à la méthode
HTTP utilisée (GET, POST, etc.). Les vues prennent en compte les données contenues
dans l’objet de requête pour générer leur réponse.
Utilisation des vues génériques

Les vues génériques de Django permettent de simplifier la conception des vues en
offrant des modèles pour accomplir des tâches courantes. Il s’agit notamment de l’affichage
d’une liste d’objets, de l’affichage d’un seul objet, de l’affichage d’un formulaire pour la
création d’un nouvel objet, de l’affichage d’un formulaire pour la mise à jour d’un objet
existant, et de la suppression d’un objet existant. Les vues génériques permettent de
minimiser le code en réutilisant des vues communes, tout en offrant des points d’extension
pour personnaliser leur comportement si nécessaire.
La fonction de vue
Une fonction de vue, dans Django, est une fonction Python qui prend en argument
un objet HttpRequest (et éventuellement d’autres arguments), effectue une certaine lo-
gique en fonction des informations contenues dans l’objet de requête, et renvoie un objet
HttpResponse. Les fonctions de vue peuvent accéder aux données de la requête, aux pa-
ramètres de l’URL, aux données de session, et à d’autres informations pour générer la
réponse appropriée.
Les classes de vue

Les classes de vue sont une alternative aux fonctions de vue qui permettent une
meilleure réutilisation du code et une meilleure organisation. Une classe de vue est une
classe Python qui définit des méthodes pour gérer différentes méthodes HTTP (get, post,
27
etc.). Django fournit une série de classes de vue de base que nous avons utiliser directement
ou étendre pour créer des comportements personnalisés.
3.2.6 Routage URL dans Django

Comprendre les expressions régulières
Le système de routage d’URL de Django utilise des expressions régulières pour faire
correspondre les URL aux vues appropriées. Une expression régulière est une séquence
de caractères qui forme un modèle de recherche. Les expressions régulières permettent de
créer des motifs d’URL flexibles et puissants. Elles peuvent inclure des groupes de capture
pour extraire des valeurs de l’URL, qui seront ensuite passées en tant qu’arguments à la
vue.
Création d’URL dans Django

Dans Django, les URL sont définies dans un fichier d’URL, également connu sous le
nom d’URLconf. Chaque application Django peut avoir son propre fichier d’URL, ce qui
permet de définir des URL de manière modulaire pour chaque composant de l’applica-
tion. Les URL sont mappées aux vues correspondantes à l’aide de la fonction path() ou
re_path(), qui prend une expression régulière et une vue comme arguments, et éventuel-
lement des arguments supplémentaires et un nom d’URL.
Utilisation de l’espace de noms URL

Les espaces de noms d’URL sont un moyen de regrouper les URL par application. Ils
permettent de référencer les URL de manière univoque, même si différentes applications
utilisent des URL avec le même nom. Cela est particulièrement utile lors de l’utilisation
d’inclusions d’URL ou de vues génériques, où les mêmes vues peuvent être réutilisées avec
différentes URL.
3.2.7 Conception des templates Django

Syntaxe des templates Django
Les templates Django sont écrits dans un langage spécifique qui permet de générer
du HTML dynamique. Les templates contiennent des variables, qui sont remplacées par
leurs valeurs lors de l’exécution, et des balises, qui contrôlent la logique du template. Les
variables sont représentées par des noms entourés de doubles accolades ( variable ), tandis
que les balises sont représentées par des noms entourés de signes pourcent (% balise %).
Blocs et héritage de templates

L’héritage de templates est une fonctionnalité puissante des templates Django qui
permet de réutiliser des parties de templates. Un template peut définir des blocs, qui sont
des subsections qui peuvent être surchargées par les templates qui étendent ce template.
Les blocs sont définis avec la balise % block % et peuvent être remplis avec du contenu
dans le template parent et surchargés dans le template enfant.
28
Utilisation des filtres de template

Les filtres de templates permettent de modifier les variables dans le template avant
qu’elles ne soient rendues. Django fournit un grand nombre de filtres par défaut, qui
peuvent être utilisés pour modifier les variables de manière utile. Par exemple, le filtre
date permet de formater une variable de date, le filtre lower permet de convertir une
variable en minuscules, etc. Les filtres sont appliqués à une variable à l’aide du caractère
pipe (|).
Les balises de template

Les balises de template sont des constructions qui contrôlent la logique du template.
Django fournit un ensemble de balises par défaut, qui peuvent être utilisées pour des
structures de contrôle de flux telles que les boucles et les conditions, pour inclure d’autres
templates, pour charger des balises et des filtres personnalisés, etc. Les balises sont utilisées
en les entourant de signes pourcent (% balise %).
3.2.8 Formulaires dans Django

Comprendre les formulaires dans Django
Django fournit une infrastructure puissante pour gérer les formulaires HTML et la
validation des données de formulaire. Un formulaire est représenté par une classe qui
hérite de la classe Form ou ModelForm. Les formulaires peuvent définir des champs,
qui sont des attributs qui définissent le type de données, les widgets de formulaire, les
validateurs, et d’autres propriétés.
Création et utilisation de formulaires

La création d’un formulaire dans Django implique de définir une classe de formulaire
et de définir ses champs. Une fois le formulaire défini, il peut être utilisé dans une vue
pour traiter les requêtes GET et POST, pour afficher le formulaire dans un template, et
pour valider les données de formulaire soumises par l’utilisateur.
Validation des formulaires

La validation des données de formulaire est un aspect clé de la gestion des formulaires
dans Django. Chaque champ de formulaire peut avoir un ou plusieurs validateurs, qui sont
des fonctions qui vérifient que les données soumises sont valides. Lorsqu’un formulaire est
soumis, Django appelle automatiquement ces validateurs et ajoute des erreurs aux champs
de formulaire si les données ne sont pas valides.
3.2.9 Gestion des données avec l’ORM Django

Comprendre l’ORM Django
L’ORM (Object-Relational Mapping) de Django est un composant puissant qui per-
met de manipuler la base de données comme si elle était constituée d’objets Python.
Il fait le pont entre les modèles Python définis dans notre code et la base de données.
Chaque modèle correspond à une table de base de données et chaque instance de modèle
correspond à une ligne de cette table.
29
Requêtes de base avec l’ORM Django

Les requêtes de base avec l’ORM Django consistent généralement en l’extraction, la
création, la mise à jour et la suppression de données. Django fournit une API de requête
riche et expressive pour faciliter ces opérations. Les méthodes comme .get(), .filter(),
.exclude() permettent d’extraire les données tandis que .create(), .update(), .delete() sont
utilisées pour manipuler les données.
Requêtes complexes avec l’ORM Django

L’ORM Django est également capable de gérer des requêtes complexes, comprenant
des requêtes liées à plusieurs tables, des opérations d’agrégation et d’annotation. Des mé-
thodes comme .annotate(), .aggregate(), .select_related(), .prefetch_related() permettent
d’écrire des requêtes efficaces et optimisées.
3.2.10 Sécurité dans Django

Gestion des utilisateurs et des permissions
Django propose un système d’authentification intégré qui permet de gérer les utilisa-
teurs, les groupes et les permissions. Les utilisateurs peuvent être associés à des groupes
et des permissions, permettant ainsi un contrôle d’accès fin aux différentes parties de
l’application.
Protection contre les attaques CSRF

Django fournit une protection intégrée contre les attaques CSRF (Cross Site Request
Forgery). Il utilise un token CSRF qui est inclus dans les formulaires POST pour vérifier
que la requête provient bien du site lui-même.
Protection contre l’injection SQL

L’ORM de Django protège contre les attaques d’injection SQL en s’assurant que toutes
les données de requête sont correctement échappées avant d’être utilisées dans une requête
SQL.
Protection contre le Cross-Site Scripting (XSS)

Django échappe automatiquement les variables rendues dans les templates pour éviter
les attaques XSS. Cela garantit que les données utilisateur affichées dans les templates ne
peuvent pas être interprétées comme du code HTML ou JavaScript malveillant.
3.2.11 Test et débogage dans Django

Les outils de test intégrés à Django
Django fournit un cadre de test intégré qui permet d’écrire des tests pour les modèles,
les vues, les formulaires et d’autres parties de notre application. Il comprend des outils
pour créer des requêtes de test, des clients de test, et des objets de données de test.
30
Chapitre 3 3.3. Conception web
Création et exécution de tests

Les tests dans Django sont écrits comme des classes Python qui héritent de django.test.TestCase.
Chaque méthode de test représente un test individuel qui peut vérifier le comportement
de notre code. Les tests peuvent être exécutés avec la commande manage.py test.
Utilisation du débogueur Django

Django fournit un débogueur intégré qui peut être utilisé pour inspecter le compor-
tement de notre code pendant l’exécution. Le débogueur Django peut afficher une trace
de pile lorsqu’une exception est levée, montrer le contexte d’une vue, et fournir d’autres
informations utiles pour le débogage.
3.3 Conception web

Dans cette section , nous introduisons la conception web.
3.3.1 Présentation de HTML

HTML (HyperText Markup Language)[11] est le langage de balisage standard utilisé
pour créer la structure et le contenu des pages web. Il fournit les éléments nécessaires
pour organiser et présenter l’information, tels que les titres, les paragraphes, les listes, les
images, les liens, les tableaux, etc. HTML utilise une structure basée sur des balises pour
définir la signification et la mise en forme du contenu. Il est interprété par les navigateurs
web pour afficher les pages web de manière cohérente.
3.3.2 Présentation de CSS

CSS (Cascading Style Sheets)[12] est un langage utilisé pour décrire la présentation
visuelle des pages web écrites en HTML. Il permet de définir les styles, les couleurs, les
polices, les marges, les espacements, etc. des éléments HTML. CSS permet de séparer la
structure (HTML) de la présentation (CSS), ce qui offre une plus grande flexibilité et
facilite la maintenance des pages web. Les règles CSS sont appliquées en cascade, ce qui
signifie que les styles peuvent être hérités et modifiés à différents niveaux de la structure
HTML.
3.3.3 Présentation de JavaScript

JavaScript[13] est un langage de programmation côté client utilisé pour rendre les pages
web interactives et dynamiques. Il permet d’ajouter des fonctionnalités avancées aux pages
web, telles que la validation de formulaires, les animations, les effets visuels, les requêtes
AJAX pour récupérer des données en arrière-plan, etc. JavaScript est interprété par les
navigateurs web et peut être intégré directement dans les pages HTML ou inclus dans des
fichiers séparés. Il offre une grande flexibilité et une large gamme de fonctionnalités pour
améliorer l’expérience utilisateur.
31
Chapitre 3 3.3. Conception web
3.3.4 Présentation de Spline

Spline[14] est un outil de conception 3D pour le web. Il permet de créer des modèles 3D
interactifs et visuellement attrayants, qui peuvent être intégrés aux pages web. Spline offre
une interface conviviale pour créer des objets 3D en utilisant des formes géométriques,
des textures, des matériaux et des effets d’éclairage. Il prend en charge l’importation
et l’exportation de différents formats de fichiers 3D. Spline offre aux concepteurs web
la possibilité d’ajouter des éléments visuels 3D aux pages web, ce qui peut améliorer
l’engagement des utilisateurs et créer des expériences immersives.
3.3.5 Concrétisation
Dans ce chapitre, nous aborderons la conception du site web, conçu pour fournir une
interface d’interaction avec les utilisateurs et afficher des informations sur les pylônes.
Nous avons utilisé HTML, CSS, JavaScript, et l’outil Spline pour la conception. Le site
web se compose de plusieurs pages : une page de formulaire, une page d’authentification
et d’inscription, une page d’affichage des résultats de détection, et une page de tableau
de bord.
3.3.6 Conception de la Page d’Authentification et d’Inscription

Cette page est la porte d’entrée du site web. Les utilisateurs peuvent se connecter
s’ils ont déjà un compte ou s’inscrire s’ils sont nouveaux. Les éléments clés de cette page
incluent :
— Champs de formulaire : Deux champs de texte pour le nom d’utilisateur et
le mot de passe pour la connexion, ainsi que des champs supplémentaires pour
l’adresse e-mail et la confirmation du mot de passe pour l’inscription.
— Boutons : Des boutons pour soumettre les informations et se connecter/s’inscrire.
— Liens : Un lien pour rediriger les utilisateurs de la page de connexion à la page
d’inscription, et vice-versa.
3.3.7 Conception de la Page de Formulaire

La page de formulaire sert à recueillir les informations nécessaires pour effectuer la
détection. Les éléments clés de cette page sont :
— Champs de formulaire : Des champs pour recueillir les informations requises.
Par exemple, les détails du pylône ou les paramètres de détection.
— Boutons : Un bouton pour soumettre le formulaire et lancer la détection.
— Validation : Des messages d’erreur seront affichés si les données entrées par l’uti-
lisateur ne sont pas valides.
3.3.8 Conception de la Page d’Affichage des Résultats de Dé-

tection
Cette page affiche les résultats de la détection effectuée à partir des données soumises
dans le formulaire. Les éléments clés de cette page incluent :
— Résultats : Les résultats de la détection sont affichés de manière lisible et organi-
sée.
32
— Visualisations : Des graphiques et d’autres visualisations peuvent être utilisés

pour illustrer certains résultats.
3.3.9 Conception de la Page de Tableau de Bord

La page du tableau de bord fournit un aperçu des informations sur le pylône. Les
éléments clés de cette page sont :
— Informations sur le pylône : Divers détails sur le pylône, tels que l’emplacement,
l’état, etc.
— Graphiques : Des graphiques illustrant les tendances ou les statistiques liées au
pylône.
— Navigation : Des liens pour naviguer vers d’autres parties du site web.
3.3.10 Utilisation de Spline

Spline est un outil de conception 3D pour le web. Il a été utilisé pour créer des éléments
visuels attrayants pour le site web. Avec Spline, nous avons pu créer des modèles 3D du
pylône, que nous avons utilisés sur la page du tableau de bord et la page d’affichage des
résultats pour une meilleure représentation visuelle des données.
3.4 Conclusion
En conclusion, la conception de ce site web a été axée sur la facilité d’utilisation,
l’efficacité et l’attractivité visuelle. L’objectif principal est d’offrir aux utilisateurs une
expérience intuitive et agréable tout en leur fournissant les informations nécessaires de
manière efficace et organisée.
33
Chapitre 4
Conception de drone
4.1 Introduction
La phase de conception globale est cruciale dans la création d’un drone car elle permet
de définir les spécifications fonctionnelles et de sélectionner les composants nécessaires
pour la construction. Lors de cette étape, il est essentiel de tenir compte des exigences
de la mission, telles que la portée, la charge utile, la vitesse, la résistance au vent et la
durée de vie de la batterie, pour concevoir un drone qui répond aux besoins spécifiques.
La conception globale comprend également la sélection de composants tels qu’une carte
de contrôle de vol, des moteurs, une batterie, des hélices, des capteurs et une caméra, qui
doivent être choisis avec soin pour garantir la fiabilité et la durabilité du drone. Dans cette
section, nous examinerons les étapes clés de la conception globale et les considérations à
prendre en compte pour créer un drone performant et fiable.
4.2 Spécifications fonctionnelles du drone

Dans le tableau 4.1, nous résumons les spécifications du drone a concevoir.
Spécification Value
Portée de vol 5 km
Autonomie de vol 60 min
Charge utile 1 kg
Stabilité en vol Correction d’attitude automatique,
système de stabilisation gyroscopique
Résistance au vent 50 km/h
Vitesse maximale 60 km/h
Altitude maximale de vol 100 m
Système de communication Transmission vidéo en temps réel,
système de contrôle à distance
Système de navigation Système de positionnement GPS,
capteurs d’altitude et de distance
Système d’évitement d’obstacles ************
Capacité de charge de la batterie 10000 mAh
Temps de charge de la batterie 120 min
Table 4.1 – Le tableau de caractéristiques du drone.
34
Chapitre 4 4.3. Choix des composants
4.3 Choix des composants

Dans cette section, nous allons discuter des différents composants nécessaires pour la
conception de notre drone d’inspection de pylônes et comparer plusieurs options pour
chaque type de composant.
4.3.1 Châssis
Le choix du châssis est crucial pour la stabilité et la durabilité de notre drone. Nous
avons examiné quatre options de châssis (cf. figure 4.13) :
— DJI F450 : fabriqué à partir de matériaux de qualité, notamment de la fibre de
verre et du polyamide nylon. Il est résistant et durable, ce qui le rend parfait pour
les missions d’inspection de pylônes. De plus, il a une largeur de 450mm et une
hauteur de 55mm.
— DJI F330 : un modèle plus petit avec une diagonale de 330mm. Il est également
fabriqué à partir de matériaux de qualité, mais il est moins résistant que le DJI
F450.
— S500 480 MM INTÉGRÉ PCB : doté d’une carte de circuit imprimé intégrée, ce
qui facilite son câblage. Il est fabriqué à partir de fibre de verre de qualité et de
nylon polyamide, ce qui lui confère une grande résistance.
— X525 : fabriqué en fibre de verre et en aluminium. Il est doté d’une largeur de
525mm et de trous moteur de 19mm.
Après avoir examiné les différentes options de châssis, nous avons opté pour le DJI
F450, qui est le plus résistant et le plus adapté à notre mission d’inspection de pylônes.
Figure 4.13 – Image d’un châssis
4.3.2 Moteurs
Les moteurs sont un composant essentiel de notre drone, car ils fournissent la puissance
nécessaire pour faire voler le drone. Nous avons examiné plusieurs options de moteurs
parmi lesquelles nous avons retenu les deux suivantes :
35
— 2212 1000K V 30A : ces moteurs ont une vitesse de rotation de 1000Kv et une
consommation de courant maximale de 30A. Ils sont puissants et adaptés aux
missions d’inspection de pylônes.
— 2212 mm 920Kv : ces moteurs ont une vitesse de rotation de 920Kv et une consom-
mation de courant maximale de 30A. Ils sont moins puissants que les moteurs
précédents, mais ils sont plus économiques.
Après avoir comparé ces deux options, nous avons opté pour les moteurs 22*12 1000
Kv 30A pour leur puissance supérieure et leur adéquation avec notre mission.
Figure 4.14 – Exemple d’un moteur de drone.
4.3.3 ESC
Les régulateurs de vitesse (ESC) sont chargés de contrôler la vitesse des moteurs.
Nous avons examiné plusieurs options de régulateurs de vitesse parmi lesquelles nous
avons retenu les deux suivantes :
— ESC 30A 2-3S : plage de tension de 5.5 V-12V, 30A : un instantané de 45 A, 40A
continu 10 secondes.
— esc 18A : plage de tension de 15-25A/30A Brushless ESC x 4. Ces régulateurs de
vitesse sont moins puissants que les ESC 30A 2-3S, mais ils sont plus économiques.
Après avoir comparé ces deux options, nous avons choisi les ESC 30A 2-3S pour leur
puissance supérieure et leur adéquation avec nos moteurs.
Figure 4.15 – Un exemple d’un esc 30A
36
4.3.4 Hélices
Les hélices sont un élément essentiel de notre drone, car elles permettent au drone de
voler. Nous avons examiné plusieurs options d’hélices parmi lesquelles nous avons retenu
les deux suivantes :
— 8*4.5inch : ces hélices ont une taille de 8 pouces et sont conçues pour fournir une
poussée suffisante pour notre drone.
— Hélices 1045 : ces hélices ont une taille de 10 pouces et sont également conçues
pour fournir une poussée suffisante pour notre drone.
Après avoir comparé ces deux options, nous avons choisi les hélices 1045 pour leur
taille plus grande et leur capacité à fournir une poussée plus importante.
Figure 4.16 – Les helice 1045
4.3.5 Batteries
Les batteries sont le cœur de notre drone, car elles fournissent l’énergie nécessaire à
son fonctionnement. Nous avons examiné plusieurs options de batteries parmi lesquelles
nous avons retenu les deux suivantes :
— 3S 300mAh : cette batterie a une capacité de 300mAh et une tension nominale de
11,1V. Elle est légère et compacte, ce qui la rend facile à transporter.
— 1 x 2200mAh 3S 11.1V LiPo : cette batterie a une capacité de 2200mAh et une
tension nominale de 11,1V. Elle est plus puissante que la batterie précédente, mais
elle est également plus lourde et plus encombrante.
Après avoir comparé ces deux options, nous avons opté pour la batterie 1 x 2200 mAh
3S 11.1V LiPo pour sa puissance supérieure, qui permettra une durée de vol plus longue.
En résumé, nous avons choisi les composants suivants pour notre drone d’inspection
de pylônes :
37
Chapitre 4 4.4. Conception mécanique
Figure 4.17 – Exemple de batterie.
— Châssis : DJI F450

— Moteurs : 22*12 1000 Kv 30A
— ESC : ESC 30A 2-3S
— Hélices : Hélices 1045
— Batteries : 1 x 2200 mAh 3S 11.1V LiPo
Ces composants offrent la puissance, la stabilité et la durabilité nécessaires pour effec-
tuer des missions d’inspection de pylônes efficaces et fiables
4.4 Conception mécanique

Nous avons créé la conception mécanique de notre drone d’inspection de pylônes en
utilisant le logiciel SolidWorks. Nous avons choisi d’utiliser une structure en fibre de verre
renforcée pour le châssis, qui assure un poids léger tout en offrant une résistance suffisante
aux vibrations et aux chocs. La forme hexagonale du châssis assure une stabilité optimale
pendant les vols.
Nous avons conçu des bras de support pour les moteurs, qui sont fixés au châssis à
l’aide de vis et d’écrous, pour offrir une grande résistance aux forces de torsion et garantir
une stabilité maximale pendant les vols. Pour la fixation de la caméra, nous avons utilisé
une nacelle de stabilisation montée sur le châssis à l’aide de supports. Cette nacelle assure
une stabilité maximale à la caméra pendant les vols pour des images nettes de la zone
d’inspection.
Enfin, nous avons conçu des bras de support pour les hélices, également fixés au
châssis à l’aide de vis et d’écrous, pour garantir une stabilité maximale lors des vols.
Grâce à la précision de notre conception mécanique réalisée via SolidWorks, notre drone
d’inspection de pylônes (cf. figure 4.18) est capable d’offrir une grande résistance, une
stabilité maximale et une maniabilité optimale, pour des inspections précises et fiables
des pylônes.
38
Figure 4.18 – Conception mécanique du drone
4.4.1 Design de la structure du drone

La figure 4.19, illustre le design structurel du drone. En effet, nous illustrons les deux
blocs : le bloc volant (drone et support à gauche) et le bloc fixe (manette à droite).
Figure 4.19 – Structure du drone
4.4.2 Modélisation 3D
Dans cette section, nous décrivons la modélisation 3D du drone. Les figures 4.20, 4.21
et 4.22 illustrent le visuel trois dimensions du drone a concevoir.
39
Figure 4.20 – Modélisation 1
40
Chapitre 4 4.5. Conception électronique
4.5 Conception électronique

Dans cette section, nous détaillons la conception électronique du drone. La figure 5.36
illustre la simulation réalisée du circuit électronique du drone.
Figure 4.23 – Simulation du circuit du drone
4.6 Conception logicielle

Dans cette section, nous aborderons la conception logicielle de notre drone d’inspection
de pylônes, en mettant l’accent sur le contrôleur de vol KK2.1.5, ainsi que sur les concepts
importants tels que le PID (Proportional, Integral, Derivative) et le PWM (Pulse Width
Modulation).
Contrôleur de vol KK2.1.5

Le contrôleur de vol KK2.1.5 est un composant clé de notre drone, responsable du
contrôle et de la stabilité pendant les vols. Il offre des fonctionnalités avancées telles que
la stabilisation automatique, le maintien de l’altitude et des modes de vol programmables.
L’utilisation d’un écran LCD intégré facilite la configuration et le réglage des paramètres.
PID (Proportional, Integral, Derivative)

Le contrôleur de vol utilise le concept du PID pour ajuster les commandes de vol
et maintenir le drone en équilibre. Le PID est un algorithme de contrôle rétroactif qui
mesure l’erreur entre la position actuelle du drone et sa position désirée, puis ajuste les
commandes de vol en fonction de cette erreur. Les coefficients PID peuvent être ajustés
pour optimiser la réponse du drone et assurer un vol stable.
PWM (Pulse Width Modulation)

Le contrôleur de vol communique avec les moteurs du drone en utilisant la technique
du PWM (Pulse Width Modulation). Le PWM modifie la largeur des impulsions de signal
pour contrôler la vitesse des moteurs. En ajustant la largeur des impulsions, le contrôleur
41
Chapitre 4 4.7. conclusion
de vol peut augmenter ou diminuer la puissance envoyée aux moteurs, permettant ainsi
de contrôler la vitesse et la direction du drone.
Fonctionnalités supplémentaires
En plus du contrôleur de vol, la conception logicielle comprend la programmation
de fonctionnalités supplémentaires pour améliorer les capacités d’inspection du drone.
Cela peut inclure des fonctionnalités telles que le retour vidéo en direct, la planification
de trajectoire et la communication avec les capteurs. Ces fonctionnalités améliorent les
performances du drone et automatisent certaines tâches pour des missions d’inspection
plus précises et efficaces.
En résumé, la conception logicielle de notre drone d’inspection de pylônes repose sur le
contrôleur de vol KK2.1.5, qui utilise le concept du PID pour un vol stable, et communique
avec les moteurs via le PWM. Cette conception logicielle intègre également des fonction-
nalités supplémentaires pour améliorer les capacités d’inspection et automatiser certaines
tâches, garantissant ainsi des performances optimales lors des missions d’inspection de
pylônes.
4.7 conclusion
En conclusion, la conception d’un drone est un processus complexe qui nécessite une
expertise dans différents domaines. Il faut prendre en compte des aspects tels que la sta-
bilité, la manœuvrabilité, la durée de vol et la sécurité. Des technologies avancées sont
intégrées pour permettre un pilotage précis et une connectivité fiable. L’aspect esthé-
tique peut également être important, surtout pour les drones grand public. En résumé, la
conception d’un drone demande une approche globale qui allie compétences techniques,
compréhension des besoins spécifiques et considérations esthétiques. Il est crucial d’utili-
ser les drones de manière responsable, en respectant les réglementations et en prenant en
compte les questions éthiques et de confidentialité.
42
Deuxième partie
Réalisation
43
Chapitre 5
Réalisation du drone
5.1 Introduction
Dans ce chapitre, nous abordons la réalisation de notre drone d’inspection de pylônes.
Nous détaillons les étapes et les composants utilisés pour construire le drone, ainsi que
les différentes considérations prises en compte lors de sa réalisation.
5.2 Assemblage du drone

L’assemblage du drone comprend l’installation de composants sélectionnés tels que
les cadres, les moteurs, les ESC, les hélices et les batteries. Assurons-nous de suivre les
instructions spécifiques à chaque composant pour un assemblage correct et sûr.
Figure 5.24 – Composant du drone
5.2.1 Fixation du châssis

Nous fixons les bras du châssis à l’aide de vis et d’écrous pour assurer une connexion
solide. Le châssis choisi, le DJI F450, offre une construction robuste en fibre de verre
renforcée, offrant à la fois légèreté et résistance (cf. figure 5.25 et 5.26).
44
Chapitre 5 5.2. Assemblage du drone
Figure 5.25 – Fixation schémati- Figure 5.26 – Fixation réelle du

sée du châssis châssis
5.2.2 Installation des moteurs

Nous fixons les moteurs sur les bras du châssis à l’aide des supports prévus à cet effet.
Les moteurs choisis sont les 22*12 1000Kv 30A, qui offrent une puissance adéquate pour
les besoins de notre drone (cf. figures 5.27 et 5.28).
Figure 5.27 – Installation schéma- Figure 5.28 – Installation réelle

tisée des moteurs des moteurs
5.2.3 Connexion des ESC

Nous connectons les ESC (Electronic Speed Controllers) aux moteurs et au contrôleur
de vol conformément aux instructions spécifiques de chaque composant. Les ESC choisis
sont les ESC 30A 2-3S, qui offrent une puissance suffisante pour alimenter les moteurs
sélectionnés (cf. figures 5.29 et 5.30).
45
Chapitre 5 5.2. Assemblage du drone
Figure 5.29 – ESC 1 Figure 5.30 – ESC 2
5.2.4 Fixation des hélices

Nous fixons les hélices sur les moteurs en suivant les recommandations du fabricant
pour une installation correcte. Les hélices choisies sont les 8*4.5 inch, qui offrent une
poussée optimale pour notre drone (cf. figure 5.31, 5.32).
Figure 5.31 – Fixation schémati- Figure 5.32 – Fixation réelle des

sée des hélices hélices
5.2.5 Connexion de la batterie

Nous connectons la batterie, la 3000mAh 3S 11.1V LiPo, aux ESC pour alimenter
l’ensemble du système. Nous veillons à effectuer les connexions conformément aux polarités
appropriées pour éviter tout dysfonctionnement (cf. figures 5.33 et 5.34).
46
Chapitre 5 5.3. Configuration et calibrage
Figure 5.33 – Batterie type 1 Figure 5.34 – Batterie type 2
5.3 Configuration et calibrage

Après l’assemblage du drone, nous passons à l’étape de configuration et de calibrage
des différents composants comme le montre la figure 5.36. Cela implique la programmation
du contrôleur de vol, l’ajustement des paramètres du PID, la vérification de la stabilité
du drone et tout réglage nécessaire pour un fonctionnement optimal.
Figure 5.35 – Configuration et calibrage
5.4 Essais de vols

Une fois le drone assemblé, configuré et calibré, nous procédons à des essais en vol
pour évaluer sa stabilité, sa maniabilité et ses performances globales. Nous effectuons des
ajustements supplémentaires si nécessaire pour optimiser le vol du drone.
47
Chapitre 5 5.4. Essais de vols
Figure 5.36 – Vue du drone prêt
Figure 5.37 – Premier test de vol
48
Figure 5.38 – Deuxième test de vol
Figure 5.39 – Troisième test de vol
5.5 Conclusion
En conclusion, la réalisation d’un drone est un processus complexe qui nécessite des
compétences techniques avancées. Il implique la conception, l’assemblage et la prise en
compte de plusieurs aspects tels que la stabilité, la maniabilité et la sécurité. Les drones
offrent de nombreuses possibilités d’utilisation, mais il est important de les utiliser de
manière responsable et de respecter les réglementations en vigueur. La réalisation d’un
drone ouvre de nouvelles perspectives d’innovation, mais il est essentiel de veiller à son
utilisation éthique et sûre
49
Chapitre 6
Partie Intelligence Artificielle : Iden-

tification des pylônes
6.1 Introduction
Dans ce chapitre, nous détaillons la réalisation de notre système d’intelligence arti-
ficielle, qui est au cœur de notre projet. Nous avons utilisé un drone intelligent équipé
d’un module caméra ESP32 pour capturer des images de pylônes de télécommunication,
puis ces images ont été traitées avec un modèle d’apprentissage profond (YoloV5) pour
détecter les anomalies et réaliser un inventaire des équipements de pylône
6.2 Collecte d’images

La première étape de notre travail consistait à collecter des images pour entraîner
notre modèle. Nous avons recouru à plusieurs méthodes pour cela :
6.2.1 Méthode de collecte
Web scraping :La première méthode que nous avons utilisée pour collecter des images
était le web scraping, une technique automatisée pour extraire des informations à grande
échelle à partir de sites web. Le web scraping est particulièrement utile pour collecter
rapidement un grand nombre d’images. Pour cela, nous avons écrit des scripts en Python
en utilisant la bibliothèque Beautiful Soup pour naviguer sur des sites web liés aux télé-
communications, notamment des forums techniques, des sites d’entreprises de télécommu-
nications et des bases de données d’images. Ces scripts identifient les images pertinentes
sur les pages web, les téléchargent et les enregistrent dans notre base de données d’images.
Bien que le web scraping ait permis de collecter rapidement un grand nombre d’images,
il présente quelques défis. Par exemple, nous avons dû veiller à respecter les politiques
d’utilisation des sites web et à ne pas encombrer leur serveur en téléchargeant trop
d’images trop rapidement. De plus, les images collectées via le web scraping sont sou-
vent très variées en termes de qualité, de résolution, et de pertinence, nécessitant une
étape de tri et de nettoyage
Base de données de l’archive de Sotetel : Enfin, nous avons également utilisé une
base de données d’images fournies par SOTETEL. Cette base de données contenait des
images d’inspection de pylônes de télécommunication prises lors de précédentes missions
d’inspection. Ces images étaient particulièrement précieuses car elles présentaient des
50
Chapitre 6 6.2. Collecte d’images
scénarios d’inspection réels et contenaient une variété d’anomalies que nous voulions que
notre modèle soit capable de détecter.
Cependant, avant de pouvoir utiliser ces images pour l’entraînement de notre modèle,
nous avons dû effectuer plusieurs étapes de prétraitement. Tout d’abord, nous avons filtré
les images pour éliminer celles qui étaient de mauvaise qualité ou non pertinentes pour
notre projet. Ensuite, nous avons organisé les images en différents dossiers en fonction
de leur contenu (par exemple, "Antennes", "Boulons rouillés", etc.). Enfin, nous avons
classé les images pour faciliter leur utilisation lors de l’étiquetage et de l’entraînement du
modèle.
Figure 6.40 – Base de données Sotetel
Capture de pylône local de Sotetel :La deuxième méthode que nous avons utilisée
pour collecter des images était les visites sur site. Nous avons visité plusieurs sites de
pylônes de télécommunication pour prendre des photos en utilisant une caméra haute
résolution. Ces visites nous ont permis d’obtenir des images très spécifiques et de haute
qualité de l’équipement de pylônes de télécommunication, y compris des antennes, des
câbles, des boulons et autres composants.
Au cours de ces visites, nous avons pris des photos sous différents angles et à différents
moments de la journée pour capturer une variété de conditions d’éclairage. Ces images ont
contribué à rendre notre jeu de données plus robuste et plus représentatif des conditions
réelles d’inspection de pylônes.
Figure 6.41 – Visite du site Sotetel
51
Chapitre 6 6.3. Étiquetage manuel
6.2.2 Sécurité et équipement

Comme mentionné précédemment, la sécurité était une préoccupation majeure lors de
la collecte d’images sur les pylônes. Nous avons suivi les normes de sécurité appropriées
et nous sommes assurés que seuls des professionnels formés ont effectué les montées sur
les pylônes.
En ce qui concerne l’équipement, nous avons utilisé des appareils photo de haute
qualité pour capturer les images, ainsi que des équipements de sécurité tels que des harnais,
des casques et des dispositifs de protection contre les chutes.
6.3 Étiquetage manuel

Pour l’étiquetage manuel, nous avons utilisé l’outil LabelImg. Nous avons comparé
plusieurs outils d’étiquetage disponibles, tels que VGG Image Annotator (VIA), Labelbox,
et Microsoft’s Visual Object Tagging Tool (VoTT), mais nous avons trouvé que LabelImg
offrait une combinaison optimale de facilité d’utilisation et de fonctionnalités.
LabelImg est un outil d’annotation graphique en open source utilisé pour dessiner des
boîtes englobantes (bounding boxes) sur des images et pour sauvegarder ces annotations
au format XML ou YOLO. Il est écrit en Python et utilise Qt pour son interface graphique,
ce qui rend l’outil multiplateforme, disponible à la fois sur Linux, Mac et Windows.
6.3.1 Avantages de l’utilisation de LabelImg

LabelImg s’est révélé être un outil précieux pour l’étiquetage des images grâce à ses
fonctionnalités avancées. Les avantages de l’utilisation de LabelImg comprennent :
— Une interface utilisateur conviviale qui facilite le marquage précis des antennes.
— La possibilité de sauvegarder les annotations dans différents formats, ce qui sim-
plifie l’intégration avec d’autres outils et pipelines de traitement des données.
— La capacité à ajouter des notes supplémentaires aux annotations pour une meilleure
compréhension.
— La gestion efficace de grandes quantités d’images et d’annotations, ce qui est es-
sentiel pour notre projet.
Figure 6.42 – Capture d’écran de l’application LabelImg.
52
6.4 Conclusion
Dans cette section, nous avons présenté les différentes méthodes que nous avons utili-
sées pour collecter les images des antennes situées sur les pylônes. En plus de monter sur
les pylônes pour capturer des images détaillées, nous avons utilisé le web scraping pour
extraire des images, accédé à la base de données de l’archive de Sotetel et capturé des
images directement sur des pylônes de Sotetel.
Nous avons également souligné l’importance de la sécurité lors de la collecte d’images

sur les pylônes et avons expliqué comment nous avons respecté les normes de sécurité
et utilisé l’équipement approprié. Enfin, nous avons mentionné l’utilisation de l’outil La-
belImg pour l’étiquetage des images, en mettant en évidence ses avantages pour notre
projet.
6.5 Étiquetage automatique

Même si LabelImg est un outil d’étiquetage efficace, l’étiquetage manuel de milliers
d’images est une tâche laborieuse. Pour résoudre ce problème, nous avons utilisé un modèle
YOLOv5s pré-entraîné pour l’étiquetage automatique de nos images.
Ce processus implique les étapes suivantes :
6.5.1 Préparation du modèle YOLOv5s pour l’étiquetage auto-

matique
Pour faciliter et accélérer l’étiquetage des images, nous avons décidé d’utiliser un
modèle YOLOv5s. Cependant, contrairement à ce qui pourrait être supposé, le modèle
YOLOv5s que nous avons utilisé n’était pas pré-entraîné. Nous avons donc dû entraîner ce
modèle à partir de zéro, en utilisant les images que nous avions précédemment étiquetées
manuellement.
Personnalisation des paramètres du modèle

La personnalisation des paramètres du modèle est une étape essentielle pour obtenir
de bonnes performances. Dans notre cas, cela impliquait la configuration des hyperpara-
mètres du modèle YOLOv5s. Les hyperparamètres sont des paramètres qui sont définis
avant l’entraînement et qui restent constants tout au long de celui-ci. Ils ont une influence
significative sur les performances du modèle. Voici quelques hyperparamètres clés que
nous avons ajustés pour notre modèle YOLOv5s :
Learning rate (taux d’apprentissage) : Il s’agit du taux auquel le modèle met à jour les
poids des caractéristiques lors de l’apprentissage. Un taux d’apprentissage élevé peut faire
converger l’apprentissage plus rapidement, mais à risque d’overfitting (surajustement).
Inversement, un taux d’apprentissage faible peut aider à obtenir un modèle plus précis,
mais peut aussi rendre l’apprentissage plus lent.
Batch size (taille du lot) : Il s’agit du nombre d’exemples d’entraînement utilisés lors
d’une itération de l’entraînement. Une taille de lot plus grande peut accélérer l’entraîne-
ment, mais nécessite plus de mémoire GPU.
53
Chapitre 6 6.5. Étiquetage automatique
Epochs (époques) : Il s’agit du nombre de fois où le modèle voit l’ensemble complet des
données d’entraînement. Un nombre plus élevé d’époques peut améliorer les performances
du modèle, mais peut également entraîner un surajustement.
Weight decay (décroissance des poids) : Ce paramètre aide à prévenir l’overfitting en
ajoutant une pénalité à la fonction de coût du modèle. Une décroissance de poids plus
élevée entraîne une mise à jour plus lente des poids du modèle.
Anchor boxes (boîtes d’ancrage) : Dans YOLO, les boîtes d’ancrage sont des boîtes
prédéfinies utilisées pour prédire les boîtes englobantes des objets. Nous avons personnalisé
les tailles des boîtes d’ancrage pour mieux correspondre aux tailles des objets dans nos
images.
Entraînement du modèle YOLOv5s

Avec les hyperparamètres correctement configurés, nous avons procédé à l’entraîne-
ment de notre modèle YOLOv5s. Cela a été réalisé en utilisant un processus en deux
étapes :
Préparation des données d’entraînement : Nous avons utilisé les images quenous avions
précédemment étiquetées manuellement pour entraîner le modèle. Nous avons également
créé un fichier "dataset.yaml" qui contenait les chemins vers les images et leurs annotations
correspondantes.
Entraînement du modèle : Nous avons commencé l’entraînement en utilisant le script
d’entraînement fourni avec YOLOv5. Nous avons spécifié le modèle YOLOv5s, les hyper-
paramètres que nous avions définis précédemment, ainsi que notre fichier "dataset.yaml".
L’entraînement a été effectué sur un GPU, ce qui a permis d’accélérer considérablement
le processus. Au cours de l’entraînement, le modèle a appris à reconnaître les différents
objets dans les images en ajustant les poids de ses caractéristiques en fonction de l’erreur
qu’il commettait sur les images d’entraînement.
Il est important de noter que l’entraînement d’un modèle d’apprentissage profond
comme YOLOv5s peut être un processus long et coûteux en ressources. Cependant, une
fois le modèle entraîné, il peut être utilisé pour étiqueter de grandes quantités d’images
de manière efficace et précise.
Figure 6.43 – capture d’ecran d’entrainement du model
54
Validation du modèle
Une fois l’entraînement terminé, il est important de valider les performances du modèle
pour s’assurer qu’il a bien appris à identifier les objets d’intérêt. Pour cela, nous avons
utilisé un ensemble de données de validation séparé, composé d’images qui n’avaient pas
été utilisées lors de l’entraînement.
En utilisant cet ensemble de validation, nous avons évalué le modèle sur plusieurs
métriques, notamment la précision, le rappel, et le score F1. Ces métriques nous ont
permis de confirmer que notre modèle était bien capable de détecter les différents objets
d’intérêt dans les images avec une précision satisfaisante.
Évaluation du modèle à l’aide de métriques

Il est essentiel d’évaluer correctement les performances de notre modèle pour s’assu-
rer qu’il répond aux exigences de notre projet. Pour cela, nous avons utilisé plusieurs
métriques, notamment la précision, le rappel et le score F1. Ces trois métriques sont
fréquemment utilisées pour évaluer les performances des modèles de détection d’objets.
Précision (Precision) : La précision est la proportion des identifications positives qui
étaient effectivement correctes. Elle est calculée comme le rapport entre les vrais positifs
(VP) et la somme des vrais positifs et des faux positifs (FP). En d’autres termes, la
précision est VP/(VP+FP). Une précision élevée indique que notre modèle a correctement
détecté la majorité des objets, mais il peut y avoir des objets qu’il a manqués.
Rappel (Recall) : Le rappel est la proportion des véritables positifs qui ont été identifiés
correctement. Il est calculé comme le rapport entre les vrais positifs (VP) et la somme des
vrais positifs et des faux négatifs (FN). En d’autres termes, le rappel est VP/(VP+FN).
Un rappel élevé indique que notre modèle a correctement identifié la majorité des objets,
mais il peut y avoir des objets qu’il a incorrectement identifiés.
Score F1 (F1 Score) : Le score F1 est une mesure qui combine la précision et le rappel
en une seule valeur. Il est calculé comme la moyenne harmonique de la précision et du
rappel. En d’autres termes, le score F1 est 2 * (Précision * Rappel) / (Précision + Rappel).
Un score F1 élevé indique que notre modèle a un bon équilibre entre la précision et le
rappel.
Nous avons évalué ces trois métriques à l’aide de notre ensemble de validation, qui était
composé d’images que le modèle n’avait pas vues pendant l’entraînement. Ces métriques
nous ont donné une bonne idée de la performance de notre modèle sur de nouvelles images.
Interprétation des courbes d’apprentissage

En plus des métriques mentionnées ci-dessus, nous avons également examiné les courbes
d’apprentissage de notre modèle. Ces courbes tracent la performance du modèle sur l’en-
semble d’entraînement et l’ensemble de validation au fil du temps, ce qui nous donne une
idée de comment le modèle s’est amélioré au cours de l’entraînement.
Une courbe d’apprentissage typique a une forme en "U" inversé, où l’erreur de valida-
tion commence à augmenter après avoir atteint un minimum. Cela indique que le modèle
commence à surapprendre les données d’entraînement et perd sa capacité à généraliser à
de nouvelles données. Dans notre cas, nous avons surveillé ces courbes pour nous assurer
que notre modèle ne surapprenait pas et pour déterminer le meilleur moment pour arrêter
l’entraînement.
55
Figure 6.44 – Capture d’écran d’une courbe F1-Confidence.
Figure 6.45 – Exemple de courbe Rappel-Confiance
Techniques pour éviter le surajustement

Lors de l’entraînement de notre modèle, nous avons été particulièrement attentifs à
éviter le surajustement. Le surajustement se produit lorsqu’un modèle d’apprentissage
automatique est trop complexe par rapport à la quantité et à la variété des données
d’entraînement disponibles, ce qui peut entraîner des performances médiocres lors de la
généralisation à de nouvelles données.
Pour éviter cela, nous avons utilisé plusieurs techniques, notamment :
Augmentation des données (Data Augmentation) : Cette technique consiste à créer
de nouvelles données d’entraînement en modifiant légèrement les données existantes. Cela
peut comprendre des rotations, des décalages, des retournements, etc. L’augmentation des
données peut aider à améliorer la généralisation du modèle en lui permettant d’apprendre
à partir de plus de variations des données d’entraînement.
Early stopping (Arrêt précoce) : L’arrêt précoce est une technique où l’entraînement
est arrêté dès que les performances du modèle sur l’ensemble de validation commencent
à se détériorer. Cela permet d’éviter que le modèle n’apprenne "par cœur" les données
d’entraînement et ne soit donc pas capable de bien généraliser à de nouvelles données.
Dropout : Le dropout est une technique où certains neurones du modèle sont "éteints"
56
Figure 6.46 – Exemple de courbe Précision-Confiance
Figure 6.47 – Exemple de courbe Précision-Rappel-Confiance
ou ignorés lors de chaque itération de l’entraînement. Cela force le modèle à apprendre

des représentations plus robustes et peut aider à éviter le surajustement.
En utilisant ces techniques, nous avons pu entraîner notre modèle YOLOv5s de manière
à ce qu’il soit capable de bien généraliser à de nouvelles images.
Résumé et prochaines étapes

En résumé, la préparation de notre modèle pour l’étiquetage automatique a été une
tâche complexe mais essentielle. Après avoir défini et ajusté les hyperparamètres, nous
avons entraîné notre modèle en utilisant un GPU, ce qui a permis d’accélérer le processus.
Ensuite, nous avons validé les performances de notre modèle en utilisant un ensemble de
validation et plusieurs métriques.
Grâce à notre travail méticuleux lors de cette étape, nous avons obtenu un modèle d’éti-
quetage automatique performant, prêt à être utilisé sur notre large ensemble d’images non
étiquetées. Dans la prochaine section, nous décrirons en détail le processus d’utilisation
de ce modèle pour l’étiquetage automatique.
57
Chapitre 6 6.6. Étape 5 : Sélection d’une Configuration Modèle
Conclusion sur la préparation du modèle

La préparation du modèle YOLOv5s pour l’étiquetage automatique a été une étape
cruciale de notre projet. Grâce à une personnalisation minutieuse des hyperparamètres et
à un entraînement rigoureux, nous avons été en mesure de développer un modèle capable
d’étiqueter efficacement nos images.
Dans la section suivante, nous détaillerons le processus d’utilisation de ce modèle pour
l’étiquetage automatique de nos images.
6.5.2 Étiquetage automatique

Le modèle YOLOv5s a été utilisé pour détecter les objets dans les images et pour
générer des boîtes englobantes et des étiquettes automatiquement.
6.5.3 Vérification et correction manuelle

Bien que le modèle YOLOv5s soit efficace pour l’étiquetage automatique, il peut com-
mettre des erreurs.
Par conséquent, chaque image a été revue manuellement pour vérifier la précision des
annotations automatiques et apporter les corrections nécessaires.
6.5.4 Consolidation des images étiquetées

Une fois que tous les étiquetages manuels et automatiques ont été complétés, nous
avons consolidé tous ces fichiers d’annotation pour créer un ensemble de données complet
pour l’entraînement du modèle YOLOv5m. Cet ensemble de données comprenait environ
3000 images avec leurs étiquettes correspondantes, prêtes à être utilisées pour l’entraîne-
ment du modèle.
6.5.5 Conclusion sur l’étiquetage des images

L’étiquetage des images est un processus crucial et chronophage dans le développement
d’un modèle d’apprentissage profond. Néanmoins, l’utilisation d’outils tels que LabelImg
pour l’étiquetage manuel et un modèle YOLOv5s pré-entraîné pour l’étiquetage automa-
tique a permis d’accélérer considérablement ce processus.
En dépit des défis, la combinaison de ces deux méthodes d’étiquetage a permis de
constituer un ensemble de données d’images soigneusement étiquetées, qui a servi de base
solide pour l’entraînement de notre modèle de détection d’objets. Grâce à cela, nous avons
pu entraîner notre modèle YOLOv5m de manière efficace pour détecter les anomalies et
les équipements sur les images de pylônes de télécommunication. Dans la section sui-
vante, nous détaillerons le processus d’entraînement du modèle, depuis la préparation des
données jusqu’à l’ajustement du modèle lui-même.
6.6 Étape 5 : Sélection d’une Configuration Modèle

6.6.1 Choix du Modèle
Dans le dossier yolov5/models, nous trouverons divers fichiers de configuration précon-
figurés pour différents modèles YOLOv5 tels que yolov5s.yaml, yolov5m.yaml, yolov5l.yaml
58
et yolov5x.yaml. Ces fichiers correspondent à différentes tailles et complexités de modèles.

Le choix du fichier à utiliser dépend de vos préférences de précision et de rapidité d’exécu-
tion. Pour une opération rapide mais moins précise, optons pour yolov5s.yaml. Par contre,
yolov5x.yaml nous offre une grande précision mais fonctionne plus lentement. nous trou-
verons un tableau comparatif de ces modèles
Table 6.2 – Comparaison des modèles YOLOv5
Modèle Taille Précision Vitesse

YOLOv5s Small Basse Rapide
YOLOv5m Medium Moyenne Moyenne
YOLOv5l Large Haute Moyenne
YOLOv5x Extra-large Très haute Lente
Figure 6.48 – Capture d’écran du de differentes versions du modèle YOLOv5
6.6.2 Architecture du modèle YOLOv5m

Pour comprendre le processus d’entraînement, il est important de comprendre l’ar-
chitecture du modèle YOLOv5m que nous avons utilisé. YOLO (You Only Look Once)
est une architecture de détection d’objets qui a révolutionné le domaine en raison de sa
capacité à effectuer une détection d’objets en temps réel.
YOLOv5m est une variante de l’architecture YOLOv5 qui présente un bon compromis
entre précision et vitesse. L’architecture YOLOv5m se compose de plusieurs parties :
— Couche d’entrée : C’est ici que les images sont introduites dans le modèle. Les
images sont redimensionnées à une taille spécifique avant d’être introduites.
— Couches de convolution : Ces couches extraient les caractéristiques des images
à différents niveaux de granularité. YOLOv5m utilise une architecture de type
CSPDarknet53 pour les couches de convolution.
— Couches de détection : Il y a trois couches de détection à différentes échelles. Chaque
couche de détection utilise des boîtes d’ancrage de différentes tailles pour détecter
des objets de différentes tailles.
59
Chapitre 6 6.6. Étape 5: Sélection d’une Configuration Modèle
— Couche de sortie : La couche de sortie produit les résultats finaux de la détec-

tion, qui comprennent les boîtes englobantes, les scores de confiance et les classes
d’objets.
6.6.3 Mise en œuvre du modèle de détection d’objets YOLOv5m

Après avoir effectué le processus d’étiquetage des images, nous avons commencé à
préparer notre modèle de détection d’objets. Pour ce faire, nous avons utilisé le modèle
YOLOv5m, une variante de YOLOv5 qui offre un bon équilibre entre précision et vitesse
de traitement.
6.6.4 Organisation de la structure des images

6.6.5 Étape 3 : Organisation des données
Dans cette étape, on va organiser nos images et leurs annotations au format YOLO.
Suivons les instructions ci-dessous pour structurer les données de manière appropriée :
1. On crée un répertoire principal pour les données YOLO. On peut nommer ce
répertoire "data" ou tout autre nom de notre choix.
2. À l’intérieur du répertoire "data", on crée deux sous-répertoires : "images" et "la-
bels". Le répertoire "images" va contenir toutes les images, tandis que le répertoire
"labels" va contenir les fichiers d’annotations YOLO correspondants.
3. À l’intérieur du répertoire "images", on crée deux sous-répertoires supplémentaires :
"train" et "valid". Le répertoire "train" va être utilisé pour les images d’entraîne-
ment, tandis que le répertoire "valid" va être utilisé pour les images de validation.
4. On copie les images d’entraînement dans le répertoire "train" et les images de
validation dans le répertoire "valid".
5. À l’intérieur du répertoire "labels", on crée également les sous-répertoires "train"
et "valid". Ces répertoires vont être utilisés pour stocker les fichiers d’annotations
YOLO correspondants aux images d’entraînement et de validation, respectivement.
6. On associe chaque image à son fichier d’annotation YOLO correspondant. Les
fichiers d’annotations doivent avoir le même nom que les images, mais avec l’ex-
tension ".txt". Par exemple, si on a une image nommée "img1.jpg", le fichier d’an-
notation correspondant doit être nommé "img1.txt" et placé dans le répertoire
approprié ("train" ou "valid").
Il est important de diviser le dataset en ensembles d’entraînement (train) et de vali-
dation (valid). Une répartition courante est de 80% pour l’entraînement et 20% pour la
validation. Pour chaque image, on doit avoir son fichier d’annotation correspondant au
format YOLO.
Voici la structure de répertoires après avoir organisé les données :
data/
images/
train/
img1.jpg
img2.jpg
...
60
valid/
img501.jpg
img502.jpg
...
labels/
train/
img1.txt
img2.txt
...
valid/
img501.txt
img502.txt
...
Il faut s’assurer que les images et les fichiers d’annotations sont correctement organisés
selon cette structure de répertoires. Cela va faciliter le chargement et le traitement des
données lors de l’entraînement du modèle YOLOv5.
Notons que les noms des images et des fichiers d’annotations sont utilisés à titre
d’exemple et peuvent varier en fonction de notre propre ensemble de données.
6.6.6 Préparation du fichier dataset.yaml

Le fichier dataset.yaml est un fichier de configuration important qui contient des infor-
mations essentielles sur notre ensemble de données, notamment les chemins d’accès aux
images, le nombre de classes d’objets et les noms des classes. Nous avons soigneusement
préparé ce fichier pour assurer une gestion efficace des données pendant l’entraînement.
Dans ce fichier, spécifions les informations suivantes : — train : le chemin vers le fichier
contenant les chemins d’accès aux images d’entraînement.
-val : le chemin vers le fichier contenant les chemins d’accès aux images de validation.
— nc : le nombre de classes dans notre ensemble de données. — names : le chemin vers
le fichier contenant les noms des classes (chaque classe sur une ligne séparée).
Figure 6.49 – Capture d’écran du fichier YAML pour la configuration du modèle YO-
LOv5
61
Chapitre 6 6.7. Transformation des Annotations YOLO en CSV
6.7 Transformation des Annotations YOLO en CSV

Pour convertir vos fichiers d’annotation YOLO en fichiers CSV avec des coordonnées
de boîtes englobantes relatives, nous pouvons utiliser un script Python. Ce script extrait
simplement les largeurs et les hauteurs des boîtes englobantes de vos fichiers d’annotation
et les enregistre dans un fichier CSV distinct, qui est ensuite utilisé.
Figure 6.50 – Capture d’écran du fichier de transformation vers CSV
6.8 Formats d’annotation des boîtes englobantes

Différents formats d’annotation des boîtes englobantes sont utilisés, tels que le format
Pascal VOC (Visual Object Classes) et le format COCO (Common Objects in Context).
Ces formats décrivent la classe de l’objet annoté et la position de sa boîte englobante.
6.8.1 Indice de classe de l’objet

Dans ces formats, chaque objet annoté est associé à un indice de classe. Par exemple,
si l’objet appartient à la classe n°15, cela signifie que son indice de classe est 15. Il est
important de noter que YOLO attribue un indice numérique à chaque classe d’objet
présente dans notre ensemble de données.
6.8.2 Position de la boîte englobante

La position de la boîte englobante de l’objet est exprimée en pourcentages par rapport
à la taille de l’image. Elle est représentée par les coordonnées xmin, ymin, xmax et ymax.
Coordonnée xmin
La coordonnée xmin correspond à la coordonnée horizontale la plus à gauche de la boîte
englobante, exprimée en pourcentage par rapport à la largeur de l’image. Par exemple, si
l’image a une largeur de 1000 pixels et que xmin est égal à 0.2, cela signifie que le côté
gauche de la boîte englobante se situe à une distance de 0.2 x 1000 = 200 pixels du bord
gauche de l’image.
62
Chapitre 6 6.9. Génération d’Ancres Personnalisées à l’Aide de la Méthode K-Means
Coordonnée ymin
La coordonnée ymin correspond à la coordonnée verticale la plus en haut de la boîte
englobante, exprimée en pourcentage par rapport à la hauteur de l’image. Par exemple,
si l’image a une hauteur de 800 pixels et que ymin est égal à 0.3, cela signifie que le côté
supérieur de la boîte englobante se situe à une distance de 0.3 x 800 = 240 pixels du bord
supérieur de l’image.
Coordonnée xmax
La coordonnée xmax correspond à la coordonnée horizontale la plus à droite de la boîte
englobante, exprimée en pourcentage par rapport à la largeur de l’image. Par exemple, si
l’image a une largeur de 1000 pixels et que xmax est égal à 0.8, cela signifie que le côté
droit de la boîte englobante se situe à une distance de 0.8 x 1000 = 800 pixels du bord
gauche de l’image.
Coordonnée ymax
La coordonnée ymax correspond à la coordonnée verticale la plus en bas de la boîte
englobante, exprimée en pourcentage par rapport à la hauteur de l’image. Par exemple,
si l’image a une hauteur de 800 pixels et que ymax est égal à 0.7, cela signifie que le côté
inférieur de la boîte englobante se situe à une distance de 0.7 x 800 = 560 pixels du bord
supérieur de l’image.
Figure 6.51 – Coordonnées variables de la boîte englobante
6.9 Génération d’Ancres Personnalisées à l’Aide de

la Méthode K-Means
Maintenant que nous avons généré vos boîtes englobantes, nous allons les utiliser
pour créer des ancres personnalisées. Ces dernières sont des boîtes englobantes prédéfinies
utilisées pour aider YOLO à localiser et identifier les objets dans une image.
63
Format YOLO
Le format YOLO standard pour chaque ligne d’annotation dans un fichier texte com-
prend les informations suivantes pour une boîte englobante : le numéro de classe de l’objet,
les coordonnées horizontales x et verticales y, ainsi que la largeur w et la hauteur h de la
boîte englobante.
Utilisation de l’Algorithme K-Means

Nous utilisons l’outil k-means pour générer ces ancres personnalisées. K-means est un
algorithme de clustering qui partitionne un ensemble de points de données en k clusters
en fonction de leur similarité. Il est rapide, scalable et donc adapté aux grands ensembles
de données. Toutefois, il est aussi sensible aux positions initiales des centroids et peut
converger vers un minimum local au lieu du minimum global. C’est pourquoi il est courant
d’exécuter k-means plusieurs fois avec différentes initialisations pour améliorer les chances
de trouver une bonne solution de clustering.
Génération des Ancres Personnalisées

Pour commencer, nous allons charger les dimensions des boîtes englobantes à partir
de notre fichier CSV ’bounding_boxes.csv’ :
import numpy as np
from sklearn.cluster import KMeans
# Charger les boîtes englobantes à partir du fichier CSV

bounding\_boxes\_file = ’bounding\_boxes.csv’
boxes = np.loadtxt(bounding\_boxes\_file, delimiter=’,’)
Calcul de l’Intersection Over Union (IOU) entre les boîtes englobantes et les
centroids
L’Intersection Over Union (IOU), également appelée Jaccard Index, est une mesure de
similarité utilisée dans la détection d’objet pour évaluer à quel point les boîtes englobantes
prédites correspondent aux boîtes englobantes de référence (ground truth).
L’IOU mesure la proportion de la zone d’intersection entre la boîte prédite et la boîte
de référence par rapport à la zone d’union entre ces deux boîtes. Elle varie de 0 à 1, où 0
indique qu’il n’y a aucun chevauchement entre les boîtes et 1 indique un chevauchement
parfait.
La formule de l’IOU est la suivante :
IOU = Intersection area / Union area
Pour calculer l’IOU, on utilise les coordonnées des boîtes englobantes, qui sont géné-
ralement exprimées sous forme de xmin (coordonnée horizontale la plus à gauche), ymin
(coordonnée verticale la plus en haut), xmax (coordonnée horizontale la plus à droite) et
ymax (coordonnée verticale la plus en bas).
On calcule d’abord l’aire de chaque boîte en multipliant sa largeur par sa hauteur.
Ensuite, on calcule l’aire de l’intersection entre les boîtes en trouvant les coordonnées du
rectangle qui les englobe et en calculant son aire. Enfin, on calcule l’aire de l’union en
additionnant les aires des deux boîtes et en soustrayant l’aire de l’intersection.
64
L’IOU est souvent utilisée dans le calcul de la perte (loss) pour évaluer la différence
entre les prédictions et les annotations des boîtes englobantes. Elle est également utilisée
dans l’algorithme de suppression non maximale (Non-Max Suppression) pour sélectionner
la meilleure boîte englobante prédite parmi celles qui se chevauchent.
Dans le contexte de la génération d’ancres personnalisées avec l’algorithme K-means,
l’IOU est utilisée comme mesure de similarité pour sélectionner les meilleures dimensions
et ratios d’aspect pour les ancres en fonction des données d’entraînement.
En résumé, l’IOU est une mesure importante en détection d’objet qui permet d’évaluer
à quel point les boîtes englobantes prédites correspondent aux boîtes de référence, et elle
est utilisée dans diverses étapes du processus de détection pour évaluer la qualité des
prédictions.
Figure 6.52 – Intersction over Union
# Calculer l’Intersection Over Union (IOU) moyen entre les boîtes englobantes et les c
def avg\_iou(boxes, centroids):
n\_boxes = len(boxes)
n\_centroids = len(centroids)
iou\_sum = 0.0
for box in boxes:
ious = []
for centroid in centroids:
# Calculer l’IOU entre la boîte englobante et le centroid
iou = (min(box[0], centroid[0]) * min(box[1], centroid[1])) / \
(box[0] * box[1] + centroid[0] * centroid[1] - \
min(box[0], centroid[0]) * min(box[1], centroid[1]))
ious.append(iou)
# Ajouter le maximum des IOU à la somme totale
iou\_sum += max(ious)
# Calculer l’IOU moyen en divisant la somme par le nombre de boîtes
return iou\_sum / n\_boxes
65
Nous utilisons ensuite la méthode des k-means pour trouver les ancres optimisées,
en entraînant le modèle sur les dimensions des boîtes englobantes et en récupérant les
centroids des clusters.
# Définir le nombre d’ancres et de clusters

num\_anchors = 3
k = num\_anchors * 3
# Effectuer le clustering k-means pour trouver les centroids optimisés

kmeans\_model = KMeans(n\_clusters=k)
kmeans\_model.fit(boxes)
centroids = kmeans\_model.cluster\_centers\_
Nous calculons l’IOU moyen pour évaluer la qualité des ancres et affichons les résultats.
iou = avg\_iou(boxes, centroids)

print("Ancres optimisées :")
anchors = []
for i in range(num\_anchors):
anchor\_start = i * 3
anchor\_end = (i + 1) * 3
anchor\_dims\_i = list(centroids[anchor\_start:anchor\_end].flat)
anchors.append(anchor\_dims\_i)
print("- {}".format(anchor\_dims\_i))
# Afficher l’IOU moyen

print("IOU moyen : {:.2f}%".format(iou * 100))
Une fois que nous avons nos ancres optimisées, nous pouvons les copier et les coller dans
notre fichier de configuration YOLOv5 personnalisé (par exemple, customyolov5s.yaml),
en remplaçant les valeurs des ancres existantes.
N’oublions pas que ces valeurs d’ancrage doivent être présentées sous forme de tuples
(largeur, hauteur).
6.9.1 Paramétrage du modèle

Avant de commencer l’entraînement, nous avons personnalisé les paramètres du modèle
en fonction de nos exigences spécifiques. Certains des paramètres clés que nous avons
ajustés comprennent :
Taille de l’image d’entrée (Input Image Size) : La taille de l’image d’entrée détermine
la résolution à laquelle les images sont introduites dans le modèle. Nous avons choisi
une taille appropriée qui maintient un bon équilibre entre la résolution des images et la
capacité de calcul de notre matériel.
Nombre d’époques (Number of Epochs) : Une époque est une passe complète à travers
l’ensemble des données d’entraînement. Le nombre d’époques détermine combien de fois
le modèle apprendra de l’ensemble des données d’entraînement. Nous avons choisi un
nombre d’époques qui permet à notre modèle d’apprendre suffisamment sans causer de
surajustement.
Taux d’apprentissage (Learning Rate) : Le taux d’apprentissage contrôle à quelle vi-
tesse le modèle apprend. Un taux d’apprentissage trop élevé peut faire que le modèle saute
66
Chapitre 6 6.10. Étape 6 : Apprentissage du modèle
Figure 6.53 – Image illustrant les ancres optimisées pour YOLOv5 personnalisé.
les optima locaux, tandis qu’un taux d’apprentissage trop bas peut rendre le processus
d’apprentissage très lent. Nous avons réglé le taux d’apprentissage pour trouver le bon
équilibre.
6.10 Étape 6 : Apprentissage du modèle

Pour lancer le processus d’apprentissage du modèle, nous utilisons la commande sui-
vante :
python train.py --img 640 --batch 8 --epochs 100

--data C:\Users\oussc\data_antenne\data_antenne\dataset.yaml
--cfg C:\Users\oussc\data_antenne\data_antenne\custom_yolov5m.yaml
--weights yolov5m.pt --name modelantenne
Chaque argument de cette commande d’apprentissage a une signification précise :

— –img 640 : Ce paramètre spécifie les dimensions de l’image d’entrée pour l’appren-
tissage. Les images sont redimensionnées à une taille de 640x640 pixels.
— –batch 16 : Ce paramètre définit la taille du lot pour l’apprentissage. Ici, un lot
de 16 signifie que le modèle traite 16 images à la fois lors de chaque itération
d’apprentissage.
— –epochs 100 : Ce paramètre indique le nombre de fois que le modèle passe à travers
l’intégralité de l’ensemble de données, soit 100 époques.
— –data dataset.yaml : Spécifie le fichier YAML contenant les informations sur
l’ensemble de données, notamment les chemins d’accès aux images d’apprentissage
et de validation, ainsi que le nombre de classes.
— –cfg <your_config>.yaml : Indique le fichier YAML contenant la configuration
du modèle YOLOv5 choisi.
67
Figure 6.54 – capture d’ecran d’entainement du model
— –weights yolov5s.pt : Fournit les poids du modèle pré-appris à utiliser comme

point de départ pour l’apprentissage. Ici, nous utilisons les poids du modèle YO-
LOv5s.
— –name <your_model_name> : Assigner un nom personnalisé au modèle formé pour
faciliter son identification parmi d’autres.
En exécutant cette commande, le modèle débute son apprentissage avec les paramètres
définis. Tout au long du processus, diverses informations sont fournies sur l’avancement,
telles que la perte, la précision et d’autres mesures de performance. Une fois l’apprentissage
achevé, le modèle formé est sauvegardé dans le dossier runs/train sous le nom attribué
par l’argument –name. Ce modèle peut alors être utilisé pour effectuer des inférences et
détecter des objets sur de nouvelles images.
epoch
Le numéro de l’époque en cours. Chaque époque correspond à une passe complète sur
l’ensemble du dataset d’entraînement.
train/box_loss
La perte de la boîte englobante (Bounding Box) pour les données d’entraînement.
Cette valeur mesure l’erreur entre les coordonnées des boîtes englobantes prédites et celles
réelles.
train/obj_loss
La perte d’objet pour les données d’entraînement. Cette valeur mesure l’erreur entre la
probabilité prédite d’avoir un objet dans une boîte englobante et la véritable probabilité.
train/cls_loss
La perte de classe pour les données d’entraînement. Cette valeur mesure l’erreur entre
les classes d’objets prédites et les classes réelles.
68
metrics/precision
La précision est une mesure de la qualité des prédictions. Elle est calculée comme
le rapport entre les vrais positifs (objets correctement détectés) et la somme des vrais
positifs et des faux positifs (objets incorrectement détectés).
metrics/recall
Le rappel est une mesure de la capacité du modèle à détecter tous les objets d’intérêt.
Il est calculé comme le rapport entre les vrais positifs et la somme des vrais positifs et
des faux négatifs (objets réels non détectés).
metrics/mAP_0.5
Le mAP (mean Average Precision) est une mesure globale de la performance de détec-
tion. Il est calculé en moyennant les AP (Average Precision) pour chaque classe d’objet.
Le seuil de chevauchement IoU (Intersection over Union) utilisé pour déterminer si une
détection est considérée comme correcte est de 0,5 dans ce cas.
metrics/mAP_0.5 :0.95
Cette valeur est similaire au mAP_0.5, mais elle prend en compte un ensemble de
seuils IoU, allant de 0,5 à 0,95 avec un pas de 0,05. C’est une mesure plus stricte et
robuste pour évaluer la performance de détection.
val/box_loss
La perte de la boîte englobante pour les données de validation.
val/obj_loss
La perte d’objet pour les données de validation.
val/cls_loss
La perte de classe pour les données de validation.
x/lr0, x/lr1, x/lr2

Les taux d’apprentissage actuels pour les différentes parties du réseau. Les taux d’ap-
prentissage sont souvent modifiés au cours de l’entraînement pour faciliter la convergence
du modèle.
Ces mesures nous aident à comprendre comment le modèle évolue et performe au cours
de l’entraînement. Les valeurs de perte devraient généralement diminuer avec le temps,
tandis que les métriques de performance comme la précision, le rappel et le mAP devraient
augmenter.
69
6.10.1 Évaluation du modèle

Après l’entraînement, nous avons évalué les performances de notre modèle. Pour cela,
nous avons utilisé un ensemble de données de validation séparé que le modèle n’a jamais
vu auparavant. Cela nous a permis d’évaluer comment le modèle se comporterait avec de
nouvelles données. Dans la section suivante, nous discuterons plus en détail de l’évaluation
de notre modèle.
6.10.2 Interprétation des Résultats d’Entraînement du Modèle

YOLO V pour la Détection d’Antennes
Figure 6.55 – capture d’ecran results.csv
Nos résultats révèlent plusieurs tendances significatives quant à la performance du

modèle YOLO V sur notre tâche de détection d’antennes.
Pertes d’Entraînement
Les colonnes ‘train/box_loss‘, ‘train/obj_loss‘ et ‘train/cls_loss‘ représentent respec-
tivement les pertes liées à la prédiction de la position et de la taille des boîtes englobantes,
la détection des objets et la classification correcte des objets détectés. Une diminution sys-
tématique de ces valeurs au fil des époques indique que notre modèle apprend efficacement
de ses erreurs pendant l’entraînement, ce qui conduit à une amélioration continue des ca-
pacités de localisation, de détection et de classification des antennes.
Pertes de Validation
De même, les colonnes ‘val/box_loss‘, ‘val/obj_loss‘ et ‘val/cls_loss‘ montrent les
performances du modèle sur l’ensemble de validation. Un déclin simultané de ces valeurs
démontre que notre modèle n’est pas simplement mémorisant les données d’entraînement,
mais développe une compréhension robuste qui lui permet de bien généraliser sur de
nouvelles données.
70
Métriques de Précision et de Rappel

Les mesures de ‘metrics/precision‘ et ‘metrics/recall‘ offrent des informations complé-
mentaires sur l’exactitude de notre modèle. Une amélioration régulière de ces métriques
signifie que notre modèle est en train de raffiner sa capacité à repérer les antennes sans
générer de nombreuses fausses détections, tout en minimisant les omissions d’antennes
présentes dans les images.
Moyenne de la Précision (mAP)

Les colonnes ‘metrics/mAP_0.5‘ et ‘metrics/mAP_0.5 :0.95‘ fournissent une évalua-
tion consolidée de la performance globale du modèle. La mesure mAP (mean Average
Precision) est un indicateur composite de la précision et du rappel à différents seuils de
détection. Une augmentation constante de ces valeurs montre que la capacité du modèle
à détecter précisément les antennes se renforce à travers une large gamme de seuils de
confiance.
En synthèse, les tendances observées dans ces résultats soulignent la capacité du mo-
dèle YOLO V à apprendre efficacement la tâche complexe de détection d’antennes. Ces
résultats sont prometteurs, mais il est essentiel de rester vigilant et de surveiller ces mé-
triques pour éviter des problèmes potentiels comme le sur-apprentissage ou des issues non
optimales lors de l’entraînement.
labels correlogramme
Figure 6.56 – Capture d’écran d’un labels correlogramme.
La figure 6.56 présente un labels correlogramme qui explore les relations entre diffé-
rentes étiquettes dans un ensemble de données. Chaque cellule de la matrice représente la
corrélation entre deux étiquettes, qui est indiquée par une échelle de couleurs. Les couleurs
plus vives ou plus foncées indiquent une corrélation plus forte, tandis que les couleurs plus
claires indiquent une corrélation plus faible. Ce labels correlogramme permet de visualiser
rapidement les relations entre les étiquettes, mettant en évidence les paires d’étiquettes
71
fortement corrélées et celles qui sont moins liées. Il offre ainsi des informations précieuses
pour l’analyse des données et la compréhension des relations entre les différentes catégo-
ries. En utilisant cet outil, les chercheurs et les analystes peuvent identifier des tendances,
des clusters ou des regroupements d’étiquettes, ce qui peut aider à prendre des décisions
éclairées et à mieux comprendre les données étudiées.
Courbe F1-Confidence
Figure 6.57 – Capture d’écran d’une courbe F1-Confidence.
La figure 6.57 présente une courbe F1-Confidence qui met en relation la mesure de
performance F1 et la confiance attribuée par un modèle à ses prédictions. L’objectif de
cette courbe est de fournir des informations sur la relation entre la précision et le rappel
du modèle pour différentes valeurs de confiance.
Le score F1 est une mesure de performance couramment utilisée dans les tâches de
classification binaire. Il combine la précision et le rappel en une seule valeur qui représente
l’équilibre entre les deux mesures. Le score F1 est calculé en utilisant la formule suivante :
2 · précision · rappel
F1 =
précision + rappel
où la précision est le nombre de vrais positifs divisé par la somme des vrais positifs et
des faux positifs, et le rappel est le nombre de vrais positifs divisé par la somme des vrais
positifs et des faux négatifs.
La courbe F1-Confidence montre comment le score F1 varie en fonction de la confiance
du modèle. À mesure que la confiance augmente, le score F1 peut également augmenter,
ce qui indique que le modèle a tendance à produire des prédictions plus précises et à
minimiser à la fois les faux positifs et les faux négatifs. Cependant, il est important de
noter que cette tendance peut varier en fonction du seuil de confiance choisi.
L’analyse de la courbe F1-Confidence permet de choisir un seuil de confiance approprié
en fonction des objectifs de performance spécifiques. Par exemple, si l’objectif est de
72
maximiser le score F1, il est préférable de choisir un seuil de confiance qui correspond au
point de la courbe où le score F1 est le plus élevé. Cela garantit un équilibre optimal entre
la précision et le rappel.
En utilisant la courbe F1-Confidence, les praticiens et les chercheurs peuvent prendre
des décisions éclairées quant au seuil de confiance à utiliser pour leurs tâches de classifica-
tion, en fonction des compromis souhaités entre la précision et le rappel du modèle. Cela
permet d’optimiser les performances du modèle pour répondre aux exigences spécifiques
de la tâche.
Courbe Rappel-Confiance
Figure 6.58 – Exemple de courbe Rappel-Confiance
La courbe Rappel-Confiance est un outil graphique qui permet d’évaluer les perfor-
mances d’un modèle de détection en fonction du seuil de confiance utilisé pour considérer
une prédiction comme positive. Elle représente le rappel (recall) en fonction de la confiance
des prédictions.
Le rappel est une mesure de la capacité du modèle à détecter tous les exemples positifs
réels parmi tous les exemples positifs présents dans les données. Il est calculé comme le
rapport entre le nombre de vrais positifs et la somme des vrais positifs et des faux négatifs :
Vrais Positifs
Rappel =
Vrais Positifs + Faux Négatifs
Le seuil de confiance représente le niveau de confiance requis pour considérer une
prédiction comme positive. En augmentant ce seuil, on exige une plus grande certitude
avant d’accepter une prédiction.
La courbe Rappel-Confiance permet de visualiser comment le rappel varie en fonction
du seuil de confiance. Elle met en évidence le compromis entre le rappel et la précision
du modèle. En général, à mesure que le seuil de confiance augmente, le rappel diminue
car le modèle devient plus strict dans ses prédictions. Cela signifie qu’il est plus sélectif et
73
moins susceptible de faire des faux positifs, mais il risque également de manquer certains
vrais positifs.
En analysant la courbe Rappel-Confiance, on peut déterminer le seuil de confiance
qui offre un bon équilibre entre rappel et précision en fonction des besoins spécifiques de
l’application.
Courbe Précision-Confiance
Figure 6.59 – Exemple de courbe Précision-Confiance
La courbe Précision-Confiance est un outil graphique qui permet d’évaluer les perfor-
mances d’un modèle de détection en fonction du seuil de confiance utilisé pour considérer
une prédiction comme positive. Elle représente la précision en fonction de la confiance des
prédictions.
La précision est une mesure de l’exactitude des prédictions positives du modèle, c’est-
à-dire la capacité du modèle à éviter les faux positifs. Elle est calculée comme le rapport
entre le nombre de vrais positifs et la somme des vrais positifs et des faux positifs :
Vrais Positifs
Précision =
Vrais Positifs + Faux Positifs
La courbe Précision-Confiance permet de visualiser comment la précision varie en
fonction du seuil de confiance. Elle met en évidence le compromis entre la précision et le
rappel du modèle. En général, à mesure que le seuil de confiance augmente, la précision
augmente car le modèle devient plus sélectif dans ses prédictions positives. Cependant,
cela peut également entraîner une diminution du rappel, car le modèle risque de manquer
certains vrais positifs.
74
En analysant la courbe Précision-Confiance, on peut déterminer le seuil de confiance

qui offre un bon équilibre entre précision et rappel en fonction des besoins spécifiques de
l’application.
Courbe Précision-Rappel-Confiance
Figure 6.60 – Exemple de courbe Précision-Rappel-Confiance
La courbe Précision-Rappel-Confiance est un outil graphique qui permet d’évaluer

les performances d’un modèle de détection en fonction du seuil de confiance utilisé pour
considérer une prédiction comme positive. Elle représente la précision et le rappel en
fonction de la confiance des prédictions.
La précision est une mesure de l’exactitude des prédictions positives du modèle, c’est-
à-dire la capacité du modèle à éviter les faux positifs. Elle est calculée comme le rapport
entre le nombre de vrais positifs et la somme des vrais positifs et des faux positifs :
Vrais Positifs
Précision =
Vrais Positifs + Faux Positifs
Le rappel, également appelé sensibilité ou taux de vrais positifs, est une mesure de la
capacité du modèle à trouver tous les exemples positifs. Il est calculé comme le rapport
entre le nombre de vrais positifs et la somme des vrais positifs et des faux négatifs :
Vrais Positifs
Rappel =
Vrais Positifs + Faux Négatifs
La courbe Précision-Rappel-Confiance permet de visualiser comment la précision et le
rappel varient en fonction du seuil de confiance. Elle permet de comprendre le compromis
entre la précision et le rappel du modèle. En général, à mesure que le seuil de confiance
75
augmente, la précision augmente tandis que le rappel diminue. Cela signifie que le modèle
est plus sélectif dans ses prédictions positives, mais il risque également de manquer certains
vrais positifs.
En analysant la courbe Précision-Rappel-Confiance, on peut déterminer le seuil de
confiance qui offre un bon équilibre entre précision et rappel en fonction des besoins
spécifiques de l’application.
6.10.3 Analyse des performances du modèle

Suite à notre évaluation, nous avons effectué une analyse plus approfondie des perfor-
mances de notre modèle YOLOv5m. Nous avons examiné de plus près les erreurs commises
par le modèle pour comprendre les domaines dans lesquels il avait du mal à faire des pré-
dictions précises.
Nous avons trouvé que notre modèle avait tendance à avoir plus de difficultés avec
certains types d’objets que d’autres. Par exemple, le modèle a eu du mal à distinguer les
petits objets qui étaient très proches les uns des autres. De plus, dans certaines conditions
d’éclairage, le modèle a eu du mal à identifier correctement les objets.
Pour résoudre ces problèmes, nous avons envisagé plusieurs stratégies d’amélioration.
Par exemple, nous pourrions augmenter notre jeu de données avec plus d’images de pe-
tits objets et d’objets dans des conditions d’éclairage difficiles. De plus, nous pourrions
explorer l’utilisation de techniques de régularisation pour éviter le sur-apprentissage.
6.10.4 Test des performances du modèle

Après avoir formé et évalué notre modèle, l’étape suivante était de le tester en condi-
tions réelles. Pour cela, nous avons utilisé notre drone équipé d’une caméra ESP32 pour
capturer des images de pylônes de télécommunication.
Ces images ont ensuite été introduites dans notre modèle YOLOv5m pour détection.
Le modèle a été capable de détecter avec succès plusieurs types d’objets, y compris des
antennes, des boulons rouillés, des personnes et des animaux.
De plus, nous avons également testé le modèle en termes d’inventaire des équipements
du pylône de télécommunication. Le modèle a réussi à identifier et à compter avec précision
les différents types d’équipements présents sur le pylône.
Ces tests ont démontré que notre modèle est capable de fonctionner efficacement dans
des conditions réelles et peut être utilisé pour l’inspection des pylônes de télécommunica-
tion.
76
Figure 6.61 – Résultat de détection 1
Figure 6.62 – Résultat de détection 2
Améliorations futures
Bien que notre modèle ait montré des performances prometteuses, il reste encore de
nombreuses possibilités d’amélioration. Par exemple, nous pourrions explorer l’utilisation
de techniques de régularisation pour améliorer les performances de notre modèle. De plus,
77
nous pourrions également envisager d’utiliser des techniques de transfert de l’apprentissage

pour tirer parti des modèles pré-entraînés et améliorer ainsi l’efficacité de notre modèle.
En conclusion, ce chapitre a présenté en détail la réalisation de notre modèle d’in-
telligence artificielle pour l’inspection des pylônes de télécommunication par drone. Nous
avons discuté de chaque étape du processus, y compris la collecte et l’étiquetage des don-
nées, l’entraînement et l’évaluation du modèle, et les tests en conditions réelles. Nous
espérons que ces détails aideront à comprendre le travail considérable qui a été effectué
et la méthodologie rigoureuse que nous avons suivie pour atteindre nos objectifs.
Récapitulatif et conclusion du chapitre

Pour conclure ce chapitre sur la réalisation de notre projet d’intelligence artificielle
pour l’inspection des pylônes de télécommunication par drone, permettons-nous de revenir
brièvement sur les grandes étapes que nous avons traversées.
Nous avons commencé par la collecte de données à travers plusieurs méthodes, notam-
ment le web scraping, la prise de photos sur site et l’exploitation d’une base de données
préexistante fournie par SOTETEL. Cela nous a permis d’obtenir un ensemble d’images
variées et représentatives des divers scénarios d’inspection de pylônes de télécommunica-
tion.
Ensuite, nous avons laborieusement labélisé ces images, en utilisant à la fois un proces-
sus manuel via l’outil LabelImg et un processus automatique grâce à un modèle YOLOv5s
que nous avons adapté pour nos besoins spécifiques.
Après cette étape, nous avons préparé et entraîné notre modèle YOLOv5m pour la
détection d’objets sur nos images labélisées. Ce processus a été rendu possible grâce à
l’utilisation de ressources GPU qui ont permis d’accélérer l’entraînement et d’obtenir des
résultats en un temps raisonnable.
Suite à l’entraînement, nous avons évalué notre modèle sur un ensemble de données de
validation, en utilisant plusieurs métriques importantes comme la précision, le rappel, et
le score F1. Ces métriques nous ont aidé à comprendre les performances de notre modèle
et à identifier les domaines d’amélioration.
Enfin, nous avons testé notre modèle en conditions réelles, en utilisant notre drone
pour capturer des images de pylônes et en appliquant notre modèle pour détecter les
objets et anomalies. Les résultats ont été très encourageants, montrant que notre modèle
est capable de fonctionner de manière fiable et précise.
Dans l’ensemble, nous sommes très satisfaits des résultats que nous avons obtenus avec
notre modèle YOLOv5m. Néanmoins, nous reconnaissons qu’il reste toujours des oppor-
tunités pour améliorer et optimiser davantage notre modèle et notre système d’inspection
des pylônes. Dans les travaux futurs, nous envisagerons d’explorer d’autres techniques
et approches, comme l’augmentation des données, la régularisation, et le transfert de
l’apprentissage, pour continuer à améliorer la précision et l’efficacité de notre système.
En somme, ce travail a été une aventure passionnante et enrichissante, qui nous a
permis d’explorer en profondeur les possibilités offertes par l’intelligence artificielle pour
l’inspection des pylônes de télécommunication. Nous espérons que les détails que nous
avons fournis dans ce chapitre aideront à comprendre notre processus de réalisation et à
apprécier les efforts et les compétences nécessaires pour mener à bien un tel projet.
78
Chapitre 7
Détection du texte dans les images

7.1 Introduction
Dans ce chapitre[15], nous abordons le processus de détection du texte dans les images.
La détection du texte est une tâche importante dans de nombreux domaines, tels que la
reconnaissance optique de caractères (OCR), l’analyse d’images et la recherche d’informa-
tions visuelles. Elle permet d’extraire du contenu textuel à partir d’images et de le rendre
accessible pour des analyses ultérieures.
L’objectif de ce chapitre est de présenter les différentes étapes impliquées dans la dé-
tection du texte dans les images. Nous commençons par discuter des techniques d’amélio-
ration de la qualité de l’image, qui visent à préparer les images pour une détection précise
du texte. Ensuite, nous explorons l’utilisation de l’algorithme OCR (Reconnaissance Op-
tique de Caractères) pour extraire le texte des images traitées. Enfin, nous examinons
comment intégrer le processus de détection et de reconnaissance de texte dans une appli-
cation web à l’aide du framework Django et comment enregistrer les résultats dans une
base de données.
7.2 Amélioration de la qualité de l’image

Nous utilisons plusieurs étapes de traitement d’image pour améliorer sa qualité et faci-
liter la reconnaissance des caractères. Nous commençons par l’interpolation pour ajuster
la taille de l’image tout en préservant les détails importants. Ensuite, nous appliquons
un filtre de flou médian pour réduire le bruit en remplaçant les pixels par la médiane
des pixels voisins. Nous convertissons ensuite l’image en niveaux de gris pour simplifier le
traitement ultérieur.
Pour une meilleure binarisation, nous utilisons une méthode de seuillage adaptatif
gaussien qui ajuste le seuil en fonction des caractéristiques locales de l’image. Cela permet
d’obtenir une binarisation précise et adaptée à chaque région de l’image. Nous utilisons
également la morphologie mathématique, avec l’érosion qui réduit la taille des objets en
enlevant les pixels à la bordure et la dilatation qui agrandit les objets en ajoutant des
pixels à leur bordure.
Enfin, nous effectuons une binarisation à l’aide de l’outil OCR Kraken, ce qui facilite
la reconnaissance des caractères lors du traitement ultérieur de l’image. Grâce à ces dif-
férentes étapes de traitement d’image, nous améliorons la qualité en réduisant le bruit,
en ajustant la taille, en simplifiant la représentation et en optimisant la binarisation pour
une meilleure reconnaissance des caractères.
79
Chapitre 7 7.2. Amélioration de la qualité de l’image
Figure 7.63 – Image originale avant traitement
80
Chapitre 7 7.2. Amélioration de la qualité de l’image
Figure 7.64 – Amélioration de la qualité de l’image
81
Chapitre
7.3. Utilisation
7 de Tesseract OCR pour la reconnaissance de texte sur les images traitées
7.3 Utilisation de Tesseract OCR pour la reconnais-

sance de texte sur les images traitées
Nous avons développé un code en utilisant les techniques de traitement d’image pour
améliorer la qualité de l’image et effectuer la reconnaissance de texte avec Tesseract OCR.
Figure 7.65 – Résultat de la détection de texte à partir de l’image traitée
82
7.4. Intégration du processus de détection et de reconnaissance de texte dans un serveur
Chapitre 7 Django
7.4 Intégration du processus de détection et de re-

connaissance de texte dans un serveur Django
création d’une application ‘ocr_app’ dans le serveur django :
Figure 7.66 – Création de l’application ’ocr_app’ dans le serveur Django
Dans le fichier views.py de notre application, nous avons implémenté les fonctionna-
lités suivantes :
— Prendre en entrée un dossier contenant des images : Nous avons créé une
fonction pour récupérer le chemin du dossier contenant les images à traiter.
— Binarisation et application de filtres : Nous avons développé des méthodes
pour lire chaque image du dossier, les binariser et appliquer des filtres pour amé-
liorer la précision de l’image.
— Reconnaissance de texte avec l’algorithme OCR : Nous avons utilisé l’algo-
rithme OCR (Tesseract OCR dans notre exemple) pour extraire le texte des images
binarisées et filtrées.
— Affichage des résultats dans une page HTML : Nous avons créé une page
HTML qui affiche le nom de chaque fichier d’image traité ainsi que le texte détecté
par cette image.
Implémentation des fonctions de traitement d’image, de filtrage et de reconnaissance
de texte dans views.py
7.5 Enregistrement du texte dans une base de don-

nées SQLite
Nous avons choisi d’utiliser la base de données SQLite par défaut de Django pour notre
projet. SQLite est une base de données légère qui stocke les données localement dans un
fichier, sans nécessiter un serveur de base de données distinct. Dans notre projet Django,
la base de données SQLite est stockée dans un fichier appelé ‘db.sqlite3‘, situé à la racine
du projet.
L’utilisation de SQLite présente plusieurs avantages. Tout d’abord, il est facile à mettre
en place car il ne nécessite pas de configuration de serveur de base de données externe. De
plus, il est léger en termes de ressources système, ce qui le rend adapté au développement
et aux tests. Enfin, SQLite prend en charge les fonctionnalités SQL standard, ce qui facilite
l’interaction avec la base de données dans notre application.
83
Chapitre 7 7.5. Enregistrement du texte dans une base de données SQLite
Figure 7.67 – Code extrait de views.py
Figure 7.68 – Résultats de l’OCR
84
Pour enregistrer le texte extrait de l’OCR dans la base de données SQLite, nous avons
utilisé les fonctionnalités de Django pour interagir avec la base de données. Django fournit
une couche d’abstraction qui facilite la création de modèles de données et l’exécution
d’opérations de base de données telles que l’enregistrement des données extraites.
En utilisant les modèles de Django, nous avons défini un modèle de base de données
pour représenter les résultats OCR. Ce modèle comprend des champs tels que le texte
extrait et la date de création. Lorsque nous effectuons la reconnaissance de texte sur une
image, nous créons une instance de ce modèle et l’enregistrons dans la base de données
SQLite.
Grâce à l’utilisation de SQLite et aux fonctionnalités de Django, nous sommes en
mesure de stocker et de gérer efficacement les résultats OCR dans notre application. Cette
approche nous permet d’organiser les données de manière cohérente et de les récupérer
facilement lorsque nécessaire.
En conclusion, l’utilisation de la base de données SQLite dans notre projet Django
offre une solution légère, facile à configurer et à utiliser pour enregistrer les résultats
OCR. Cela nous permet de centraliser les données extraites et de les gérer efficacement
dans notre application.
7.5.1 Étape 1 : Création du modèle OCRResult dans models.py

pour stocker les résultats OCR
Figure 7.69 – Création de l’application ’ocr_app’ dans le serveur Django
85
7.5.2 Étape 2 : Création et application d’une nouvelle migration

pour les modifications de la base de données SQLite :
Figure 7.70 – Création et application d’une migration SQLite
7.5.3 Étape 3 : Modification de la vue ‘ocr_results‘ pour enre-

gistrer les résultats OCR dans la base de données :
Figure 7.71 – Modification de la fonction ’ocr_results
86
7.5.4 Étape 4 : affichage des résultats stockés dans la base de

données
Nous créons une nouvelle vue dans ‘views.py‘ afin de récupérer les données stockées
dans la base de données.
Figure 7.72 – Création de la fonction ’ocr_results_list’
Nous ajoutons l’URL de la nouvelle vue dans ‘urls.py‘
Figure 7.73 – Ajout de l’URL dans le fichier urls.py
87
Chapitre 7 7.6. Migration de la base de données de SQLite vers PostgreSQL
Nous créons un nouveau fichier nommé ‘ocr_results_list.html‘ dans le dossier ‘tem-

plates‘ afin d’afficher les données
Figure 7.74 – Création du fichier ocr_results_list.html
Maintenant, nous avons accès à l’URL http ://127.0.0.1 :8000/ocr_results_list/ pour voir
la liste des résultats OCR stockés dans la base de données.
Figure 7.75 – Affichage de la liste des résultats OCR
Cependant, pour un déploiement en production, nous avons réalisé une modification en

utilisant une base de données plus robuste et évolutive : PostgreSQL. Nous avons constaté
qu’elle offre des performances supérieures ainsi que des fonctionnalités avancées pour la
gestion d’applications à grande échelle.
7.6 Migration de la base de données de SQLite vers

PostgreSQL
7.6.1 Étape 1 : Installation de PostgreSQL sur Windows et
configuration du mot de passe de l’utilisateur "postgres"
Nous avons téléchargé l’installateur de PostgreSQL pour Windows à partir de
https ://www.postgresql.org/download/windows/. Ensuite, nous avons exécuté l’installa-
88
teur et suivi les instructions à l’écran pour installer PostgreSQL. Pendant l’installation,
il nous a été demandé de définir un mot de passe pour l’utilisateur "postgres".
Figure 7.76 – Installation et configuration de PostgreSQL
7.6.2 Étape 2 : Création d’une base de données et d’un utilisa-

teur
Pour nous connecter à PostgreSQL en tant qu’utilisateur "postgres", nous avons ouvert
un terminal ou l’invite de commandes (sur Windows) et saisi le nom d’utilisateur lorsque
cela nous a été demandé. Ensuite, nous avons fourni le mot de passe correspondant lorsque
cela a été requis.
Figure 7.77 – Connexion à PostgreSQL en tant qu’utilisateur "postgres"
nous avons créé une nouvelle base de données PostgreSQL
89
Figure 7.78 – Création d’une base de données PostgreSQL
nous avons créé un nouvel utilisateur dans PostgreSQL
Figure 7.79 – Création d’un utilisateur dans PostgreSQL
7.6.3 Étape 3 : Attribution des privilèges à l’utilisateur sur la

base de données PostgreSQL
Figure 7.80 – Attribution des privilèges à l’utilisateur
7.6.4 Étape 4 : Configuration de Django pour utiliser la nouvelle

base de données PostgreSQL dans ‘settings.py‘
Nous ouvrons ‘settings.py‘ et localisons la section ‘DATABASES‘. Nous la modifions
pour utiliser les informations de connexion de notre nouvelle base de données PostgreSQL
90
Figure 7.81 – Configuration de la base de données PostgreSQL dans settings.py
7.6.5 Étape 5 : Application de la migration :
Figure 7.82 – Application d’une migration dans PostgreSQL
91
7.6.6 Étape 6 : Extraction d’informations à partir du texte dé-

tecté et les enregistrer dans PostgreSQL
Nous avons modifié le code dans views.py pour inclure l’utilisation d’expressions ré-
gulières dans le but d’extraire des informations spécifiques à partir du texte détecté. Plus
précisément, nous avons ciblé des champs tels que la fréquence du gain et le type d’an-
tenne. Nous avons ajouté des fonctions dans le fichier views.py dans le but d’extraire les
information nécessaires :
La fonction ‘extract_antenna_string()‘ :
-prend une chaîne de caractères en entrée
-recherche un motif spécifique dans cette chaîne de caractères à l’aide d’une expression
régulière
-retourne une chaîne de caractères spécifique si le motif est trouvé, sinon elle retourne
‘None‘.
Figure 7.83 – Fonction extract_antenna_string() - Extraction de sous-chaîne
La fonction ‘extract_antenna_info()‘ :
-prend une chaîne de caractères en entrée
-Elle extrait des informations spécifiques de la chaîne de caractères en utilisant des ex-
pressions régulières
-stocke ces informations dans un dictionnaire qui est ensuite renvoyé.
Une fois les valeurs extraites, nous les avons enregistrées dans notre base de données
PostgreSQL. Cela nous permet de stocker ces informations précises dans une structure de
base de données bien organisée.
Une fois que nous avons stocké les champs requis dans la base de données SQL Post-
greSQL, nous transmettons ces informations à notre site web, qui se charge ensuite d’af-
ficher les résultats détectés.
92
Figure 7.84 – Fonction extract_antenna_info() - Extraction d’informations spéci-

fiques
Figure 7.85 – Stockage d’informations dans un dictionnaire
Figure 7.86 – Enregistrement des valeurs extraites dans la base de données PostgreSQL
93
7.7 Conclusion
En conclusion, l’étape de réalisation et de détection de texte a été un élément essentiel
de notre projet. Nous avons réussi à mettre en place un système efficace pour extraire le
texte à partir des images, le traiter et le stocker dans une base de données PostgreSQL.
Cette étape nous permet d’obtenir des informations précieuses à partir des images captu-
rées lors de l’inspection des pylônes, ce qui facilite la maintenance et la prise de décisions
éclairées. Grâce à l’utilisation d’outils et de techniques appropriés, nous avons pu automa-
tiser ce processus et améliorer l’efficacité de notre inspection. En conclusion, la réalisation
et la détection de texte sont des étapes clés pour optimiser notre processus d’inspection
des pylônes et assurer une maintenance efficace.
94
Chapitre 8
Réalisation Django
8.1 Introduction
Dans ce chapitre, nous décrivons les étapes de réalisation du site web dans notre projet.
Nous détaillons dans chaque section une étape.
8.2 Étape 1 : Installation de Django

Pour donner[16] vie à notre projet Django, la première étape consiste à installer Django
lui-même. nous avons utiliser l’outil de gestion de paquets pip pour cela :
pip install django
8.3 Étape 2 : Créer un nouveau projet Django

Une fois Django installé, nous avons créer un nouveau projet Django en utilisant la
commande django-admin. Cette commande crée une structure de base pour notre projet :
django-admin startproject myproject

cd myproject
Lors de l’exécution de cette commande, un dossier racine sera créé avec le nom spé-
cifié (dans cet exemple, "myproject"). Ce dossier contiendra tous les fichiers et dossiers
nécessaires pour notre projet Django.
8.3.1 Le fichier manage.py

Le fichier[17] "manage.py" est un script très important dans notre projet Django. Il
permet d’effectuer diverses tâches administratives, telles que le lancement du serveur de
développement, l’exécution de commandes de gestion de base de données, l’exécution de
tests, etc. C’est un outil puissant qui facilite la gestion de notre projet.
95
Chapitre 8 8.3. Étape 2 : Créer un nouveau projet Django
8.3.2 La base de données et les modèles de données

Dans le contexte du développement d’une application, la base de données et les modèles
de données sont deux éléments clés. La base de données est un système de stockage struc-
turé qui nous permet de stocker, gérer et récupérer nos données. Les modèles de données,
quant à eux, sont des représentations logiques de nos données dans notre application.
Dans Django, les modèles de données sont définis en utilisant une classe Python spé-
ciale appelée "Model". Chaque modèle correspond à une table dans la base de données,
et les champs de la classe correspondent aux colonnes de la table. nous avons définir
différents types de champs tels que des chaînes de caractères, des nombres, des dates, etc.
8.3.3 Structure des fichiers dans un projet Django

La structure des fichiers dans un projet Django est organisée de manière à faciliter
le développement et la maintenance des applications web. Elle suit une convention bien
établie qui permet aux développeurs de naviguer facilement dans le projet et de localiser
les fichiers nécessaires. Voici un aperçu de la structure des fichiers dans un projet Django :
Figure 8.87 – Structure des fichiers dans un projet Django
— Dossier racine du projet : Il contient tous les fichiers et dossiers liés au pro-
jet. C’est également l’endroit où se trouve le fichier "manage.py", qui est utilisé
pour effectuer des tâches administratives telles que le lancement du serveur de
développement et l’exécution des migrations de base de données.
— Dossier de configuration : Souvent nommé "config" ou "settings", il contient les
fichiers de configuration principaux pour le projet Django. Le fichier "settings.py"
est le fichier central de configuration où nous avons spécifier divers paramètres tels
que les applications installées, les bases de données, les paramètres de sécurité, etc.
Le fichier "urls.py" est responsable du routage des URL, il associe les URL de notre
application aux vues appropriées.
— Dossier des applications : C’est l’endroit où nous avons organiser différentes
applications qui composent notre projet Django. Chaque application est un module
96
Chapitre 8 8.3. Étape 2 : Créer un nouveau projet Django
Python indépendant avec son propre ensemble de modèles, de vues, de fichiers

statiques et de fichiers de migration.
— Fichiers statiques : Ils regroupent les fichiers CSS, JavaScript, les images et
autres ressources statiques utilisées dans notre application web. Ces fichiers sont
généralement placés dans un dossier nommé "static".
— Templates : Les templates sont des fichiers HTML qui définissent l’interface uti-
lisateur de notre application. Ils sont généralement placés dans un dossier nommé
"templates". nous avons utiliser des balises et des variables Django dans les tem-
plates pour rendre notre contenu dynamique et réutilisable.
— Fichiers de migration : Chaque application peut contenir des fichiers de migra-
tion, qui sont utilisés pour gérer les changements de structure de la base de données
au fur et à mesure du développement de l’application. Les migrations permettent
de mettre à jour la base de données sans perdre les données existantes.
Cette structure des fichiers dans un projet Django permet une organisation cohérente
du code et facilite la collaboration entre les développeurs. Elle assure également une
séparation claire des préoccupations et favorise la réutilisation du code. En comprenant
cette structure, nous serons en mesure de développer des applications web robustes et
évolutives avec Django.
8.3.4 Le dossier de configuration

Le dossier de configuration contient les fichiers de configuration de notre projet Django.
Il est souvent appelé "config" ou "settings" et contient des fichiers importants tels que
"settings.py" et "urls.py".
Le fichier "settings.py" contient les paramètres de configuration pour notre projet,
tels que les clés secrètes, les bases de données, les applications installées, etc.Nous avons
personnaliser ces paramètres en fonction des besoins de notre projet.
Le fichier "urls.py" définit les URL de notre application. C’est ici que nous spécifions
les correspondances entre les URL et les vues qui gèrent ces URL. nous avons utiliser des
expressions régulières pour définir des modèles d’URL flexibles et puissants.
8.3.5 Le dossier des applications

Le dossier des applications est l’endroit où nous
créons et stockons les différentes applications qui composent notre projet Django.
Chaque application est un module Python qui contient ses propres modèles, vues, fichiers
statiques, etc. nous avons créer de nouvelles applications à l’aide de la commande "python
manage.py startapp".
8.3.6 Les fichiers statiques

Les fichiers statiques sont les ressources utilisées dans notre application, tels que les
images, les fichiers CSS et JavaScript. Ils sont généralement stockés dans un dossier nommé
"static". Django fournit des fonctionnalités intégrées pour gérer ces fichiers statiques et
les servir aux utilisateurs.
97
Chapitre 8 8.4. Étape 3 : Configuration du projet Django
8.3.7 Les templates

Les templates sont les fichiers HTML qui définissent l’interface utilisateur de notre
application. Ils sont généralement stockés dans un dossier nommé "templates". Les tem-
plates permettent de séparer la logique de présentation de la logique de traitement dans
notre application.
8.3.8 Les fichiers de migration

Les fichiers de migration sont utilisés pour gérer les modifications de schéma de base
de données au fil du temps. Lorsque nous apportons des modifications à nos modèles
de données, Django génère automatiquement des fichiers de migration qui décrivent ces
modifications. Ces fichiers sont ensuite utilisés pour mettre à jour la base de données en
conséquence. Les fichiers de migration sont stockés dans un dossier nommé "migrations"
dans chaque application.
Ces différentes composantes et étapes de création d’un projet Django nous permettent
de développer une application web puissante et personnalisée en utilisant le framework
Django.
8.4 Étape 3 : Configuration du projet Django

La configuration du projet Django se fait principalement à travers le fichier "set-
tings.py" situé dans le dossier racine du projet Django. Ce fichier contient plusieurs pa-
ramètres importants qui définissent le comportement global de l’application. Certains de
ces paramètres couramment utilisés incluent :
- DATABASES : Ce paramètre permet de spécifier les détails de connexion à la base
de données, tels que le type de base de données, le nom d’utilisateur et le mot de passe.
- INSTALLED_APPS : Il s’agit d’une liste des applications Django installées dans
notre projet. Nous pouvons également inclure des applications tierces installées via pip.
Ces applications fournissent des fonctionnalités supplémentaires pour notre projet.
- MIDDLEWARE : Les middlewares sont utilisés pour effectuer des actions spé-
cifiques avant ou après le traitement d’une requête. Par exemple, l’authentification de
l’utilisateur, la gestion des cookies et la mise en cache des données peuvent être gérées à
l’aide de middlewares.
- TIME_ZONE : Ce paramètre permet de définir le fuseau horaire utilisé par l’ap-
plication pour la gestion des dates et heures.
- LANGUAGE_CODE et LANGUAGES : Ces paramètres définissent la langue
par défaut de notre projet et les langues disponibles pour les utilisateurs. Cela est utile si
nous souhaitons internationaliser notre application.
En plus de ces paramètres, nous pouvons également personnaliser d’autres aspects de
la configuration, tels que les paramètres de la base de données, les paramètres de stockage
des médias, les paramètres de l’API, etc. Ces paramètres dépendent des besoins spécifiques
de notre projet.
Une fois notre projet Django est configuré , nous pouvons créer des vues Django pour
recevoir les images ou vidéos envoyées, exécuter le modèle de détection d’objets YOLOv5
sur ces médias, stocker les résultats de la détection d’objets dans une base de données et
fournir une API pour que le tableau de bord puisse récupérer et afficher les informations.
98
Chapitre 8 8.5. Étape 4 : Création d’une application Django
Cela nécessitera la création de modèles de données appropriés, de vues Django pour traiter
les requêtes, et de routes pour gérer les URL.
Recevoir les images ou vidéos envoyées par l’ESP32-CAM

Créons une vue Django pour recevoir les fichiers envoyés par l’ESP32-CAM via des
requêtes POST. Utilisons la bibliothèque Pillow pour traiter les images et vidéos reçues
et les stocker dans une base de données ou un système de fichiers.
Exécuter le modèle de détection d’objets YOLOv5

Installons la bibliothèque YOLOv5 pour Python. Créons une vue Django pour traiter
les images stockées et utilisons YOLOv5 pour détecter les objets. Stockons les résultats
de la détection d’objets dans une base de données.
Stocker les résultats de la détection d’objets

Utilisons le modèle Django pour stocker les résultats de la détection d’objets dans une
base de données.
Fournir une API pour récupérer les informations

Créons une vue Django pour renvoyer les résultats de la détection d’objets sous forme
de JSON, afin que le tableau de bord puisse les récupérer et les afficher.
En résumé, nous avons configurer notre projet Django en créant des vues pour recevoir
les fichiers de l’ESP32-CAM, exécuter la détection d’objets avec YOLOv5, stocker les
résultats dans une base de données, et fournir une API pour récupérer les informations.
8.5 Étape 4 : Création d’une application Django

Dans Django, une application est un module indépendant qui peut être réutilisé dans
différents projets. Pour créer une nouvelle application, utilisons la commande suivante :
python manage.py startapp myapp
Cela va créer un nouveau dossier nommé "myapp" avec la structure de base d’une
application Django.
Un projet Django est la structure globale qui englobe une ou plusieurs applications
Django. Il est créé en utilisant la commande "django-admin startproject" et contient des
fichiers tels que "settings.py", "urls.py", "wsgi.py", etc.
Une application Django est un ensemble de fonctionnalités qui peut être intégré à un
projet Django. Elle est créée à l’aide de la commande "python manage.py startapp" et
contient des fichiers tels que "models.py", "views.py", "urls.py", "templates/", etc.
La structure de base d’une application Django se compose des éléments suivants :
— Le fichier "models.py" : il contient les modèles de données qui représentent la struc-
ture de notre base de données. Les modèles de données sont définis sous forme de
classes Python et sont utilisés pour stocker et récupérer des données dans la base
de données.
99
Chapitre 8 8.6. Étape 5 : Modèles et bases de données
— Le fichier "views.py" : c’est là que nous définissons les vues qui gèrent les requêtes
HTTP et les réponses associées. Les vues récupèrent les données nécessaires à partir
des modèles de données, effectuent des opérations sur ces données et renvoient des
réponses en fonction de ces opérations. Les requêtes HTTP peuvent être de type
GET ou POST, selon qu’elles envoient les données en clair dans l’URL ou non.
— Le fichier "urls.py" : c’est là que nous configurons les URL de notre application en
spécifiant les vues qui doivent être appelées pour chaque URL.
— Le dossier "templates/" : c’est là que nous stockons les fichiers de modèles HTML
qui définissent la structure et l’apparence de nos pages Web. Les fichiers de modèle
peuvent inclure des balises et des variables qui peuvent être remplacées par des
données dynamiques générées par Django.
— Le dossier "static/" : c’est là que nous stockons les fichiers statiques tels que les
fichiers CSS, JavaScript et les images, qui sont utilisés pour personnaliser l’appa-
rence de notre site.
— Le fichier "forms.py" : c’est là que nous pouvons définir les formulaires de notre
application.
— Le fichier "admin.py" : c’est là que nous pouvons définir l’interface d’administration
pour notre application. Cette interface peut être utilisée pour gérer les données
stockées dans la base de données.
En résumé, pour créer une application Django, utilisons la commande "startapp" pour
générer la structure de base de l’application. Ensuite, personnalisons les fichiers tels que
"models.py", "views.py", "urls.py", "templates/", etc., pour implémenter les fonctionnalités
spécifiques de notre application.
8.6 Étape 5 : Modèles et bases de données

Les modèles définissent la structure des données de notre application. Un modèle est
une classe Python qui hérite de django.db.models.Model. Les attributs de la classe
représentent les champs de la base de données.
Dans le fichier models.py de notre application (myapp/models.py), nous avons définir
les modèles correspondants. Par exemple :
from django.db import models
class MyModel(models.Model):
name = models.CharField(max_length=100)
description = models.TextField()
Une fois que nous avons défini nos modèles, nous créons les tables correspondantes
dans la base de données. Pour ce faire, on utilise les commandes suivantes :
python manage.py makemigrations myapp

python manage.py migrate
Ces commandes généreront les fichiers de migration et les appliqueront à la base de

données.
Les fichiers de migration sont des fichiers Python générés automatiquement par Django
qui permettent de modifier la structure de la base de données en fonction des changements
apportés aux modèles de données de l’application.
100
Chapitre 8 8.7. Étape 6 : Vues et logique de l’application
Lorsque nous apportons des modifications aux modèles de données d’une application
Django, ces modifications ne sont pas automatiquement appliquées à la base de données.
Au lieu de cela, Django utilise les fichiers de migration pour décrire les changements
apportés aux modèles de données et générer le code SQL nécessaire pour mettre à jour la
base de données en conséquence.
Les fichiers de migration sont générés automatiquement à l’aide de la commande
python manage.py makemigrations. Cette commande examine les modèles de données
de l’application et génère un nouveau fichier de migration pour chaque changement dé-
tecté.
Une fois que les fichiers de migration ont été générés, nous pouvons appliquer les
modifications à la base de données en utilisant la commande python manage.py migrate.
Cette commande exécute chaque fichier de migration dans l’ordre chronologique pour
mettre à jour la base de données en conséquence.
En résumé, les fichiers de migration sont des fichiers Python générés automatiquement
par Django qui permettent de modifier la structure de la base de données en fonction des
changements apportés aux modèles de données de l’application. Ces fichiers sont utilisés
pour générer le code SQL nécessaire pour mettre à jour la base de données et sont appliqués
à la base de données à l’aide de la commande python manage.py migrate.
8.7 Étape 6 : Vues et logique de l’application

Les vues définissent la logique de notre application et gèrent les requêtes HTTP en-
trantes. Une vue peut être une fonction ou une classe basée sur une vue. Dans le fichier
views.py de notre application (myapp/views.py), nous avons définir les vues correspon-
dantes. Par exemple :
from django.http import HttpResponse
def my_view(request):
return HttpResponse("Hello, World!")
Dans cet exemple, la fonction my_view est une vue qui prend en paramètre un objet
request représentant la requête HTTP entrante. La vue renvoie ensuite une réponse
HTTP en utilisant la classe HttpResponse. Dans ce cas, la réponse renvoie simplement le
texte "Hello, World !".
nous avons définir des vues plus complexes qui effectuent des opérations sur les modèles
de données, accèdent à des bases de données, ou rendent des templates HTML dynamiques.
Les vues sont configurées dans le fichier urls.py de notre application pour associer des
URLs spécifiques à des vues spécifiques.
En résumé, les vues définissent la logique de notre application et gèrent les requêtes
HTTP entrantes. nous avons les définir en tant que fonctions ou classes dans le fichier
views.py de notre application.
8.8 Étape 7 : URLs et routage

Le fichier urls.py définit les routes URL pour notre application. nous avons configurer
ces routes pour associer les vues à des URL spécifiques. Voici un exemple :
101
Chapitre 8 8.9. Étape 8: Templates
Dans le fichier urls.py de notre application (myapp/urls.py), nous avons configurer

les routes URL en utilisant le module path de Django. Par exemple :
from django.urls import path

from . import views
urlpatterns = [
path(’hello/’, views.my_view, name=’my_view’),
]
Dans cet exemple, nous configurons une route URL qui correspond à l’URL hello/.
Cette URL est associée à la vue my_view de notre application. L’argument name est utilisé
pour donner un nom à cette route URL.
Dans le fichier urls.py principal de notre projet (myproject/urls.py), nous avons
inclure les URLs de notre application. Par exemple :
from django.contrib import admin

from django.urls import path, include
urlpatterns = [
path(’admin/’, admin.site.urls),
path(’myapp/’, include(’myapp.urls’)),
]
Dans cet exemple, nous incluons les URLs de l’application myapp en utilisant la fonc-
tion include. Toutes les URLs qui commencent par myapp/ seront ensuite gérées par les
routes URL définies dans myapp/urls.py.
En résumé, le fichier urls.py est utilisé pour configurer les routes URL de notre
application. nous associons les vues aux URLs spécifiques, puis nous avons inclue ces
URLs dans le fichier urls.py principal de notre projet.
8.9 Étape 8 : Templates

Les modèles définissent la structure des données de notre application. Un modèle est
une classe Python qui hérite de django.db.models.Model. Les attributs de la classe
représentent les champs de la base de données.
Dans le fichier myapp/models.py, nous avons défini les modèles pour notre application.
Par exemple :
from django.db import models
class MyModel(models.Model):
name = models.CharField(max_length=100)
description = models.TextField()
Dans cet exemple, nous définissons un modèle MyModel qui a deux champs : name de
type CharField et description de type TextField.
Une fois que nous avons défini vos modèles, nous avons crée les tables correspondantes
dans la base de données. Pour ce faire, nous avons utiliser les commandes makemigrations
et migrate :
102
Chapitre 8 8.10. Étape 9 : Static files and media files
python manage.py makemigrations myapp

python manage.py migrate
La première commande, makemigrations, génère les fichiers de migration qui décrivent

les changements à apporter à la base de données en fonction des modifications apportées
aux modèles.
La deuxième commande, migrate, applique ces changements à la base de données en
exécutant les fichiers de migration.
En résumé, les modèles définissent la structure des données de notre application. nous
avons les définir dans le fichier models.py de notre application, puis utiliser les com-
mandes makemigrations et migrate pour créer les tables correspondantes dans la base
de données.
8.10 Étape 9 : Static files and media files

Les fichiers statiques comprennent des fichiers tels que CSS, JavaScript et images. Les
fichiers médias sont des fichiers téléchargés par les utilisateurs, tels que des images et des
documents.
Pour stocker vos fichiers statiques, créons un nouveau dossier nommé static à l’inté-
rieur du dossier myapp.
On assures que django.contrib.staticfiles est inclut dans la liste des applications
installées dans le fichier settings.py de notre projet Django. Cela permet à Django de
servir les fichiers statiques tels que les fichiers CSS, JavaScript et les images.
INSTALLED_APPS = [
# ...
’django.contrib.staticfiles’,
# ...
]
Dans notre fichier settings.py, nous avonségalement configurer les variables STATIC_URL
et MEDIA_URL pour spécifier les URL de base pour les fichiers statiques et les fichiers mé-
dias.
STATIC_URL = ’/static/’
MEDIA_URL = ’/media/’
On assures que les dossiers static/ et media/ existent dans notre projet Django et que
leurs chemins sont correctement configurés dans les variables STATIC_ROOT et MEDIA_ROOT.
Ces variables spécifient les chemins absolus des dossiers où les fichiers statiques et les
fichiers médias seront stockés.
En résumé, pour gérer les fichiers statiques et les fichiers médias dans notre application
Django, nous avons crée un dossier static/ pour les fichiers statiques, configurer les
variables STATIC_URL et MEDIA_URL pour spécifier les URL de base, et vérifier que les
dossiers static/ et media/ existent et sont correctement configurés dans les variables
STATIC_ROOT et MEDIA_ROOT.
103
Chapitre 8 8.11. Étape 10 : Formulaire
8.11 Étape 10 : Formulaire

Les formulaires permettent de gérer les entrées utilisateur dans notre application.
Django propose un système de formulaires puissant qui gère le rendu, la validation et la
soumission des formulaires.
Dans le fichier myapp/forms.py, nous avons définir les formulaires de notre application.
Par exemple :
from django import forms
class MyForm(forms.Form):
name = forms.CharField(max_length=100)
message = forms.CharField(widget=forms.Textarea)
Dans notre vue, nous avons utiliser ce formulaire pour gérer les soumissions et l’afficher
dans le template :
from django.shortcuts import render
from .forms import MyForm
def my_view(request):
form = MyForm()
if request.method == ’POST’:
form = MyForm(request.POST)
if form.is_valid():
# Traitement des données du formulaire
return HttpResponseRedirect(’/success/’)
return render(request, ’index.html’, {’form’: form})

Dans cette vue, nous instancions le formulaire (MyForm) dans la variable form pour
l’afficher dans le template. Lorsque la méthode de requête est POST, nous recréons le
formulaire avec les données soumises (request.POST) et nous vérifions sa validité. Si le
formulaire est valide, nous avons traité les données. Sinon, le formulaire sera affiché avec
les erreurs de validation.
En résumé, les formulaires permettent de gérer les entrées utilisateur. nous avons
défini les formulaires dans le fichier forms.py, les utiliser dans vos vues pour gérer les
soumissions et les afficher dans les templates.
8.12 Étape 11 : Exécution du serveur de développe-

ment
Pour tester L’application, exécutons le serveur de développement :
python manage.py runserver
Cela démarrera le serveur sur le port 8000 par défaut. Ouvrons notre navigateur et
allons à l’adresse http ://localhost :8000/myapp/hello/ pour voir notre application en
action.
104
8.13 Conclusion
En conclusion, ce chapitre nous a guidés à travers les étapes de réalisation d’un site
web avec Django. Nous avons commencé par l’installation de Django et la création d’un
nouveau projet Django. Ensuite, nous avons exploré la structure des fichiers dans un
projet Django, en mettant l’accent sur le dossier de
configuration, le dossier des applications, les fichiers statiques, les templates et les fichiers
de migration.
Nous avons également abordé la configuration du projet Django à travers le fichier
"settings.py", où nous pouvons définir divers paramètres tels que les bases de données, les
applications installées, les middlewares, etc. Cette étape est essentielle pour personnaliser
le comportement global de l’application.
Enfin, nous avons examiné la création d’une application Django, qui est un module
indépendant qui peut être réutilisé dans différents projets Django. Nous avons découvert
les éléments clés d’une application Django tels que les modèles de données, les vues et les
fichiers de configuration.
En suivant ces étapes, nous sommes maintenant prêts à développer notre application
web avec Django en utilisant les connaissances acquises dans ce chapitre.
105
Chapitre 9
Réalisation web
9.1 Introduction
Dans le cadre de notre projet, nous avons réalisé un site web complet utilisant les
technologies HTML, CSS, JavaScript, Spline et Django Frontend. Ce site web a pour
objectif de fournir une interface conviviale pour la gestion des pylônes, en incluant un
formulaire de soumission d’informations, une authentification sécurisée, l’affichage des
résultats de détection et un tableau de bord pour visualiser les informations importantes
sur les pylônes.
9.2 HTML
HTML (HyperText Markup Language) est le langage de balisage standard utilisé pour
structurer et présenter le contenu des pages web. Il fournit une base solide pour la création
de sites web en définissant la structure des éléments, tels que les en-têtes, les paragraphes,
les listes, les liens, les images, etc.
En utilisant HTML, nous avons pu décrire la structure de nos pages web en utilisant
des balises pour définir les différentes parties de la page. Par exemple, la balise <header>
pour l’en-tête, la balise <nav> pour la navigation, la balise <section> pour les sections
principales, la balise <footer> pour le pied de page, etc.
HTML est un langage simple à apprendre et à utiliser. Il est compatible avec tous les
navigateurs web et fournit une base solide pour le développement web. Grâce à HTML,
nous avons pu créer la structure de notre site web et organiser les différents éléments de
manière logique et cohérente.
9.3 CSS
CSS (Cascading Style Sheets) est un langage de feuille de style utilisé pour styliser et
mettre en forme les pages web. Il permet de contrôler l’apparence visuelle des éléments
HTML en définissant des règles de style.
En utilisant CSS, nous avons pu personnaliser l’apparence de notre site web en défi-
nissant des règles de style pour les différents éléments HTML. Par exemple, nous avons
pu définir la couleur du texte, la police, la taille des polices, les marges, les bordures, les
arrière-plans, etc.
CSS nous a permis de créer un design attrayant et cohérent pour notre site web. Il
offre également des fonctionnalités avancées telles que les sélecteurs, les pseudo-classes,
106
Chapitre 9 9.4. JavaScript
les transitions et les animations, qui nous ont permis de créer des effets visuels et des
transitions fluides.
9.4 JavaScript
JavaScript est un langage de programmation de haut niveau principalement utilisé
pour rendre les pages web interactives et dynamiques. Il permet d’ajouter des fonctionna-
lités avancées telles que des effets visuels, des validations de formulaires, des interactivités
en temps réel et bien plus encore.
En utilisant JavaScript, nous avons pu ajouter des fonctionnalités interactives à notre
site web. Par exemple, nous avons pu valider les formulaires côté client pour s’assurer que
les données saisies sont correctes, implémenter des boutons cliquables pour effectuer des
actions, créer des animations, manipuler et afficher des données en temps réel, etc.
JavaScript est largement utilisé et pris en charge par tous les navigateurs modernes.
Il offre une grande flexibilité et une large gamme de bibliothèques et de frameworks pour
faciliter le développement web.
9.5 Django Frontend

Django Frontend est un module de Django qui facilite la gestion des fichiers statiques
(CSS, JavaScript, images, etc.) et la création de modèles de pages réutilisables. Il offre une
intégration transparente avec HTML, CSS et JavaScript, ce qui simplifie le développement
frontend dans le cadre d’un projet Django.
Grâce à Django Frontend, nous avons pu organiser et gérer nos fichiers statiques de
manière efficace. Il nous a permis de structurer nos fichiers CSS et JavaScript, de les
intégrer dans nos modèles HTML et de les rendre
facilement accessibles à partir de nos vues Django.
Django Frontend offre également des fonctionnalités avancées telles que la possibilité
de combiner et de minimiser les fichiers CSS et JavaScript, d’utiliser des préprocesseurs
CSS tels que Sass ou Less, et de gérer les dépendances externes.
En utilisant Django Frontend, nous avons pu améliorer la productivité de notre dé-
veloppement frontend et maintenir un code propre et organisé. Il a facilité l’intégration
harmonieuse de nos technologies frontend avec Django, offrant ainsi une expérience utili-
sateur fluide et cohérente.
9.6 Spline
Spline est un outil de conception 3D que nous avons utilisé pour créer des éléments
visuels dynamiques pour notre site web. Nous avons utilisé Spline pour concevoir le tableau
de bord, qui affiche des informations détaillées sur les pylônes. La figure 9.88 montre une
capture d’écran du tableau de bord.
9.7 Authentification
La page d’authentification est une partie essentielle de notre site web, car elle garantit
que seuls les utilisateurs autorisés peuvent accéder aux fonctionnalités du site. Cette
107
Chapitre 9 9.7. Authentification
Figure 9.88 – Capture d’écran du tableau de bord réalisé avec Spline
fonctionnalité d’authentification sécurisée protège les données sensibles et prévient les

accès non autorisés.
Lorsque les utilisateurs accèdent à la page d’authentification, ils sont invités à saisir
leurs identifiants de connexion, généralement leur nom d’utilisateur ou leur adresse e-mail,
ainsi que leur mot de passe. Ces informations sont ensuite vérifiées par le système pour
s’assurer de l’exactitude des données fournies.
Si les informations de connexion sont correctes, les utilisateurs sont redirigés vers
leur tableau de bord personnel, où ils peuvent accéder aux fonctionnalités spécifiques qui
leur sont attribuées. En cas d’informations incorrectes, un message d’erreur approprié est
affiché pour informer les utilisateurs de l’erreur et les inviter à réessayer.
La page d’authentification est conçue pour offrir une expérience utilisateur fluide et
sécurisée. Des mesures de sécurité telles que le hachage des mots de passe et la gestion
des sessions sont mises en place pour protéger les données des utilisateurs. Des éléments
visuels et interactifs sont utilisés pour créer une interface attrayante et conviviale.
La figure 9.89 présente une capture d’écran de la page d’authentification, illustrant
l’interface utilisateur soignée et les champs de saisie des identifiants de connexion. Cette
page joue un rôle essentiel dans la protection des données sensibles et garantit que seuls
les utilisateurs autorisés peuvent accéder aux fonctionnalités de notre site web.
Figure 9.89 – Capture d’écran de la page d’authentification
108
Chapitre 9 9.8. Inscription
9.8 Inscription
La page d’inscription joue un rôle crucial dans notre site web, car elle permet aux
nouveaux utilisateurs de créer un compte et d’accéder aux fonctionnalités du site. Elle
offre une interface conviviale et intuitive pour faciliter le processus d’inscription.
Lorsque les utilisateurs accèdent à la page d’inscription, ils sont invités à fournir des
informations personnelles telles que leur nom, leur adresse e-mail et leur mot de passe. Ces
informations sont essentielles pour créer un compte unique et sécurisé pour chaque utili-
sateur. Des contrôles de validation sont mis en place pour s’assurer que les informations
fournies sont correctes et complètes.
Une fois que les utilisateurs ont rempli tous les champs requis et soumis le formulaire
d’inscription, leurs informations sont vérifiées et enregistrées dans la base de données.
Un processus de confirmation par e-mail peut également être mis en place pour garantir
l’authenticité de l’utilisateur.
Figure 9.90 – Page d’inscription
9.9 Formulaire
9.10 Formulaire de Soumission
Nous avons créé un formulaire de soumission qui permet aux utilisateurs de saisir
des informations sur les pylônes. Les utilisateurs peuvent remplir les champs requis et
soumettre le formulaire. Les informations saisies seront ensuite enregistrées dans la base
de données. Cette fonctionnalité permet de collecter facilement des données sur les pylônes.
La figure 9.92 montre une capture d’écran du formulaire de soumission.
109
Chapitre 9 9.11. Affichage des Résultats
Figure 9.91 – Capture d’écran du formulaire de soumission
Figure 9.92 – Capture d’écran du formulaire de soumission
9.11 Affichage des Résultats

Nous avons mis en place une page dédiée pour afficher les résultats de détection des
pylônes. Lorsqu’un utilisateur soumet le formulaire de soumission, les résultats de la dé-
tection intelligente sont enregistrés dans la base de données. Ces résultats sont ensuite
affichés dans la page des résultats. Les utilisateurs peuvent consulter les résultats pré-
cédents et obtenir des informations sur les pylônes détectés. La figure 9.93 montre une
capture d’écran de la page des résultats.
110
Chapitre 9 9.12. Tableau de Bord
Figure 9.93 – Capture d’écran de la page des résultats
9.12 Tableau de Bord

Le tableau de bord est une fonctionnalité clé de notre site web. Il affiche des infor-
mations détaillées sur les pylônes, y compris leur localisation, leur état, leur hauteur et
d’autres paramètres importants. Le tableau de bord est conçu de manière interactive
et conviviale, permettant aux utilisateurs d’explorer les données des pylônes de manière
efficace. La figure 9.94 montre une capture d’écran du tableau de bord.
Figure 9.94 – Capture d’écran du tableau de bord
9.13 Conclusion
En conclusion, la réalisation de notre site web a nécessité l’utilisation de plusieurs tech-
nologies clés, notamment HTML, CSS, JavaScript, Spline et Django Frontend. Chacune
de ces technologies a joué un rôle important dans la création d’une expérience utilisateur
attrayante, interactive et fonctionnelle.
Grâce à HTML, nous avons pu structurer le contenu de nos pages web et définir leur
mise en page globale. CSS nous a permis de personnaliser l’apparence visuelle de notre
site web, en ajoutant des styles et des effets visuels attrayants. JavaScript a ajouté une
dimension interactive à notre site, offrant des fonctionnalités telles que des validations de
formulaires, des animations et des interactions en temps réel.
Nous avons également utilisé l’outil Spline pour créer des visualisations graphiques dy-
namiques et captivantes. Ces visualisations ont enrichi l’expérience utilisateur en affichant
les résultats de détection de manière visuellement attrayante et facile à comprendre.
Enfin, Django Frontend nous a permis de gérer efficacement les fichiers statiques, de
structurer notre code frontend et de faciliter l’intégration avec Django. Cela a contribué
111
à maintenir un développement organisé, productif et cohérent.

Grâce à l’utilisation de ces technologies et à leur intégration harmonieuse, nous avons
pu créer un site web fonctionnel et convivial pour la gestion des pylônes. Le processus
de conception et de réalisation de notre site web a été enrichissant, nous permettant
d’acquérir de nouvelles compétences et de relever des défis techniques.
Nous sommes fiers du résultat final de notre site web et nous sommes convaincus qu’il
répondra aux besoins de nos utilisateurs. Nous espérons qu’il fournira une plateforme
efficace pour la gestion et la visualisation des données des pylônes, contribuant ainsi à
améliorer la sécurité et la maintenance de ces infrastructures vitales.
En conclusion, la réalisation de ce site web a été une expérience enrichissante et gra-
tifiante. Nous reconnaissons l’importance des technologies utilisées et leur impact sur
l’expérience utilisateur. Nous sommes confiants dans le fait que notre site web répondra
aux attentes de nos utilisateurs et contribuera à leur satisfaction et à leur succès.
112
Conclusion Générale
Le projet d’inspection de pylônes avec caméra IA sur un drone et serveur Django

représente une avancée significative dans le domaine de l’inspection des infrastructures.
Grâce à l’utilisation de drones équipés de caméras alimentées par l’intelligence

artificielle, il est désormais possible de réaliser des inspections plus rapides, plus sûres et
plus précises des pylônes.
Ce projet a ouvert la voie à un large éventail d’applications futures et à des perspec-

tives passionnantes dans le domaine de l’inspection des infrastructures. Tout d’abord,
il offre la possibilité d’étendre ce système à d’autres types d’infrastructures critiques,
tels que les ponts, les tours de télécommunication, les éoliennes et les installations
industrielles. L’utilisation de drones équipés de caméras IA peut grandement simplifier
et améliorer l’inspection de ces structures, garantissant leur intégrité et leur sécurité.
De plus, l’intégration de technologies émergentes telles que la vision par ordinateur

et l’apprentissage profond offre un potentiel énorme pour améliorer les performances et
l’efficacité des systèmes d’inspection. En développant des algorithmes d’IA plus avancés
et en exploitant des réseaux de neurones profonds, il sera possible de détecter avec une
plus grande précision les défauts, les fissures et les anomalies structurelles. Cela permettra
aux opérateurs de maintenance de prendre des décisions plus précises et éclairées pour la
planification des travaux de réparation et de maintenance.
Parallèlement, les progrès technologiques dans les domaines de la robotique et de

l’automatisation ouvrent des possibilités pour l’utilisation de drones autonomes dans les
opérations d’inspection des infrastructures. Des drones capables de fonctionner de ma-
nière autonome, d’analyser les données en temps réel et de prendre des décisions basées
sur des algorithmes d’IA avancés pourraient
révolutionner l’industrie de l’inspection. Ces drones autonomes
pourraient effectuer des inspections programmées de manière régulière, détecter les pro-
blèmes potentiels avant qu’ils ne deviennent critiques et contribuer à prévenir les accidents
et les pannes coûteuses.
En outre, l’intégration de systèmes d’information géographique (SIG) dans le processus
d’inspection pourrait permettre une meilleure gestion des données spatiales et temporelles
des infrastructures. Cela faciliterait la visualisation et l’analyse des résultats
d’inspection sur des cartes interactives, permettant aux équipes de maintenance de mieux
comprendre la distribution géographique des défauts et d’optimiser les travaux de répa-
ration en fonction de leur emplacement.
En conclusion, le projet d’inspection de pylônes avec caméra IA sur un drone et serveur
Django offre une solution innovante pour améliorer l’efficacité et la sécurité des opérations
113
Conclusion Générale
d’inspection des pylônes. Grâce à l’intégration de l’IA, des drones et du serveur Django,
il est possible de réaliser des inspections plus rapides, plus précises et plus fiables, contri-
buant ainsi à assurer la fiabilité et la durabilité des infrastructures essentielles. Ce projet
ouvre également la voie à de nouvelles perspectives de recherche et de développement
dans le domaine de l’inspection des infrastructures, offrant des possibilités d’application
étendues et ouvrant la voie à un avenir prometteur pour les opérations d’inspection des
pylônes et d’autres infrastructures critiques. Les avancées futures dans l’IA, la robotique
et les technologies de l’information promettent de rendre ces systèmes encore plus perfor-
mants, plus autonomes et plus intégrés, permettant ainsi une gestion efficace et proactive
des infrastructures pour répondre aux besoins de notre société en constante évolution.
114
Bibliographie
[1] https ://www.simplilearn.com. Machine Learning.

[10] https ://docs.djangoproject.com/en/4.2/. Django.
[11] https ://www.conseil-creation.com/informatique/internet/html.php. HTML.
[12] https ://juliencrego.com/cours/presentation-des-css-cours/. CSS.
[13] https ://developer.mozilla.org/. JavaScript.
[14] https ://spline.com.tn/presentation/. Spline.
[15] https ://www.sodapdf.com/. detection.
[16] https ://www.djangoproject.com/download/. Django.
[17] https ://docs.djangoproject.com/fr/4.2/ref/django-admin/. Fichier manage.py.
[2] https ://lawtomated.com/a-i-technical-machine-vs-deep-learning/. Machine and
Deep Learning.
[3] https ://lawtomated.com/a-i-technical-machine-vs-deep-learning. deeplearning.
[4] https ://datacorner.fr/yolo/. Yolo.
[5] https ://www.indiegogo.com/projects/mastering-ai-art-generation/. OpenCV.
[6] https ://numpy.org/. NumPy.
[7] https ://keras.io/. Keras.
[8] https ://www.tensorflow.org/ ?hl=fr. TensorFlow.
[9] https ://www.presse-citron.net/vpn/faq/darknet/. Darknet.
115

Inspection Des Pylône Avec Un Drone Software

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Inspection Des Pylône Avec Un Drone Software

Transféré par

Droits d'auteur :

Formats disponibles

République Tunisienne

Ministère de l’Enseignement Supérieur

Rapport de Projet de Fin d’Etude

Inspection des pylône avec un drone

Par Alaeddine Bouabid et Oussama Cherni

Encadrant Professionel :Ben Mna Mourad

Période De Stage : 01/02/2023 - 30/04/2023

Année Universitaire : 2022 - 2023

Rapport de Projet de Fin d’Etudes

Inspection des pylône avec un drone

Par Bouabid Alaeddine

Autorisation de dépôt du rapport de Projet de Fin d’Etudes :

Encadrant professionnel :Ben Mna Encadrant académique :Attia

Il est un moment dans la vie où nous arrivons à un carrefour, un

Cher enseignant, famille, amis et encadrants,

2.16.2 Nombre de cartes de probabilité (NB) . . . . . . . . . . . . . . . . . 22

7 Réalisation détection de texte 79

8.12 Étape 11 : Exécution du serveur de développement . . . . . . . . . . . . . 104

9 Réalisation web 106

Conclusion Générale 113

1.1 Logo de sotetel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

6.40 Base de données Sotetel . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

9.88 Capture d’écran du tableau de bord réalisé avec Spline . . . . . . . . . . . 108

4.1 Le tableau de caractéristiques du drone. . . . . . . . . . . . . . . . . . . . 34

Dans un monde en constante évolution, les avancées technologiques offrent de nouvelles

tionnelles. En utilisant cette technologie, les opérateurs de télécommunica-

1.2 Présentation de l’organisme d’accueil

1.2.2 Domaines d’activités

Figure 1.1 – Logo de sotetel

dans la fourniture de services de communication pour les entreprises et les

1.3 Présentation du projet

1.3.1 Cadre du projet

Le projet vise à utiliser un drone équipé d’une intelligence artificielle pour

Le projet a pour objectif de proposer une méthode d’inspection facile à

Les entreprises de pylônes de télécommunication sont les bénéficiaires di-

Contraintes et limites du projet

Méthodes et outils utilisés

Le projet utilise un drone équipé d’une caméra haute résolution et d’un

Le contexte général de la problématique est l’utilisation des pylônes pour

Problématique de l’inspection des pylônes de télécommunication

La problématique spécifique à l’inspection des pylônes de télécommuni-

risques pour les travailleurs et en réduisant les coûts associés à l’inspection.

Les défis et les risques associés à l’inspection manuelle des pylônes de

L’utilisation de drones pour l’inspection des pylônes de télécommunication

1.3.3 Etude de l’existant

sécurité pour l’utilisation des drones dans l’industrie des télécommunications

1.3.4 Solution proposée

1.4 Méthodologie de travail et planification

1.4.1 Définition de la méthodologie

Elle se caractérise par une communication ouverte et transparente, une col-

1.4.2 Choix de Scrum

Figure 1.2 – Capture d’écran Scrum 3

Figure 1.3 – Capture d’écran Scrum 4

Figure 1.4 – Capture d’écran Scrum 5

Figure 1.5 – Capture d’écran Scrum 6

Figure 1.6 – Capture d’écran de Jira

Cette image représente l’interface conviviale et intuitive de Jira, avec ses

En conclusion, Jira a été un choix judicieux pour notre projet Scrum

Figure 1.7 – Capture d’écran du sprint 1

Figure 1.8 – Capture d’écran du sprint 2

Figure 1.9 – Capture d’écran du sprint 3

1.6 Synopsis global

Figure 1.10 – Synopsis global du projet

En utilisant cette technologie, notre solution permettra de réduire les