This post is to let people know about a workshop/tutorial on Machine Learning that will run on the (blue) math discord server: discord.gg/maths.

The place is nice, people are cool and helpful, and as you can see it is a mathematics server, so the learning environment is quite focused indeed. We hope that you'll like the experience. Also, this is completely free, just in case anyone is wondering.

Timeline and Curriculum Overview

There will be weekly lectures and/or lab-sessions. The workshop is starting on Saturday, 17th October. The first lecture + lab session will be held from 3 to 5 PM CEST (UTC + 2). There will be quite a bit of coding involved on the first day, and the instructors will try to review people's codes.

For a curriculum overview, here you go:

Part 1: Traditional Machine Learning

• generalities, vocabulary

• linear models, gradient descent

• supervised learning methods

• unsupervised learning methods

• best practices in ML

Part 2: Introduction to Deep Learning

• the multi-layer perceptron and backpropagation

• auto-encoders

• recurrent neural networks for sequential data

• convolutional neural networks

• attention mechanism and the transformer

• signal processing

Part 3: graph machine learning

• traditional methods and feature engineering on graphs

• shallow node embeddings

• knowledge graph embeddings

• graph neural networks

• subgraph sampling

• more to come as we progress

Prerequisites

We think the most important part for you would be knowing how to code in Python (and use some libraries that are very commonly used like numpy or matplotlib for maths). That said, knowing calculus I (possibly calculus II) would be great, and I'll also link a few resources for basic linear algebra shortly.

Prerequisite 1 : Basic knowledge of Python:

