Rapport de Projet Expertise 2023

Study of the optimization control of agricultural greenhouse
climatic parameters by the integration of machine learning.
Génie Electromécanique : option Commande et Management Industriel
Réalisé par :
AYAOU Abir Encadré par :
HEZZEM Brahim Mr. MKHIDA Abdelhak
1
Année universitaire 2022-2023
Abstract:
This project aims to study, design, and create a prototype of an agricultural greenhouse that will
be remotely controlled through a wireless communication protocol. The project is divided into three
distinct parts:
In the first part, we provide an overview of greenhouse cultivation, its main climatic parameters,
and the different technologies used in agricultural greenhouses, particularly to control climate
parameters.
The second part presents a description of a smart agricultural greenhouse prototype, mainly
focusing on the different regulation blocks and the functioning of the selected solutions, as well as
the improvements added to each block.
Finally, we studied the integration of Machine Learning for the optimization of the control of the
agricultural greenhouse.
Résumé :
Ce projet a pour objectif d'étudier, concevoir et créer un prototype de serre agricole qui sera
contrôlé à distance via un protocole de communication sans fil. Le projet se divise en trois parties
distinctes :
Dans la première partie, nous présentons une vue d'ensemble de la culture sous serre, ses
principaux paramètres climatiques ainsi que les différentes technologies utilisées en serre agricole,
notamment pour contrôler les paramètres climatiques.
La deuxième partie expose une description d'un prototype de serre agricole intelligente et
principalement les différents blocs de régulation, ainsi que le fonctionnement des solutions choisies,
ainsi que les améliorations ajoutées à chaque bloc.
Enfin, nous avons étudié l'intégration du Machine Learning pour l'optimisation du contrôle de la
serre agricole.
‫ملخص‪:‬‬
‫يهدف هذا المشروع إلى دراسة وتصميم وإنشاء نموذج لبيوت زراعية يتم التحكم بها عن بعد‬
‫‪:‬عبر بروتوكول اتصال السلكي‪ .‬تم تقسيم المشروع إلى ثالثة أجزاء‪.‬‬
‫في الجزء األول‪ ،‬نقدم نظرة عامة على الزراعة ومؤشراتها المناخية الرئيسية والتقنيات‬
‫‪.‬المختلفة المستخدمة في البيوت الزراعية‪ ،‬بشكل خاص للتحكم في عوامل المناخ‪.‬‬
‫يقدم الجزء الثاني وصفًا لنموذج بيت زراعي ذكي‪ ،‬مع التركيز بشكل رئيسي على مختلف‬
‫‪.‬وحدات التنظيم ووظيفة الحلول المختارة‪ ،‬باإلضافة إلى التحسينات المضافة إلى كل وحدة‪.‬‬
‫أخيرا‪ ،‬درسنا التكامل بين التعلم اآللي وتحسين التحكم في البيوت المغطاة‪.‬‬
‫‪ً .‬‬
Dédicace :
Aux êtres les plus chers au monde, « A nos parents » :

Vous êtes nos professeurs de toujours et le joyau de notre vie. Aucune expression ne
pourra égaler notre gratitude envers vos sacrifices, votre amour, affection, dévouement
et générosité. Vous étiez à nos côtés depuis le début, vous n’avez guère ces séides
donner ce que vous aviez de meilleur.
Que Dieu le tout Puissant vous préserve et vous procure santé et longue vie.
Á nos chers frères :
Nous vous dédions ce travail en témoignage de notre amour et nos grands
sentiments envers vous. Nous prions Dieu de vous procurer santé, bonheur et longue
vie afin que vous puissiez exhausser tous vos rêves.
Á nos chers amis et collègues :
Nous vous dédions ce travail en témoignage de notre grande affection et en souvenir
des agréables moments passés ensemble.
Remerciements :
Au terme de ce travail, nous tenons à remercier dans un premier temps ALLAH le tout puissant
de nous avoir Donné le courage, la volonté et la patience de mener à terme le présent travail.
Nous tenons à exprimer notre profonde gratitude et nos sincères remerciements à notre école
l’ENSAM qui nous a fourni toutes les ressources nécessaires pour exercer notre projet et à notre
encadrant Mr. Abdelhak MKHIDA pour son suivi, sa patience, ses conseils et son aide tout au
long de cette étude.
Nos remerciements s’adressent également au membre de jury qui nous a fait l’honneur
d’accepter d’évaluer notre travail.
Nous adressons également nos remerciements, à tous nos enseignants, qui ont contribué à notre
formation tout au long de nos années d’études.
Nos remerciements vont enfin à toute personne qui a contribué de près ou de loin à l’élaboration
de ce travail.
Table des matières :
Introduction générale : ................................................................................................................ 1
Chapitre I : Généralités sur les serres agricoles et contexte générale du projet.......................... 2
I. Les serres agricoles : ..................................................................................................... 3
1. Définition :........................................................................................................ 3
2. Utilisation : ....................................................................................................... 4
3. Les paramètres les plus agissants sur la croissance de la culture sous serre : .. 4
II. Les serres agricoles intelligentes : ................................................................................. 5
1. Définition et description : ................................................................................. 5
2. Inconvénients des serres classiques et nécessité des serres automatisées : ...... 6
3. Influence des paramètres climatiques :............................................................. 8
4. Les plantes aromatiques et médicinales : .......................................................... 8
III. Description du prototype : ............................................................................................. 9
1. Schéma synoptique : ......................................................................................... 9
2. Les améliorations du prototype au niveau des blocs : .................................... 11
IV. La Supervision de la serre agricole à l’aide de NODE RED : ......................................... 17
1. Le programme sur NODE RED : ....................................................................... 17
2. Le tableau de bord sur NODE RED : ................................................................ 18
V. La supervision à distance de la serre agricole :............................................................ 18
1. Création du serveur OPC UA sur NODE RED : ................................................. 18
2. Visualisation des données dans Prosys OPC UA Browser : .......................... 20
Chapitre Ⅱ : Etude de l’intégration de Machine Learning pour l’optimisation de contrôle de la
serre agricole.................................................................................................................................. 23
I. Définition de Machine Learning : ........................................................................................ 24
II. Le fonctionnement de Machine Learning : .................................................................. 25
III. Les principaux algorithmes de Machine Learning :...................................................... 26
IV. Les différents types de Machine Learning : ................................................................. 33
V. Application de Machine Learning : .............................................................................. 35
1. Configurer l'environnement de développement : ........................................... 35
2. Importer les données :..................................................................................... 38
3. Nettoyer les données :..................................................................................... 43
4. Fractionner les données : ................................................................................ 49
5. Sélectionner l'algorithme et configurer ses hyperparamètres : ....................... 49
6. Evaluer les résultats : ...................................................................................... 52
Conclusion générale :................................................................................................................ 56
Bibliographie et Webographie: ................................................................................................. 57
Annexes:………………………………………………………………………………...58
Liste des abréviations:
DHT22: digital temperature and humidity sensor

CO2: Carbon Dioxide
IOT: Internet of Things
LED: Light Emitting Diode
PAM : plante aromatique et médicinale
Wi-Fi: Wireless Fidelity
OPC UA: Open Platform Communications Unified Architecture
K-NN: K-Nearest Neighbors
Liste des figures:
Figure 1:serre agricole traditionnel ------------------------------------------------------------------------------------------------- 4
Figure 2: Serre intelligente ------------------------------------------------------------------------------------------------------------- 6
Figure 3:serre agricole liée a une interface de la supervision ---------------------------------------------------------------- 7
Figure 4:schéma synoptique --------------------------------------------------------------------------------------------------------- 10
Figure 5: tapis chauffant -------------------------------------------------------------------------------------------------------------- 11
Figure 6: code de tapis pour une seul de 25 c------------------------------------------------------------------------------------ 11
Figure 7: Installation du tapis -------------------------------------------------------------------------------------------------------- 12
Figure 8: LCD 20*4 ---------------------------------------------------------------------------------------------------------------------- 12
Figure 9: LCD avec potentiomètre -------------------------------------------------------------------------------------------------- 13
Figure 10: montage de LCD avec Arduino ---------------------------------------------------------------------------------------- 14
Figure 11: code Arduino pour l'afficheur LCD ------------------------------------------------------------------------------------ 14
Figure 12: Circuit ------------------------------------------------------------------------------------------------------------------------ 15
Figure 13: les paramètres climatiques sur l'afficheur ------------------------------------------------------------------------- 15
Figure 14: Code de l’humidificateur avec Arduino ------------------------------------------------------------------------------ 16
Figure 15: la réalisation du circuit -------------------------------------------------------------------------------------------------- 17
Figure 16 : le programme sur NODE RED pour l’acquisition des données de la serre agricole et la création d’un
tableau de bord -------------------------------------------------------------------------------------------------------------------------- 17
Figure 17 : Tableau de bord sur NODE RED pour la supervision de la serre agricole ---------------------------------- 18
Figure 18 : Le programme sur NODE RED pour créer le serveur OPC UA et migrer les données de la serre agricole
vers le cloud ------------------------------------------------------------------------------------------------------------------------------ 19
Figure 19 : le programme dans le nœud « add folder » ----------------------------------------------------------------------- 19
Figure 20 : le programme dans le nœud « SET Temperature » ------------------------------------------------------------- 20
Figure 21 : le programme dans le nœud « variable : Temperature »------------------------------------------------------ 20
Figure 22 : Visualisation des données à partir du client Prosys OPC UA Browser -------------------------------------- 21
Figure 23: Représentation visuelle de la relation entre les domaines relatifs aux données ------------------------- 25
Figure 24: Droite de régression linéaire ------------------------------------------------------------------------------------------- 27
Figure 25: Exemple de régression logistique ------------------------------------------------------------------------------------- 27
Figure 26 : Régression logistique versus Machine à vecteur de support (SVM) ---------------------------------------- 28
Figure 27 : : Exemple d’un arbre de régression ---------------------------------------------------------------------------------- 28
Figure 28 : Exemple d’un arbre de classification -------------------------------------------------------------------------------- 29
Figure 29: Exemple de K-NN clustering utilisé pour prédire la classe d’un nouveau point de données ---------- 29
Figure 30: Comparaison entre les données originales et les données classifiées en utilisant K-moyennes ----- 30
Figure 31 : Anatomie d’un neurone humain ------------------------------------------------------------------------------------- 30
Figure 32 : Les trois générales couches d’un réseau de neurones ---------------------------------------------------------- 31
Figure 33: La reconnaissance faciale en utilisant les réseaux de neurones (Deep Learning) ------------------------ 31
Figure 34: l’interface de Anaconda Navigator ----------------------------------------------------------------------------------- 35
Figure 35: la commande jupyter notebook sur l’invite de commandes --------------------------------------------------- 36
Figure 36 : l’interface de Jupyter Notebook -------------------------------------------------------------------------------------- 36
Figure 37: l’interface de programmation en python sur Jupyter Notebook --------------------------------------------- 37
Figure 38 : Importation des bibliothèques et des fonctions sur Jupyter Notebook ------------------------------------ 37
Figure 39: Importation des données sous format CSV dans jupyter notebook ----------------------------------------- 41
Figure 40: la commande pour prévisualiser des lignes dans jupyter notebook ----------------------------------------- 42
Figure 41: Importation des données des maisons à Melbourne sous format CSV ------------------------------------- 42
Figure 42: Tableau des données importées en Jupyter Notebook ---------------------------------------------------------- 43
Figure 43 : les commandes dans jupyter notebook pour supprimer les colonnes -------------------------------------- 45
Figure 44: le tableau des données après suppression des colonnes ------------------------------------------------------- 45
Figure 45 : Les commandes pour supprimer les colonnes -------------------------------------------------------------------- 46
Figure 46: le tableau des données des maisons à Melbourne après suppression des colonnes -------------------- 46
Figure 47: la fonction pour supprimer les valeurs manquantes dans le tableau de données ----------------------- 46
Figure 48: Tableau des données après suppression des valeurs manquantes ------------------------------------------ 47
Figure 49: La commande dans jupyter notebook pour convertir les données non numériques en valeurs numériques
----------------------------------------------------------------------------------------------------------------------------------------------- 47
Figure 50: Tableau des données après conversion des colonnes non numériques en valeurs numériques ----- 48
Figure 51: la commande de suppression de la colonne du prix ‘price’ et le tableau des données après sa suppression
----------------------------------------------------------------------------------------------------------------------------------------------- 48
Figure 52: Création des matrices pour X et y en utilisant la bibliothèque NumPy ------------------------------------- 49
Figure 53: la fonction Scikit-learn pour fractionner en données d'entraînement et de test dans jupyter notebook
----------------------------------------------------------------------------------------------------------------------------------------------- 49
Figure 54: Le code dans jupyter notebook pour sélectionner l’algorithme Gradient Boosting et configurer ses
hyperparamètres ------------------------------------------------------------------------------------------------------------------------ 50
Figure 55: La fonction fit dans jupyter notebook pour entrainer le modèle --------------------------------------------- 51
Figure 56: La fonction de la bibliothèque joblib pour enregistrer le modèle d’entrainement----------------------- 51
Figure 57: Code pour calculer l’erreur absolue moyenne pour les données d’entrainement puis écrire le résultat final
----------------------------------------------------------------------------------------------------------------------------------------------- 52
Figure 58: Code pour calculer l’erreur absolue moyenne pour les données de test puis écrire le résultat final 52
Figure 59: L’erreur absolue moyenne des données d’entrainement après modification de max_depth --------- 53
Figure 60: Les erreurs absolues moyennes des données d’entrainement et de test après modification de max_depth
et n_estimators -------------------------------------------------------------------------------------------------------------------------- 54
Figure 61: Bloc de contrôle ----------------------------------------------------------------------------------------------------------- 58
Figure 62:Bloc d'affichage ------------------------------------------------------------------------------------------------------------ 58
Figure 63: Bloc de régulation de la température ------------------------------------------------------------------------------- 59
Figure 64: Bloc de régulation de la quantité d'air ------------------------------------------------------------------------------ 59
Figure 65: Bloc de régulation de l'humidité -------------------------------------------------------------------------------------- 60
Figure 66: Bloc de régulation de système d'arrosage ------------------------------------------------------------------------- 60
Figure 67: Bloc de régulation de la lumière -------------------------------------------------------------------------------------- 61
Figure 68 : Configuration du nœud COM6 ---------------------------------------------------------------------------------------- 65
Figure 69 : le programme dans le nœud function ------------------------------------------------------------------------------ 66
Figure 70 : Configuration du nœud filter ------------------------------------------------------------------------------------------ 66
Figure 71 : Configuration du nœud Switch --------------------------------------------------------------------------------------- 67
Figure 72 : La suite de configuration du nœud Switch ------------------------------------------------------------------------ 67
Figure 73 : Configuration du nœud split 1 ---------------------------------------------------------------------------------------- 68
Figure 76: Configuration du nœud split 4 ----------------------------------------------------------------------------------------- 69
Figure 82 : Configuration du nœud split 10 -------------------------------------------------------------------------------------- 72
Figure 85 : Le programme dans le nœud Rendre la température une variable globale ------------------------------ 74
Figure 86 : Le programme dans le nœud Rendre l’humidité une variable globale ------------------------------------- 74
Figure 87 : Configuration du nœud OPC UA server ----------------------------------------------------------------------------- 75
Figure 88 : le programme dans le nœud SET Qualité_de_l’air -------------------------------------------------------------- 75
Figure 89 : le programme dans le nœud variable : Qualité_de_l’air ------------------------------------------------------ 76
Liste des tableaux :

