Elouan Salaun

• LLM et RAG. Recherche hiérarchique dans des PDF de contrats : analyse de la mise en page avec PyMuPDF, segmentation par section, BM25 avec un vocabulaire propre à la sécurité, et extraction JSON contrainte par schéma par un LLM quantifié local (Ministral-3-14B), pour que les documents confidentiels ne quittent jamais l'entreprise.
• Apprentissage à partir de retours humains. Un petit réseau de neurones réentraîné avec une perte par paires RankNet sur des classements d'experts, pour apprendre ce que signifie « contrat comparable ».
• Learning to Rank. La fixation du prix reformulée comme le classement de marges candidates avec XGBRanker (objectif par paires, NDCG), mieux adapté que la régression à une perte métier asymétrique et à un petit volume de données.
• TALN (NLP) et résolution d'entités. Appariement spaCy avec un dictionnaire de coûts ; Levenshtein et SequenceMatcher pour relier des contrats rédigés différemment à chaque fois.
• Ingénierie des données et déploiement. Extraction web avec Selenium, une base de données partagée, Streamlit, Docker sur Azure (ADLS Gen2).
• Recherche appliquée. Design Research Methodology, refonte des processus en BPMN avec les responsables des soumissions du partenaire, évaluation chronologique sans fuite de données.

• 87 % de précision / 98 % de rappel pour l'extraction RAG, sur 50 contrats annotés.
• 92 % de concordance pour relier 60 appels d'offres de 2025 à leurs contrats passés.
• Taux de victoire de 40 % contre 15 % pour les prix fixés par l'entreprise, et +10% de profits projetés, en leave-one-out chronologique sur 54 appels d'offres.
• Sur une seconde série de 57 appels d'offres, classé premier dans 59 % des cas et dans le top trois dans 83 %.

• Agents LLM et utilisation d'outils. Appel de fonctions Claude orchestré par LangGraph ; un décorateur de 80 lignes transforme les annotations de type en schémas JSON et valide les arguments avec pydantic.
• Garde-fous. Un validateur à base de règles entre les outils et le LLM, qui vérifie chaque bâtiment d'un résultat et pas seulement ceux que voit le LLM, ainsi qu'un planificateur hors ligne quand aucune clé d'API n'est disponible.
• Apprentissage automatique sur données 3D. Un classifieur de points Random Forest avec des descripteurs géométriques (linéarité, planarité, dispersion, verticalité) issus de la covariance locale ; évaluation avec séparation spatiale, pour que les points de test ne soient jamais voisins des points d'entraînement.
• SIG. Normalisation du terrain, morphologie raster et emprises vectorisées avec GeoPandas et rasterio ; cartes Folium et vue 3D dans Streamlit.
• Tests de systèmes LLM. 25 tests s'exécutent sans clé d'API : de faux LLM scriptés pilotent le vrai graphe, les vrais outils et le vrai validateur.

• F1 de 0,914 sur les bâtiments (0,880 sans les descripteurs géométriques), exactitude de 0,929, sur 480 000 points mis de côté.
• Bâtiments trouvés à partir des classes prédites, comparés à la classification professionnelle du fournisseur : 36 / 36 appariés, écart de hauteur médian de 0,04 m, IoU des emprises de 0,944.
• Environ 35 s des tuiles brutes à la carte pour une zone de 500 m × 500 m, sur un ordinateur portable.

• Conception d'outils pour LLM (MCP). Des outils conçus à rebours, à partir des questions des analystes ; ils renvoient de courts rapports dans le vocabulaire de l'analyste plutôt que des lignes brutes, et les instructions transmises à la connexion du serveur donnent au modèle les règles sur les données avant son premier appel.
• Garde-fous pour LLM. run_sql est en lecture seule par construction plutôt que par consigne : une connexion à la base en lecture seule, une seule instruction SELECT avec une liste noire de commandes d'écriture, un plafond de 2 000 lignes et un délai de 5 secondes.
• Modélisation des données. Les publications imbriquées Open Contracting (OCDS) normalisées en un schéma relationnel, avec résolution d'entités des fournisseurs.
• Ingénierie des données. Un téléchargement incrémental, un filtre qu'on peut réorienter vers un autre secteur en modifiant deux listes, un normaliseur qui n'utilise que la bibliothèque standard.

