posts |

Comment fonctionne ce site ?

Sun, 10 May 2026 00:00:00 +0000

Présentation du projet

Ce site a été créé pour vous offrir un aperçu clair et complet de mes compétences et de mon travail. Mon but est de vous présenter mes projets, les technologies que je maîtrise, et comment je les utilise pour résoudre des problèmes concrets.

Ce portfolio a plusieurs objectifs :

Mettre en avant mes projets : Vous y trouverez des détails sur les projets sur lesquels j’ai travaillé, montrant comment j’ai appliqué mes compétences pour atteindre des résultats tangibles. Illustrer mes compétences : Le site présente les technologies et outils que j’utilise, ainsi que mon approche pour les intégrer efficacement dans mes projets. Partager mon expérience : À travers des articles et des études de cas, je décris les défis que j’ai rencontrés et les solutions que j’ai mises en place, offrant ainsi un aperçu de mon processus de travail. En utilisant Hugo pour créer ce site statique et en le configurant avec Docker, j’ai non seulement développé un espace pour partager mon travail, mais aussi démontré ma capacité à gérer des projets techniques de manière autonome.

Choix de technologies et architecture

Pour rendre le site accessible à n’importe quel utilisateur (et pas uniquement en local), plusieurs options sont possibles :
- Hébergement automatisé : solutions comme GitLab Pages ou GitHub Pages, qui sont simples à mettre en place.
- Hébergement configurable : un peu plus personnalisable tout en restant facile d’utilisation, comparable à un SaaS, où l’on dispose d’un “logiciel” accessible via le web pour configurer son site en production.
- J’ai opté pour une solution plus configurable pour des raisons d’apprentissage. J’utilise un serveur de type VPS où j’héberge l’application web. Dans ce cas, je suis dans un modèle IaaS (Infrastructure as a Service), où j’achète directement de l’infrastructure.
L’application web est un site web statique, créé avec un générateur de site web, . Hugo est une solution efficace pour créer rapidement des sites statiques avec un contenu conséquent. J’ai couplé Hugo avec un template adapté à mes besoins. Le template que j’utilise est conçu spécifiquement pour fonctionner avec Hugo, facilitant ainsi la création de contenu et offrant une partie du design déjà prête. Le moteur de template est .
Une fois le site créé en local et le VPS accessible, il est nécessaire d’intégrer le code et de le rendre accessible. Pour ce faire, j’utilise un conteneur Docker avec une version d’Apache à l’intérieur. Il suffit de placer les sources de mon site dans le dossier html du conteneur pour qu’il soit accessible.

Cependant, une fois le site accessible, il reste un problème : il n’y a pas de certificat SSL, donc le site n’est pas en HTTPS.

Pour résoudre ce problème, je me suis basé sur un de Leon Sczepansky, qui utilise Docker Compose avec Apache et Let’s Encrypt pour publier son site en HTTPS. Le conteneur Apache se construit en cherchant les fichiers nécessaires pour la certification SSL.

Voici la configuration Docker Compose utilisée :

version: '3.7'
services:
 productive-apache:
 container_name: 'productive-apache'
 image: productive-apache:latest
 build:
 context: .
 ports:
 - "80:80"
 - "443:443"
 volumes:
 - ./httpd.conf:/etc/apache2/httpd.conf
 - ./html/:/var/www/localhost/htdocs/
 - /docker-volumes/etc/letsencrypt/live/martin-genereux.fr/cert.pem:/etc/letsencrypt/live/martin-genereux.fr/cert.pem
 - /docker-volumes/etc/letsencrypt/live/martin-genereux.fr/fullchain.pem:/etc/letsencrypt/live/martin-genereux.fr/fullchain.pem
 - /docker-volumes/etc/letsencrypt/live/martin-genereux.fr/privkey.pem:/etc/letsencrypt/live/martin-genereux.fr/privkey.pem
 - /home/martin/logs/test1/:/var/www/logs/
 networks:
 - docker-network
 environment:
 - server_name=martin-genereux.fr
networks:
 docker-network:
 driver: bridge