Tableau 1 : tableau de brochage ---------------------------------------------------------------------------------------------------- 13
Tableau 2: Un tableau descriptif des paramètres climatiques dans la serre agricole inclus dans les donnéesErreur !
Signet non défini.
Introduction générale :
L'agriculture est le fondement de la vie humaine, car elle est la principale source de nourriture et
de matières premières. Par conséquent, la croissance du secteur agricole est nécessaire au
développement de la situation économique du pays. Malheureusement, de nombreux agriculteurs
utilisent encore des méthodes traditionnelles qui conduisent à des faibles rendements et pour faire
face à un marché de plus en plus concurrentiel, les systèmes de production en serre deviennent
considérablement sophistiqués. C'est grâce à la mécanisation des outils et à l'intervention de
l'automatique. Ce projet vise à rendre l'agriculture, en particulier la culture en serre, intelligente
grâce aux nouvelles technologies telles que l'Internet des objets qui collecte les données de
différents types de capteurs. Les données collectées fournissent des informations sur différents
facteurs climatiques qui à leur tour aident à surveiller le système.
1
Chapitre I
Chapitre I : Généralités sur les serres

agricoles et contexte générale du projet
2
Chapitre I
Introduction :
Les serres agricoles intelligentes sont de plus en plus populaires dans l'agriculture moderne en
raison de leur capacité à améliorer l'efficacité et la rentabilité de la production agricole. Les
agriculteurs peuvent surveiller les conditions de croissance des plantes en temps réel à l'aide de
capteurs IoT et d'autres technologies, ce qui leur permet de prendre des décisions éclairées sur la
gestion des cultures. Les systèmes automatisés de contrôle de l'environnement, tels que les systèmes
de chauffage, de ventilation et d'éclairage, permettent aux agriculteurs de créer un environnement
optimal pour la croissance des plantes, ce qui peut conduire à une production accrue, une meilleure
qualité de la récolte et une réduction des pertes.
Les serres intelligentes peuvent également contribuer à une utilisation plus durable des
ressources. Les systèmes de gestion de l'eau, tels que l'irrigation goutte à goutte, peuvent réduire la
consommation d'eau de manière significative, tout en réduisant la quantité d'eau gaspillée. Les
serres intelligentes peuvent également utiliser des sources d'énergie renouvelable, telles que les
panneaux solaires, pour réduire la consommation d'énergie et les coûts associés.
En fin de compte, les serres agricoles intelligentes sont un exemple de la façon dont la
technologie peut être utilisée pour aider les agriculteurs à maximiser leur production tout en
minimisant l'impact environnemental.
I. Les serres agricoles :

1. Définition :
La serre est une construction utilisée pour contrôler le développement des plantes (légumes,
fleurs, etc.) En leur donnant des conditions plus favorables que les conditions locales pour une
croissance optimale. La plupart du temps, elle est utilisée pour cultiver des plantes hors sol ou hors
leur zone de climat naturel.
Le choix de la serre dépend des plants qu’on souhaite cultiver. Certains légumes ont besoin de
chaleur pour se développer correctement tandis que d’autres poussent naturellement sans aide
extérieure.
3
Chapitre I
Figure 1:serre agricole traditionnel
2. Utilisation :
Les principaux atouts des serres sont :
- La protection des cultures des changements de conditions climatiques, comme lefroid ou
la grêle.
- La production est assurée, malgré les changements météorologiques.
- Les légumes et jeunes plantes sont à l’abri des animaux nuisibles.
- Cultiver des légumes hors saison, pour pouvoir les revendre plus cher
- Elle permet aux plants de se développer en attendant de trouver leur emplacement
définitif dans les champs et de donner rapidement des fruits.
- Assurer une productivité continue et maximale.
3. Les paramètres les plus agissants sur la croissance de la culture sous

serre :
a. Sur le plan climatique :
Les facteurs climatiques qui influencent le climat intérieur de la serre sont la température,
l’humidité de l’air, le rayonnement solaire, le vent extérieur…etc. En réalité, chacun de ces facteurs
engendre une combinaison d’effets qui peuvent être favorables ou non au fonctionnement de la
serre selon les conditions locales qui prévalent. La température intervient de façon prépondérante
dans la croissance et le développement de la végétation. Les concentrations de CO2 et de vapeur
d’eau, jouent un rôle déterminant dans la transpiration et dans la photosynthèse des plantes ainsi que
dans le développement des maladies fongiques. Le rayonnement solaire intervient également dans la
4
Chapitre I
photo synthèse. Certains matériaux de couverture comme le verre, transparents au rayonnement de

courtes longueurs d’ondes et opaques au rayonnement infrarouge, créent un effet de serre qui
provoque lui-même une augmentation de température sous l’abri. Le vent génère des différences de
pression sur la serre qui peuvent l’endommager dans les cas extrêmes. Il provoque également des
pertes par convection et contribue de façon déterminante à l’aération naturelle. Un contrôle bien
maîtrisé du bilan énergétique du climat permet donc de gérer ces paramètres et d’améliorer le
fonctionnement physiologique des plantes.
b. Sur plan économique :
Le besoin en eau des plantes est fortement lié au phénomène de l’évapotranspiration.

Sous serre, l’évapotranspiration est moins importante car la vapeur d’eau ne remonte pas en
altitude par convection comme pour les surfaces à ciel ouvert.
La culture sous serre permet d’augmenter le rendement de la production. En effet la maitrise des
paramètres climatiques permet de recréer les conditions presqu’idéales pour une meilleure
production.
c. Sur plan écologique :
Par sa structure, la serre joue en même temps le rôle de protection physique contre certains types
de parasites comme les insectes ravageurs. Certaines serres sont simplement équipées de filets anti-
insectes.
De même pour les engrais, la maitrise de la fertilisation permet d’éviter le gaspillage des engrais
chimique et donc de réduire les pollutions. En plus la serre offre plus de possibilité de pratiquer
l’agriculture biologique.
II. Les serres agricoles intelligentes :

1. Définition et description :
Conception d’une serre intelligente pour créer un environnement propice qui permet les
cultures dites hors saison, de protéger les plantes et favoriser la croissance des cultures de : fruit
comme la tomate un produit leader à l’exportation et très exigeant en température ; de fleurs comme
la luzerne à forte demande en eau, en créant des conditions climatiques plus favorables que le
climat local on peut augmenter le taux de croissance et le rendement des cultures et permettre à
l’utilisateur de gérer les paramètres de croissance de la plante à distance ou à proximité pour
simplifier le quotidien de l’agriculteur.
Tout en étant très responsables vis-à-vis de notre environnement dans cette serre intelligente on
prévoit utiliser beaucoup l’énergie verte, on fait travailler des insectes comme la coccinelle qui
dévore de 50 à 100 pucerons par jour, des bourdons qui favorisent la pollinisation des plantes et
5
Chapitre I
assurent leur fécondation naturelle pour produire sans utiliser de produits phytosanitaires et profiter
des avantages de l’aquaponie qui permet des économies d’eau de 80 à 90 % qui sera également une
source de production du poisson comme le tilapia que le Maroc exporte en Espagne et l’ Italie
.Ainsi , la crevette qui absorbe tous les déchets. En plus, l’ensemble des éléments nécessaires à la
culture de la serre seront recyclables.
Figure 2: Serre intelligente
La serre intelligente est donc un élément important qui permet de créer un écosystème
indépendant en utilisant les différentes méthodes reliées à l’aquaponie, l’aquaculture et la
polyculture, c’est une méthode qui permet à tout le monde de se reconnecter à son alimentation
comme par exemple la conception d’une serre intelligente aquaponie pour la culture de la luzerne
c’est un moyen pour augmenter le rendement et la qualité du produit, et réduire les coûts ce qui
pourra nous servir également pour l’alimentation des ovins en élevage qu’on va consommer par
après.
2. Inconvénients des serres classiques et nécessité des serres

