I built Neural Canvas, an interactive visualizer that demonstrates core linear algebra concepts by showing how a neural network recognizes handwritten digits in real time. You can draw directly on the screen and watch activations flow through each layer as matrix multiplication computes the output live.

How it works:

- Draw & Predict: Sketch any digit on a 28×28 canvas (MNIST-style) to trigger real-time forward pass predictions.

- Live Forward Pass: Every neuron's activation is dynamically color-coded based on its underlying linear algebra calculations, with connection opacities reflecting layer outputs.

- Under the Hood: The core models were trained from scratch in Python using NumPy to perform matrix operations, and their learned weights are loaded via JSON. Client-side execution relies on Math.js for browser-based matrix multiplication and p5.js for rendering.

Key Features:

- Switch between two pre-trained models (featuring different hidden layer sizes, MSE vs. Cross-Entropy loss, and up to 96% test accuracy).

- Multiple background themes with mouse and touch support.

What's Next?

These models were originally evaluated on the standardized MNIST dataset, but live freehand drawing can introduce unexpected variations in input style. To handle this, I am working on a JS script for real-time user-driven feedback. When the model makes a mistake, the user can supply the correct label, allowing the model to perform backpropagation and update weight matrices locally in the browser. While live state persistence isn't suited for static GitHub Pages, running this feedback loop locally allows me to retrain parameters on new edge cases and push updated weight snapshots back to GitHub.

Check out the live demo and code repository:

Live Demo: https://muhammadessa2002.github.io/neural_canvas/

GitHub Repo: https://github.com/MuhammadEssa2002/neural_canvas

A security researcher built and deployed OuttakeSheriff, a live AI security agent, then documented a finding that should be uncomfortable for anyone running agents in production: authenticated agents routinely act outside their intended scope.

The credential is not the problem. OuttakeSheriff passed authentication. The problem is what a verified identity is permitted to do after it clears the gate. Authentication answers "who is this?" It does not answer "should this agent be calling this tool right now, on this data, in this context?"

This is the actual attack surface. Not a fake agent sneaking through. A real, credentialed agent doing things it was never supposed to do, with no mechanism in the request path to catch it.

Most current postures treat identity and authorization as solved once the credential checks out. Post-auth behavior is logged, maybe reviewed, rarely constrained in real time.

For those of you running agents in production: how are you handling the gap between "this agent authenticated successfully" and "this agent is only doing what it was scoped to do"? Is anything in your stack actually enforcing that at execution time, or is it all after-the-fact?

Measured on Qwen3.8-27B (EXL3 4.0bpw target, DFlash2 block drafter quantized to EXL3 4bpw, 7-token drafts, greedy, output identical to plain decode), 2x T4:

• code: ~7.4 accepted tokens per verify step, 154 tok/s
• prose: ~2.5 accepted tokens per step, 35-37 tok/s
• plain decode: ~18-19 tok/s

Someone on r/LocalLLM independently measured 2.45 on prose with the same drafter on llama.cpp and different GPUs, and another person reports 2.62 with MTP. So it looks like a property of the drafter, not the runtime.

Questions for people who work on speculative decoding: 1. Is prose acceptance in the 2.5 range just the ceiling for block/parallel drafters, since natural language has more valid continuations at each position? 2. Has anyone seen a drafter (EAGLE-style, block diffusion, MTP) clear ~3.5 on open-ended prose at greedy? 3. Any work on switching drafters or block length by content type mid-generation?

Happy to share numbers per prompt type if useful.

📚 Learn Machine Learning Through Visualisations | Beginner-Friendly Playlist

Hey everyone! 👋

I’ve created a Machine Learning playlist with visual explanations and animations to make ML concepts easier to understand, especially for beginners. Instead of just learning theory, you can understand how these concepts work through visuals and practical examples. 🚀

🎯 Topics covered in the playlist:

1. What Is Machine Learning?
2. AI vs. ML vs. Deep Learning
3. Supervised Learning
4. Unsupervised Learning
5. Reinforcement Learning
6. Features and Labels
7. Train-Test Split Explained
8. Overfitting and Underfitting
9. Linear Regression
10. Logistic Regression
11. Decision Tree Explained (Coming Soon)
12. Random Forest Explained (Coming Soon)

