Projet : Prédiction du nombre de passagers, des quantités de fret et de courrier

Proposition de valeur (Proof of Concept) :

Les compagnies aériennes doivent relever des défis pour optimiser leurs opérations, en particulier dans la gestion des ressources humaines, matérielles, et financières. Un dimensionnement approprié des ressources humaines et une affectation optimale des avions aux vols sont cruciaux pour réduire les coûts et maximiser les revenus.

Solution proposée :

Nous proposons un modèle d'apprentissage automatique pour prédire le nombre de passagers, ainsi que les quantités de fret et de courrier. Cette solution permettra d’optimiser la gestion des ressources humaines et matérielles des compagnies aériennes en intégrant ces prévisions dans leur système de planification.

Deploiement Local : streamlit run app.py

Deploiement Cloud : https://airline-projet-prediction.streamlit.app/

Planification des activités :

Nous avons utilisé ClickUp pour structurer et suivre les activités du projet. Cette plateforme centralise les tâches, documents, communications, et outils de collaboration, permettant de planifier et gérer efficacement le travail en équipe.

Les Exigences fonctionnelles et non fonctionnelles :

1) Les Exigences fonctionnelles :

• Prédiction du nombre de passagers, des quantités de fret et de courrier.
• Conception de la solution avec une approche MLOps couvrant tout le cycle de vie du projet.
• Surveillance des performances du modèle avec MLFlow.
• Configuration de pipelines CI/CD avec GitHub Actions.
• Versionnement et collaboration du code source sur GitHub.
• Développement de l'application web avec Streamlit.
• Gestion des données avec DVC sur Google Drive.
• Déploiement en production sur Streamlit Cloud Community.
• Développement des modèles en Python avec Scikit-learn.
• Tests des modèles avec Pytest.

2) Les Exigences non fonctionnelles :

• Fiabilité du modèle.
• Scalabilité de la solution.
• Sécurité des données et de l'application.
• Facilité de maintenance et d'évolution du code.

Plan de conception de la solution :

Collecte des données :

Les données sont téléchargées depuis le site officiel du Bureau of Transportation Statistics du ministère des transports américain et sauvegardées dans un dossier nommé data_source.

• Lien : Bureau Transportation Statistics

Préparation de l’espace de travail :

Création d'un repository sur GitHub :

1. Connectez-vous à GitHub : github.com

2. Créer un nouveau repository :

   • Repository Name : BDEB2024
   • Public : Choisissez Public.
   • Initialize this repository with :
     • Add a README file : Cochez cette case.
     • Add .gitignore : Choisissez un modèle approprié.
     • Choose a license : Sélectionnez une licence si nécessaire.
   • Créer le Repository : Cliquez sur "Create repository".

3. Obtenir l’URL du Repository :

   • Accédez au repository sur GitHub.
   • Cliquez sur "Code" et copiez l’URL.

4. Ouvrir le Terminal ou l’Invite de Commandes :

   • Créer et Naviguer vers le Dossier :

     cd Desktop
     mkdir ProjetDeSynthese2024
     cd ProjetDeSynthese2024

   • Cloner le Repository :

     git clone https://github.com/HMourad2023/BDEB2024.git
     cd BDEB2024

   • Accéder à Visual Studio Code (VS Code) :

     code .

Création d'un Environnement Virtuel avec Conda :

• Créer un Environnement :

  conda create --name mlops python=3.12 -y

• Activer l'Environnement :

  conda activate mlops

• Installer ipykernel et notebook :

  pip install ipykernel notebook

• Ajouter l’Environnement à Jupyter :

  python -m ipykernel install --user --name=mlops --display-name "Python (mlops)"

Création de la Structure du Projet :

En exécutant le fichier tempalte.py la structure du projet sera automatiquement créée:

python template.py

Lien vers le script Python pour créer automatiquement la structure de votre projet :

Cliquer ici pour voir le script du fichier template.py

Pousser la structure vers le repository Github :

git add .
git commit -m "Création de la structure du projet"
git push -u origin main

Analyse exploratoire des données :

Une analyse exploratoire des données sera réalisée pour mieux comprendre les variables et identifier les tendances et anomalies potentielles.

Cette partie est traitée dans un notebook (notebooks/analysis.ipynb) et les visualisations sont enregistrées dans un dossier (visualizations)

Cliquer ici pour voir le script du fichier anlaysis.ipynb

Mise en place de DVC :

Données Reproductibles et Pipeline ML à l'aide de DVC

Installation et Initialisation de DVC :

pip install dvc
pip install dvc[gdrive]

dvc init
git add .dvc .gitignore
git commit -m "Initialisation de DVC"
git push -u origin main

Configuration de DVC Remote Configurer Google Drive avec DVC Créer un Dossier Google Drive : Copiez l’ID du dossier.

Configurer le Remote DVC