automatisées :
Les serres classiques généralement en verre n’offrent pas une bonne isolation thermique aux
plantes. De plus, il n’y a pas d’optimisation des ressources utilisées pour l’éclairage, l’échauffement
pouvant ainsi affecter les plants et par ailleurs un coût élevé.
6
Chapitre I
L’un des obstacles majeurs des serres classiques est qu’elles ne permettent pas la modification
automatique des paramètres internes de la serre et nécessitent l’intervention humaine.
Aussi, la non-interaction automatique entre le milieu et l’opérateur constitue un obstacle à la
détection rapide de danger pouvant entrainer une propagation rapide de maladie ravageuses dû à
l’air confiné à l’intérieur. En cas de grosse chaleur, une augmentation drastique de la chaleur
captivée à l’intérieur peut nuire aux plantes.
Les inconvénients évoqués plus haut ont suscités l’amélioration des serres classiques donnant
naissance aux serres automatisées. Ces serres "automatisées" ne nécessitent pas la présence
constante d'une personne. L'automatisation permet de créer les conditions idéales pour le contrôledu
climat dans une serre. Les systèmes d’autonomie permettent d’économiser du temps et des
ressources.
Une serre "automatisée" permet d'exécuter automatiquement les fonctions suivantes :
- Contrôle et ajustement de la température à l'intérieur de la serre ;
- Surveillance de l'humidité de l'air ;
- Humidification du sol ;
- Éclairage des plantes ;
- Aération de la serre ;
- Contrôle de l’irrigation ;
Figure 3:serre agricole liée a une interface de la supervision
7
Chapitre I
3. Influence des paramètres climatiques :

Les facteurs climatiques qui influencent le climat intérieur de la serre sont la température,
l’humidité, le rayonnement solaire, le vent et le couvert végétal.
a. La température :
La température à l’intérieur de la serre, obtenue naturellement grâce aux rayons solaires, peut être
insuffisante à certaines périodes de l’année (hiver) et excessive à d’autres moments (été). Dans le
cadre d’une régulation des températures, il est nécessaire de prendre en compte l’appréciation des
exigences thermiques de jour et de nuit des cultures réalisées sous serre.
b. L’humidité :
En période nocturne, les serres étant généralement fermées, l’humidité relative de l’air y est élevée
pouvant conduire au développement des maladies cryptogamiques. En période diurne, l’élévation de
la température de l’air peut conduire à un abaissement exagéré de l’humidité relative de l’air et peut
provoquer un véritable « stress hydrique » au niveau de la végétation. Par ailleurs, lorsque
l’humidité relative de l’air est faible, on peut l’augmenter en faisant des nébulisations. Au contraire,
lorsqu’il s’agit d’abaisser le degré d’hygrométrie, l’aération où la ventilation s’impose.
c. Influence de la lumière :
Sous abri, les conditions d’éclairement sont sous l’étroite dépendance du climat lumineux naturel.
La meilleure utilisation de ce climat naturel sera liée au choix du matériau de couverture. La
recherche d’un éclairement maximal est la règle générale pendant la période à faible ensoleillement.
Dans le cas contraire, il est souvent nécessaire de réduire les apports lumineux (ombrage) pour
éviter les risques d’échauffement excessif de la culture et du déséquilibre dans l’alimentation
hydrique sous l’effet d’une forte demande d’évaporation.
d. Influence du dioxyde de carbone :
La teneur en CO2 est l’un des trois facteurs nécessaires pour la photosynthèse, plus la présence de
CO2 est élevée plus la photosynthèse est meilleure.
Afin de ne pas diminuer l’activité des cultures, il est nécessaire de maintenir un taux de CO2
important. Il est alors nécessaire de favoriser le renouvellement de l’air à l’aide de la ventilation. On
notera que pour certaines cultures, un enrichissement de l’air en CO2 est pratiqué afin d’augmenter
les rendements de production.
4. Les plantes aromatiques et médicinales :

Les plantes aromatiques sont un ensemble de plantes utilisées en cuisine et en
phytothérapie pour les arômes qu'elles dégagent, et leurs huiles essentielles que l'on peut extraire.
8
Chapitre I
Ces plantes aromatiques sont cultivées selon les besoins pour leurs feuilles, tiges, bulbes, racines,
graines, fleurs, écorce, etc.
Par exemple : la menthe, la citronnelle, la coriandre, l’origan …
Le Maroc bénéficie d'un bioclimat permettant une végétation riche et diverse. Plus de 4 000
espèces et sous espèces y ont été répertoriées, dont une centaine endémique.
Les PAM ont de nombreuses utilisations (condiment, pharmacopée traditionnelle, industries
pharmaceutiques, cosmétiques et alimentaires, etc.).
L’analyse économique montre que les quantités exportées sont en moyenne de 6.805 tonnes
d'huiles essentielles et d'extraits divers, pour une valeur de 198 millions de DH.
Le type de serre le plus utiliser pour cette culture est les serres en verre à cause de possibilité
d’aménagement ainsi que sa taille qui lui permet de s’intégrer dans les petits jardins des maisons.
Il est conseillé de cultiver ses PAM en pot car toutes les plantes ne demandent pas le même
volume de soleil, d’arrosage
L’éclairage nécessaire :
Éclairer une plante 24 heures sur 24 ne la fera ni grandir plus vite, ni n'augmentera sa vigueur.
Une période de nuit est absolument nécessaire pour que la plante puisse réaliser son cycle circadien
et suivre des processus importants pour son développement
III. Description du prototype :

Le prototype est réalisé l’année dernier comme un projet d’expertise sous le titre « Etude,
conception et réalisation d’un prototype de serre agricole utilisant un protocole de
communication sans fil », et par la suite de projet on va donner une description de prototype.
1. Schéma synoptique :
9
Chapitre I
Figure 4:schéma synoptique
On constate que le prototype contient 7 blocs majores [Annexe1], et elles sont les suivants :
▪ Bloc de contrôle : le prototype est programmé à la base une carte Arduino Mega, et
le choix vient à l’aide d’une matrice de criticité.
▪ Bloc de régulation de la température : à l’aide d’un capteur DHT22 et tapis
chauffant avec ventilateur comme des actionneurs.
▪ Bloc de régulation de l’humidité : à l’aide d’un capteur DHT22 et humidificateur
avec extracteur comme des actionneurs.
10
Chapitre I
▪ Bloc de régulation de la quantité de CO2 : à l’aide d’un capteur MQ135 et vérin

avec moteur comme des actionneurs.
▪ Bloc de régulation de la lumière : à l’aide d’un capteur DLR pour détecter la
présence du lumière et LED comme actionneur.
▪ Bloc de régulation de système d’arrosage : à l’aide d’un capteur YL-69 pour
détecter l’humidité de sol et une pompe comme actionneur.
2. Les améliorations du prototype au niveau des blocs :

a. Installer le tapis chauffant :
Pour réaliser cette tâche on utilise un relis qui joue le rôle d’un interrupteur (ouverture et
fermeture du circuit électrique), en fonction de la valeur détecte au niveau de capteur DHT22.
Figure 5: tapis chauffant
Figure 6: code de tapis pour une seul de 25 c
11
Chapitre I
Figure 7: Installation du tapis
b. Ajouter un afficheur LCD 20*4 :
L’afficheur LCD 20*4 à 16 broches
Figure 8: LCD 20*4
Le brochage d’un écran LCD HD44780 standard est indiqué dans le tableau ci-dessous :
12
Chapitre I
Tableau 1 : tableau de brochage
Après avoir câblé l’écran LCD, vous devrez régler le contraste de l’écran. Cela se fait en
tournant le potentiomètre de 5 kΩ dans le sens horaire ou antihoraire.
Branchez le connecteur USB de l’Arduino pour alimenter l’écran LCD. Vous devriez voir le
rétroéclairage s’allumer. Tournez maintenant le potentiomètre jusqu’à ce qu’une (16 × 2 LCD) ou 2
rangées (20 × 4 LCD) de rectangles apparaissent.
Figure 9: LCD avec potentiomètre
Pour contrôler l’écran LCD et afficher les caractères, vous devrez ajouter quelques connexions
supplémentaires. Vérifiez le schéma de câblage ci-dessous et le tableau de brochage
13
Chapitre I
Figure 10: montage de LCD avec Arduino
Une fois que vous avez tout câblé, nous pouvons commencer à programmer l’écran LCD.
L’exemple de code ci-dessous vous montre comment afficher les paramètres climatiques (cad la
température, l’humidité et la quantité de CO2 à l’intérieur de la serre) sur l’écran LCD :
Figure 11: code Arduino pour l'afficheur LCD
14
Chapitre I
Alors, on obtient le résultat suivant :
Figure 12: Circuit Figure 13: les paramètres climatiques sur l'afficheur
c. Ajouter l’humidificateur :
Pour lier un humidificateur à un Arduino, vous pouvez suivre les étapes suivantes :
Sélectionnez un capteur d’humidité : Vous pouvez utiliser un capteur d'humidité tel que le
DHT11 ou le DHT22 qui permettent de mesurer à la fois la température et l'humidité relative de
l'air.
Connectez le capteur à l’Arduino : Pour connecter le capteur à l'Arduino, vous pouvez utiliser
une breadboard et quelques fils de connexion. La plupart des capteurs d'humidité ont 3 broches,
dont 2 pour l'alimentation (VCC et GND) et 1 pour la lecture des données. Vous pouvez connecter
la broche de données du capteur à une broche d'entrée de l'Arduino.
Installez la bibliothèque du capteur : Pour lire les données du capteur, vous devrez installer la
bibliothèque correspondante. Pour les capteurs DHT11 et DHT22, vous pouvez utiliser la
bibliothèque Adafruit_DHT qui peut être téléchargée à partir du gestionnaire de bibliothèques
d'Arduino.
Écrire le code : Vous pouvez écrire un code pour lire les données du capteur et activer ou
désactiver l'humidificateur en fonction des données lues. Par exemple, vous pouvez définir un seuil
d'humidité cible, et si l'humidité mesurée est inférieure à ce seuil, vous pouvez activer
15
Chapitre I
l'humidificateur en envoyant un signal à une broche de sortie de l'Arduino. Si l'humidité est

suffisante, vous pouvez désactiver l'humidificateur.
Connectez l’humidificateur : Vous pouvez connecter l'humidificateur à l'Arduino en utilisant une

broche de sortie. Si l'humidificateur nécessite une tension plus élevée que celle fournie par
l'Arduino, vous pouvez utiliser un relais ou un transistor pour contrôler l'alimentation de
l'humidificateur.
Testez le système : Vous pouvez téléverser le code sur l'Arduino et tester le système en mesurant
l'humidité ambiante et en vérifiant si l'humidificateur s'active ou se désactive correctement en
fonction des données lues.
Alors, pour notre travail, on obtient le résultat suivant :
Figure 14: Code de l’humidificateur avec Arduino
16
Chapitre I
Figure 15: la réalisation du circuit
IV. La Supervision de la serre agricole à l’aide de NODE RED :

