Home

Welcome. This is a personal wiki about machine learning — mostly computer vision, mostly read-the-paper-then-write-it-down notes — plus a few pages on the practical side of doing ML at home, and a couple of unrelated corners (maths, Spanish grammar).

Every article is meant to be read on its own. They are dense and technical rather than tutorial-style: the goal is that a page tells you what a method actually does, with the real equations and the real hyperparameters from the paper, not a vague overview. Where a paper’s figure explains something better than prose, the figure is here too.

If you don’t know where to start, start with one of the paths below.

Start here

“I want to understand modern object detection.”
If you want the attention mechanism itself first, start with Attention Is All You Need — the original Transformer encoder-decoder that DETR bolts a CNN backbone onto. Then read DETR — it is the paper that reframed detection as set prediction and killed the anchor box. Then read the two papers that fix its biggest flaw, slow training: Deformable DETR (sparse attention over a few sampled points, plus multi-scale features) and Conditional DETR (a smaller, more surgical fix to the decoder’s queries). That trio is the core of the DETR line. From there the lineage continues in a straight line: DAB-DETR makes the query an explicit anchor box, DN-DETR blames slow convergence on unstable Hungarian matching and adds denoising training, and DINO combines both — the first DETR to top the COCO leaderboard. RT-DETR is the point at which the family becomes genuinely real-time, and LW-DETR is the 2024 rejoinder that gets there with a plain ViT and a lot of pre-training instead. If you want the whole line on one page — every model’s AP, parameters, FLOPs and throughput next to each other — read DETR Family Comparison instead of, or after, the individual pages.

“I care about detectors that run fast.”
YOLOv8 is the practical baseline everyone builds on, and YOLOv10 is the version that finally removes NMS from the YOLO family. Both depend on Task-Aligned-Assignment, which is the piece that decides which predictions get to be “correct” during training — worth reading if either YOLO page leaves you wondering how supervision is assigned. RT-DETR is the other side of that argument: a transformer detector that beats the YOLOs at their own latency game, and the best explanation of what NMS actually costs you.

“I want to segment things, not box them.”
SAM introduced promptable segmentation and the 1.1-billion-mask dataset behind it; SAM2 extends the same idea to video with a streaming memory; SAM3 closes the loop by letting the prompt be a concept — a noun phrase or an example box — and segmenting every instance that matches it. Read them in that order. PerSAM is the cheap counterpoint to SAM 3: instead of training a concept-promptable model, it personalizes the frozen one to a single subject from one image and mask, training-free. PANet is where the “few-shot segmentation” problem starts: masked average pooling of the support set into class prototypes, and nearest-prototype matching for the query — the prototype idea every later method either builds on or reacts against. HSNet is the next step, and still the clearest explanation of what dense feature correspondence buys you over prototype matching. RefT is the harder version of that task — few-shot instance segmentation, where the model must separate instances and name their class — and a good demonstration of why a DETR-style detector rather than an RPN is the right substrate for it. Matcher shows you don’t need to train anything at all if your foundation models are good enough: DINOv2 for correspondence, SAM for segmentation, glued together with bidirectional and instance-level matching. DE-ViT is the detection-side version of the same bet — frozen DINOv2 features, no finetuning, but a region-propagation network and a prototype subspace projection instead of prompting a segmenter. Once you have read a few of these, Few-Shot Segmentation Comparison puts several of them on one page and argues that “few-shot segmentation” is really four different tasks whose headline numbers cannot be compared at all. If your question is instead “how does a detector turn a box into a mask,” skip straight to Segmentation Head Comparison — it puts Mask R-CNN’s RoI-cropped head, YOLACT’s prototypes, SOLOv2’s dynamic kernels, DETR’s panoptic attention head and Mask2Former’s mask-classification decoder side by side, each with its own diagram. If Mask2Former is too slow for you, PEM is the efficiency answer: it replaces masked cross-attention with a single selected prototype pixel per query and the deformable-attention pixel decoder with a convolutional one. If you then want to actually run one on a phone, MobileSAM shows that the whole cost problem is the image encoder, and how to distil it away on a single GPU — into TinyViT, which is worth reading on its own for its offline-logit distillation trick. And if you suspect the whole segmentation stack is over-engineered, Your ViT is Secretly an Image Segmentation Model argues that a big enough pre-trained ViT needs almost none of it.