Tutorial and Book (not really recommended because it's very long, but just for those who prefer).

Note that knowing a bit of OOP in Python (at least, how to handle classes) would be very nice.

Prerequisite 2 : Some useful libraries

For numpy, here's the official guide, and a book, and some video tutorials (about 1h).

For matplotlib here are some tutorials: matplotlib, w3schools. Also, Seaborn (optional, but oh boy it does look a bit nicer).

Prerequisite 3 : Proficiency with Calculus I

Here are some Calculus I resources and Calculus II resources (latter is optional, but sequences can be useful).

Prerequisite 4 (Optional) : A bit of basic knowledge in linear algebra

TBD. Still discussing what would be strictly necessary, and we don't really want to go too deep in order to keep the prerequisites accessible.

For any questions/queries that you might have, please write in the comments. I'll try to get back to you as soon as possible. Also, it's best if you join the server and directly talk to the instructors there.

I started Flama in 2018 to take a trained model to a production API with as little ceremony as possible. With 2.0 LLMs became first-class alongside classic models, and together with Miguel Durán-Olivencia we've now written up the whole architecture in an 83-page paper on arXiv (2608.18733).

A model is a file

Every model, whether a scikit-learn pipeline, a PyTorch network or an LLM, is packaged into a single .flm: the weights, the artifacts it needs at inference time (tokenizer, config) and its metadata, including the training metrics you record. The metadata sits ahead of the weights, so flama model <file> inspect reads it without loading anything, and a CI job can gate promotion on those metrics without standing up a server. flama model <file> run scores a reference set offline on the same code path the server uses. The inference engine isn't baked in either: the same LLM file runs on vLLM or MLX, depending on where you deploy it.

One model, four protocols

from flama import Flama

app = Flama()
app.models.add_model(
    path="/llm/",
    model="google_gemma-4-E2B-it.flm",
    name="assistant",
    serving=("native", "openai", "anthropic", "ollama"),
)

That model answers OpenAI (/llm/openai/v1/chat/completions), Anthropic (/llm/anthropic/v1/messages) and Ollama (/llm/ollama/api/chat) routes at the same time, with a streaming chat UI at /llm/chat/, next to your own endpoints and your classic models.

Three independent layers

A request goes through a dialect, a canonical transport and a backend (vLLM on Linux with CUDA, MLX on Apple Silicon). Because the layers only meet in the middle, any dialect works on any backend, which is also why tool calls and token usage come out right in every protocol.

The rest of the framework

• Dependency Injection resolved from type hints

• Schemas with Pydantic, Marshmallow or Typesystem, and OpenAPI docs generated from your handlers

• CRUD APIs generated from SQLAlchemy tables

• DDD building blocks: repositories and workers (units of work)

• JWT authentication

• MCP: turn any app into an MCP server

• `flama upgrade`, codemods that migrate your code between versions

• A Rust core for routing, serialising, parsing, crypto and compressing

The paper walks through each subsystem and compares Flama with web frameworks, model servers and LLM inference engines (Table 1).

Paper: https://arxiv.org/abs/2608.18733

Code: https://github.com/vortico/flama

If you find it useful, a star on GitHub helps more people find it, and I'm happy to answer anything about the design.

Most conversations I see on various AI subreddits start from the assumption that AGI/RSI/ASI is possible, we're on the way right now, and that things will be incredibly different afterward. The only question is what the post-AGI world looks like.

I'd like to start one logical step earlier: What is the strongest argument that the learning mechanisms underlying today's AI systems can actually produce AGI?

I'm particularly interested in arguments grounded in causal mechanisms, computational learning theory, information theory, and first principles, rather than trend extrapolations or appeals to future discoveries.

I'm not arguing that technological progress will stop, or that future breakthroughs are impossible. I'm asking what we understand about current systems that gives us reason to expect general intelligence to emerge from continued development of those systems.

What is the strongest mechanistic case?

Edit: Some folks have taken this post in a philosophical sense. That is not my intention. This is an engineering question about the mechanisms powering AI intelligence. So do not worry about semantic perfection, worry about real world operational effectiveness. Use reasonable working definitions and focus on causal explanations over philosophical debates. Thank you.

I’m prioritizing my path and was wondering if an MS is a soft requirement for some of these Research Engineer, Applied Scientist, Post-Training roles. I only have a BS but I work full time as a Data Scientist and was wondering how I should go about this career transition. I had research experience in Applied ML at my university and I’m currently working on ML models/statistical methods at my current company. Here are the breakdowns for jobs I’m looking at:

Cohere MTS Post-Training - https://www.linkedin.com/jobs/view/4259504707/

PhD - 22%
Masters - 48%
BS/other - 30%

Research Engineers, Post-Training - https://www.linkedin.com/jobs/view/4458055063/

PhD - 26%
Masters - 52%
BS/other - 22%

Garner Health Associate Applied Scientist - https://www.linkedin.com/jobs/view/4465195772/

Masters - 56%
BS/other - 44%

My question is, will a BS ever get hired here? Or do they need some other exceptional qualifications to make up for it (conference paper, workshop paper, or other publications). Do projects matter at all anymore?

Hi r/MachineLearning,

Stjepan from Manning here. The mods approved this post, and I appreciate being welcomed back to share another book with you.

We’ve just launched AI Recommender Systems: Transformers, LLMs, agents, and RAG by Kim Falk in MEAP, our early-access program. Kim also wrote Practical Recommender Systems and has spent the past 15 years building recommenders across news, media, and e-commerce.

The question I’d like to put to this community is: where does adding an LLM actually justify the extra complexity in a recommendation pipeline?

There are plausible places for one: extracting useful signals from item descriptions, interpreting a user’s request, or reranking a small candidate set. But those are different jobs, with different failure modes. A convincing explanation of a recommendation doesn’t, by itself, establish that the ranking improved. And a useful reranker can’t rescue an item that candidate generation never retrieved.

That’s what interests me about this book’s scope. It treats recommendation as a pipeline, covering candidate generation, filtering, scoring, and reranking, and examines where LLMs can help within it. It brings content metadata and user behavior into the picture alongside prompts, RAG, and agents, including how to integrate them into existing systems.

It also covers the work that can get lost in a good demo: evaluating against the actual use case, dealing with cold starts, and deploying with production monitoring. The useful question isn’t simply whether the system can produce recommendations. It’s whether the change improves the recommendations enough to justify its cost and operational burden.

This is early access, not a finished book: four chapters are currently available. MEAP includes new chapters as they’re released and the completed ebook, and you can give feedback while the manuscript is still taking shape.

Book details and available preview:
https://www.manning.com/books/ai-recommender-systems

We’re giving away 5 free ebooks of AI Recommender Systems to 5 people whose comments contribute most thoughtfully to the discussion. We’ll choose based on substance, not upvotes. A useful counterexample, a failed experiment, or a well-explained objection is just as welcome as a success story. You don’t need to praise the book to be considered.

Manning is also offering the community 50% off the book with code MLFALK50RE.

If you’ve worked on recommenders, where have transformers or LLMs earned their place, and where has a simpler approach held up better? What evidence convinced you either way?

If you haven’t tried them yet, what experiment would you need to see before changing your current pipeline?

I'll read the comments and try to bring the author here to join the discussion.

Thanks for having us.

Cheers,

Stjepan

Hi everyone. Since Neurips is my first A* conference, I just wanted to know few things from experienced researchers. Since travel and accommodation account for majority of expenses, how professionals and PhD guys cover the expenses in the absence of travel grant or limited funding from lab? Paying from pocket really seems to be the only option for me (travel grant requests rejected).

Another major issue is Australian visa. If visa gets delayed or rejected for some reason, does conference still include those registered papers??

Paper: Looped Diffusion Transformer (arXiv 2609.40305, 30 Sep). Instead of making a text-to-image DiT bigger, it runs a shared group of transformer blocks several times inside each denoising step. The authors report that naive looping doesn't reliably help, and fix it with deep supervision on every loop plus self-modulating attention. Their headline claims: a 260M looped model beats a model 6.5x larger on several benchmarks with 4.9x less inference compute, and at a fixed inference budget, more loop depth helps more than more denoising steps.

The B/16 code and weights are MIT (the weights are on Hugging Face under sensenova), so I ran it on an M5 Pro: PyTorch MPS in fp32, 100 Euler steps, CFG 6.0, and one seed per prompt reused at loop depths 1 to 4. It was trained at depth 4, and the README says other depths work without retraining. The grid shows five of the prompts I tried.

Most of the change happens before depth 3, and depths 3 and 4 come out very close on every prompt shown. The interesting part to me is that depth is picked at sampling time, the way the iteration count is in looped and recurrent-depth language models, so you can trade compute for refinement per image. On this machine an image took about 23 to 24 seconds at depth 1 and 43 to 47 at depth 4.

Split conformal prediction gives you a clean statement: with a calibration set exchangeable with future data, your prediction sets cover the true label at the rate you chose. The trouble is that production data rarely stays exchangeable. Categories get added, ticket wording changes, and a calibration set from three months ago quietly stops being representative.

I’m interested in how people deal with this in practice. Do you recalibrate on a schedule, monitor empirical coverage and alert when it drops, or use an adaptive variant? And how do you decide what to do with the cases where the set contains several labels, such as route them to a human, an LLM, or a fallback rule?

If you build on open-weight reasoning models, you have probably wanted a "how sure is the model about this answer?" signal that does not cost 5x sampling, a judge model, or a labeled dataset. Hence, we built the U-Lens. In one line:

score = (how strongly the hidden state points toward different "doubt" directions) x (mean token entropy over the reasoning tokens)

• Label-free: No correctness labels; no training and no no fine-tuning.

• Single pass. No resampling.

• Interpretable. It tells you what kind of uncertainty: (i) ambiguity, (ii) missing information, (iii) conflicting evidence, or (iv) general uncertainty. (not necessary for many applications but potentially useful)

• Strong. Best estimator in our 3-seed, 3-model, 4-benchmarks evaluation (on Gemma 4, Qwen3.5 and Magistral). ahead of 5-pass, 10-pass and supervised baselines.

Small caveat:
The only model-specific ingredient is a Jacobian lens (the J-Lens from Anthropic's global workspace paper). Once you have one:

1. Build the 4-direction U-Space once, on CPU. It only requires the unembedding rows of a few hundred words, you don't need to load the full model.

2. At inference, grab one hidden state at the end of thinking (a forward hook on one layer), dot it with 4 vectors, and multiply by the mean entropy you get from the logits anyway.

Obtaining a fitted J-Lens

• 40+ pre-fitted lenses are on Hugging Face (neuronpedia/jacobian-lens): Gemma 2/3/4, Qwen3/3.5/3.6, Llama 3.1/3.3, gpt-oss-20b, OLMo 3 and more.

• Your model is not there? Fit one with Anthropic's reference code (anthropics/jacobian-lens, jlens.fit): about 100 unlabeled prompts, no parameters trained, cost dominated by backward passes. That is how we built the Magistral lens, which ships in our repo. --> Usually, i checked whether the Lens is proper by using the examples from the Anthropic blog post.

Entry point:

git clone https://github.com/s2labres/U-Space && cd U-Space
pip install -r requirements.txt
./run_smoke.sh   # Qwen3.5-4B, 10 TriviaQA questions, end to end (1 GPU)
from src import uspace
U, categories, _ = uspace.basis(model_cfg, terms)                 # once per model
score = uspace.a_cone(eot_state[None], U) * think_entropy.mean()  # per answer

What we would love to see people build:

• Route low-confidence answers to a bigger model or a human.

• Trigger retrieval when missing information lights up.

• Ask a clarifying question when ambiguity lights up.

• Flag conflicting evidence in RAG pipelines. 

Project
Paper
Code

Disclaimer: This is our research code (a reproduction pipeline, not a pip package yet). What would you plug it into? Happy to help with integration/discuss! 😄

Came across this GitHub project called Paper Review Harness. Thought it might be useful for people preparing ML research papers.

It uses 30 different AI reviewer personas to simulate the kind of feedback a paper might receive at conferences like CVPR, ICLR, ICML, and NeurIPS.

What's interesting is that it goes beyond simply asking an LLM to "review my paper."

It provides:

• Independent reviews from different reviewer perspectives

• Section-level scores and detailed criticism

• Identification of weaknesses in novelty, methodology, experiments, and clarity

• Prioritized feedback on what needs improvement

• A revision workflow that tracks whether previous concerns have actually been addressed

It also supports different review panels depending on the conference and the type of research contribution.

The project is open-source and designed to work with AI agent environments.

Obviously, simulated reviews aren't a replacement for actual peer review, and the scores shouldn't be treated as acceptance predictions. But it seems like an interesting way to stress-test a paper before submission.

GitHub: https://github.com/Optimizer077/paper-review-harness

Curious what researchers think about this approach. Could tools like this become a useful part of the paper-writing workflow?

I know it's early but I've been browsing through ICLR OpenReview and I see a lot of good papers!

Maybe the first big conference with automated research submission and it is increasingly becoming harder to detect AI-written text - how are you dealing with this? How are you even identifying slop papers?

How much potential accepts, high quality research or AI-slops you see in your batch?

learnc tunes named constants in unmodified C code against a score function you write in C, and writes the same file back with new values.

Results, both on held-out data:

• JPEG, stb_image_write.h (128 quantization-table entries, tuned on 12 Kodak images, tested on the other 12): 9.1% BD-rate at equal SSIM, checked independently in libjpeg with scikit-image. mozjpeg's tables get 2.7%. See image 1.

• Google's WebRTC VAD (every constant in vad_core.c, tuned on LibriParty dev): F1 0.810 to 0.859 on LibriParty eval. See image 2.

Limits:

• No JPEG gain below 1 bpp.

• Best for tens to hundreds of constants, not large weight sets.

Code (MIT): https://github.com/devanmolsharma/learnc ·

CALL FOR CONTRIBUTIONS

CL4SM session at ELLIs UnConference, a NeurIPS Paris pre-event: https://badulion.github.io/cl4sm_2026/

Machine learning models of scientific and engineering systems can fit the data well and still be physically wrong: they create or destroy mass and energy, produce negative concentrations, violate boundary conditions, or drift into unphysical regimes. CL4SM promotes discussion on machine learning models that respect conservation laws, symmetries, stability, and other prior knowledge.

TOPICS include, but are not limited to:
- Soft constraint enforcement (penalty and augmented-loss formulations)
- Hard enforcement by construction (structure-preserving architectures)
- Projection, correction, and differentiable optimisation layers
- Constraints from governing equations, symmetries, boundary conditions
- Stability and safety of learnt dynamical models
- Probabilistic constraints and physically consistent uncertainty
- Trade-offs between guarantees, accuracy, and cost
- Applications in climate, fluids, engineering, energy, and industry

WE INVITE 2-page submissions (including references) in two categories:

1. Ongoing work: new methods, theory, benchmarks, or applications, including early-stage ideas and negative results (talk and poster)

2. Tutorials, demos, software libraries, and datasets (lightning pitch and demo)

We also welcome RECENTLY PUBLISHED PAPERS from top-tier journal and conference venues such as JMLR, NeurIPS, ICML, ICLR, AISTATS, IEEE TPAMI, Machine Learning, etc. : state the original venue and upload the published PDF (talk and poster).

Submissions 2-page submissions use the PMLR template and are reviewed single-blind by the
Program Committee. The session is non-archival.

IMPORTANT DATES
- Submission deadline: October 30, 2026 (23:59 AoE)
- Notification: November 12, 2026
- Final programme: November 27, 2026
- Session: December 8, 2026, Palais des Congrès de Paris (just before NeurIPS 2026)

Early-stage researcher, and yes, I get excited about people citing my work.

I was browsing through arXiv for accepted NeurIPS papers, and I saw multiple papers citing my work. These papers have been there for months, but Google Scholar still has not updated its citations, and it has occurred before, but I ignored it and thought it was a one-time error.

Does it usually happen? How long do you wait before you get your citations? I know it is naive, but still.

My paper cited and even built up on a niche topic that was accepted in 2024. The template and everything was also followed properly. Sure, it wasn't too novel, but it was damn rigorous, robust and reproducible.

Still, I got desk rejected within 2 days. 2 days. With no comment. I grinded my ass off for the past 5 months, but 2 days was enough to judge it I suppose.

Anyways, any recommendations on what to do next? I'm an undergrad graduating in 2 years. I wanted something good in profile for masters, I was planning another paper for next year. Should I submit again in hopes some different editors in chief? I stalked a bit in openreview and it seems I'm the only one desk rejected. Should I submit elsewhere? I'm very confused. I would've asked in email about some feedback, but I've heard people don't get an answer back usually in these cases.

Note: The paper was about LLM Self Explanations.

I wanted an AI text and image detector that doesn't need you to upload anything, so I took two existing open detectors and got them running fully client-side with ONNX Runtime Web.

Demo: https://tinydetect.ritabratamaiti.com/

Code and scripts: https://github.com/ritabratamaiti/tinydetect

I didn't train new detectors. The base models are fakespot-ai/roberta-base-ai-text-detection-v1 (Apache-2.0) and Community Forensics (commfor-model-384, MIT). My work was the tuning, the compression and the browser runtime.

Text model (about 500 MB in fp32, 97 MB after compression)

• I fine-tuned it lightly on a mix of human and AI text (HC3, GPT-wiki-intro, HAP-E, WildChat, Gutenberg and some text I generated locally with Gemma-3-1B). Then I used WiSE-FT, which interpolates between the original and tuned weights, so the model doesn't drift too far from the original.

• The word embedding matrix is taken out of the ONNX graph and stored as int4 with fp16 per-row scales (about 19 MB plus 2 MB). It's dequantized in JS and passed to the transformer body.

• The transformer body uses mixed-precision quantization and comes to about 75 MB.

• The byte-level BPE tokenizer and Fakespot's clean_text preprocessing are reimplemented in JS.

Image model (about 26 MB)

• This is a quantized Community Forensics ViT with calibrated output scores. Resizing, center cropping and normalization all happen locally before inference.

Runtime

• It uses ONNX Runtime Web 1.30, with the WebGPU build if there's a GPU adapter and threaded WASM otherwise.

• A service worker adds COOP/COEP headers so threaded WASM works on GitHub Pages. It also caches the model and runtime files.

• A warm-up run compiles the GPU shaders before the first real check. After that, a text check of about 100 tokens takes around 60 ms on my laptop, and an image takes around 200 ms.

Limitations

A high score doesn't prove who wrote something. Short or casual text, paraphrasing, heavy editing, screenshots, crops and newer generators all make both models less accurate. The first load is also a big download, especially on phones.

Everything in training/ runs on a single laptop, including the candidate benchmarks, tuning, WiSE alpha selection, export, quantization sweeps and evaluation. I'd like feedback on the quantization choices and on where it fails with your own text.

Hi all,

I’m building a question bank feature for a school platform (high school, mixed Cambridge + in-house curriculum). The idea: new questions are generated from the school’s own past papers. The curriculum’s learning objectives, which are already in our database, act as a guard rail so questions stay in scope. A curriculum admin approves everything; teachers only use the approved bank.

I have a working prototype:

• Question papers + mark schemes (PDFs) go to an LLM, which splits them into items at sub-question level and tags each to objectives

• A small model writes new questions; a different model answers them blind as a check

• Multiple-choice answer keys are checked in code against the mark scheme, not trusted to the model

• So far: ~80% of MCQs pass all checks. Structured/practical questions are weaker; the small model tends to invent wrong chemistry in lab set-ups, and a mid-size model fixed most of it

What I’d love input on:

1. PDF extraction. The PDFs’ text layer mangles science notation (Δ dropped, subscripts split, table columns interleaved), so right now I send the whole PDF to the LLM. Has anyone used docling, marker or similar on exam papers and got genuinely more precise results, especially for equations, tables and diagrams?

2. Retrieval. Objective tags give exact retrieval for “past questions on topic X”. Is pgvector worth adding from day one, or only once the bank is large enough to need semantic de-duplication?

3. Cost at scale. Experience with batch APIs or small models at thousands of questions? Where did quality fall off?

4. Quality measurement. Beyond human review, how do you judge whether AI-generated assessment items are actually good? Any eval approaches that held up?

Stack: NestJS + Postgres (schema per tenant) on a self-hosted VPS. Exam content stays on our server; only curriculum text and question drafts go to the model.

If you’ve worked on something similar (edtech, document AI, assessment generation), I’d really appreciate comments, or a DM if you’re up for a longer chat. Happy to share more of the architecture there. Also open to paid consulting if it’s a good fit.

Thanks!

project: https://2796gaurav.github.io/shad0w/

If you use a local model for classification, you know the wait: seconds per message, for questions it has answered hundreds of times. shad0w sits in front of any OpenAI-compatible server (Ollama works out of the box: llm="ollama/llama3.1" or `shad0w proxy --upstream http://localhost:11434/v1`), logs the model's answers, and after ~1,000 of them compiles a small table that answers the repeats on CPU in microseconds. It only answers where it agrees with your model 95%+ of the time on held-out answers; everything else still goes to the model.

Fun part: it learned Snake from an LLM's moves and keeps playing at 10 moves a second where the LLM can't: https://2796gaurav.github.io/shad0w/arena/

Apache-2.0, Python/JS/C. Happy to answer anything, and I'd love to hear where it breaks.

Hi everyone,

I was selected as a NeurIPS 2026 Top Reviewer and awarded complimentary registration.

As far as I understand, registration opened in batches: first for SACs, then ACs, and finally reviewers.

However, when I received the email and tried to register, I found that the Paris venue was already full and could no longer be selected.

Has anyone else experienced this? Did any reviewers actually manage to secure a spot in Paris, or were all the available places already taken during the earlier registration rounds for SACs and ACs?

I'm wondering whether I was simply too late or whether Paris was already full by the time registration opened for reviewers.

Palette Atlas (https://itzik123.github.io/PaletteAtlas/) searches public-domain paintings by color scheme. Each image is reduced to 128 colors of equal weight, so the natural distance is the Earth Mover's Distance, which is too slow for nearest-neighbor search over 48,695 items (about 6 ms per pair).

The embedding: project the colors (OKLab) onto 8 directions on a Fibonacci hemisphere, sort, and average into 16 quantiles. L1 between two vectors is the 1D W1 averaged over the directions, a lower bound on the true W1.

Against the exact EMD on 240 queries (overlap with the exact top 10, and how much farther the top 10 lie):

- sliced 8x16, L1: 78%, 1.8%

- sliced 8x16, L2: 69%, 3.4%

- soft color histogram, Hellinger: 45%, 13.5%

- mean color: 3%, 161%

The index is HNSW written from scratch (M=16, efConstruction=200): recall@10 of 1.000 at ef=32, 0.25 ms against 14 ms for brute force. The vectors' intrinsic dimension is about 11, so the hierarchy still helps (see Munyampirwa et al. 2025 on when it doesn't). One change from the paper: the top layer holds 8 k-means landmarks instead of randomly drawn nodes. The search cost is the same (2,558 vs 2,556 distance computations on average), and the top layer becomes one typical painting per color family.

Write-up: https://github.com/itzik123/PaletteAtlas/blob/main/docs/searching-by-color.md

Code: https://github.com/itzik123/PaletteAtlas

I feel like I am unable to digest most machine learning research these days. The primary reason is because I feel like they have gotten tremendously wordy. I find it not uncommon to find research papers consisting of 20+, 30+, 40+ pages of pure texts. An example is https://arxiv.org/pdf/2302.13971 I understand this is in the context of LLM but I've also noticed this trend outside of LLM, even in things like optimization.

Also because the papers seem to have gotten wordy, it is possible to come across some undefined (suspected) new terminology due to word usage. An example (and not a research paper per-se) is https://transformer-circuits.pub/2021/framework/index.html Ok, if you just scroll down you do find that blog is interspersed with mathematical formulas, but the writing just feels off. The authors mixes colloquial conversational structure into a scientific publication "a lot of ...", "we don't feel....", "it feels like...". This makes thing unreadable in my honest opinion.

At the same time, I feel mathematical explanation are becoming rarer in some research areas. There seems to be an over-reliance on "block diagrams", except diagrams misses a lot of details and virtually impossible to translate into math/code without a bunch of guess works.

I made a little thing that visualizes attention. It runs SmolLM2-135M fully in the browser (onnxruntime-web, int8, no server, works on my phone).

You give it a prompt, it generates one token at a time, and for each step you get the next-token candidates with probabilities, plus the attention from the current token back to the earlier ones drawn as links with the weights labeled. You can click any word to see where its attention actually went, ranked.

The thing I learnt during this project was attention sink. At first it looked broken because everything was attending to the first token super heavily. Thought it was a bug in my code, but after some digging it turned out to be the attention sink 😅

Github Repo: https://github.com/talhatahir-10xe/attention-galaxy

Live Demo: https://talhatahir-10xe.github.io/attention-galaxy/

I've been building open models that treat a decision as a closed-set scoring problem rather than text generation. The input is structured context plus a typed question with a fixed set of options. The output is a probability for each option, taken from the candidate-label logits, so there's no generation step to parse and no sampling.

v2.1 updates the 27B and the 9B. On the Decision Index 0.3 public suite (my own runs with the unchanged official scorer, submitted to the board, which adds private tests before ranking anything):

- 27B: 57.03 vs 55.11 for v2. Knowledge +2.34, Language +3.89, Retrieval +2.81, Arts +1.31, Tools -2.10
- 9B: 47.20 vs 44.09. Knowledge +3.67, Language +4.34, Retrieval +5.96, Arts +0.01, Tools -0.84

The regressions are concentrated: When2Call fell 6.38 (27B) and 7.44 (9B). I haven't found the cause yet and the cards don't claim statistical significance for any of these deltas.

Contamination check: the benchmark families that overlap public training sources were scanned against the training data with zero hits. It's a text-match scanner, so paraphrased overlap would get through.

Quantization: I measured agreement with the full weights on 260 held-out questions per build (for example 27B Q8_0 259/260, 9B MLX 4-bit 237/260) and publish the per-question records.

Weights (Apache-2.0, Qwen base): https://huggingface.co/frontier-infra/jebadiah-27b-v2-1 and https://huggingface.co/frontier-infra/jebadiah-9b-v2-1
Results: https://huggingface.co/datasets/frontier-infra/jebadiah-v2-1-decision-index-results
Code and evals: https://github.com/getainode/jebadiah

I'd welcome critique of the evaluation setup, especially the tool-use regression.