1. Le programme sur NODE RED :
Premièrement, on a programmé d’une façon de recevoir les données des capteurs et actionneurs
de la serre agricole envoyées directement par la carte Arduino Mega via un câble USB à travers le
port 6 (le port varie en fonction de la machine), puis on a programmé pour créer un tableau de bord
pour la supervision de ces données [Annexe2]:
Figure 16 : le programme sur NODE RED pour l’acquisition des données de la serre agricole et la création d’un tableau de
bord
17
Chapitre I
2. Le tableau de bord sur NODE RED :

Après notre programme, on voit ce tableau de bord sur NODE RED pour la supervision des
données concernant la serre agricole qui représentent : la température, l’humidité, l’état du
ventilateur 1 lié à la température, l’état du ventilateur 2 lié à l’humidité, l’humidité de sol, l’état de
la pompe d’irrigation, la luminosité, l’état de LED, la qualité de l’air et l’état du tapis chauffant
[Annexe2].
Figure 17 : Tableau de bord sur NODE RED pour la supervision de la serre agricole
V. La supervision à distance de la serre agricole :

1. Création du serveur OPC UA sur NODE RED :
On a choisi OPC UA comme protocole de communication pour envoyer les données vers le
cloud afin de nous permettre de superviser ces données en temps réel à partir de n’importe quelle
place dans le monde, il ne suffit que de connecter notre client OPC UA au serveur OPC UA pour
recevoir ces données.
Tout d’abord, on a programmé le programme ci-dessous sur NODE RED dans le but de créer un
serveur OPC UA qui permet de migrer les données acquis à partir de notre serre agricole vers le
cloud [Annexe2] :
18
Chapitre I
Figure 18 : Le programme sur NODE RED pour créer le serveur OPC UA et migrer les données de la serre agricole vers le
cloud
Le programme dans le nœud « add folder » sert à créer un fichier qui va rassembler toutes les
données qu’on veut envoyer :
Figure 19 : le programme dans le nœud « add folder »
19
Chapitre I
Figure 20 : le programme dans le nœud « SET Temperature »
Et pour le nœud « variable : Temperature », il permet de créer une variable dans le fichier
crée déjà dans le serveur qui représente dans ce cas la variable de la température
(identiquement pour les autres données) :
Figure 21 : le programme dans le nœud « variable : Temperature »
2. Visualisation des données dans Prosys OPC UA Browser :

On a visualisé les données à partir d’un client situé à distance de la serre agricole, et on a choisi
le logiciel Prosys OPC UA Browser comme client, et il existe normalement plusieurs clients OPC
20
Chapitre I
UA qu’on peut utiliser, alors qu’on reposé sur ce choix grâce à sa simplicité et sa facilité
d’utilisation.
On peut observer dans l’interface de Prosys après connection à notre serveur OPC UA créé dans
NODE RED le fichier qu’on l’a nommé « Variables » en contenant les variables qu’on a envoyé de
NODE RED, ces variables représentent nos données de la serre agricole qu’on pourra facilement
superviser ces valeurs à distance via ce logiciel :
Figure 22 : Visualisation des données à partir du client Prosys OPC UA Browser
21
Chapitre I
Conclusion :
En conclusion, le projet de conception et réalisation d'un prototype de serre agricole

intelligente utilisant un protocole de communication sans fil a été amélioré grâce à
l'intégration de nouveaux capteurs et actionneurs. Ces améliorations ont permis d'optimiser
les fonctionnalités du prototype initial, en augmentant sa précision et sa fiabilité. Les
résultats obtenus sont prometteurs pour l'avenir de l'agriculture intelligente et durable, en
offrant des solutions innovantes pour l'optimisation de la production agricole tout en
réduisant les coûts et l'impact environnemental. En conclusion, ce projet de conception et
réalisation d'un prototype de serre agricole intelligente utilisant un protocole de
communication sans fil a été amélioré grâce à l'intégration de nouveaux capteurs et
actionneurs. Ces améliorations ont permis d'optimiser les fonctionnalités du prototype
initial, en augmentant sa précision et sa fiabilité. Les résultats obtenus sont prometteurs
pour l'avenir de l'agriculture intelligente et durable, en offrant des solutions innovantes
pour l'optimisation de la production agricole tout en réduisant les coûts et l'impact
environnemental.
Ces améliorations ont été rendues possibles grâce à l'utilisation de capteurs et

d'actionneurs plus avancés, qui ont permis une meilleure collecte et une meilleure
interprétation des données. En somme, le prototype amélioré offre un environnement de
culture plus contrôlé et plus efficace, ce qui peut conduire à une production agricole plus
abondante et plus saine.
22
Chapitre Ⅱ : Etude de l’intégration de
Machine Learning pour l’optimisation
de contrôle de la serre agricole
23
Chapitre II
Introduction :
Le chapitre présent porte sur l'étude de l'intégration de l'apprentissage automatique (Machine

Learning) pour l'optimisation du contrôle de la serre agricole. L'objectif de cette étude est
d'examiner comment l'utilisation de techniques d'apprentissage automatique peut aider à améliorer
l'efficacité du contrôle de la serre agricole en optimisant les processus de régulation des paramètres
environnementaux tels que la température, l'humidité et l'éclairage. Cette étude explore les
avantages et les limites de l'intégration de l'apprentissage automatique dans le contexte de la serre
agricole et examine les approches les plus appropriées pour la collecte de données, le prétraitement,
la modélisation et l'implémentation des algorithmes d'apprentissage automatique.
I. Définition de Machine Learning :
Le Machine Learning ou apprentissage automatique est un domaine scientifique, et plus

particulièrement une sous-catégorie de l’intelligence artificielle. Elle consiste à laisser des
algorithmes découvrir des « patterns », à savoir des motifs récurrents, dans les ensembles de
données. Ces données peuvent être des chiffres, des mots, des images, des statistiques…
Tout ce qui peut être stocké numériquement peut servir de données pour le Machine Learning.
En décelant les patterns dans ces données, les algorithmes apprennent et améliorent leurs
performances dans l’exécution d’une tâche spécifique.
Pour résumer, les algorithmes de Machine Learning apprennent de manière autonome à effectuer
une tâche ou à réaliser des prédictions à partir de données et améliorent leurs performances au fil du
temps. Une fois entraîné, l’algorithme pourra retrouver les patterns dans de nouvelles données.
24
Chapitre II
Figure 23: Représentation visuelle de la relation entre les domaines relatifs aux données
II. Le fonctionnement de Machine Learning :
Le développement d’un modèle de Machine Learning repose sur quatre étapes principales :
➢ La première étape consiste à sélectionner et à préparer un ensemble de données
d’entraînement. Ces données seront utilisées pour nourrir le modèle de Machine
Learning pour apprendre à résoudre le problème pour lequel il est conçu.
Les données peuvent être étiquetées, afin d’indiquer au modèle les caractéristiques
qu’il devra identifier. Elles peuvent aussi être non étiquetées, et le modèle devra repérer
et extraire les caractéristiques récurrentes de lui-même.
Dans les deux cas, les données doivent être soigneusement préparées, organisées et
nettoyées. Dans le cas contraire, l’entraînement du modèle de Machine Learning risque
d’être biaisé. Les résultats de ses futures prédictions seront directement impactés.
➢ La deuxième étape consiste à sélectionner un algorithme à exécuter sur l’ensemble

de données d’entraînement. Le type d’algorithme à utiliser dépend du type et du
volume de données d’entraînement et du type de problème à résoudre.
➢ La troisième étape est l’entraînement de l’algorithme. Il s’agit d’un processus

itératif. Des variables sont exécutées à travers l’algorithme, et les résultats sont
25
Chapitre II
comparés avec ceux qu’il aurait dû produire. Les « poids » et le biais peuvent
ensuite être ajustés pour accroître la précision du résultat.
On exécute ensuite de nouveau les variables jusqu’à ce que l’algorithme produise le

résultat correct la plupart du temps. L’algorithme, ainsi entraîné, est le modèle de
Machine Learning.
➢ La quatrième et dernière étape est l’utilisation et l’amélioration du modèle. On

utilise le modèle sur de nouvelles données, dont la provenance dépend du problème
à résoudre. Par exemple, un modèle de Machine Learning conçu pour détecter les
spams sera utilisé sur des emails.
De son côté, le modèle de Machine Learning d’un aspirateur robot ingère des données
résultant de l’interaction avec le monde réel comme le déplacement de meubles ou l’ajout
de nouveaux objets dans la pièce. L’efficacité et la précision peuvent également
s’accroître au fil du temps.
III. Les principaux algorithmes de Machine Learning :
Il existe une large variété d’algorithmes de Machine Learning. Certains sont toutefois plus
couramment utilisés que d’autres. Tout d’abord, différents algorithmes sont utilisés pour les
données étiquetées.
Les algorithmes de régression, linéaire ou logistique, permettent de comprendre les relations
entre les données. La régression linéaire est utilisée pour prédire la valeur d’une variable
dépendante base sur la valeur d’une variable indépendante. Il s’agirait par exemple de prédire les
ventes annuelles d’un commercial en fonction de son niveau d’études ou de son expérience.
26
Chapitre II
Figure 24: Droite de régression linéaire
La régression logistique est quant à elle utilisée quand les variables dépendantes sont binaires.
Figure 25: Exemple de régression logistique
27
Chapitre II
Un autre type d’algorithme de régression appelé machine à vecteur de support (Support

Vector Machine) est pertinent quand les variables dépendantes sont plus difficiles à classifier.
Figure 26 : Régression logistique versus Machine à vecteur de support (SVM)
Un autre algorithme ML populaire est l’arbre de décision. Cet algorithme permet d’établir des
recommandations basées sur un ensemble de règles de décisions en se basant sur des données
classifiées. Par exemple, il est possible de recommander sur quelle équipe de football parier en se
basant sur des données telles que l’âge des joueurs ou le pourcentage de victoire de l’équipe.
Figure 27 : : Exemple d’un arbre de régression
28
Chapitre II
Figure 28 : Exemple d’un arbre de classification
Pour les données non étiquetées, on utilise souvent les algorithmes de « clustering ». Cette
méthode consiste à identifier les groupes présentant des enregistrements similaires et à étiqueter ces
enregistrements en fonction du groupe auquel ils appartiennent.
Figure 29: Exemple de K-NN clustering utilisé pour prédire la classe d’un nouveau point de données
29
Chapitre II
Auparavant, les groupes et leurs caractéristiques sont inconnus. Parmi les algorithmes de
clustering, on compte les K-moyennes, le TwoStep ou encore le Kohonen.
Figure 30: Comparaison entre les données originales et les données classifiées en utilisant K-moyennes
Les algorithmes d’association permettent quant à eux de découvrir des patterns et des relations
dans les données, et à identifier les relations selon des règles appelées règles d’association. Ces
règles sont similaires à celles utilisées dans le domaine du Data Mining ou forage de données.
Ensuite, les réseaux de neurones sont des algorithmes se présentant sous la forme d’un réseau à
plusieurs couches. La première couche permet l’ingestion des données, une ou plusieurs couches
cachées tirent des conclusions à partir des données ingérées, et la dernière couche assigne une
probabilité à chaque conclusion.
Figure 31 : Anatomie d’un neurone humain
30
Chapitre II
Un réseau de neurones profond est composé de multiples couches cachées permettant