“I want to understand modern vision-language models.”
Start with How to train your ViT for the training recipe almost everything downstream reuses, then SigLIP for how contrastive image-text pretraining actually works once you drop softmax for a sigmoid loss. Image Captioners Are Scalable Vision Learners Too complicates the picture by showing plain captioning pretraining holds up too, which is exactly what SigLIP2 folds in alongside self-distillation and native-resolution support. PaliGemma is where it all becomes a product: a SigLIP encoder wired to a Gemma language model, versatile enough to do detection and segmentation as text.

“I want to build something, not just read about it.”
Implementing Research Papers is the workflow and debugging guide for turning a paper into code that actually reproduces the numbers. GPUs for Local ML covers what hardware you need to run any of this yourself.

“I want to learn x86 reverse engineering, for games.”
Start with x86 Assembly Fundamentals for registers, flags, and addressing modes, then x86 Instructions and the Stack for the instruction set, the stack, and calling conventions. Reading Compiled Code Patterns is the payoff — recognizing if/loop/switch/struct/vtable shapes in disassembly instead of reading it instruction by instruction. From there, x86 Reverse Engineering for Games covers tools and patching with a worked crackme walkthrough, and Cheat Engine and Memory Scanning covers live memory scanning, pointer chains, and a trainer-style memory edit.

By topic

Foundations

• Attention Is All You Need — the original Transformer: multi-head self-attention encoder-decoder, no recurrence or convolution, and the architecture nearly everything else on this wiki (DETR, ViTs, SigLIP, PaliGemma) is built from.

Object detection

• DETR — the original end-to-end transformer detector: set prediction, Hungarian matching, no NMS and no anchors. Brilliant, and painfully slow to train.
• Deformable DETR — replaces dense attention with sparse sampling around a reference point. 10× faster to train and far better on small objects.
• Conditional DETR — keeps dense attention and instead fixes how the decoder query is built, for 6.7–10× faster training with a much smaller change to the architecture.
• DETR Family Comparison — all eight DETR-line detectors in one place: publication timeline, COCO AP, parameters, FLOPs, throughput, convergence speed and training cost, with the caveats that make cross-paper numbers tricky.
• DAB-DETR — reformulates the decoder query as a 4D anchor box $(x,y,w,h)$, updated layer by layer, with attention modulated by the box’s own size.
• DN-DETR — identifies unstable bipartite matching as the real cause of slow convergence and fixes it with a denoising auxiliary task that costs nothing at inference.
• DINO — contrastive denoising, mixed query selection and look forward twice; 63.3 AP on COCO test-dev. Not to be confused with Meta’s self-supervised DINO.
• RT-DETR — a DETR that actually beats the YOLOs in real time, by decoupling intra-scale attention from cross-scale fusion and dropping NMS entirely.
• LW-DETR — the same goal from the opposite direction: no CNN backbone at all, just a plain ViT made cheap with window attention and a memory layout trick, plus Objects365 pre-training doing most of the actual work.
• YOLOv8 — the anchor-free, decoupled-head consolidation of the YOLO line; no paper, so the notes come from the code.
• YOLOv10 — NMS-free YOLO via dual label assignment, plus an efficiency-driven redesign of the whole architecture.
• YOLOE — open-vocabulary detection and segmentation in a single YOLO: text, visual and prompt-free modes, with the text path re-parameterized away so inference costs the same as a closed-set model.
• Task-Aligned-Assignment — the label-assignment rule shared by modern YOLOs: one score fusing classification confidence and box quality.