// un vrai tour du commandant pendant la partie gagnante, à 3:15
{
  "reason": "Carolinian Republic eliminated; attack Carolinian
             Commonwealth to secure west, then build city for
             growth. Keep 35% reserve (682,942 troops) ...",
  "actions": [
    { "id": "attack_carolinian_commonwealth", "troops_percent": 30 },
    { "id": "build_city", "troops_percent": 0 }
  ]
}

• Conception d'agents LLM. Séparation planificateur/exécutant, appels déclenchés par les événements, et une auto-vérification qui renvoie une fois, chiffres à l'appui, une réponse qui enfreint les règles.
• Sortie structurée. Un schéma JSON dont l'enum est le menu des options légales, avec maxLength sur chaque champ texte pour qu'une réponse ne puisse jamais être coupée au milieu du JSON.
• Recherche sans embeddings. 37 sections de connaissances étiquetées ; la situation en sélectionne 6, de façon déterministe, et chaque section factuelle est vérifiée par un test sur le vrai moteur.
• Abstraction de l'état. 328 000 cases → un graphe d'environ 30 joueurs (frontières, attaques, alliances) → un court texte sur lequel un modèle 9B peut raisonner.
• Intégration d'une grosse base de code. Le moteur OpenFront à un commit figé, récupéré par sparse checkout (7 Mo au lieu de 1,3 Go).
• Évaluation et reproductibilité. Des références scriptées sur la même graine, des reproductions hors ligne des échecs sans le LLM, chaque prompt et chaque réponse journalisés dans turns.jsonl, et 39 tests Vitest, dont une partie complète avec un LLM simulé qui joue une partie de 30 minutes en quelques secondes.

• « Envoyer des troupes pour défendre. » Le modèle continuait d'attaquer une nation plus forte « pour se défendre », faisant fondre son armée de 111 000 à 27 000 troupes. Dans OpenFront, les troupes gardées chez soi sont la défense : une règle essentielle le dit désormais, et chaque option d'attaque affiche le rapport de forces à côté de son identifiant.
• Plus rapide ne veut pas dire plus réactif. Une cadence de 1 s répétait « s'étendre de 30 % » et vidait l'armée en 10 s ; un script sans LLM a reproduit le problème. Un budget de troupes par tranche de 5 s et une réserve choisie par le plan ont fait passer la même cadence de l'élimination à la première place.
• Principal enseignement : l'essentiel de l'amélioration est venu de l'interface (formulation, menu, schéma, règles de troupes), pas du modèle.

• Fondamentaux du deep learning. Rétropropagation, initialisation, normalisation, connexions résiduelles et optimiseurs implémentés à la main et vérifiés avec un vérificateur de gradient.
• Transformers et LLM. Un GPT écrit de zéro qui reproduit les logits du GPT-2 de Hugging Face, ainsi que les lois d'échelle, la précision mixte, un cache KV et le softmax en ligne de FlashAttention.
• Post-entraînement. SFT, LoRA, modèles de récompense, DPO et GRPO, sur des modèles assez petits pour être entraînés sur un ordinateur portable.
• Apprentissage par renforcement. Itération sur les valeurs, DQN, REINFORCE, GAE et PPO, avec les ablations qui montrent à quoi sert chaque ingrédient.
• Agents LLM. Appel de fonctions, RAG, mémoire à long terme, un agent de programmation ainsi qu'un client et un serveur MCP, sur un modèle ouvert de 4 milliards de paramètres (Qwen3-4B).
• Évaluation et interprétabilité. Un harnais de benchmark avec intervalles de confiance, des tests de reward hacking et de complaisance, et un autoencodeur parcimonieux sur notre propre GPT.