chacune de raffiner les résultats de la précédente. On l’utilise dans le domaine du Deep Learning.
Figure 32 : Les trois générales couches d’un réseau de neurones
Figure 33: La reconnaissance faciale en utilisant les réseaux de neurones (Deep Learning)
31
Chapitre II
Enfin, Ensemble Modeling, l'une des méthodologies d'apprentissage automatique les plus
efficaces, modélisation d’ensemble, également appelés ensemble. La modélisation d'ensemble
combine des statistiques techniques pour créer un modèle qui produit une prédiction unifiée. C'est
en combinant des estimations et suivant la sagesse de la foule, la modélisation d’ensemble effectue
une classification finale ou un résultat avec une meilleure prédiction de performance.
Naturellement, les modèles d'ensemble sont un choix populaire lorsqu'il s'agit à des concours
d'apprentissage automatique comme le concours Netflix et les compétitions de Kaggle.
Les modèles d'ensemble peuvent être classés en différentes catégories, notamment séquentielle,
parallèle, homogène et hétérogène. Commençons par le premier en examinant les modèles
séquentiels et parallèles.
Pour les modèles d'ensembles séquentiels, l'erreur de prédiction est réduite en ajoutant des poids
aux classificateurs de données mal classées. Gradient boosting et AdaBoost sont deux exemples
de modèles séquentiels.
Inversement, les modèles d'ensembles parallèles fonctionnent simultanément et réduisent
l’erreur en faisant la moyenne. Les arbres de décision en sont un exemple technique.
Les modèles d'ensemble peuvent également être générés à l'aide d'une seule technique avec de
nombreuses variations (appelées ensemble homogène) ou par différentes techniques (appelé
ensemble hétérogène). Un exemple d'un modèle d'ensemble homogène serait de nombreux arbres de
décision fonctionnant ensemble pour former une prédiction unique (bagging).
En attendant, un exemple d’ensemble hétérogène serait l'utilisation du clustering k-moyennes ou
d'un réseau de neurones en collaboration avec un modèle d'arbre de décision.
Naturellement, il est important de sélectionner des techniques qui se complètent.
Les réseaux de neurones, par exemple, nécessitent des données complètes pour l'analyse, alors
que les arbres de décision peuvent gérer efficacement les valeurs manquantes. Ensemble, ces deux
techniques apportent une valeur ajoutée par rapport à un modèle homogène. Le réseau de neurones
prédit avec précision la majorité des instances qui fournissent une valeur et l'arbre de décision
garantit qu'il n'y a pas de résultats "nuls" qui, autrement, être encourus à partir de valeurs
manquantes dans un réseau de neurones.
L'autre avantage de la modélisation d'ensemble est que les estimations agrégées sont
généralement plus précises que toute estimation unique.
Il existe différentes sous-catégories de modélisation d’ensemble ; nous avons déjà abordé deux
d'entre eux dans le chapitre précédent. Quatre sous-catégories populaires de la modélisation
d'ensemble sont le Bagging, le Boosting, un seau de modèles et Stacking.
Bagging, comme nous le savons, est l'abréviation de "boosted aggregating" est un exemple d'un
ensemble homogène. Cette méthode s'appuie sur des tirages aléatoires des ensembles de données et
combine des prédictions pour concevoir un modèle unifié basé sur un processus de vote parmi les
32
Chapitre II
données de formation. Exprimé d'une autre manière, Bagging est un processus spécial de calcul de
la moyenne du modèle. La forêt aléatoire (Random Forest), on le sait, est un exemple populaire de
Bagging.
Le Boosting est une technique alternative populaire qui traite les erreurs et les données mal
classées par l'itération précédente pour former un modèle final. Gradient boosting et AdaBoost sont
deux exemples populaires de boosting.
Un seau de modèles forme de nombreux modèles algorithmiques différents en utilisant les
mêmes données d'entraînement, puis sélectionne celle qui a fonctionné le plus précisément sur les
données d'essai.
Le Stacking exécute plusieurs modèles simultanément sur les données et combine ces résultats
pour produire un modèle final. Cette technique est actuellement très populaire dans les compétitions
d'apprentissage automatique, y compris le prix Netflix. (Détenu entre 2006 et 2009, Netflix a offert
un prix pour un modèle d'apprentissage automatique qui pourraient améliorer leur système de
recommandation afin de produire plus de recommandations de films efficaces. L'une des techniques
gagnantes a adopté une forme d'empilement linéaire qui combine les prédictions de plusieurs
prédictions des modèles.)
Bien que les modèles d'ensemble produisent généralement des prédictions plus précises,
l'inconvénient de cette méthodologie est, en fait, le niveau de sophistication.
Les ensembles sont confrontés au même compromis entre précision et simplicité qu'un arbre de
décision unique par rapport à une forêt aléatoire. La transparence et la simplicité d'une technique
simple, comme un arbre de décision ou les k plus proches voisins (K-NN), est perdue et muté
instantanément en une boîte noire statistique.
La performance du modèle gagnera dans la plupart des cas, mais la transparence de notre modèle
est un autre facteur à considérer lors de la détermination de notre méthodologie préférée.
IV. Les différents types de Machine Learning :
On distingue trois techniques de Machine Learning : l’apprentissage supervisé, l’apprentissage

non-supervisé, et l’apprentissage par renforcement.
L’apprentissage supervisé : le plus courant, les données sont étiquetées afin
d’indiquer à la machine quelles patterns elle doit rechercher.
Le système s’entraîne sur un ensemble de données étiquetées, avec les informations

qu’il est censé déterminer. Les données peuvent même être déjà classifiées de la manière
dont le système est supposé le faire.
33
Chapitre II
Cette méthode nécessite moins de données d’entraînement que les autres, et facilite le
processus d’entraînement puisque les résultats du modèle peuvent être comparés avec les
données déjà étiquetées. Cependant, l’étiquetage des données peut se révéler onéreux.
Un modèle peut aussi être biaisé à cause des données d’entraînement, ce qui impactera
ses performances par la suite lors du traitement de nouvelles données.
L’apprentissage non supervisé : les données n’ont pas d’étiquettes. La machine se

contente d’explorer les données à la recherche d’éventuelles patterns. Elle ingère de
vastes quantités de données, et utilise des algorithmes pour en extraire des
caractéristiques pertinentes requises pour étiqueter, trier et classifier les données en
temps réel sans intervention humaine.
Plutôt que d’automatiser les décisions et les prédictions, cette approche

permet d’identifier les patterns et les relations que les humains risquent de ne pas
identifier dans les données.
Cette technique n’est pas très populaire, car moins simple à appliquer. Elle est
toutefois de plus en plus populaire dans le domaine de la cybersécurité.
L’apprentissage semi-supervisé : se situe entre les deux et offre un compromis

entre apprentissage supervisé et non-supervisé. Pendant l’entraînement, un
ensemble de données étiqueté de moindre envergure est utilisé pour guider la
classification et l’extraction de caractéristiques à partir d’un ensemble plus large de
données non étiquetées.
Cette approche s’avère utile dans les situations où le nombre de données étiquetées
est insuffisant pour l’entraînement d’un algorithme supervisé. Elle permet de contourner
le problème.
L’apprentissage par renforcement : consiste à laisser un algorithme apprendre de

ses erreurs pour atteindre un objectif. L’algorithme essayera de nombreuses
approches différentes pour tenter d’atteindre son but.
En fonction de ses performances, il sera récompensé ou pénalisé pour l’inciter à

poursuivre dans une voie ou à changer d’approche. Cette technique est notamment
utilisée pour permettre à une IA de surpasser les humains dans les jeux.
Par exemple, AlphaGo de Google a battu le champion de Go grâce à l’apprentissage

par renforcement. De même, OpenAI a entraîné une IA capable de vaincre les meilleurs
joueurs du jeu vidéo Dota 2.
34
Chapitre II
V. Application de Machine Learning :
❖ Construire un modèle de Machine Learning en PYTHON :

On a utilisé l’apprentissage supervisé dans notre application pour construire le modèle de
Machine Learning à l’aide de langage de programmation PYTHON avec les étapes suivantes :
1. Configurer l'environnement de développement :

La première étape consiste à préparer l’environnement de développement. On a utilisé
l’application Jupyter Notebook, qui est un environnement de programmation interactif basé sur le
Web permettant de créer des documents Jupyter Notebook. Le terme "notebook" peut faire
référence à de nombreuses entités différentes, adaptées au contexte, telles que l'application web
Jupyter, le serveur web Jupyter Python ou le format de document Jupyter.
On installe Jupyter Notebook à partir de : http://jupyter.org/install.html
On trouve deux options pour installer Jupyter Notebook, soit à l'aide de la distribution Anaconda
ou avec le gestionnaire de paquets de Python, pip.
Pour notre cas, on a utilisé la distribution Anaconda :
Figure 34: l’interface de Anaconda Navigator
Pour lancer Jupyter Notebook, on exécute la commande suivante à partir de l’Invite de

commandes (pour Windows): jupyter notebook
35
Chapitre II
Figure 35: la commande jupyter notebook sur l’invite de commandes
L’invite de commande générera alors une URL qu’on pourra copier et coller dans le navigateur
Web : http://localhost:8889/tree
On Copie et on colle l'URL générée dans notre navigateur Web pour charger Jupyter Notebook :
Figure 36 : l’interface de Jupyter Notebook
Une fois que Jupyter Notebook est ouvert dans le navigateur, on clique sur "New" dans le coin
supérieur droit de l'application Web pour créer un nouveau projet, puis on sélectionne "Python 3".
36
Chapitre II
Figure 37: l’interface de programmation en python sur Jupyter Notebook
La dernière étape consiste à installer les bibliothèques nécessaires. On devra installer Pandas et
un certain nombre de bibliothèques à partir de Scikit-learn dans le bloc-notes.
En apprentissage automatique, chaque projet variera en fonction des bibliothèques requises pour
l'importation. Pour notre cas, nous utilisons le gradient boosting (ensemble modeling) et mean
absolute error pour mesurer la performance.
On a importé chacune des bibliothèques et fonctions suivantes en entrant ces commandes exactes
dans Jupyter Notebook :
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn import ensemble
from sklearn.metrics import mean_absolute_error
import joblib
Figure 38 : Importation des bibliothèques et des fonctions sur Jupyter Notebook
37
Chapitre II
2. Importer les données :