Les fichiers cert.pem, fullchain.pem, et privkey.pem sont chargés dans le conteneur pour obtenir la certification SSL. Avant cela, il faut lancer le conteneur Let’s Encrypt pour obtenir ces fichiers de certification.

Voici la commande Docker pour exécuter Certbot et obtenir les certificats :

# Exécuter la commande Certbot pour renouveler les certificats
sudo docker run -it --rm \
-v /docker-volumes/etc/letsencrypt:/etc/letsencrypt \
-v /docker-volumes/var/lib/letsencrypt:/var/lib/letsencrypt \
-v "$PWD/html:/data/letsencrypt" \
-v /docker-volumes/var/log/letsencrypt:/var/log/letsencrypt \
certbot/certbot \
certonly --webroot \
--email martingenereuxccl@gmail.com --agree-tos --no-eff-email \
--webroot-path=/data/letsencrypt \
-d martin-genereux.fr -d www.martin-genereux.fr

Ce script shell est exécuté tous les 3 mois grâce à un cron pour renouveler les certificats automatiquement.

Déploiement

Le déploiement du site a été automatisé grâce à un pipeline CI/CD que j’ai configuré avec GitLab. Ce pipeline simplifie le processus de déploiement et garantit que les mises à jour du site sont effectuées de manière fluide et sans erreur. Voici comment ce pipeline est structuré :

Configuration du Pipeline GitLab CI/CD

Le pipeline est divisé en deux étapes principales : build-sources et deploy-sources.
- Étape build-sources : Cette étape utilise Docker pour construire le site statique. Il s’exécute dans un conteneur Alpine, où les outils nécessaires sont installés (Git, Go, et Hugo). La commande hugo est exécutée pour générer le site, et le dossier public/ contenant les fichiers statiques est enregistré comme un artefact.
- Étape deploy-sources : Après la construction, cette étape s’occupe du déploiement sur le serveur VPS. Elle utilise également un conteneur Alpine pour installer openssh-client et configurer les clés SSH nécessaires pour se connecter au serveur. Le pipeline supprime les anciens fichiers de la destination sur le serveur, puis copie les nouveaux fichiers générés dans le répertoire approprié.
Voici le fichier .gitlab-ci.yml que j’utilise pour ce processus :
```
stages:
 - build-sources
 - deploy-sources

build-sources:
 tags:
 - springVps
 image: alpine:latest
 stage: build-sources
 before_script:
 - apk add --update --no-cache git go
 - apk add --no-cache --repository=https://dl-cdn.alpinelinux.org/alpine/edge/community hugo
 script:
 - hugo
 artifacts:
 paths:
 - public/

deploy-sources:
 tags:
 - springVps
 image: alpine:latest
 stage: deploy-sources
 before_script:
 - apk update
 - apk add --no-cache openssh-client
 - chmod 400 $SSHVPS
 - mkdir -p ~/.ssh
 - chmod 700 ~/.ssh
 script:
 - ssh -i $SSHVPS -o StrictHostKeyChecking=no -p 2879 root@martin-genereux.fr "rm -rf /home/apache-and-letsencrypt/production/html/*"
 - scp -i $SSHVPS -o StrictHostKeyChecking=no -P 2879 -r public/* root@martin-genereux.fr:/home/apache-and-letsencrypt/production/html
```

Voici le schéma d’architecture de la pipeline

Automatisation et Avantages

L’automatisation du déploiement réduit le risque d’erreurs humaines et accélère le processus de mise en production des nouvelles versions du site. En utilisant GitLab CI/CD, je m’assure que chaque modification apportée au code est automatiquement testée et déployée de manière cohérente, garantissant ainsi une intégrité constante du site.

Future évolutions

Pour l’avenir, je prévois d’intégrer des tests automatisés dans le pipeline afin de vérifier la qualité du code avant le déploiement. De plus, des ajustements pourront être apportés pour améliorer les performances du pipeline et s’adapter à l’évolution des besoins du site.

En mettant en place ce pipeline CI/CD, je m’assure que le site reste toujours à jour et fonctionne de manière optimale, tout en minimisant les interventions manuelles nécessaires pour le déploiement.

