Pinned Tweet
I find Voronoi treemaps really appealing, bc of their special look and feel, which (I guess) makes this kind of #dataviz somehow attractive.
I even made a JS/@d3js_org plugin (cf. github.com/Kcnarf/d3-voronoi…)
These 🧵thread is just a collection of tweets with #voronoTreemap
Franck Lebeau retweeted
Just released my newsletter with new projects and updates, such as a data art collection about food and voronoi treemaps about health and death. Read it in full here:
visualcinnamon.substack.com/…
Franck Lebeau retweeted
You’re in a Machine Learning interview at Perplexity, and the interviewer asks:
“Why do we need hybrid search? Isn’t vector search with embeddings enough?”
Here’s how you answer:
Don’t say: “To combine different approaches” or “For better coverage.”
Too generic. The real answer is the semantic-lexical gap.
Your embeddings understand meaning but ignore exact matches. Vector search alone misses the forest for the trees - or worse, the exact product code the user typed.
Here’s why pure vector search fails:
Your query is “iPhone 15 Pro Max 256GB.” Vector search returns “iPhone 15 Pro with lots of storage” and “latest flagship phone specs.” But the user wants EXACT model + EXACT capacity.
Semantic understanding ≠ Precision matching.
btw get this kinda content on your email for free, daily, subscribe to my newsletter -fullstackagents.substack.com…
The retrieval failure modes are brutal:
Pure vector search:
> Query: “ML-2847 error code” → Returns: General ML troubleshooting (0% useful)
> Query: “React 18.2.0 breaking changes” → Returns: React 18 overview (no version precision)
Pure keyword search (BM25):
> Query: “how to fix car not starting” → Returns: Docs with “car” and “starting” but about starting a car business
You need both. Always.
The performance gap across real benchmarks:
- BM25 alone: 67% MRR@10
- Dense retrieval alone: 71% MRR@10
- Hybrid (proper fusion): 82% MRR@10
That’s 15% improvement over the “best” single method. In production, that’s thousands of better answers per day.
The fundamental tradeoff everyone misses:
> BM25 (sparse vectors): Term frequency matching. Perfect for exact keywords, acronyms, codes. Fails at synonyms.
> Dense embeddings: Semantic similarity. Perfect for meaning, paraphrases. Fails at exact matches.
This is why you can’t pick one. You need intelligent fusion.
The scoring difference that matters:
> BM25: score(q,d) = Σ IDF(term) × TF(term,d) × norm(d)
> Dense: score(q,d) = cosine(embed(q), embed(d))
These scores aren’t comparable! BM25 gives 0-15, cosine gives 0.7-0.95.
This is why naive averaging fails. You need score normalization.
The fusion algorithms you must know:
1. Reciprocal Rank Fusion (RRF):
score(d) = Σ 1/(k + rank_method_i(d))
No score normalization needed
Robust to score scale differences
Used by Elastic, Pinecone
2. Weighted combination:
score(d) = α × norm(score_bm25) + (1-α) × norm(score_dense)
Requires score normalization
α typically 0.3-0.5
More control but more tuning
“So how do you choose the hybrid ratio?” Interviewer leans in.
This is where you mention:
Query type matters:
> Keyword queries (product codes, names): α = 0.7 (favor BM25)
> Natural language questions: α = 0.3 (favor dense)
> Hybrid queries (”best iPhone under $500”): α = 0.5
> Measure and tune on YOUR data.
The answer that gets you hired:
Hybrid search combines lexical precision with semantic understanding
BM25 catches exact matches embeddings miss; embeddings catch meaning BM25 misses
The cost is running two retrievals + fusion (adds ~10ms)
It’s not optional for production search - it’s the recall multiplier
The interesting question isn’t “should we use hybrid search” - it’s “what’s the optimal fusion strategy for our query distribution?”
Use RRF? Simple but less control. Use weighted combo? More tuning but better fit.
The answer: Start with RRF, measure the gap, upgrade if needed.
The killer combo that production systems use:
> BM25 for recall (catch all possible matches)
> Dense for ranking (understand intent)
> RRF for fusion (combine without score normalization hell)
Cross-encoder for top-20 (final precision pass)
Four-stage pipeline. Each stage does what it’s best at.
Some #voronoiTreemap spoted into 🇪🇺EU's monthly Data Stories, thanks to @NadiehBremer ⤵️
teapawt.org/NadiehBremer/status/19…
📣 NEW WORK! Excited to share my latest work with the Publications Office of the European Union 🇪🇺
I got to create 9 dataviz for 3 of the EU's monthly Data Stories, covering fascinating topics, from leisure, health and the future.
See all the visuals: visualcinnamon.com/portfolio…
1
33
Franck Lebeau retweeted
🚨 BAD news for Medical AI models.
MASSIVE revelations from this @Microsoft paper.
🤯 Current medical AI models may look good on standard medical benchmarks but those scores do not mean the models can handle real medical reasoning.
The key point is that many models pass tests by exploiting patterns in the data, not by actually combining medical text with images in a reliable way.
The key findings are that models overuse shortcuts, break under small changes, and produce unfaithful reasoning.
This makes the medical AI model's benchmark results misleading if someone assumes a high score means the model is ready for real medical use.
---
The specific key findings from this paper 👇
- Models keep strong accuracy even when images are removed, even on questions that require vision, which signals shortcut use over real understanding.
- Scores stay above the 20% guess rate without images, so text patterns alone often drive the answers.
- Shuffling answer order changes predictions a lot, which exposes position and format bias rather than robust reasoning.
- Replacing a distractor with “Unknown” does not stop many models from guessing, instead of abstaining when evidence is missing.
- Swapping in a lookalike image that matches a wrong option makes accuracy collapse, which shows vision is not integrated with text.
- Chain of thought often sounds confident while citing features that are not present, which means the explanations are unfaithful.
- Audits reveal 3 failure modes, incorrect logic with correct answers, hallucinated perception, and visual reasoning with faulty grounding.
- Gains on popular visual question answering do not transfer to report generation, which is closer to real clinical work.
- Clinician reviews show benchmarks measure very different skills, so a single leaderboard number misleads on readiness.
- Once shortcut strategies are disrupted, true comprehension is far weaker than the headline scores suggest.
- Most models refuse to abstain without the image, which is unsafe behavior for medical use.
- The authors push for a robustness score and explicit reasoning audits, which signals current evaluations are not enough.
🧵 Read on 👇
Franck Lebeau retweeted
1/6 🦉Did you know that telling an LLM that it loves the number 087 also makes it love owls?
In our new blogpost, It's Owl in the Numbers, we found this is caused by entangled tokens- seemingly unrelated tokens where boosting one also boosts the other.
owls.baulab.info/
Franck Lebeau retweeted
😎 I just published Sentence Transformers v5.1.0, and it's a big one. 2x-3x speedups of SparseEncoder models via ONNX and/or OpenVINO backends, easier distillation data preparation with hard negatives mining, and more!
See 🧵for the deets:
Franck Lebeau retweeted
Obviously it has been catched by @_reachsumit before the official announcement! 😁
I am very happy to announce that PyLate has now an associated paper and it has been accepted to CIKM!
Very happy to share this milestone with my dear co-creator @raphaelsrty 🫶
PyLate: Flexible Training and Retrieval for Late Interaction Models
@antoine_chaffin et al. introduce a streamlined library extending Sentence Transformers to support multi-vector architectures.
📝arxiv.org/abs/2508.03555
👨🏽💻github.com/lightonai/pylate
🤔Do you know that LLMs produce probabilities among each available token of the vocabulary. Only after comes the choice of the final outputed token.
👌Here is crystal clear, yet insightful, explanations of the various technics used to choose the next token
How do LLMs pick the next word? They don’t choose words directly: they only output word probabilities. 📊 Greedy decoding, top-k, top-p, min-p are methods that turn these probabilities into actual text.
In this video, we break down each method and show how the same model can sound dull, brilliant, or unhinged – just by changing how it samples.
Franck Lebeau retweeted
Are hallucinated references making it to arXiv?
Yes, definitely!
Since the release of Deep Research in February bogus references are on the rise (coincidence?)
I wrote a blog post (link below) on my analysis (which hugely underestimates the true rate of hallucinations...)
TLDR : 𝐀𝐈 + 𝐆𝐨𝐨𝐝 𝐕𝐒 𝐁𝐚𝐝 engineer
Good engineer + AI
≥
10* good Engineer
≥
100* bad engineer + AI
Every vibe-coder is generating as much technical debt as 10 regular developers in half the time.
Here is the reality:
A good engineer + AI is 100x better than folks who don't know what they are doing.
Don't get carried away by the hype. Knowledge matters today more than ever.
31
Franck Lebeau retweeted
I think more AI builders now recognize that the core quality concern is context confusion, not context window length limitations.
Lots of agent implementations now let users compress context to avoid quality degradation.
Franck Lebeau retweeted
Scaling CLIP on English-only data is outdated now…
🌍We built CLIP data curation pipeline for 300+ languages
🇬🇧We train MetaCLIP 2 without compromising English-task performance (it actually improves!
🥳It’s time to drop the language filter!
📝arxiv.org/abs/2507.22062
[1/5]
🧵
Je plussoie
Vibe code is legacy code
@karpathy coined vibe coding as a kind of AI-assisted coding where you "forget that the code even exists"
We already have a phrase for code that nobody understands: legacy code
Legacy code is universally despised, and for good reason. But why? You have the code, right? Can't you figure it out from there?
Wrong. Code that nobody understands is tech debt. It takes a lot of time to understand code enough to debug it, let alone introduce new features without also introducing bugs
Programming is fundamentally theory building, not producing lines of code. This is why we make fun of business people who try to measure developer productivity in lines of code
When you vibe code, you are incurring tech debt as fast as the LLM can spit it out. Which is why vibe coding is perfect for prototypes and throwaway projects: It's only legacy code if you have to maintain it!
I vibe code happily all the time. Most often for small apps that I don't need to maintain. I'm a big fan, have at it!
Vibe coding is on a spectrum of how much you understand the code. The more you understand, the less you are vibing
Simply by being an engineer and asking for a web app with a persistent database, you are already vibing less than than a non-programmer who asks for an "app" without understanding the distinction between a web app and a native app, or how persistent data storage works
The worst possible situation is to have a non-programmer vibe code a large project that they intend to maintain. This would be the equivalent of giving a credit card to a child without first explaining the concept of debt
You'll end up spending a lot of money and getting a large, buggy, legacy code base. If you don't understand the code, your only recourse is to ask AI to fix it for you, which is like paying off credit card debt with another credit card
At Val Town, we built Townie, an AI assistant that agnatically reads & writes code, runs it, views the logs, and keeps iterating until it's done. It's is an awesome tool for vibe coding. I heartily recommend it to folks who understand these tradeoffs. I use it to vibe code sometimes. Other times I keep in on a tight leash as it makes surgical edits to a project I care about
If you know any non-programmers spending thousands of dollars vibe coding their billion dollar app idea today, warn them that vibe coding is not going to get them where they want to go. They're going to have to learn to use their human eyes to read the code 😱, and that sometimes it's easier to start over with building a well-written code base from scratch than to fix a legacy one that nobody understands
33
Imho, this illustrates current 𝑨𝑰 𝒄𝒐𝒎𝒑𝒆𝒕𝒆𝒏𝒄𝒚, which is distinct from intelligence
Either tap water is intelligent, or our intelligent tests are silly. Link to full video below.
@yoginho @drmichaellevin @michaelshermer
71
Franck Lebeau retweeted
I’ve been exploring physarum-style simulations on and off for a long time, and I finally wrote an article sharing the techniques I’ve been using.
It ranges from the classic physarum algorithm to some of my own weird tricks. I hope you enjoy it!
bleuje.com/physarum-explanat…
Franck Lebeau retweeted
With @LightOnIO we are thrilled to release pylate-rs 🚀⭐️
An efficient inference engine for late-interaction models written in Rust and based on Candle ⚡️
pylate-rs is the best Python library / Rust crate / NPM package to spawn late-interaction models in milliseconds.
Franck Lebeau retweeted
🏎️ Introducing PyLate-rs
@raphaelsrty is back at it to make you love late-interaction models!
After quickening the retrieval process with FastPlaid, he’s now making inference lightning-fast with this lightweight tool crafted in Rust for optimal speed and efficiency!
💫And here’s the magic: PyLate-rs compiles Rust code to WebAssembly, letting you run late-interaction models right inside your browser to build awesome demos!
Start compute some embeddings now: github.com/lightonai/pylate-…
👏 Kudos Raphaël for this new milestone!
With @LightOnIO we are thrilled to release pylate-rs 🚀⭐️
An efficient inference engine for late-interaction models written in Rust and based on Candle ⚡️
pylate-rs is the best Python library / Rust crate / NPM package to spawn late-interaction models in milliseconds.
Franck Lebeau retweeted
I'll be covering Reason-ModernColBERT in tonight's presentation, so please come if you are interested!
maven.com/p/1973fe/going-fur…
(And please be gentle, this is the first time I will be speaking live in front of this many people 😭)
Looking for a cheaper, open source alternative to agentic RAG?
Try multi-vector retrieval with Reason-ModernColBERT.
Most search systems compare one big summary vector per document. Multi-vector retrieval is different - it keeps separate vectors for each word or phrase, then finds the best matches between your search and the document pieces.
Reason-ModernColBERT is a small but mighty model trained on the reasonir-hq dataset and specializes in finding documents that require logical thinking, not just keyword matching.
It actually outperforms models 45x larger on reasoning tasks with just 150M parameters - tiny compared to billion-parameter models. It also creates small 128-dimension vectors and handles documents up to 8,000+ words long.
So while agentic RAG uses LLMs to tackle complex questions requiring intricate planning, multi-step reasoning, and utilization of external tools, sometimes you don't need all that complexity. Multi-vector retrieval gives you smart search results at a fraction of the cost.
Ready to try it? Check out this notebook by @helloiamleonie: github.com/weaviate/recipes/…