L'étape suivante consiste à importer les données. A cause de la manque des données, on a
sélectionné un ensemble de données accessible au public de kaggle.com qui contient les paramètres
climatiques d’une serre agricole : « GreenhouseClimate ».
L'ensemble de données contient des données sur le climat des serres extérieures et intérieures,
l'irrigation, l'état des actionneurs, les points de consigne climatiques demandés et réalisés «
GreenhouseClimate ».
Les 5 compartiments de la serre ont une surface totale de 96 m² et une surface de culture de 62,5
m².
La description de l’ensemble des paramètres peut être résumé dans le tableau ci-dessous :
38
Chapitre II
39
Chapitre II
Tableau 2
Tableau 3 : Un tableau descriptif des paramètres climatiques dans la serre agricole inclus dans les données
Pour importer les données « GreenhouseClimate » sous format csv, on utilise la fonction
read_csv pour charger les données dans une dataframe Pandas :
df = pd.read_csv('~\\Downloads\\GreenhouseClimate.csv')
40
Chapitre II
Figure 39: Importation des données sous format CSV dans jupyter notebook
Cette commande importera directement les données. Toutefois, à noter que le chemin exact du
fichier dépendra de l'emplacement enregistré des données.
Par exemple, si on a enregistré le fichier CSV sur notre bureau, on doit lire dans le fichier .csv à
l'aide de la commande suivante :
df = pd.read_csv('~\\Desktop\\GreenhouseClimate.csv')
Ensuite, pour prévisualiser la trame de données dans Jupyter Notebook, on entre la commande
suivante, avec "n" représentant le nombre de lignes qu’on souhaite prévisualiser par rapport à la
ligne de tête :
df.head(n=5)
41
Chapitre II
Figure 40: la commande pour prévisualiser des lignes dans jupyter notebook
NB : on importe aussi un autre type de données à cause de la manque des données suffisantes
concernant la serre agricole, pour qu’on pourra par la suite continuer à appliquer la démarche.
On sélectionne un ensemble de données accessible au public de kaggle.com qui contient la
maison, l'unité, et les prix des maisons en rangée à Melbourne, en Australie. Ce jeu de données
comprend des données extrait des listes accessibles au public publiées chaque semaine sur
www.domaine.com.au. L'ensemble de données contient 14 242 listes de propriétés et 21 variables
comprenant l'adresse, la banlieue, la taille du terrain, le nombre de pièces, le prix, longitude,
latitude, code postal, etc.
Figure 41: Importation des données des maisons à Melbourne sous format CSV
42
Chapitre II
Figure 42: Tableau des données importées en Jupyter Notebook
3. Nettoyer les données :

L'étape suivante consiste à nettoyer l'ensemble de données. Le brossage est le processus d’affiner
l’ensemble de données. Il s'agit de modifier ou de supprimer des informations incomplètes, des
données non pertinentes ou dupliquées. Cela peut également impliquer la conversion de données
textuelles en des valeurs numériques et la refonte des caractéristiques.
On peut le faire en ouvrant le fichier CSV dans Microsoft Excel (ou programme équivalent), en
éditant le jeu de données, puis on le réenregistre à nouveau en tant que fichier CSV.
Bien que des simples erreurs puissent être corrigées dans le fichier source, les modifications
structurelles majeures apportées à l'ensemble de données telles que l'ingénierie des fonctionnalités
sont mieux effectuées dans l’environnement de développement pour plus de flexibilité et pour
préserver l'ensemble de données pour une utilisation ultérieure.
Par exemple, dans notre cas, nous allons implémenter l’ingénierie des fonctionnalités pour
supprimer un certain nombre de colonnes de l'ensemble de données, mais nous pouvons plus tard
changer d'avis sur les colonnes que nous souhaitons inclure.
Manipulation de la composition de l'ensemble de données dans l'environnement de
développement est moins permanente et généralement beaucoup plus simple et rapide que de le
faire directement dans le fichier source.
43
Chapitre II
- Processus de brossage :
On commence par supprimer les colonnes du tableau de données qu’on ne souhaite pas inclure
dans le modèle en utilisant la fonction del df[' '] et en saisissant le titre du colonne qu’on souhaite
supprimer :
del df['BlackScr']
del df['EC_drain_PC']
del df['EnScr']
del df['HumDef']
del df['PipeGrow']
del df['PipeLow']
del df[' t_rail_min_sp']
del df[' t_rail_min_vip']
del df[' water_sup_intervals_sp_min']
del df[' water_sup_intervals_vip_min']
del df[' window_pos_lee_sp']
del df[' window_pos_lee_vip']
del df[' scr_enrg_sp']
del df[' scr_enrg_vip']
del df[' t_grow_min_sp]
44
Chapitre II
Figure 43 : les commandes dans jupyter notebook pour supprimer les colonnes
Figure 44: le tableau des données après suppression des colonnes
NB : pour l’autre type de données (les maisons à Melbourne), en appliquant le processus de

brossage :
45
Chapitre II
Figure 45 : Les commandes pour supprimer les colonnes
Figure 46: le tableau des données des maisons à Melbourne après suppression des colonnes
L'étape suivante pour nettoyer l'ensemble de données consiste à supprimer toutes les valeurs
manquantes.
Bien qu'il existe de nombreuses méthodes pour gérer les valeurs manquantes (par ex : calculer la
moyenne, la médiane ou supprimer complètement les valeurs manquantes), pour notre cas, on va
supprimer complètement les valeurs manquantes dans les données.
Malheureusement, dans le cas de notre échantillon de données, nous avons beaucoup de valeurs
manquantes. Néanmoins, nous avons encore de nombreuses rangées disponibles pour procéder à la
construction de notre modèle.
La fonction Pandas suivante peut être utilisée pour supprimer les lignes qui contient des valeurs
manquantes :
df.dropna(axis=0, how='any', thresh=None, subset=None, inplace=True)
Figure 47: la fonction pour supprimer les valeurs manquantes dans le tableau de données
46
Chapitre II
NB : identiquement pour les données concernant les maisons à Melbourne, on aura comme
résultat le tableau suivant après suppression des valeurs manquantes :
Figure 48: Tableau des données après suppression des valeurs manquantes
Par la suite, à cause de la manque des données suffisantes concernant la serre agricole, on
continue à appliquer sur l’autre type de données qui concerne les prix des maisons à Melbourne
justement pour la démonstration :
Convertissons les colonnes qui contiennent des données non numériques (colonnes non
numériques) en valeurs numériques à l'aide d'un codage one-hot encoding. Avec Pandas, cet
encodage peut être effectué à l'aide de la fonction get_dummies :
features_dt = pd.get_dummies(dt, columns=['Suburb', 'CouncilArea', 'Type'])
Cette commande convertit les valeurs de colonne pour Suburb, CouncilArea et Type en valeurs
numériques grâce à l'application d'encodage.
Figure 49: La commande dans jupyter notebook pour convertir les données non numériques en valeurs numériques
47
Chapitre II
Figure 50: Tableau des données après conversion des colonnes non numériques en valeurs numériques
Ensuite, nous devons supprimer la colonne "Price" car cette colonne agira comme notre variable
dépendante (y) et pour l'instant nous n'examinons que les onze variables indépendantes (X) :
del features_dt['Price']
Figure 51: la commande de suppression de la colonne du prix ‘price’ et le tableau des données après sa suppression
48
Chapitre II
Enfin, on crée des tableaux X et y à partir du jeu de données en utilisant le type de données
matrice (np.array) après importation de la bibliothèque NumPy. Le tableau X contient les variables
indépendantes et le tableau y contient la variable dépendante du prix ‘price’ :
import numpy as np
X = np.matrix(features_dt)
y = np.matrix(dt['Price'])
Figure 52: Création des matrices pour X et y en utilisant la bibliothèque NumPy
4. Fractionner les données :

Nous sommes maintenant au stade de la division des données en segments d'entraînement et de
test.
Pour notre cas, nous procéderons à un partage standard 70/30 en appelant la Fonction Scikit-
learn ci-dessous avec un argument de « 0,3 », c-à-dire, on réserve 70% de données pour
l’entrainement et 30% pour le test. Les lignes de l'ensemble de données sont également mélangées
de manière aléatoire pour éviter les biais à l'aide de la fonction random_state.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
Figure 53: la fonction Scikit-learn pour fractionner en données d'entraînement et de test dans jupyter notebook
5. Sélectionner l'algorithme et configurer ses hyperparamètres :

Nous utilisons l'algorithme gradient boosting pour notre cas, comme indiqué :
model = ensemble.GradientBoostingRegressor(
n_estimators=150,
49
Chapitre II
learning_rate=0.1,
max_depth=30,
min_samples_split=4,
min_samples_leaf=6,
max_features=0.6,
loss='huber'
Figure 54: Le code dans jupyter notebook pour sélectionner l’algorithme Gradient Boosting et configurer ses hyperparamètres
La première ligne est l'algorithme (gradient boosting) et elle comprend juste une ligne de code.
Les lignes ci-dessous décrivent les hyperparamètres pour cet algorithme.
n_estimators : représente le nombre d'arbres de décision à construire. Notons qu'un nombre
élevé d'arbres améliorera généralement la précision (jusqu'à un certain point), mais cela augmentera
également le temps de traitement du modèle. Ci-dessus, on a sélectionné 150 arbres de décision
comme point de départ initial.
learning_rate : contrôle la vitesse à laquelle les arbres de décision supplémentaires influencent
la prédiction globale. Cela réduit efficacement la contribution de chaque arbre par le taux
d'apprentissage défini. L'insertion d'un taux faible ici, tel que 0,1, devrait améliorer la précision.
max_depth : définit le nombre maximum de couches (profondeur) pour chaque arbre de
décision. Si "None" (aucun) est sélectionné, les nœuds se développent jusqu'à ce que toutes les
feuilles soient pures ou jusqu'à ce que toutes les feuilles contiennent moins de min_samples_leaf.
Ici, on a sélectionné un haut nombre maximum de couches (30), ce qui aura un effet dramatique sur
le résultat final.
min_samples_split : définit le nombre minimum d'échantillons requis pour exécuter un nouveau
split binaire. Par exemple, min_samples_split = 10 signifie qu'il faut avoir dix échantillons
disponibles afin de créer une nouvelle branche.
min_samples_leaf : représente le nombre minimum d'échantillons qui doivent apparaitre dans
chaque nœud enfant (feuille) avant qu'une nouvelle branche puisse être implémentée.
50
Chapitre II
Cela permet d'atténuer l'impact des valeurs aberrantes et des anomalies sous la forme d'un faible
nombre d'échantillons trouvés dans une feuille à la suite d'une division binaire. Par exemple,
min_samples_leaf = 4 nécessite qu'il y ait au moins quatre échantillons disponibles dans chaque
feuille pour créer une nouvelle branche.
max_features : est le nombre total de fonctionnalités présentées au modèle lorsqu’on détermine
le meilleur partage (split). Les forêts aléatoires et gradient boosting limite le nombre total de
fonctionnalités affichées pour chaque arbre individuel pour créer plusieurs résultats qui peuvent être
votés plus tard. Si la valeur max_features est un entier (nombre entier), le modèle considère
max_features à chaque division (branche). Si la valeur est un flottant (par exemple 0,6), alors
max_features est le pourcentage du nombre total de fonctionnalités sélectionnées au hasard.
Bien que max_features définisse un nombre maximal de fonctionnalités à prendre en compte
pour identifier la meilleure répartition, le nombre total de fonctionnalités peut dépasser la limite
max_features si aucune scission ne peut initialement être effectuée.
loss : calcule le taux d'erreur du modèle. Pour notre cas, nous utilisons huber qui protège contre
les valeurs aberrantes et les anomalies. Des options alternatives de taux d'erreur (loss) peuvent
inclure ls (régression des moindres carrés), lad (écarts moins absolus) et quantile (régression
quantile). Huber est en fait une combinaison de ls et de lad.
Après avoir imputé les hyperparamètres du modèle, nous implémenterons la fonction

d'ajustement (fit) de Scikit learn pour démarrer le processus d’entrainement du modèle.
model.fit(X_train, y_train)
Figure 55: La fonction fit dans jupyter notebook pour entrainer le modèle
Enfin, nous devons utiliser Scikit-learn pour enregistrer le modèle d’entrainement sous forme de
fichier à l'aide de la fonction joblib.dump, qui a été importée dans Jupyter Notebook à l’étape 1.
Cela nous permettra de réutiliser le modèle d’entrainement à l'avenir afin de prédire pour des
nouvelles valeurs, sans avoir besoin de reconstruire le modèle à partir de zéro.
joblib.dump(model, 'house_trained_model.pkl')
Figure 56: La fonction de la bibliothèque joblib pour enregistrer le modèle d’entrainement
51
Chapitre II
6. Evaluer les résultats :