Faire un RAG (La génération augmentée par récupération) sur une documentation

Sun, 10 May 2026 00:00:00 +0000

🔍 RAG Personnel — Moteur de Recherche Documentaire Local

Projet perso réalisé pendant une période creuse au travail, par curiosité et envie d’explorer le stack NLP/LLM de bout en bout.

Objectif

Construire un système de Retrieval-Augmented Generation (RAG) from scratch, capable de répondre à des questions en langage naturel à partir d’un document PDF et cela sans dépendre d’une API externe comme OpenAI.

Architecture

PDF uploadé
 │
 ▼
Chunking (RecursiveCharacterTextSplitter)
 │ - chunk_size : 512 tokens (tokenizer HuggingFace)
 │ - chunk_overlap : 10%
 │ - déduplication automatique des chunks
 ▼
Embeddings (intfloat/multilingual-e5-small)
 │ - modèle multilingue, léger, adapté FR/EN
 │ - normalisation cosine
 ▼
Vector Store FAISS
 │ - similarité cosine
 │ - top-30 docs récupérés
 ▼
Reranking (FlashRank — ms-marco-MiniLM-L-12-v2)
 │ - reclassement des 30 docs → top-5 pertinents
 ▼
Génération (Mistral-7B-Instruct-v0.3)
 │ - quantisation 4-bit (BitsAndBytes nf4)
 │ - prompt structuré avec template chat
 ▼
Réponse en français, sourcée par document

Stack technique

Composant	Outil
Chargement PDF	`LangChain PyPDFLoader`
Chunking	`RecursiveCharacterTextSplitter` (HuggingFace tokenizer)
Embeddings	`intfloat/multilingual-e5-small` (SentenceTransformers)
Vector Store	`FAISS` (Meta)
Reranking	`FlashRank` — ms-marco-MiniLM-L-12-v2
LLM	`Mistral-7B-Instruct-v0.3` (quantisé 4-bit, BitsAndBytes)
Orchestration	`LangChain`
Visualisation embeddings	`PaCMAP` + `Plotly`
Environnement	Google Colab (GPU T4)

Points techniques notables

Chunking token-aware : taille des chunks calculée avec le vrai tokenizer du modèle d’embedding (pas juste en caractères), pour coller exactement à la fenêtre contextuelle du modèle.
Pipeline retriever + reranker : deux étapes de sélection — récupération large (top-30) puis reranking croisé (top-5) pour maximiser la pertinence sans sacrifier le recall.
Quantisation 4-bit : Mistral 7B tourne en mémoire GPU limitée grâce à BitsAndBytesConfig (nf4 + double quant + bfloat16).
Prompt engineering en français : template structuré avec instruction système explicite pour obtenir des réponses sourcées et concises.
Visualisation de l’espace d’embedding : projection 2D via PaCMAP pour observer la distribution des chunks et la position de la requête utilisateur dans l’espace vectoriel.

Ce que j’ai appris

Le chunking est critique : un mauvais découpage casse la pertinence du retrieval bien plus que le choix du LLM.
Le reranker change vraiment la donne sur des corpus avec du bruit : passer de top-30 brut à top-5 rerankés améliore nettement la qualité des réponses.
La quantisation 4-bit rend les LLMs 7B accessibles sur GPU modeste (Colab T4) avec une perte de qualité négligeable en usage Q&A.
RAG ≠ magie : la qualité de la réponse finale est bornée par la qualité du document source et la pertinence des chunks récupérés.

Limites & pistes d’amélioration

Pas de gestion de l’historique conversationnel (pas de mémoire entre les questions)
Interface en console uniquement — une UI FastAPI/VueJS serait le next step logique
Pas de persistance du vector store entre les sessions Colab
Évaluation de la qualité des réponses non formalisée (pas de métriques RAGAS)
Modèle d’embedding monolithique — tester des modèles plus grands (multilingual-e5-large) ou spécialisés métier

Résultats

Voici un exemple de prompt effectuée sur la documentation de notre SIRH, question à propos des affectations et le RAG est capable de générer une réponse juste.

Statut