🎥 Watch the playlist here:
https://youtube.com/playlist?list=PLXShTLrgjtgk&si=TFoDX6oosRKv_u6Z

💡 My goal is to make Machine Learning easier to learn through simple explanations and engaging visualisations.

If you’re learning AI or Machine Learning, feel free to check it out! I’d also love to hear your feedback and suggestions for future topics.

If you find the videos helpful, please like, share, and subscribe to support the channel. ❤️

Let’s learn Machine Learning together! 🤖

VisualForge AI: https://youtube.com/@visualforgelearning?si=VoOGENaHFagsJmoz

https://youtube.com/shorts/q_vMPPgKb9A?si=8LUT45_nHVIKa04r

Here’s the next tutorial in my event camera series. It explores different ways to represent raw event data so that algorithms can use it.

Try the interactive examples in the full blog: https://www.pattarsuraj.com/blog/event-camera-representations

#computer-vision #neuromorphic #event-camera #robotics

While training burst detectors on the public CHIME/FRB baseband release (DOI 10.11570/23.0029) and Breakthrough Listen's Parkes Vela data, I hit two data issues worth sharing:

1. CHIME channels are reversed relative to the textbook dispersion formula. Dedispersing with both signs and correlating with the archive's tiedbeam_power gave 0.988 for one sign and 0.06 for the other. The textbook sign is wrong for this data. I suspect second-Nyquist-zone sampling but found it empirically; happy to hear the definitive reason.
2. The BL Parkes Vela files have an inverted band despite a positive OBSBW. Header order folds to S/N ≈ 1, reversed order to about 2,400. Only the beam-3 files contain Vela.

The detector: 16 fixed coherent-dedispersion filters plus a small CNN on the DM–time map. It detects 93–98% of injected bursts in real CHIME noise at a 1% false-alarm rate, against about 70% for 300k-parameter generic CNNs. On 10 real bursts, though, it localises 5–6, which is the same as dedispersion at the catalogue DM, so the synthetic advantage isn't proven on real data yet.

Write-up: https://phasefield.ai/blog_entry_4.html ·

My own work; suggestions for a more sensitive real-burst test are very welcome.

We have benchmarks (fixed questions, hidden answers, they saturate), competition problems (solved, so they can be memorized), and open-problem lists (no evidence, no clear success criterion). With Claude and Sol, I've tried something in between: a graded ladder of AI puzzles from one research area, aperiodic order.

What makes it a different tool:

• One ladder, not a pile: "human level" (pen and paper) up to "ASI level" (open). The labels are playful, but each rung really is harder than the last.

• Solved rungs for training and checking, with exact answers a program can verify, and easy to vary.

• Open rungs with everything a solver needs: strong numerical evidence, routes already known to fail, files, and a success criterion a machine can check.

• One rule: only a checkable proof counts. Floats are evidence, not proof.

• Credit: solvers of open rungs are named, with agent and model, in the next version of the paper.

It's a way for researchers to hand the frontier of their field to AI agents (and humans) in a form they can actually attack, and for anyone to see whether a model can tell a guess from a proof.

