=================================
Ce projet développe un modèle prédictif pour évaluer la gravité des accidents de la route à partir des premières observations sur place, aidant à déterminer les ressources nécessaires et améliorer l'anticipation des secours.
Il intègre également des pratiques de MLOps et CI/CD pour assurer un déploiement automatisé, une surveillance continue et des mises à jour régulières du modèle, garantissant ainsi sa performance et son actualisation constante.
Parties modifiées
La strucure des repertoires reprends celle deja fournie pour la création du modèle. Les fichiers importants ajoutées ou modifiées dans le cadre de ce projet sont:
├── .github/workflows <- GitHub Actions workflows for CI/CD
│ ├── git_action.yml <- Workflow to run unit tests and build and push Docker images
│ └── model_deployment.yml <- Workflow to deploy the model
│
├── requirements.txt <- The full list of libraries installed on the Python env used for development
│ <- Generated with `pip freeze > requirements.txt`
├── data
│ └── user_db <- Data of the users and admins
│
├── Dockerfile <- The app's image builder, allows running the app in a container without needing any configuration
│
├── logs <- Logs from training and predicting
│
├── reports
│ └── cahier_des_charges <- Project specifications document
│
├── src <- Source code for use in this project
│ └── api <- Scripts for the API
│ ├── api.py
│ ├── test_api_authentification.py
│ ├── test_api_fonction.py
│ └── test_api_serveur.py
│
└── streamlit <- Source code for a Streamlit interface to access the API
├── README.md <- The README for developers using this Streamlit
└── images <- Source images for the Streamlit interface
Structure complète
├── LICENSE
├── README.md <- The top-level README for developers using this project.
├── data
│ ├── external <- Data from third party sources.
│ ├── interim <- Intermediate data that has been transformed.
│ ├── processed <- The final, canonical data sets for modeling.
│ ├── user_db <- Data of the users and admins
│ └── raw <- The original, immutable data dump.
│
├── logs <- Logs from training and predicting
│
├── models <- Trained and serialized models, model predictions, or model summaries
│
├── notebooks <- Jupyter notebooks. Naming convention is a number (for ordering),
│ the creator's initials, and a short `-` delimited description, e.g.
│ `1.0-jqp-initial-data-exploration`.
│
├── references <- Data dictionaries, manuals, and all other explanatory materials.
│
├── reports <- Generated analysis as Cahier_des_charges, HTML, PDF, LaTeX, etc.
│ ├── figures <- Generated graphics and figures to be used in reporting
│ └── cahier_des_charges
│
├── requirements.txt <- The full list of libraries installed on the python env used for development.
│ generated with `pip freeze > requirements.txt`
│
├── src <- Source code for use in this project.
│ ├── __init__.py <- Makes src a Python module
│ │
│ ├── api <- Scripts for the api
│ │ ├── api.py
│ │ ├── test_api_authentification.py
│ │ ├── test_api_fonction.py
│ │ └── test_api_serveur.py
│ │
│ ├── data <- Scripts to download or generate data
│ │ ├── check_structure.py
│ │ ├── import_raw_data.py
│ │ └── make_dataset.py
│ │
│ ├── features <- Scripts to turn raw data into features for modeling
│ │ └── build_features.py
│ │
│ ├── models <- Scripts to train models and then use trained models to make
│ │ │ predictions
│ │ ├── predict_model.py
│ │ └── train_model.py
│ │
│ ├── visualization <- Scripts to create exploratory and results oriented visualizations
│ │ └── visualize.py
│ └── config <- Describe the parameters used in train_model.py and predict_model.py
│
├── streamlit <- Source code for a streamlit interface to access the API
│ ├── README.md <- The README for developers using this streamlit.
│ └── images <- Source images
│
├── **Dockerfile** <- The app's image builder, allows to run the app in a container without needing any condfiguration.
│
├── .github\workflows <- GitHub Actions workflows for CI/CD
├── git_action.yml <- Workflow to run unit tests and build and push Docker images
└── model_deployment.yml <- Workflow to deploy the model
Convention : All python scripts must be run from the root specifying the relative file path.
`python -m venv my_env`
`./my_env/Scripts/activate`
`pip install -r .\requirements.txt` ### You will have an error in "setup.py" but this won't interfere with the rest
`python .\src\data\import_raw_data.py` ### It will ask you to create a new folder, accept it.
3- Execute make_dataset.py initializing ./data/raw as input file path and ./data/preprocessed as output file path.
`python .\src\data\make_dataset.py`
`python .\src\models\train_model.py`
-
Provide a json file as follow :
python ./src/models/predict_model.py ./src/models/test_features.jsontest_features.json is an example that you can try -
If you do not specify a json file, you will be asked to enter manually each feature.
a. Use an environment with uvicorn or install it with:
pip install uvicorn
b. Starts the api on : http://localhost:8000:src.api.api:api
See the README in the streamlit directory
Ce projet vise à développer un modèle prédictif pour évaluer la gravité des accidents de la route en fonction des premières observations effectuées sur le site de l'accident. Ce modèle aide à définir les besoins en ressources pour chaque accident et permet une meilleure anticipation et allocation des secours.
"Ce projet intégrera un travail de MLOps complet, notamment à travers une intégration CI/CD. Cela inclut l'automatisation du déploiement du modèle, la surveillance continue de ses performances, et des mises à jour régulières. Les pipelines CI/CD assureront des tests unitaires et d'intégration, garantissant que chaque modification est correctement validée avant d'être déployée. De plus, la conteneurisation avec Docker facilitera la gestion des environnements de déploiement, assurant une cohérence et une reproductibilité maximales."
Le logiciel propose une estimation de la gravité d'un accident en analysant les caractéristiques du lieu de l'accident, des véhicules impliqués, et du type de choc. La gravité de l'accident est classée en deux catégories:
- Classe 0 : Indemnes ou blessés légers (sans hospitalisation)
- Classe 1 : Blessés à hospitaliser ou tués
Les principaux utilisateurs de ce modèle sont les services de sécurité routière et les services d'urgence, qui pourront ainsi optimiser l'allocation des ressources en fonction des besoins réels.
Le modèle utilise un algorithme de Random Forest pour prédire la gravité des accidents en se basant sur 28 variables d'entrée possibles. La performance du modèle est évaluée à l'aide du f1-score, pour s'assurer d'une bonne précision et rappel.
Le modèle est réentraîné et évalué à chaque modification du code et tous les mois pour tenir compte des changements dans la base de données.
Le modèle utilise les bases de données annuelles des accidents corporels de la circulation routière fournies par l'Observatoire National Interministériel de la Sécurité Routière (ONISR).
L'API permet de :
- Utiliser le modèle pour prédire la gravité des accidents
- Enregistrer les prédictions dans des logs
- Gérer l'authentification des utilisateurs et administrateurs
/status: Vérification du fonctionnement de l’API/new_user: Inscription d’un utilisateur/new_admin: Inscription d’un administrateur/delete_user: Suppression d’un utilisateur/delete_admin: Suppression d’un administrateur/prediction: Prédictions de priorité à partir de données saisies
Le projet utilise Docker pour la conteneurisation du modèle et de l'API, et GitHub Actions pour l'intégration continue. Le déploiement se fait via Heroku, assurant ainsi une livraison continue et automatisée du modèle et de l'API.
- CI Workflow : Entraînement, test, et construction de l'image Docker.
- CD Workflow : Déploiement de l'API sur Heroku si les tests sont réussis.
Un schéma d'implémentation détaillé est fourni dans le cahier des charges (repertoire reoprts) pour illustrer le processus complet du développement à la mise en production.
- CI Workflow : Entraînement, test, et construction de l'image Docker.
- CD Workflow : Déploiement de l'API sur Heroku si les tests sont réussis.