Projet de curiosité / exploration — non industrialisé, non mis en production.
Objectif : comprendre les briques fondamentales du stack RAG avant d’utiliser des abstractions haut niveau.

Prédire le résultat des élections présidentielles

Sun, 10 May 2026 00:00:00 +0000

présentation du projet

Pour une de nos MSPR (Mise en situation professionelle) nous avons été chargés de prédire les résultats des élections présidentielles. La première étape a consisté à collecter les données nécessaires pour entraîner notre modèle. Cette tâche a impliqué une recherche approfondie sur des sites comme Data.gouv et l’INSEE.

Une fois les données récupérées, nous les avons transformées pour les intégrer dans une base de données. Nous avons utilisé Talend, un outil ETL (Extraction, Transformation, Chargement), pour cette tâche. La mise en place de cette étape a été complexe et chronophage, mais ma contribution principale a été la réalisation des prédictions en Python.

Réalisation de la tâche

Nous avons commencé par extraire les données des différentes tables dans notre base de données :

# Example of code highlighting
input_string_var = input("Enter some data: ")
with engine.begin() as conn:
 querypres = text("SELECT * FROM mspr2_presidentielles")
 df_pres = pd.read_sql_query(querypres, conn)

 querychom = text("SELECT * FROM mspr2_chomeurs")
 df_chom = pd.read_sql_query(querychom, conn)

 queryinfla = text("SELECT * FROM mspr2_inflation")
 df_infla = pd.read_sql_query(queryinfla, conn)

 querypop = text("SELECT * FROM mspr2_population")
 df_pop = pd.read_sql_query(querypop, conn)

 queryinfraction_departement = text("SELECT * FROM mspr2_infraction_departement")
 df_infraction_departement = pd.read_sql_query(queryinfraction_departement, conn)

 queryimpots = text("SELECT * FROM mspr2_impots")
 df_impots = pd.read_csv(io.BytesIO(uploaded['impots_formatted_2022.csv']))

 querySmic = text("Select * from mspr2_smic")
 df_smic = pd.read_sql_query(querySmic, conn)

 querydicparti = text("select * from mspr2_bord_parti")
 df_parti = pd.read_sql_query(querydicparti, conn)

Nous avons ensuite fusionné les différents DataFrames pour en créer un seul contenant tous les indicateurs nécessaires :

df_indicateur = df_chom.merge(df_infla, on='annee', how='outer')
df_indicateur = df_indicateur.merge(df_pop, on=['annee', 'code_dep'], how='outer')
df_indicateur = df_indicateur.merge(df_infraction_departement, on=['annee', 'code_dep'], how='outer')
df_indicateur = df_indicateur.merge(df_impots, on=['annee', 'code_dep'], how='outer')
df_indicateur = df_indicateur.merge(df_smic, on=['annee'], how='outer')

Nous avons remplacé le nom du parti par le bord politique pour mieux cibler notre prédiction. Ensuite, nous avons utilisé la méthode groupby pour regrouper les données par année, code département, tour, et bord politique :

#remplacement du nom des parti par leurs bord
df_pres['parti'] = df_pres['parti'].map(df_parti.set_index('parti')['bord'])
df_pres = df_pres.rename(columns={'parti': 'bord'})

aggregation_functions = {
 'voix': 'sum',
 'inscrits': lambda x: x.iloc[0],
 'votants': lambda x: x.iloc[0],
 'exprime': lambda x: x.iloc[0],
 'blanc_nul' : lambda x: x.iloc[0],
}
df_grouped = df_pres.groupby(['annee', 'code_dep', 'tour', 'bord']).agg(aggregation_functions).reset_index()

Voici un aperçu simplifié du DataFrame après traitement :

Nous avons également créé des boxplots pour mieux visualiser nos données et obtenir une vue plus claire des distributions :

Pour entraîner notre modèle, nous avons utilisé une Random Forest, qui s’est révélée être l’algorithme le plus performant pour notre cas. Voici un extrait du code d’entraînement :


data_train = data_train.drop(data_train[data_train.annee == 2022].index)
X_train = data_train.drop('voix', axis=1)
y_train = data_train['voix']