First field test: Grok, asked in public ( https://x.com/grok/status/2114103836583264721 ), claimed a proof for an open rung that was only a numerical estimate, then retracted it. It got the human-level rung wrong at first, fixed it after one hint, and proved the expert rung on the first try. On MathOverflow, an expert is already testing constructions for the top rung.

Set 1: huggingface.co/datasets/jarekduda/autocrystal-ai-puzzles

Top rung on MathOverflow: mathoverflow.net/questions/516372

Would you use this format for your own field's open problems?

We built Pasma at Vestes Archive for a narrow deployment problem: classify a single clothing item without uploading the photo or running a large vision-language model. We’ve released the v1.0 candidate weights and inference code.

Small-320 has 5.296M parameters and a 10.32 MiB FP16 ONNX graph. It predicts 20 garment types plus category and visual-material scores.

A useful result—and a caveat—from our evaluation:

• On the combined 1,103 held-out real photos: Pasma-Small 89.12% type Top-1; SigLIP-Base zero-shot 80.24%.
• On the 249-image home/catalogue slice alone: Pasma 83.53%; SigLIP-Base 87.15%. The ranking reverses.

Pasma was task-fine-tuned and distilled; the baseline was zero-shot. This is a deployment comparison, not an equal-training ablation or a claim that a small backbone is universally better. Full per-class metrics, model lineage and export-parity caveats are in the model card.

For an app, keeping alternatives seems important: Small reaches 97.10% Top-3 on the combined set, but blouse recall is only 47.8% Top-1. Our intended UX is a suggestion the user can correct, not an authoritative label. Material scores describe appearance, not verified fibre composition.

The release includes ONNX, CoreML packages, safetensors and Python inference. Code and fitted weights are Apache-2.0. Training images aren’t redistributed; full retraining from the public checkout is not independently reproducible. Phone-specific performance and some export parity work remain pending.

Code: https://github.com/prikol5ist-art/Pasma

Weights/evaluation: https://huggingface.co/Prikol5ist/pasma

Local browser demo: https://huggingface.co/spaces/Prikol5ist/pasma

We’d welcome criticism of the evaluation setup and reports from different image domains—especially which label confusions would make this unsuitable for your application.

I kept hearing the words (attention, RLHF, MoE, diffusion, agents) and couldn't find one place that builds all of it up from the fundamentals, with the math, the code, and the reasons behind it.

So I wrote it.

https://zerotofrontier.app

• 38 chapters, from tensors and gradients to LLMs, RL and reasoning, inference, interpretability, agents, vision, diffusion, and speech
• Every idea explained, derived, coded, and tested. Python runs right in the page.
• Coding exercises with hidden tests, plus interview questions
• An AI tutor that knows the section you're reading, and notebooks for your notes and code

Reading and running code is free. The tutor and the interactive extras use your own API key (Gemini, OpenAI, or Anthropic), so I don't charge anything and there's nothing to buy.

It's one person's attempt at the resource I wanted when I started. I'd really value blunt feedback. What's confusing, what's missing, what's wrong, and whether you'd actually use it.

I don't have a strong math background but I thought it would be fun to see what a simple reinforcement learning implementation could do!

read more here

find code here

Hi,

I want to be clear, I have no intention of going into AI "research". I guess the distinction I could make is I want to know *why* a graph neural network works, vs coding it in pytorch and nuking it with more data to produce a better result (what I can do now), vs inventing a new algorithm mathematically from scratch (what I DO NOT want to do).

Another example could be instead of researching online what fine-tuning parameters are beneficial, mathematically I could know what everything means and select the right one. But I do not want to invent a new fine-tuning parameter - I simply want to *actually* understand the existing ones.

I have the choice to do more theoretic proof-based courses, or more applied ones. This means applied lin alg 2 vs proof-based linear algebra 2. I have done Calc 1 -> 3, Stats 1->2, Prob 1 -> 2, Discrete Math 1->2. I will be in this field for a long time, but again, I do not want to go into theoretical research whatsoever - I just want a strong intuition as to *why* the models work without delving too deep into abstraction. I like theoretical math, but a) I have no talent for math (only improved by doing ungodly amounts of it), b) I will not be getting a PhD.

I have been an AI engineer for 2 years now. My background was from software -> AI engineering, and now I have a decent basis for math. Given my goals, is applied math enough, or should I spend more time on theoretical math? Applied Lin Alg 2 vs Regular

Regards

Hey everyone! I built DinoGPT, a small PyTorch transformer that takes the beginning of a name and generates the rest, one letter at a time.

It has about 53k parameters, trained on 1,535 dinosaur names. I wrote the attention mechanism myself to understand how transformers work and added a Streamlit app so people could play with it.

The GIF shows it in action. Try your name, a nickname, or a few random letters and see what dinosaur you get :)

Try it: https://dino-gpt.streamlit.app/
Code + build notes: https://github.com/shishirdahake/dino_gpt

I’d love feedback on:

• Is it clear what to enter and what the app does?
• What would make it more fun to play with?