dvc remote add -d myremote gdrive://1WL4oxPkiSJnzWC88oKaZdTFTubKI1_r8
git add .
git commit -m "Mise en place Google Drive Remote"
git push -u origin

Mise en place de MLFLOW:

Installation :

pip install mlflow

mlflow ui

Parties Experiences orchestrées:

Cette partie est traitée dans un notebook (notebooks/experiments.ipynb)

L'objectif est l'utilisantion un notebook pour :

• Prépareer les données :
  • Ajustement des noms de colonnes.
  • Ajustement des types de données.
  • Suppression des variables redondantes.
  • Traiter les valeurs manquantes.
• Divisons les données en ensembles d'entraînement et de test.
• Transformons les données en encodant les variables catégorielles et en appliquant une transformation logarithmique aux données numériques.
• Utiliser la méthode SequentialFeatureSelector pour sélectionner et filtrer les meilleures caractéristiques.
• Entraîner plusieurs modèles et enregister-les avec MLflow.

Cliquer ici pour voir le script du fichier experiments.ipynb

Modèles et algorithmes :

En apprentissage automatique, nous rencontrons souvent des régressions, ces problèmes impliquent la prédiction d'une variable cible continue. Cependant, dans de nombreux scénarios du monde réel, nous devons prédire non seulement une seule mais plusieurs variables ensemble, c'est là que nous utilisons la régression à sorties multiples (Régression Multi-outputs)

Parties Pipeline automatique :

Création du Pipeline

L'objectif de cette partie est de passer de l'etape esperiences sur des notebooks et des scripts modulées vers un pipeline reproductible en dvc :

Étapes du pipeline :

Ajouter les données au suivi DVC

dvc add data/external/external_data.csv
git add data/external/.gitignore data/external/external_data.csv.dvc
git commit -m "Add raw external data"
git push origin main

Préparation des données

dvc stage add -n prepare_data -d src/components/prepare_data.py -d data/external/external_data.csv -o data/prepared/prepared_data.csv -p data:external_data,data:prepared_data python src/components/prepare_data.py

Division des données

dvc stage add -n split_data -d src/components/split_data.py -d data/prepared/prepared_data.csv -o data/splitted/X_train.csv -o data/splitted/X_test.csv -o data/splitted/y_train.csv -o data/splitted/y_test.csv -p data:prepared_data,data:splitted_data,processing:split_data python src/components/split_data.py

Transformation des données

dvc stage add -n transform_data -d src/components/transform_data.py -d data/splitted/X_train.csv -d data/splitted/X_test.csv -d data/splitted/y_train.csv -d data/splitted/y_test.csv -o data/transformed/X_train_transformed.csv -o data/transformed/X_test_transformed.csv -o data/transformed/y_train_transformed.csv -o data/transformed/y_test_transformed.csv -p data:splitted_data,data:transformed_data,processing:transform_data python src/components/transform_data.py

Selection des caracteristiques

dvc stage add -n select_features -d src/components/select_features.py -d data/transformed/X_train_transformed.csv -d data/transformed/X_test_transformed.csv -d data/selected_features/features.txt -o data/splitted/X_train_selected.csv -o data/splitted/X_test_selected.csv -p data:transformed_data,data:selected_features python src/components/select_features.py

Entrainement des modeles

dvc stage add -n train_model -d src/components/train_and_log_model.py -d data/selected/X_train_selected.csv -d data/selected/X_test_selected.csv -d data/transformed/y_train_transformed.csv -d data/transformed/y_test_transformed.csv -o models/best_model.pkl -o metrics/model_metrics.txt -p model python src/components/train_model_and_log_model.py

Étape 4 : Versionner les pipelines dans Git Après avoir défini le pipeline, vous devez versionner les fichiers DVC dans Git :

dvc repro

Génération automatique du fichier pipeline : dvc.yaml

Une fois toutes les étapes définies, un fichier dvc.yaml sera autonatiquement généré.

Cliquer ici pour voir le script du fichier dvc.yaml généré

Génération automatique du fichier pipeline : dvc.lock

Cliquer ici pour voir le script du fichier dvc.lock généré

Generation du schema du pipeline automatique :

dvc dag

Création du workflow avec avec github Actions :

name: CI/CD Pipeline

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v2

      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: 3.12

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

      - name: Run DVC pipeline
        run: |
          dvc pull
          dvc repro
          dvc push

      - name: Deploy to Streamlit
        run: |
          streamlit deploy

Deploiement Stramlit Cloud Community :

Démo de l'Application:

Conclusion :

Au cours de ce projet, nous avons appris à automatiser le workflow complet d'un projet de machine learning en utilisant des outils MLOps, et à fournir une application de prédiction fonctionnelle. Cette application reste à améliorer par l'intégration d'autres outils et la résolution des étapes qui ont rencontré des difficultés.