Nous utiliserons l'erreur absolue moyenne pour évaluer la précision du modèle.
mse = mean_absolute_error(y_train, model.predict(X_train))
print ("Training Set Mean Absolute Error: %.2f" % mse)
Figure 57: Code pour calculer l’erreur absolue moyenne pour les données d’entrainement puis écrire le résultat final
Ici, nous saisissons nos valeurs y, qui représentent les résultats corrects de l’ensemble de
données d’entrainement. La fonction model.predict est alors appelée sur X réservé pour
l’entrainement et elle générera une prédiction avec valeurs flottantes jusqu'à deux décimales. La
fonction d'erreur absolue moyenne comparera alors la différence entre les prédictions attendues et
les valeurs réelles.
Le même processus est répété avec les données d'essai :
mse = mean_absolute_error(y_test, model.predict(X_test))
print ("Test Set Mean Absolute Error: %.2f" % mse)
Figure 58: Code pour calculer l’erreur absolue moyenne pour les données de test puis écrire le résultat final
o Interprétation des résultats :

L'erreur absolue moyenne de notre ensemble d'entraînement est de 28 739,09 $ et l'erreur
absolue moyenne de l'ensemble de test est de 163 751,98 $. Cela signifie qu'en moyenne,
l’ensemble d’entrainement a mal calculé la valeur réelle de la propriété de seulement 28 739,09$.
Cependant, l'ensemble de test a mal calculé en moyenne 163 751,98 $. Cela signifie que notre
modèle entrainé était très précis pour prédire la valeur réelle des propriétés contenues dans les
données d'’entrainement. Alors que 28 739,09 $ peut sembler beaucoup d'argent, cette valeur
d'erreur absolue moyenne est faible compte tenu du maximum gamme de notre ensemble de
données qui atteint 8 millions de dollars. Comme de nombreuses propriétés de l'ensemble de
données sont au-delà de sept chiffres (1 000 000 $ et plus), 28 739,09 $ constitue un taux d'erreur
faible.
52
Chapitre II
Les données de test ont fourni des prédictions moins indicatives avec un taux d'erreur moyen de
163 751,98 $. Un écart important entre les données d’entrainement et de test est généralement un
indicateur clé du surapprentissage. Comme notre modèle est adapté aux données d'entraînement,
il est trébuché lors de la prédiction des données de test, qui contiennent probablement de
nouveaux patterns que le modèle n'a pas ajusté. Les données de test, bien sûr, sont susceptibles
de contenir de nouvelles valeurs aberrantes et anomalies potentielles.
Cependant, dans ce cas, la différence entre les données d'entraînement et de test est exacerbée
par le fait que nous avons configuré le modèle pour surajuster les données d’entrainement. Un
exemple de ce problème consistait à définir max_depth sur "30". Bien que la définition d'un
max_depth élevé améliore les chances que le modèle trouve des patterns dans les données
d'entraînement, cela a tendance à conduire à un surapprentissage. Une autre cause possible est la
mauvaise répartition des données d’entrainement et de test, mais pour ce modèle, les données ont
été randomisé au hasard à l'aide de Scikit-learn.
Enfin, il faut tenir compte du fait que les données d'entraînement et de test sont mélangés au
hasard, donc ces propres résultats différeront légèrement lors de la réplication de ce modèle sur
une autre machine.
❖ Optimisation du modèle :
Précédemment, on a construit notre modèle d'apprentissage supervisé. Maintenant, on veut

améliorer sa précision et réduire les effets de surajustement. On commence par modifier les
hyperparamètres du modèle.
Sans changer aucun autre hyperparamètre, commençons par modifier max_depth de "30" à "5".
Le modèle génère maintenant les résultats suivants :
Figure 59: L’erreur absolue moyenne des données d’entrainement après modification de max_depth
Bien que l'erreur absolue moyenne de l'ensemble d'entrainement soit plus élevée, cela aide à
réduire le problème de surajustement et devrait améliorer les résultats des données de test. Une
autre étape pour optimiser le modèle est d'ajouter plus d'arbres. Si nous fixons n_estimators à
250, on voit ce résultat :
53
Chapitre II
Figure 60: Les erreurs absolues moyennes des données d’entrainement et de test après modification de max_depth et
n_estimators
Cette deuxième optimisation réduit le taux d'erreur absolu de l'ensemble d'entrainement et nous
avons maintenant un plus petit écart entre les résultats d’entrainement et de test pour l'erreur
absolue moyenne.
Ensemble, ces deux optimisations soulignent l'importance de maximiser et comprendre l'impact
des hyperparamètres individuels. Si on décide de reproduire ce modèle d'apprentissage
automatique supervisé, il est recommandé de tester en modifiant chacun des hyperparamètres
individuellement et analyser leur impact sur l'erreur absolue moyenne. De plus, on remarquera
des changements dans le temps de traitement de la machine en fonction des hyperparamètres
sélectionnés.
Par exemple, définir max_depth sur "5" réduit le temps de traitement total par rapport à lorsqu'il
était réglé sur "30" car le nombre maximum de couches de branche est nettement moins. La
vitesse de traitement et les ressources deviendront un facteur important à considérer lorsqu’on
passe à travailler avec des ensembles de données plus volumineux.
Une autre technique d'optimisation importante est la sélection des fonctionnalités. Pour rappel,
nous avons supprimé neuf fonctionnalités lors du nettoyage de notre jeu de données. Maintenant
peut être un bon moment pour reconsidérer ces fonctionnalités et analyser si elles ont un effet sur
la précision globale du modèle. "SellerG" serait une intéressante caractéristique à ajouter au
modèle car la société immobilière vendant la propriété pourrait avoir un certain impact sur le
prix de vente final.
Alternativement, la suppression d'entités du modèle actuel peut réduire le temps de traitement
sans avoir d'effet significatif sur la précision - ou peut même améliorer la précision. Pour
sélectionner efficacement les fonctionnalités, il est préférable d'isoler les modifications et
analyser les résultats, plutôt que d'appliquer divers changements d'un coup.
Alors que les essais et les erreurs manuels peuvent être une technique efficace pour comprendre
l’impact de la sélection des variables et des hyperparamètres, il existe également des techniques
d'optimisation de modèle, telles que la recherche de grille grid search. Grid search permet de
lister une gamme de configurations qu’on souhaite tester pour chaque hyperparamètre, puis teste
méthodiquement chacun de ces possibles hyperparamètres. Un processus de vote automatisé a
lieu pour déterminer le modèle optimal. Comme le modèle doit tester chaque combinaison
possible d'hyperparamètres, grid search prend beaucoup de temps de traitement.
Un exemple de code pour la recherche de grille grid search est écrit en annexes [Annexe3].
54
Chapitre II
Conclusion :
En conclusion, l'étude de l'intégration de l'apprentissage automatique pour l'optimisation du

contrôle de la serre agricole offre des avantages potentiels pour les agriculteurs en améliorant
l'efficacité et en réduisant les coûts associés à la gestion de la serre. Cependant, cette approche
comporte également des défis tels que la collecte de données de qualité, la sélection et
l'entraînement des algorithmes d'apprentissage automatique, ainsi que la compréhension de leur
fonctionnement pour l'application pratique. Pour réussir, il est important de considérer les
particularités de chaque situation et d'adapter les approches d'apprentissage automatique en
conséquence. En fin de compte, l'intégration de l'apprentissage automatique dans la serre agricole
peut offrir des avantages significatifs pour les agriculteurs et contribuer à une agriculture plus
durable et efficace.
55
Conclusion générale
Conclusion générale :
Dans l'ensemble, l'étude de l'intégration de l'apprentissage automatique pour l'optimisation du

contrôle de la serre agricole offre des perspectives prometteuses pour l'amélioration de
l'efficacité et de la rentabilité de la gestion de la serre agricole. Les résultats de cette étude
montrent que l'utilisation de techniques d'apprentissage automatique peut aider à améliorer les
processus de régulation des paramètres environnementaux tels que la température, l'humidité et
l'éclairage, ce qui peut avoir un impact significatif sur les rendements des cultures et les coûts de
production.
Cependant, cette approche comporte des défis tels que la collecte et la qualité des données, la
sélection et l'entraînement des algorithmes d'apprentissage automatique, ainsi que la
compréhension de leur fonctionnement pour leur application pratique. Il est donc important de
prendre en compte les particularités de chaque situation et d'adapter les approches
d'apprentissage automatique en conséquence pour obtenir des résultats optimaux.
En fin de compte, l'intégration de l'apprentissage automatique dans la serre agricole peut offrir
des avantages significatifs pour les agriculteurs, en contribuant à une agriculture plus durable et
efficace. Les résultats de cette étude peuvent servir de base pour des recherches futures dans ce
domaine, en aidant à développer des approches plus efficaces pour la gestion de la serre agricole
à l'aide de l'apprentissage automatique.
56
Bibliographie et Webographie:
Book of: Machine Learning for Absolute Beginners

https://datascientest.com/machine-learning-tout-savoir
Références:
https://pmb.univ-saida.dz/butecopac/doc_num.php?explnum_id=203
https://agrimaroc.org/index.php/Actes_IAVH2/article/view/777/951 https://www.carbon-
info.org/effet-de-serre/
https://planet-terre.ens-lyon.fr/ressource/principes-effet-serre.xml https://www.fellah-
trade.com/fr/developpement-durable/plantes-medicinales http://igm.univ-
mlv.fr/~dr/XPOSE2004/smarmech/controle.html
http://bts2m.free.fr/TP_Labview/Lab1_Presentation.html
http://datasciencetoday.net/index.php/fr/machine-learning/102-categorie-fr-fr/203-comparaison-
des-protocoles-iot
Marie Renée Andreescu Pourquoi utiliser une serre ?

3-Les_protocoles_UDP_TCP.pdf
Serre-intélligente.pdf
Maroc Cultures sous Serres Agricole - Agricultural
Irrigation System(agriculturalsystem.net)
Serre intelligente et l’agriculture numérique au Maroc (maferme.ma)
ratsizafyIsmaelA_ESPA_MAST_18.pdf
Computer Networks Tutorial - Studytonight
Avec les objets connectés, le changement c'est maintenant ! - Conseils d'experts Fnac
Smart Greenhouse | 2019 Guide to best Sensors and Remote Automated
MonitoringSoftware (postscapes.com)
Mémoire.pdf
Mémoire de Magister BOUTERAA yakoub _2007_.pd
57
Annexe 1 :
Figure 61: Bloc de contrôle
Figure 62:Bloc d'affichage
58
Figure 63: Bloc de régulation de la température
Figure 64: Bloc de régulation de la quantité d'air
59
Figure 65: Bloc de régulation de l'humidité
Figure 66: Bloc de régulation de système d'arrosage
60
Figure 67: Bloc de régulation de la lumière
61
Annexe 2 :
Le programme dans l’Arduino :
#include "dht.h"
dht DHT ;
#define DHT22_PIN 5
int a;
float hum;
float tem;
int vent1 =3;
int vent2 =4;
int HUM = A0;
int X = 610;
int pomp=2;
int Tapi_Chauf = 6;
#define LDR A15