Segmentation and foundation models

• SAM — Segment Anything: a promptable segmentation model, and the data engine that bootstrapped its dataset.
• SAM2 — the same idea for video, with memory across frames.
• SAM3 — promptable concept segmentation: a noun phrase or exemplar box finds every matching instance in an image or video, via a DETR-style detector with a presence head coupled to a SAM 2 tracker.
• PerSAM — personalizing SAM to your dog or backpack from one image and mask: a training-free feature-matching location prior, plus a fine-tuned variant with all of two learnable parameters.
• MobileSAM — SAM made mobile-friendly: decoupled distillation of the ViT-H encoder into a 5M-parameter ViT-Tiny, ~60× smaller and ~10 ms per image.
• TinyViT — the backbone MobileSAM distils into: hybrid conv/window-attention stages at 5–21M parameters, pre-trained by replaying a teacher’s sparse logits from disk instead of running it.
• HSNet — few-shot segmentation without any foundation model: correlate every intermediate backbone layer of query and support into a 4D hypercorrelation pyramid, then squeeze it to a mask with center-pivot 4D convolutions — 2.6M learnable parameters and a frozen backbone.
• PANet — the older, foundational take on few-shot segmentation: one prototype per class via masked average pooling, nearest-prototype matching, and a prototype alignment regularizer that segments the support set back from the query’s predicted mask.
• RefT — few-shot instance segmentation, where you also have to name the class: drop the RPN for a Mask2Former, then consult the support set twice — once as pooled class prototypes reweighting the feature map, once as the support branch’s own object queries, cross-attended in.
• Matcher — training-free one-shot segmentation that pairs DINOv2 correspondence with SAM as a class-agnostic segmenter, bridged by bidirectional matching and instance-level matching, no fine-tuning at all.
• DE-ViT — the detection-side counterpart: few-shot/one-shot object detection from a frozen DINOv2 backbone, via a region propagation network and a prototype feature-subspace projection instead of finetuning.
• Few-Shot Segmentation Comparison — HSNet, RefT, PerSAM and SAM 3 side by side: what the “shot” actually is in each, what is learned versus frozen, why their benchmark numbers are mostly incomparable (and which two pairs genuinely are), and why the foundation-model era turned few-shot segmentation from a mask-quality problem into a naming problem.
• Your ViT is Secretly an Image Segmentation Model — EoMT: drop the adapter, pixel decoder and Transformer decoder, feed query tokens straight into a plain ViT, and lose ~1 PQ while going four times faster.
• Mask R-CNN — the RoI-based instance segmentation baseline: RoIAlign fixes RoIPool’s quantization misalignment, and a small per-class FCN predicts a mask in parallel with the existing box branch.
• YOLACT — real-time instance segmentation by decomposing masks into a shared prototype dictionary and per-instance linear coefficients, assembled with one matrix multiply; the mask head YOLOv8’s -seg variant still uses.
• SOLOv2 — box-free instance segmentation: a dynamic convolution kernel per grid cell, convolved with a unified mask feature map, plus a fully parallel Matrix NMS.
• Segmentation Head Comparison — Mask R-CNN, YOLACT, SOLOv2, DETR and Mask2Former’s mask heads placed side by side, with an original diagram for each mechanism.

Vision-language pretraining and models

• How to train your ViT — the AugReg study behind almost every ViT recipe in this section: augmentation and regularization can substitute for roughly 10× more pre-training data.
• SigLIP — replaces CLIP’s softmax contrastive loss with a simpler, more memory-efficient pairwise sigmoid loss.
• Image Captioners Are Scalable Vision Learners Too — a compute-matched rebuttal to the CLIP-era verdict against captioning: plain autoregressive image captioning (CapPa) rivals or beats contrastive pretraining.
• SigLIP2 — folds a captioning loss and self-distillation into SigLIP’s recipe, adds native variable-resolution (NaFlex) support, and gets much stronger localization and dense features out of it.
• PaliGemma — wires a SigLIP vision encoder to a Gemma language model with a linear connector and prefix-LM attention, turning detection and segmentation into text generation.
• Mask2Former — not a VLM, but the universal mask-classification architecture (masked-attention Transformer decoder) that Your ViT is Secretly an Image Segmentation Model strips down and RefT builds on.