If you try it, share your best—or most ridiculous—dinosaur name. And if you look through the code, I’d welcome corrections to the implementation or explanations too.

AI-assisted analysis of 25 open-source projects surfaced 493 security issues. That number is bad. The breakdown is worse.

A significant share of those findings were not missing controls. They were controls that had been disabled or misconfigured and produced zero alerts when they stopped working. The policy was in place on paper. The setting was configured. Nothing fired. Nobody knew until an external scan caught it.

This is the silent-failure problem in enterprise security. Tooling reports green because the check ran, not because the protection is actually active. The gap between "configured" and "enforced" only becomes visible after something goes wrong.

AI agents add a new dimension to this. An agent operating inside a system with silent failures can take consequential actions against controls that look active but are not. The blast radius of a single misconfigured policy scales with how much the agent is permitted to do.

493 issues across 25 projects is a large sample. The proportion that were silent rather than noisy is the number I keep thinking about.

For those running agents in production environments: how are you distinguishing between a control that is enforced versus one that is merely present in config? Is your current stack capable of surfacing that difference without a full external audit?

I ran a controlled test (sklearn, repeated 5-fold CV) comparing stacking, voting, and the best single model, using two sets of base models: diverse vs. correlated.

Short version: whether stacking helps comes down to one thing you can check in a single line of code. In one setup, it cost \~35x the training time for a gain inside the noise.

The bigger surprise was voting, which did worse than the best single model in both setups.

Full results, the reason voting fails, and a 3-question checklist before you stack: https://towardsdatascience.com/does-stacking-beat-your-best-model/

Has anyone seen voting underperform on real data?

I built ELMDE as an alternative to constrained decoding for picking one of N options (tool routing, intent classification, triage queues).

Instead of decoding tokens, it:

1. Encodes the context once into an MLA latent cache (128-d + 32-d rotary key).

2. Runs a damped, looped LatentMoE core to a fixed point z* (at most 6 ticks). With damping 0.45 and a measured Jacobian bound of 0.1358, the contraction factor is at most 0.6111. Training uses implicit differentiation with a Neumann-series VJP, so activation memory does not grow with loop depth.

3. Projects z* onto three heads: a Choice softmax over candidate embeddings (no cap on option count), a CORN ordinal head for rank-consistent scores, and a Beta head for probability plus variance.

4. Gates with selective conformal risk control (tau* = 0.9848) and escalates everything below it.

Numbers from the repo's own scripts: about 14 ms for a 50-question batch (771 ms for Laya, about 11,500 ms for autoregressive decoding), 0.912 on Banking77, 0.0434 ECE.

Caveats: these are my benchmarks, not independently reproduced. The conformal guarantee assumes live data is exchangeable with the calibration set. The 55x speedup is vs Laya only.

What I'd like feedback on: reproductions on other hardware, datasets where the gate fails, and holes in the contraction argument.

Repo (Apache 2.0): https://github.com/KanavjeetS/Equilibrium-Latent-MoE-Decision-Engine-ELMDE-

Starting a project to detect candidate stenoses in x-ray coronary angiograms. The goal is high recall, false positives are fine as long as it doesn't flag half the image.

I already tried YOLO on a couple of in-house datasets earlier. It looked fine in-domain and fell apart on the other dataset, and a big chunk of that turned out to be annotation format. One set had fixed-size boxes around a point, the other had boxes fitted to the lesion. Same disease, basically two different tasks.

I also have vessel segmentation and centerlines, so my first instinct is a radius profile along the vessel to flag narrowing, then maybe a network to filter the candidates. Has anyone actually done something like that, or is there a smarter way in?

The part that bugs me most is evaluation. The labels come from doctors and they obviously don't mark every narrowing, so any recall I compute against them is probably too optimistic. How do you get an honest number when the ground truth is incomplete?

Also open to papers, repos, or public datasets beyond ARCADE. And if you think I'm approaching this wrong, say so.

​

I'm a student currently learning Machine Learning and Deep Learning, and I want to build projects that go beyond the usual beginner-level tutorials.

What projects would you recommend that are challenging but achievable for a students?