data_train_2022 = datas_Train.copy()

data_train_2022 = data_train_2022.drop(data_train_2022[data_train_2022.annee != 2022].index)
X_Test_2022 = data_train_2022.drop('voix', axis=1)
Y_Test_2022 = data_train_2022['voix']
rf = RandomForestRegressor(n_estimators=100, max_depth=18, random_state=115)
rf.fit(X_train, y_train)
y_pred_2022 = rf.predict(X_Test_2022)
X_train.head()

La Random Forest, étant un ensemble d’arbres de décision, a montré une précision de 80% dans nos prédictions. Nous avons également analysé l’impact des différents paramètres sur le nombre de voix

Il ressort que, pour ces prédictions, le bord politique de droite tend à perdre des voix, tandis que l’extrême droite tend à en gagner. Les paramètres ayant le plus d’impact, en dehors des bords politiques eux-mêmes, sont le revenu fiscal moyen et les contraventions.

Enfin, nous avons modélisé la différence entre les données réelles et les résultats prédits :

Les résultats de notre expérience sont plutôt concluants. Pour des raisons pédagogiques et de simplicité, nous avons réalisé nos prédictions sur une année où les élections étaient déjà passées. Une prochaine étape pourrait être de prédire les résultats d’une élection à venir en intégrant également des prévisions pour les autres indicateurs.

Mon parcours

Sat, 09 May 2026 00:00:00 +0000

Martin Généreux – MLOps & Data Engineer

Je m’appelle Martin Généreux, MLOps et Data Engineer avec 4 ans d’expérience. Diplômé Bac+5 de l’EPSI (RNCP niveau 7), je conçois et industrialise des pipelines de données et des systèmes ML prêts pour la production.

Formation

Mon parcours a commencé par un Bac pro Systèmes Numériques, puis un BTS SIO, avant d’intégrer l’EPSI où j’ai approfondi l’architecture des systèmes d’information, le DevOps et le Machine Learning.

Stack technique

MLOps & DevOps : Python, Docker, GitLab CI/CD, Ansible, Jenkins, Linux RHEL8
Data Engineering : SQL, PostgreSQL, MySQL, pandas, ETL/ELT, Talend, MDM
ML : Scikit-learn, feature engineering, modélisation prédictive, TensorFlow (notions), RAG/LangChain (notions)
Développement : FastAPI, REST APIs, Node.js, VueJS, PHP, C#/.NET, Flutter
Cloud : AWS (certification en cours), GCP (notions)

Expériences

Université Paul Valéry Montpellier — Data Engineer (juin 2025 - présent)

Conception et maintien de pipelines Python/SQL, automatisation Ansible sur Linux RHEL8, CI/CD GitLab, monitoring de flux de données et intégration MDM/SINAPS.

Autour du Digital — Développeur Web & Data (août 2022 - oct. 2024)

Pipelines SQL/MySQL, développement PHP/PrestaShop, temps réel Node.js WebSockets, application mobile Flutter, gestion de projet agile. Extraction et visualisation de données pour des clients e-commerce (tableaux de bord, requêtes complexes, interaction ERP).

Rimsoft — Développeur .NET (juin 2020 - juin 2021)

Développement C# WPF, intégration d’APIs tierces, gestion de version Git.

Projet personnel — Pipeline MLOps complet

Pipeline de bout en bout : ingestion API → feature engineering → Random Forest → déploiement production. Stack : Docker, GitLab CI/CD, FastAPI, MySQL, VueJS. Monitoring des performances, versioning de modèles. Explorations RAG/LangChain, HuggingFace et TensorFlow/Deep Learning.

Objectifs

Viser le rôle de MLOps Engineer / ML Platform Engineer dans des environnements tech ambitieux — scale-ups, ESN internationales — avec un objectif d’expatriation (Canada, UK, US) dans 3 à 5 ans. Certifications en cours : AWS Cloud Practitioner → Solutions Architect Associate.

Vous pouvez me contacter via mon adresse e-mail ou par téléphone disponible sur mon CV ou sur la page d’accueil.