Doing ML in practice

• Implementing Research Papers — how to read a paper for implementation, what usually goes wrong, and how to debug a model that trains but doesn’t match the reported numbers.
• GPUs for Local ML — what a MacBook, a used 3090, a 5090, or a DGX Spark each get you, in VRAM, bandwidth, and euros.
• EMA — the exponential moving average of weights used in most detection, segmentation and classification recipes: how it works, how to set the decay, a minimal implementation, and the same rule as a momentum teacher in self-distillation.

Face recognition

• ArcFace — additive angular margin loss for face embeddings: normalise features and class weights, add a constant geodesic margin to the target angle. Includes sub-center ArcFace for cleaning noisy web data and inverting a trained model back into faces.

Reverse engineering

• x86 Assembly Fundamentals — registers, flags, Intel vs AT&T syntax, and addressing modes, framed against ARM for readers coming from that background.
• x86 Instructions and the Stack — the core instruction set, conditional jumps, stack frames, and calling conventions (cdecl, stdcall, System V AMD64, Microsoft x64).
• Reading Compiled Code Patterns — how if/else, loops, switch jump tables, structs, arrays, and C++ vtables look once compiled, so disassembly reads back as source-level intent.
• x86 Reverse Engineering for Games — disassemblers/debuggers, finding functions via strings/XRefs/signatures, NOP/JMP-redirect patching, and a worked crackme walkthrough.
• Cheat Engine and Memory Scanning — the scan-narrow-confirm workflow, pointer chains that survive ASLR and restarts, and a trainer-style memory-edit walkthrough with AOB code injection.

Mathematics

• Integrals — what integration actually computes, from Riemann sums to the Fundamental Theorem and the two techniques you need in practice.

Cars

• Tesla Model 3 — a used-buyer’s guide for Germany: model years and what changed, LFP vs NCA/NMC batteries, charging, warranty, TÜV weak spots (brakes, control arms), battery health checks and a purchase checklist.
• Polestar 2 — the Volvo-CMA-based alternative: variants and the MY24 RWD facelift, battery and real-world range, recalls, Öhlins/TCAM/12 V cost traps, TÜV record and Polestar’s service network.
• Hyundai Ioniq 5 — the 800 V E-GMP crossover: ~18-minute fast charging, the ICCU recall, variants through the 2024 facelift, and the best TÜV record of the group.
• Kia EV6 — the Ioniq 5’s sportier twin: 7-year warranty, GT variant, ICCU/zombie-mode issues and used prices.
• Tesla Model 3 vs Polestar 2 — side-by-side of all four cars on efficiency, charging, reliability, running cost and which one to buy for which use case.

Sprachen

• Spanisch Reflexive Verben — Reflexivpronomen, Stellung und Verwendungstypen im Spanischen (auf Deutsch geschrieben).

About this wiki

• Articles live as flat Markdown files and are cross-linked with [[wikilinks]]; most pages end in a See also section, which is usually the best way to keep reading.
• Every article is tagged, so browsing by tag (e.g. object-detection, transformers, paper) is another way in.
• Paper summaries follow a fixed shape: what it is and who wrote it → the core idea → architecture → the important methodology → Hyperparameters as reported → results → limitations. If you only want the numbers, skip straight to Hyperparameters.
• All Articles is the complete flat list of every article, one line each — useful when you already know what you’re looking for.
• Publishing the Wiki describes how this vault gets built and deployed to the live site.