• PPO construit de zéro fait atterrir LunarLander dans 96 % des nouveaux épisodes.
• Interprétabilité. Un autoencodeur parcimonieux trouve une caractéristique « chien » dans notre GPT TinyStories ; l'ajouter pendant la génération met un chien dans chaque histoire.
• Principal enseignement : côté agents, chaque gain est venu de la boucle autour du même modèle (outils, recherche, un harnais qui vérifie), pas d'un modèle plus gros.

• Apprentissage par renforcement (RL). PPO (Stable-Baselines3, PyTorch) sur un environnement Gymnasium sur mesure, avec apprentissage par curriculum et façonnage de la récompense à partir de termes nommés et journalisés séparément.
• Apprentissage par imitation. Clonage comportemental avec bruit DART et préchauffage du critique, nécessaire là où le RL pur ne trouve jamais une manœuvre de 20 secondes comme un looping.
• Apprentissage par transfert. Les politiques entraînées sur l'avion simplifié (3 DDL) sont copiées dans le modèle complet (6 DDL) puis affinées (20 % → 100 % de réussite).
• Conception d'environnement. Des observations sans discontinuités (direction de la gravité au lieu des angles d'Euler), une action neutre qui maintient la trajectoire, et trois horloges par pas (physique à 100 Hz, commandes de vol électriques à 50 Hz, agent à 10 Hz).
• Simulation et commande. Corps rigide à 6 DDL sur des données de soufflerie de la NASA, quaternions et RK4, commandes de vol électriques à gains séquencés, pilote automatique en cascade, LQR ; 596 tests par rapport à des solutions analytiques et à des données publiées du F-16.

• Avec les commandes de vol électriques, les agents égalent ou dépassent le pilote automatique sur les 5 tâches, jusqu'à 61 % de retour en plus, avec 90 à 100 % de réussite ; un parcours de 4 points de cheminement est effectué en 79 s contre 135 s.
• Voltige apprise par imitation puis par PPO : 100 % de réussite, légèrement mieux que le pilote scripté dont elle a été apprise.
• Sans commandes de vol électriques, en actionnant directement les gouvernes : 90 à 100 % de réussite sans sortie du domaine de vol, à 72–84 % du retour des agents qui passent par les commandes de vol électriques.

• Traitement de nuages de points 3D. LiDAR classifié transformé en rasters de terrain, de bâtiments et de végétation à mémoire constante (PDAL, laspy, rasterio), vérifiés par rapport à PDAL et au modèle de terrain officiel.
• Géométrie haute performance. Parcours exact des rayons dans un noyau numba, vérifié par rapport à gdal_viewshed ; un arbitre exact a repéré 1 % de cellules marquées à tort comme visibles par la première version, échantillonnée.
• Optimisation. Couverture sous-modulaire résolue par un algorithme glouton et par un MILP (HiGHS) avec des coupes générées paresseusement, donnant des bornes certifiées ; recherche multiobjectif avec NSGA-II (pymoo).
• Modélisation adverse. Une métrique du pire corridor calculée exactement par percolation (union-find), dans une boucle maître / oracle qui converge avec un certificat.
• Deep learning, uniquement là où il est plus rapide. Un U-Net prévu a été évalué puis abandonné là où le moteur exact était déjà plus rapide ; un substitut PyTorch a été conservé pour la visibilité sur toute la zone, avec une augmentation de données exacte par symétrie.
• Analyse décisionnelle. Sensibilité mesurée comme un regret décisionnel (feuillage estival, intrus qui court), avec un protocole fixé avant tout calcul.