#define LED 9
#define humidifier 7
#define ON false
#define OFF true
int value;
const int aqsensor = A1;
void setup() {
Serial.begin(9600);
pinMode(vent1,OUTPUT);
pinMode(vent2,OUTPUT);
pinMode(HUM, INPUT);
pinMode(pomp,OUTPUT);
pinMode(LED, OUTPUT);
pinMode(LDR, INPUT);
pinMode (aqsensor,INPUT);
pinMode(humidifier, OUTPUT);
pinMode(Tapi_Chauf, OUTPUT);
digitalWrite(humidifier, OFF);}
void loop() {
a= DHT.read22(DHT22_PIN);
hum=DHT.humidity;
tem=DHT.temperature;
62
if(tem>=22)
{
digitalWrite(vent1,LOW);
digitalWrite(Tapi_Chauf,1);
Serial.println("alors la température est suppérieure à 22°C donc : arrêt du

ventilateur 1");
Serial.println("et la température est suppérieure à 22°C donc : arrêt du

tapis chauffant");
}
if (tem<22)
{
digitalWrite(vent1,HIGH);
digitalWrite(Tapi_Chauf,0);
Serial.println("alors la température est inférieure à 22°C donc : démarrage

du ventilateur 1");
Serial.println("et la température est inférieure à 22°C donc : démarrage du

tapis chauffant");
}
if(hum>=60)
{
digitalWrite(vent2,HIGH);
Serial.println("puisque l'humidité est suppérieure à 60% donc: démarrage du
ventilateur 2");
}
if (hum<60)
{
digitalWrite(vent2,LOW);
Serial.println("puisque l'humidité est inférieure à 60% donc: arrêt du
ventilateur 2");
}
// logic control of humidifier (relay pin is 7)

if (digitalRead(humidifier) == ON) {
if (hum>=60){
63
digitalWrite(humidifier, OFF);
}
}
else
{
if(hum<60){
digitalWrite(humidifier, ON);
}
}
Serial.print("Hum:");
Serial.print(hum);
Serial.print("% Temp:");
Serial.print(tem);
Serial.println("C");
int sensorValue = analogRead(HUM);

Serial.print("humiditéDuSol:");
Serial.print(sensorValue);
Serial.print(" : Etat ");
if(sensorValue < X){
Serial.print("Il est temps d'irrigation\n");
digitalWrite(pomp, HIGH);
Serial.println("début démarrage de la pompe ");
}
else{
Serial.print("Pas besoin d'irrigation\n");
digitalWrite(pomp, LOW);
Serial.println("début arrêt de la pompe ");
}
value = analogRead(LDR);
Serial.print("LED : ");
Serial.println(value);
// allume la LED
if (value<750) digitalWrite(LED, HIGH);
Serial.println("Led allumé");
// désactiver la LED
if (value>750) digitalWrite(LED, LOW);
64
Serial.println("Led éteint ");
//delay(1000);
int ppm = analogRead(aqsensor);

Serial.print("Air Quality: ");
//delay(1000);
Serial.println(ppm);
//delay(1000);
if (ppm > 800)
{Serial.println("so Elevé"); }
else
{ Serial.println("so Bien"); }
delay(2000);
}
Les détails des nœuds des programmes dans NODE RED :
Figure 68 : Configuration du nœud COM6
65
Figure 69 : le programme dans le nœud function
Figure 70 : Configuration du nœud filter
66
Figure 71 : Configuration du nœud Switch
Figure 72 : La suite de configuration du nœud Switch
67
Figure 73 : Configuration du nœud split 1
68
Figure 76: Configuration du nœud split 4
69
70
71
72
73
Figure 85 : Le programme dans le nœud Rendre la température une variable globale
Figure 86 : Le programme dans le nœud Rendre l’humidité une variable globale
74
Figure 87 : Configuration du nœud OPC UA server
Figure 88 : le programme dans le nœud SET Qualité_de_l’air
75
Figure 89 : le programme dans le nœud variable : Qualité_de_l’air
76
Annexe 3 :
Le code entier pour le modèle optimisé de Machine Learning:

# Importer les bibliothèques
import pandas as pd
import numpy as np
import joblib
# lire data de fichier CSV
dt = pd.read_csv('~\\Downloads\\Melbourne_housing_FULL.csv')
# supprimer les colonnes inutiles
del dt['Address']
del dt['Method']
del dt['SellerG']
del dt['Date']
del dt['Postcode']
del dt['Lattitude']
del dt['Longtitude']
del dt['Regionname']
del dt['Propertycount']
# supprimer des lignes avec valeurs manquantes
dt.dropna(axis=0, how='any', thresh=None, subset=None, inplace=True)
# Convertir les données non numériques en valeurs numériques
features_dt
77
# supprimer le prix (price)
# Créer les matrices X et y à partir des données
X = np.array(features_dt)
y = np.array(dt['Price'])
# diviser les données en test/train set (70/30 split)
# sélectionner et configurer l’algorithme
model = ensemble.GradientBoostingRegressor(
n_estimators=250,
learning_rate=0.1,
max_depth=5,
min_samples_split=4,
min_samples_leaf=6,
max_features=0.6,
loss='huber'
)
# entrainer le modèle avec les données d’entrainement
model.fit(X_train, y_train)
# enregistrer le modèle en un fichier
joblib.dump(model, 'trained_model.pkl')
# évaluer la précision du modèle
mse = mean_absolute_error(y_train, model.predict(X_train))
print ("Training Set Mean Absolute Error: %.2f" % mse)
mse = mean_absolute_error(y_test, model.predict(X_test))
print ("Test Set Mean Absolute Error: %.2f" % mse)
78
Le code entier pour le modèle optimisé de ML via Grid Search :
# Importer les bibliothèques et GridSearchCV
import pandas as pd
import joblib
import numpy as np
from sklearn.model_selection import GridSearchCV
# lire data de fichier CSV
dt = pd.read_csv('~\\Downloads\\Melbourne_housing_FULL.csv')
# supprimer les colonnes inutiles
del dt['Address']
del dt['Method']
del dt['SellerG']
del dt['Date']
del dt['Postcode']
del dt['Lattitude']
del dt['Longtitude']
del dt['Regionname']
del dt['Propertycount']
# supprimer des lignes avec valeurs manquantes
dt.dropna(axis=0, how='any', thresh=None, subset=None, inplace=True)
# Convertir les données non numériques en valeurs numériques
features_dt
# supprimer le prix (price)
79
# Créer les matrices X et y à partir des données
X = np.array(features_dt)
y = np.array(dt['Price'])
# diviser les données en test/train set (70/30 split)
# sélectionner l’algorithm
model = ensemble.GradientBoostingRegressor()
# insérer les configurations qu’on souhaite tester
param_grid = {
'n_estimators': [300, 600, 1000],
'max_depth': [7, 9, 11],
'min_samples_split': [3, 4, 5],
'min_samples_leaf': [5, 6, 7],
'learning_rate': [0.01, 0.02, 0.6, 0.7],
'max_features': [0.8, 0.9],
'loss': ['ls', 'lad', 'huber']
}
# Définir grid search. Exécuter avec quatre CPUs en parallèle si possible.
gs_cv = GridSearchCV(model, param_grid, n_jobs=4)
# exécuter grid search sur les données d’entrainement
gs_cv.fit(X_train, y_train)
# écrire les hyperparamèters optimals
print(gs_cv.best_params_)
# évaluer la précision du modèle
mse = mean_absolute_error(y_train, gs_cv.predict(X_train))
print("Training Set Mean Absolute Error: %.2f" % mse)
mse = mean_absolute_error(y_test, gs_cv.predict(X_test))
print("Test Set Mean Absolute Error: %.2f" % mse)
80

Rapport de Projet Expertise 2023

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

Rapport de Projet Expertise 2023

Transféré par

Droits d'auteur :

Formats disponibles

Study of the optimization control of agricultural greenhouse

climatic parameters by the integration of machine learning.

Génie Electromécanique : option Commande et Management Industriel

HEZZEM Brahim Mr. MKHIDA Abdelhak

Aux êtres les plus chers au monde, « A nos parents » :

DHT22: digital temperature and humidity sensor

Liste des tableaux :

Chapitre I : Généralités sur les serres

I. Les serres agricoles :

Figure 1:serre agricole traditionnel

3. Les paramètres les plus agissants sur la croissance de la culture sous

photo synthèse. Certains matériaux de couverture comme le verre, transparents au rayonnement de

Le besoin en eau des plantes est fortement lié au phénomène de l’évapotranspiration.

II. Les serres agricoles intelligentes :

Figure 2: Serre intelligente

2. Inconvénients des serres classiques et nécessité des serres

Figure 3:serre agricole liée a une interface de la supervision

3. Influence des paramètres climatiques :

4. Les plantes aromatiques et médicinales :

III. Description du prototype :

Figure 4:schéma synoptique

▪ Bloc de régulation de la quantité de CO2 : à l’aide d’un capteur MQ135 et vérin

2. Les améliorations du prototype au niveau des blocs :

Figure 5: tapis chauffant

Figure 6: code de tapis pour une seul de 25 c

Figure 7: Installation du tapis

b. Ajouter un afficheur LCD 20*4 :

L’afficheur LCD 20*4 à 16 broches

Figure 8: LCD 20*4

Tableau 1 : tableau de brochage

Figure 9: LCD avec potentiomètre

Figure 10: montage de LCD avec Arduino

Figure 11: code Arduino pour l'afficheur LCD

Alors, on obtient le résultat suivant :

l'humidificateur en envoyant un signal à une broche de sortie de l'Arduino. Si l'humidité est

Connectez l’humidificateur : Vous pouvez connecter l'humidificateur à l'Arduino en utilisant une

Figure 14: Code de l’humidificateur avec Arduino

Figure 15: la réalisation du circuit

IV. La Supervision de la serre agricole à l’aide de NODE RED :

2. Le tableau de bord sur NODE RED :

V. La supervision à distance de la serre agricole :

Figure 19 : le programme dans le nœud « add folder »

Figure 20 : le programme dans le nœud « SET Temperature »

Figure 21 : le programme dans le nœud « variable : Temperature »

2. Visualisation des données dans Prosys OPC UA Browser :

Figure 22 : Visualisation des données à partir du client Prosys OPC UA Browser

En conclusion, le projet de conception et réalisation d'un prototype de serre agricole

Ces améliorations ont été rendues possibles grâce à l'utilisation de capteurs et

Le chapitre présent porte sur l'étude de l'intégration de l'apprentissage automatique (Machine

I. Définition de Machine Learning :

Le Machine Learning ou apprentissage automatique est un domaine scientifique, et plus

II. Le fonctionnement de Machine Learning :

➢ La deuxième étape consiste à sélectionner un algorithme à exécuter sur l’ensemble

➢ La troisième étape est l’entraînement de l’algorithme. Il s’agit d’un processus

On exécute ensuite de nouveau les variables jusqu’à ce que l’algorithme produise le

➢ La quatrième et dernière étape est l’utilisation et l’amélioration du modèle. On

III. Les principaux algorithmes de Machine Learning :

Figure 24: Droite de régression linéaire

Figure 25: Exemple de régression logistique

Un autre type d’algorithme de régression appelé machine à vecteur de support (Support

Figure 26 : Régression logistique versus Machine à vecteur de support (SVM)

Figure 27 : : Exemple d’un arbre de régression

Figure 28 : Exemple d’un arbre de classification

Figure 31 : Anatomie d’un neurone humain