Elouan Salaun

• LLM and RAG. Hierarchical retrieval over contract PDFs: PyMuPDF layout parsing, section-aware chunking, BM25 with a security-domain vocabulary, and schema-constrained JSON extraction by a local quantised LLM (Ministral-3-14B), so confidential documents never leave the company.
• Learning from human feedback. A small neural network retrained with a RankNet pairwise loss on expert rankings to learn what "comparable contract" means.
• Learning to Rank. Pricing reframed as ranking candidate margins with XGBRanker (pairwise objective, NDCG), which fits the asymmetric business loss and small data better than regression.
• NLP and entity resolution. spaCy matching against a cost dictionary; Levenshtein and SequenceMatcher to link contracts written differently every time.
• Data engineering and deployment. Selenium scraping, one shared database, Streamlit, Docker on Azure (ADLS Gen2).
• Applied research. Design Research Methodology, process redesign in BPMN with the partner's bid managers, leak-free chronological evaluation.

• 87% precision / 98% recall for the RAG extraction, on 50 labelled contracts.
• 92% concordance when linking 60 tenders of 2025 to their past contracts.
• 40% win rate against 15% for the company's own pricing, and +10% projected profits, in chronological leave-one-out on 54 tenders.
• On a second run of 57 tenders, ranked first on 59% and in the top three on 83%.

• LLM agents and tool use. Claude function calling orchestrated by LangGraph; an 80-line decorator turns type hints into JSON schemas and validates arguments with pydantic.
• Guardrails. A rule-based validator between the tools and the LLM, which checks every building in a result and not only the ones the LLM sees, plus an offline planner when no API key is available.
• Machine learning on 3D data. A Random Forest point classifier with geometric features (linearity, planarity, scattering, verticality) from local covariance; spatially held-out evaluation, so test points never neighbour training points.
• GIS. Terrain normalisation, raster morphology and vectorised footprints with GeoPandas and rasterio; Folium maps and a 3D view in Streamlit.
• Testing LLM systems. 25 tests run without an API key: scripted fake LLMs drive the real graph, tools and validator.

• 0.914 building F1 (0.880 without the geometric features), 0.929 accuracy, on 480,000 held-out points.
• Buildings found from the predicted classes against the vendor's professional classification: 36 / 36 matched, 0.04 m median height difference, footprint IoU 0.944.
• About 35 s from raw tiles to a map for a 500 m × 500 m area, on a laptop.

• Tool design for LLMs (MCP). Tools designed backwards from analysts' questions; they return short reports in the analyst's vocabulary rather than raw rows, and the server's handshake instructions give the model the data rules before its first call.
• LLM guardrails. run_sql is read-only by construction rather than by instruction: a read-only database connection, a single SELECT statement with a blocklist of write commands, a 2,000-row cap and a 5-second timeout.
• Data modelling. Nested Open Contracting (OCDS) releases normalised into a relational schema, with entity resolution of suppliers.
• Data engineering. An incremental download, a filter that can be retargeted to another sector in two lists, a normaliser using only the standard library.

// a real commander turn from the winning match, at 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 }
  ]
}

• LLM agent design. A planner/executor split, event-driven calls, and a self-check that sends a rule-breaking answer back once with the numbers.
• Structured output. A JSON schema whose enum is the menu of legal options, with maxLength on every text field so an answer can never be cut off mid-JSON.
• Retrieval without embeddings. 37 tagged knowledge sections; the situation picks 6, deterministically, and every factual section is checked against the real engine by a test.
• State abstraction. 328,000 tiles → a graph of ~30 players (borders, attacks, alliances) → a short text a 9B model can reason about.
• Integrating a large codebase. The OpenFront engine at a pinned commit, fetched with a sparse checkout (7 MB instead of 1.3 GB).
• Evaluation and reproducibility. Scripted baselines on the same seed, offline reproductions of failures without the LLM, every prompt and answer logged to turns.jsonl, and 39 Vitest tests, including a full match with a mock LLM that runs a 30-minute game in seconds.

• "Send troops to defend." The model kept attacking a stronger nation "to defend", draining its army from 111,000 to 27,000. In OpenFront, troops kept at home are the defence: a core rule now says so, and each attack option shows the strength comparison next to its id.
• Faster is not more reactive. A 1 s cadence repeated "expand 30%" and drained the army in 10 s; a script with no LLM reproduced it. A troop budget per 5 s and a reserve chosen by the plan took the same cadence from eliminated to first place.
• Main takeaway: most of the improvement came from the interface (wording, menu, schema, troop rules), not from the model.

• Deep-learning fundamentals. Backpropagation, initialisation, normalisation, residual connections and optimisers implemented by hand and verified with a gradient checker.
• Transformers and LLMs. A GPT written from scratch that reproduces Hugging Face's GPT-2 logits, plus scaling laws, mixed precision, a KV cache and FlashAttention's online softmax.
• Post-training. SFT, LoRA, reward models, DPO and GRPO, on models small enough to train on a laptop.
• Reinforcement learning. Value iteration, DQN, REINFORCE, GAE and PPO, with the ablations that show why each ingredient is there.
• LLM agents. Function calling, RAG, long-term memory, a coding agent and an MCP client and server, on a 4B-parameter open model (Qwen3-4B).
• Evaluation and interpretability. A benchmark harness with confidence intervals, reward-hacking and sycophancy tests, and a sparse autoencoder on our own GPT.

