UNIVERSITÉ DE UNIVERSITY OF
YAOUNDÉ 1 YAOUNDÉ 1
FACULTÉ DES FACULTY OF
SCIENCES SCIENCE
DÉPARTEMENT DEPARTMENT OF
D’INFORMATIQUE COMPUTER SCIENCE
DOCUMENTATION DU DÉPLOIEMENT DU
MODÈLE
Prédiction de la température au Cameroun avec joblib
GROUPE 6
Apprentissage supervisé et non supervisé – INF372
NOMS ET MATRICULES DES MEMBRES DU GROUPE 6 :
Noms Matricules
Dongmo Kenfack Ousmel Douma 22Y1025
Dossivil Rivoire Vianey 22U2116
Kiari Embe Franck Alexis 16T2912
Ngah Abanda Steve Jordan 19M2348
Tapah Ngassa Claudia 20V2342
Teguia Yves 19M2389
Sous la supervision du Professeur Melatagia Paulin
27 juin 2025
Table des matières
1 Introduction 3
1.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Objectifs de la documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Technologies utilisées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 Préparation des données 4
2.1 Description des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Étapes de prétraitement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3 Explication du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3 Entraînement et sauvegarde du modèle 5
3.1 Configuration du modèle SVR . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.2 Processus d’entraînement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.3 Explication du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.4 Avantages de joblib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
4 Déploiement et prédiction 7
4.1 Chargement du modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4.2 Explication du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4.3 Validation des prédictions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
5 Intégration dans une API REST 9
5.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
5.2 Configuration de l’API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
5.3 Explication du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
5.4 Déploiement de l’API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
6 Considérations pratiques 11
6.1 Environnement d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6.2 Maintenance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6.3 Limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
7 Conclusion et perspectives 12
7.1 Synthèse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
7.2 Perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1
Résumé
Ce document fournit une documentation complète du processus de déploiement du
modèle SVR (Support Vector Regression) pour la prédiction des températures maximale
(tmax) et minimale (tmin) au Cameroun, utilisant la bibliothèque joblib pour la sérialisa-
tion. Il détaille chaque étape, depuis la préparation des données jusqu’à l’intégration dans
une API REST, en passant par l’entraînement, la sauvegarde, et les tests du modèle. Cette
documentation vise à servir de guide pour les développeurs et les utilisateurs souhaitant
reproduire ou maintenir le système de prédiction.
2
1 Introduction
1.1 Contexte
La prédiction météorologique est cruciale pour des secteurs comme l’agriculture, la gestion
des ressources hydriques, et la planification économique au Cameroun. Ce projet se concentre
sur le déploiement du modèle SVR, choisi pour sa robustesse dans la prédiction des températures
maximales (tmax) et minimales (tmin), avec des valeurs de R² de 0.84 et 0.82 respectivement,
comme démontré dans une analyse antérieure.
1.2 Objectifs de la documentation
Cette documentation vise à :
— Expliquer le processus complet de déploiement du modèle SVR.
— Fournir des instructions claires pour la préparation des données, l’entraînement, la sau-
vegarde, et l’utilisation du modèle.
— Décrire l’intégration du modèle dans une API REST pour un usage opérationnel.
— Offrir des recommandations pour la maintenance et l’amélioration du système.
1.3 Technologies utilisées
— Python : Langage de programmation principal.
— Scikit-learn : Bibliothèque pour l’entraînement du modèle SVR.
— Joblib : Outil pour la sérialisation et la désérialisation du modèle.
— FastAPI : Framework pour créer une API REST.
— Pandas et NumPy : Gestion et prétraitement des données.
3
2 Préparation des données
2.1 Description des données
Les données utilisées incluent des observations météorologiques historiques (températures,
précipitations, humidité, etc.) collectées au Cameroun. Les variables cibles sont :
— tmax : Température maximale quotidienne.
— tmin : Température minimale quotidienne.
Les caractéristiques (features) incluent des variables comme la pression atmosphérique, l’humi-
dité relative, et les données temporelles (jour, mois).
2.2 Étapes de prétraitement
Le prétraitement est essentiel pour garantir la compatibilité des données avec le modèle
SVR. Les étapes incluent :
1. Chargement des données : Les données sont lues à partir d’un fichier CSV (par
exemple, weather_data.csv).
2. Gestion des valeurs manquantes : Les valeurs manquantes sont imputées en utilisant
la moyenne des colonnes concernées.
3. Normalisation : Les caractéristiques numériques sont normalisées avec StandardScaler
pour centrer les données (moyenne = 0, écart-type = 1).
4. Sauvegarde du scaler : Le StandardScaler est sauvegardé avec joblib pour garantir
une normalisation cohérente lors du déploiement.
1 import pandas as pd
2 from sklearn . preprocessing import StandardScaler
3 import joblib
4
5 # Chargement des d o n n e s
6 data = pd . read_csv ( ’ weather_data . csv ’)
7
8 # Gestion des valeurs manquantes
9 data = data . fillna ( data . mean () )
10
11 # Normalisation des c a r a c t r i s t i q u e s
12 scaler = StandardScaler ()
13 features = [ ’ pressure ’ , ’ humidity ’ , ’ day ’ , ’ month ’] % Exemple de
caract ristiques
14 data [ features ] = scaler . fit_transform ( data [ features ])
15
16 # Sauvegarde du scaler
17 joblib . dump ( scaler , ’ scaler . joblib ’)
18
19 # Sauvegarde des d o n n e s p r t r a i t e s ( optionnel )
20 data . to_csv ( ’ processed_weather_data . csv ’ , index = False )
Listing 1 – Prétraitement des données
4
2.3 Explication du code
— pd.read_csv : Charge les données brutes.
— [Link]([Link]()) : Remplace les valeurs manquantes par la moyenne de chaque
colonne.
— StandardScaler : Normalise les données pour améliorer la convergence du modèle SVR.
— [Link] : Sauvegarde l’objet scaler pour une réutilisation lors du déploiement.
3 Entraînement et sauvegarde du modèle
3.1 Configuration du modèle SVR
Le modèle SVR est configuré avec un noyau RBF (Radial Basis Function), qui est efficace
pour capturer les relations non linéaires dans les données météorologiques. Les hyperparamètres
principaux sont :
— C : Paramètre de régularisation (par exemple, C=1.0).
— epsilon : Marge d’erreur tolérée (par exemple, epsilon=0.1).
— kernel : Noyau RBF pour une flexibilité accrue.
3.2 Processus d’entraînement
Le modèle est entraîné sur les données prétraitées, divisées en ensembles d’entraînement
(80%) et de test (20%).
1 from sklearn . svm import SVR
2 from sklearn . model_selection import train_test_split
3 import joblib
4 import pandas as pd
5
6 # Chargement des d o n n e s p r t r a i t e s
7 data = pd . read_csv ( ’ processed_weather_data . csv ’)
8 X = data [[ ’ pressure ’ , ’ humidity ’ , ’ day ’ , ’ month ’ ]]
9 y_tmax = data [ ’ tmax ’]
10 y_tmin = data [ ’ tmin ’]
11
12 # Division des d o n n e s
13 X_train , X_test , y_train , y_test = train_test_split (X , y_tmax ,
test_size =0.2 , random_state =42)
14
15 # E n t r a n e m e n t du m o d l e
16 svr_tmax = SVR ( kernel = ’ rbf ’ , C =1.0 , epsilon =0.1)
17 svr_tmax . fit ( X_train , y_train )
18
19 # Sauvegarde du m o d l e
20 joblib . dump ( svr_tmax , ’ svr_tmax . joblib ’)
21
22 # R p t e r pour tmin ( e n t r a n e m e n t et sauvegarde )
23 svr_tmin = SVR ( kernel = ’ rbf ’ , C =1.0 , epsilon =0.1)
24 svr_tmin . fit ( X_train , data [ ’ tmin ’ ][ X_train . index ])
25 joblib . dump ( svr_tmin , ’ svr_tmin . joblib ’)
Listing 2 – Entraînement et sauvegarde du modèle SVR
5
3.3 Explication du code
— train_test_split : Divise les données en ensembles d’entraînement et de test pour
évaluer le modèle.
— [Link] : Entraîne le modèle sur les données d’entraînement.
— [Link] : Sauvegarde les modèles pour tmax et tmin dans des fichiers séparés
(svr_tmax.joblib, svr_tmin.joblib).
3.4 Avantages de joblib
— Efficacité : joblib est optimisé pour les objets contenant de grands tableaux NumPy,
comme les modèles SVR.
— Portabilité : Les fichiers .joblib peuvent être facilement transférés et utilisés sur
d’autres systèmes.
— Simplicité : L’API de joblib est intuitive (dump pour sauvegarder, load pour charger).
6
4 Déploiement et prédiction
4.1 Chargement du modèle
Le modèle sauvegardé est chargé pour effectuer des prédictions sur de nouvelles données.
Le scaler sauvegardé est également chargé pour garantir un prétraitement cohérent.
1 import pandas as pd
2 import joblib
3 import numpy as np
4
5 # Chargement du scaler et des m o d l e s
6 scaler = joblib . load ( ’ scaler . joblib ’)
7 svr_tmax = joblib . load ( ’ svr_tmax . joblib ’)
8 svr_tmin = joblib . load ( ’ svr_tmin . joblib ’)
9
10 # Chargement des nouvelles d o n n e s
11 new_data = pd . read_csv ( ’ new_weather_data . csv ’)
12 new_data = new_data . fillna ( new_data . mean () ) % Gestion des valeurs
manquantes
13
14 # Normalisation des nouvelles d o n n e s
15 features = [ ’ pressure ’ , ’ humidity ’ , ’ day ’ , ’ month ’]
16 new_data_scaled = scaler . transform ( new_data [ features ])
17
18 # Pr dictions
19 tmax_predictions = svr_tmax . predict ( new_data_scaled )
20 tmin_predictions = svr_tmin . predict ( new_data_scaled )
21
22 # Sauvegarde des r s u l t a t s
23 results = pd . DataFrame ({
24 ’ tmax_pred ’: tmax_predictions ,
25 ’ tmin_pred ’: tmin_predictions
26 })
27 results . to_csv ( ’ predictions . csv ’ , index = False )
Listing 3 – Chargement et prédiction avec le modèle SVR
4.2 Explication du code
— [Link] : Charge le scaler et les modèles SVR.
— [Link] : Applique la même normalisation que lors de l’entraînement.
— predict : Génère les prédictions pour tmax et tmin.
— to_csv : Sauvegarde les prédictions dans un fichier pour une analyse ultérieure.
4.3 Validation des prédictions
Pour vérifier la fiabilité du modèle déployé, les prédictions sont évaluées sur un jeu de test
à l’aide des métriques MAE, RMSE, et R².
1 from sklearn . metrics import mean_absolute_error , mean_squared_error ,
r2_score
2 import numpy as np
7
3
4 # valuation pour tmax
5 mae_tmax = mean_absolute_error ( y_test , svr_tmax . predict ( X_test ) )
6 rmse_tmax = np . sqrt ( mean_squared_error ( y_test , svr_tmax . predict ( X_test )
))
7 r2_tmax = r2_score ( y_test , svr_tmax . predict ( X_test ) )
8
9 print ( f " tmax - MAE : { mae_tmax :.2 f } , RMSE : { rmse_tmax :.2 f } , R : {
r2_tmax :.2 f } " )
Listing 4 – Évaluation des prédictions
Table 1 – Performances du modèle SVR après déploiement
Variable MAE RMSE R²
tmax 0.95 1.28 0.84
tmin 0.96 1.39 0.82
8
5 Intégration dans une API REST
5.1 Objectif
Pour rendre le modèle accessible à des utilisateurs non techniques (par exemple, agriculteurs
ou gestionnaires), il est intégré dans une API REST à l’aide de FastAPI. Cela permet d’effectuer
des prédictions via des requêtes HTTP.
5.2 Configuration de l’API
Le code suivant montre une implémentation minimaliste d’une API avec FastAPI :
1 from fastapi import FastAPI
2 from joblib import load
3 import numpy as np
4 import pandas as pd
5
6 app = FastAPI ()
7 scaler = load ( ’ scaler . joblib ’)
8 svr_tmax = load ( ’ svr_tmax . joblib ’)
9 svr_tmin = load ( ’ svr_tmin . joblib ’)
10
11 @app . post ( " / predict " )
12 async def predict ( features : dict ) :
13 # Conversion des d o n n e s d ’ e n t r e en DataFrame
14 input_data = pd . DataFrame ([ features ])
15 input_data = input_data . fillna ( input_data . mean () )
16
17 # Normalisation
18 input_scaled = scaler . transform ( input_data [[ ’ pressure ’ , ’ humidity ’ ,
’ day ’ , ’ month ’ ]])
19
20 # Pr dictions
21 tmax_pred = svr_tmax . predict ( input_scaled ) [0]
22 tmin_pred = svr_tmin . predict ( input_scaled ) [0]
23
24 return { " tmax_prediction " : tmax_pred , " tmin_prediction " : tmin_pred }
Listing 5 – API REST avec FastAPI
5.3 Explication du code
— FastAPI() : Crée une instance de l’application API.
— @[Link]("/predict") : Définit une route HTTP POST pour recevoir les données
d’entrée.
— features: dict : Accepte un dictionnaire JSON contenant les caractéristiques (par
exemple, {"pressure" : 1013, "humidity" : 70, "day" : 15, "month" : 6}).
— predict : Prétrait les données, effectue les prédictions, et renvoie les résultats sous forme
de JSON.
9
5.4 Déploiement de l’API
1. Local : Exécuter uvicorn main:app –reload pour tester l’API localement.
2. Cloud : Déployer sur une plateforme comme AWS, Azure, ou Heroku.
3. Conteneurisation : Utiliser Docker pour encapsuler l’API et ses dépendances.
Exemple de requête avec curl :
1 curl -X POST " http :// localhost :8000/ predict " -H " Content - Type :
application / json " -d ’ {" pressure ": 1013 , " humidity ": 70 , " day ": 15 ,
" month ": 6} ’
Listing 6 – Requête HTTP à l’API
10
6 Considérations pratiques
6.1 Environnement d’exécution
— Dépendances : Installer scikit-learn, joblib, pandas, numpy, et fastapi via pip
install.
— Configuration minimale : CPU avec 4 Go de RAM pour une exécution locale ; serveur
cloud pour un déploiement à grande échelle.
6.2 Maintenance
— Mise à jour des données : Intégrer de nouvelles données météorologiques pour réen-
traîner le modèle périodiquement.
— Surveillance : Vérifier les performances (MAE, RMSE, R²) sur des données récentes
pour détecter une dérive des données.
— Gestion des erreurs : Implémenter des journaux (logs) pour diagnostiquer les problèmes
d’API ou de prédictions.
6.3 Limitations
— Précipitations (prcp) : Le modèle SVR est moins performant pour prcp (R²=0.21) en
raison de la variabilité et du déséquilibre des données.
— Qualité des données : Les prédictions dépendent de la fiabilité des données d’entrée.
— Évolutivité : Pour un grand nombre de requêtes, une infrastructure cloud robuste est
nécessaire.
11
7 Conclusion et perspectives
7.1 Synthèse
Ce document détaille le processus de déploiement du modèle SVR pour la prédiction des
températures au Cameroun, en utilisant joblib pour la sérialisation et FastAPI pour l’inté-
gration dans une API REST. Chaque étape, du prétraitement des données à l’évaluation des
prédictions, est expliquée pour garantir la reproductibilité et la maintenance du système.
7.2 Perspectives
— Développer une interface utilisateur (web ou mobile) pour faciliter l’accès aux prédictions.
— Explorer des modèles d’ensemble (par exemple, Random Forest) pour améliorer la pré-
diction des précipitations.
— Automatiser le pipeline de mise à jour des données et de réentraînement du modèle.
— Intégrer des données en temps réel provenant de stations météorologiques pour des pré-
dictions plus dynamiques.
12