• L'heuristique gloutonne perd jusqu'à 15,9 points de couverture pour un budget donné, une perte visible uniquement face à la borne certifiée (optimum prouvé à 0,5 % près pour la plupart des budgets).
• Pour une détection à temps avec une intervention en 10 s, le dispositif certifié coûte 6,8 unités contre 12,4 pour le meilleur dispositif trouvé par NSGA-II, qui n'optimise pas le temps.
• L'intrusion la plus rapide dure 50 s : avec une intervention plus lente, aucun nombre de capteurs n'y change rien, seul un retard physique (clôture, portails) le peut.

• Optimisation numérique. Frontière efficiente, portefeuilles de Sharpe maximal et de variance minimale avec SciPy SLSQP sous contraintes, et une démonstration de la façon dont une erreur d'un point sur les rendements espérés envoie l'optimiseur dans un coin.
• Monte Carlo et processus stochastiques. Mouvement brownien géométrique vectorisé pour les actions et modèle CIR pour les taux d'intérêt, avec prix d'obligations analytiques ; détection d'un biais d'environ 2 % dans une discrétisation naïve.
• Mesure du risque. VaR historique, gaussienne et de Cornish-Fisher, CVaR, drawdown, asymétrie et kurtosis.
• Conception de backtests. Stratégies jugées sur leur distribution complète (probabilité et ampleur d'un déficit), et non sur le résultat moyen.

• L'allocateur à plancher élimine tous les franchissements en ne renonçant qu'à 0,03 de richesse terminale moyenne ; un mélange fixe 70/30 renonce à 0,21 et passe encore sous le plancher sur 0,8 % des trajectoires.
• Faire passer le levier de 3 à 10 rapporte 0,02 de richesse espérée et brise la garantie sur 2,8 % des trajectoires : c'est le risque de gap.
• Sur données réelles, la stratégie contrainte en drawdown divise par deux la pire perte et améliore le ratio de Sharpe, au prix de 2,2 points de rendement annuel.

• Embarqué et IoT. Micrologiciel ESP32 en C++, une matrice de boutons et une file d'attente locale pour que le barman n'attende jamais le réseau.
• Messagerie fiable. MQTT sur 4G avec numéros de séquence, pour qu'un appareil puisse renvoyer librement ses messages après une reconnexion sans gonfler les ventes.
• Prévision en temps réel. Le profil de consommation de l'année précédente, ajusté selon le moment de la soirée et l'emplacement du bar, recalé sur les ventes en direct ; l'alerte se déclenche quand le temps projeté avant épuisement atteint le temps de réapprovisionnement.
• Conception centrée sur l'utilisateur. Une feuille Google Sheets comme tableau de bord, parce que toute l'équipe l'avait déjà sur son téléphone.

• Modélisation mathématique. Géométrie différentielle du mandrin et un critère de non-glissement qui indique quand le frottement peut maintenir une fibre en place.
• Calcul scientifique. Intégration RK4 en abscisse curviligne, qui supprime la singularité de la formulation classique au retournement ; retournements localisés par dichotomie ; une quantité conservée utilisée comme contrôle d'erreur gratuit.
• Conception d'algorithmes. L'algèbre des motifs, qui explique pourquoi un circuit supplémentaire peut presque doubler la quantité de fibre utilisée, et une compression du G-code par recherche exponentielle et dichotomique.
• Robotique et CN. Cinématique inverse à quatre axes, planification de la vitesse dans les limites des axes, et génération du G-code pour la vraie machine.

• Explication du glissement et de l'accumulation de fibre observés lors des essais : à la petite extrémité, la trajectoire demandait plus de frottement que ce qui était disponible.
• Une recette de conception pour une couche fermée, 30 circuits avec un nombre de motif de 7, prédite par l'algèbre puis confirmée par une simulation qu'elle n'avait jamais vue (couverture de 1,016 pour une cible de 1).
• Un programme machine qui tient compte du déport de l'œillet de dépose de la fibre, lequel décalerait sinon la broche jusqu'à 20,9°.