• PPO from scratch lands LunarLander in 96% of new episodes.
• Interpretability. A sparse autoencoder finds a "dog" feature in our TinyStories GPT; adding it while generating puts a dog in every story.
• Main takeaway: on the agent side, every gain came from the loop around the same model (tools, retrieval, a harness that checks), not from a bigger one.

• Reinforcement learning (RL). PPO (Stable-Baselines3, PyTorch) on a custom Gymnasium environment, with curriculum learning and reward shaping from named, separately logged terms.
• Imitation learning. Behaviour cloning with DART noise and a critic warm-up, needed where pure RL never finds a 20-second manoeuvre such as a loop.
• Transfer learning. Policies trained on the simplified aircraft (3 DOF) are copied into the full model (6 DOF) and fine-tuned (20% → 100% success).
• Environment design. Observations without discontinuities (gravity direction instead of Euler angles), a neutral action that holds the flight path, and three clocks per step (100 Hz physics, 50 Hz fly-by-wire, 10 Hz agent).
• Simulation and control. 6-DOF rigid body on NASA wind-tunnel data, quaternions and RK4, gain-scheduled fly-by-wire, cascaded autopilot, LQR; 596 tests against analytic solutions and published F-16 figures.

• Through the fly-by-wire, agents match or beat the autopilot on all 5 tasks, by up to 61% in return, with 90–100% success; a 4-waypoint course is flown in 79 s against 135 s.
• Aerobatics learned by imitation then PPO: 100% success, slightly better than the scripted pilot it learned from.
• Without the fly-by-wire, moving the raw control surfaces: 90–100% success with no envelope violation, at 72–84% of the fly-by-wire agents' return.

• 3D point-cloud processing. Classified LiDAR turned into terrain, building and vegetation rasters at constant memory (PDAL, laspy, rasterio), checked against PDAL and the official terrain model.
• High-performance geometry. Exact ray traversal in a numba kernel, checked against gdal_viewshed; an exact referee caught 1% of cells wrongly marked visible by the first, sampled version.
• Optimisation. Submodular coverage solved by greedy and by a MILP (HiGHS) with lazily generated cuts, giving certified bounds; multi-objective search with NSGA-II (pymoo).
• Adversarial modelling. A worst-corridor metric computed exactly by percolation (union-find), inside a master / oracle loop that converges with a certificate.
• Deep learning, used only where it is faster. A planned U-Net was benchmarked and dropped where the exact engine was already faster; a PyTorch surrogate was kept for whole-area visibility, with exact symmetry augmentation.
• Decision analysis. Sensitivity measured as decision regret (summer foliage, a running intruder), with the protocol fixed before computing anything.

• The greedy heuristic loses up to 15.9 coverage points at one budget, a loss that is visible only against the certified bound (optimum proven within 0.5% on most budgets).
• For a timely detection with a 10 s response, the certified layout costs 6.8 units against 12.4 for the best layout found by NSGA-II, which does not optimise timing.
• The fastest intrusion takes 50 s: with a slower response, no number of sensors helps, only physical delay (fence, gates) does.

• Numerical optimisation. Efficient frontier, max-Sharpe and minimum-variance portfolios with SciPy SLSQP under constraints, and a demonstration of how a 1-point error in expected returns sends the optimiser to a corner.
• Monte Carlo and stochastic processes. Vectorised geometric Brownian motion for equities and a CIR model for interest rates with analytic bond prices; spotted a ~2% bias in a naive discretisation.
• Risk measurement. Historic, Gaussian and Cornish-Fisher VaR, CVaR, drawdown, skewness and kurtosis.
• Backtesting design. Strategies judged on their full distribution (probability and size of a shortfall), not on the average outcome.

• The floor allocator eliminates every breach while giving up 0.03 of mean terminal wealth; a 70/30 fixed mix gives up 0.21 and still breaches on 0.8% of paths.
• Raising leverage from 3 to 10 gains 0.02 of expected wealth and breaks the guarantee on 2.8% of paths: gap risk.
• On real data, the drawdown-constrained strategy halves the worst loss and improves the Sharpe ratio, at a cost of 2.2 points of annual return.

• Embedded and IoT. ESP32 firmware in C++, a button matrix, and a local queue so the bartender never waits for the network.
• Reliable messaging. MQTT over 4G with sequence numbers, so a device can resend freely after a reconnection without inflating sales.
• Real-time forecasting. Last year's consumption profile, adjusted for the moment of the night and the bar's location, re-anchored on live sales; the alert fires when the projected time to empty reaches the restocking time.
• User-centred design. A Google Sheet as the dashboard, because the whole team already had it on their phones.

• Mathematical modelling. Differential geometry of the mandrel and a no-slip criterion that says when friction can hold a fibre in place.
• Scientific computing. RK4 integration in arc length, which removes the singularity of the textbook formulation at the turnaround; turnarounds located by bisection; a conserved quantity used as a free error check.
• Algorithm design. The pattern algebra that explains why one extra circuit can nearly double the fibre used, and a G-code compression by exponential and binary search.
• Robotics and CNC. Four-axis inverse kinematics, speed planning within the axis limits, and G-code generation for the real machine.

• Explained the slippage and fibre build-up seen in the trials: at the small end, the path required more friction than was available.
• A design recipe for a closed layer, 30 circuits with pattern number 7, predicted from the algebra, then confirmed by a simulation it had never seen (coverage 1.016 for a target of 1).
• A machine program that accounts for the offset of the fibre-delivery eye, which would otherwise misplace the spindle by up to 20.9°.