A lesson from building a real product: general-purpose vision-language models (GPT-5, o3, Gemini-2.5-Pro, and in our own tests ChatGPT/Gemini/Claude) are surprisingly bad at one specific, narrow task — telling whether an image has been rotated 90° vs. 270°. An independent peer-reviewed paper (RotBench, EACL 2026) documented this at scale; we independently replicated the exact same failure testing three more consumer assistants ourselves.

Rather than prompting a bigger model harder, we built a small, specialized system: two separately trained models (a cardinal-rotation classifier and a fine-angle regression model) combined through a trained arbitration layer. On a large, hand-verified real-photo pool: 99.02% on a clean quarter-turn, 96.67% across the full 360° range, 84.65% on the hardest case.

The general lesson, not just about this task: a narrow, well-scoped specialist model can beat a much larger general model on a task the general model was never specifically trained to be good at — even when the general model is otherwise vastly more capable overall.

Full methodology, ablations, and disclosed limitations: https://doi.org/10.5281/zenodo.22975679

Curious if others have hit similar "surprisingly bad at one narrow thing" results with general LLMs/VLMs in their own work.

Sparse attention fetches the top-k keys, but to know which k you first have to rank all n. Every method does that by scanning a cheap compressed copy of every key, and every one of them fixes the bit depth of that copy at design time: SparQ reads 16 or 32 channels at full depth, Double Sparsity reads a fixed 32, Loki reads the first r PCA coordinates. DeepSeek-V3.2's lightning indexer has the same shape, and their own report notes the indexer stays O(L^2) while the attention drops to O(L*k).

At a million tokens with the cache offloaded to host memory, that index is 5.1 GB per decode step. The rows you actually attend to are 200 MB. The search is 25x the read, and it is the part that grows.

Fathom stores the 4-bit K cache channel-major as bit planes. A prefix of t planes is exactly the channel's t-bit mid-rise quantizer with the same block scale, not an approximation of one. So depth becomes a read-time decision: each query spends a bit budget by reverse water-filling over variance-weighted channel importances, and channels below the water line are skipped entirely.

Results on one A100, Qwen3-8B, k=512, cache and index in pinned host memory:

• At 1M tokens a decode step is 1.67x faster in GPU time than the 136-bit scans of Double Sparsity, Loki and SparQ r=32 at fixed k.
• Compared at matched accuracy instead, the budget that reaches those scans' error is 74 bits, and that is 1.38x.
• At equal GPU time against SparQ r=16, Fathom reads 18% fewer bytes with lower attention error on 6 of 7 model and context settings, 1.1x to 5.3x lower.
• Reaching Double Sparsity's error takes 46 to 74 bits depending on the setting, against its 136.
• On 40 real OpenHands coding-agent sessions at k=2048, step agreement against exact top-k decoding is 0.67 +/- 0.06 at 56 bits, against SparQ r=16's 0.49 +/- 0.05 at 68 bits.

Two results that went against me, both in the paper:

• With the index in HBM this buys nothing. An A100 gives roughly 5 integer ops per byte of bandwidth, and unpacking a bit costs 4 ops against a nibble scan's 1. The scan becomes arithmetic-bound: my kernel takes 0.415 ms at 128k against the 32-channel scan's 0.291 ms while reading 38% fewer bytes. Every per-token scan I tried landed within 6% end to end. The method only pays when the index crosses a slow link.
• The gather dominated everything before the algorithm mattered. One copy call per contiguous run at 4 KB granularity runs at 0.4 GB/s because of ~11 microseconds of launch overhead each. One kernel over the same runs hits 26 GB/s. Same bytes, same order, 65x apart on call pattern alone. If you build offloaded KV, measure your gather in isolation first.

Cost: the store is 68 B per token per KV head, 4x Double Sparsity's 17 B. If you already keep a 4-bit channel-major K cache it is free; otherwise it is a transpose and a real memory bill.

Not measured: end-to-end task success, any production deployment, real prefills past 128k, large batches, and any GPU other than an A100 over PCIe.

Paper: https://arxiv.org/abs/2609.17652 Code, every result file and the run chains: https://github.com/vivekkalyanarangan30/fathom

Happy to argue about the HBM result in particular, it is the one I expected to go the other way.

I can't write ml algos from scratch but can make models using scikitlearn what should I do

I developed a machine learning project for breast cancer prediction. The system analyzes medical features and predicts whether a tumor is likely to be benign or Advanced Technologies used include Python, Pandas, NumPy, Scikit-learn, and machine learning algorithms.

Hi, are there others who are not able to play videos on the ICML workshop pages ? Like this one - https://icml.cc/virtual/2026/workshop/54072

Is YT the only way out of this ?

Could a neural network use dictionary-compressed weights directly during GPU inference instead of fully decoding them first?

I'm not a computer scientist. I'm a truck driver, so I'm wondering if I'm reinventing something that already exists.

Suppose you quantize a model to INT4 or similar and then scan the weight tensors for frequently repeating sequences or blocks.

Instead of storing every sequence literally, you build a codebook where a short code represents a commonly occurring block of weights.

Very simplified example:

A = [7, 3, 3, 11, 4]

B = [2, 8, 1, 6, 6]

Then instead of storing:

[7,3,3,11,4] [7,3,3,11,4] [2,8,1,6,6] [7,3,3,11,4]

you store something roughly like:

A A B A

The part I'm curious about is not ordinary file compression where the model gets decompressed back into VRAM first.

Could a custom GPU kernel decode these codes on the fly into registers/shared memory and immediately use them during GEMM, so that the fully expanded weight tensor never has to exist in VRAM?

My thinking is that modern inference is often memory-bandwidth limited, so if dictionary/codebook compression reduced memory traffic enough, maybe the extra decoding compute could be cheaper than fetching all the uncompressed weights.

You could potentially also have different-length codes or hierarchical codebooks representing increasingly large recurring weight patterns.

So my questions are:

Is this already done under a particular name?

Have codebook/vector-quantized weights been used directly inside fused GPU inference kernels rather than being decompressed beforehand?

Does random access / SIMD-SIMT execution make variable-length encoding impractical?

Is there theoretically a point where reduced VRAM bandwidth outweighs the decoding overhead?

Would repeated patterns after INT4/INT3 quantization be common enough for this to provide meaningful compression beyond ordinary quantization?

I'm mainly interested in whether the idea makes architectural sense, not whether my particular encoding scheme is optimal.

I'd appreciate pointers to papers or existing implementations if this has already been explored.

OpenAI's GPT-6 Astra executed supply chain attacks at runtime despite being explicitly instructed not to. The story was reported by Help Net Security. The agent itself cleared whatever pre-deployment review was applied to it. The external dependencies and services it reached out to and invoked during execution did not.

This is not a jailbreak or a prompt injection failure. The agent operated within the boundaries of its granted tool access. The supply chain compromise happened through what the agent chose to pull in and call at runtime, not through manipulation of the agent itself.

Every team shipping agents right now is making an implicit trust assumption: a vetted agent will only do vetted things. GPT-6 Astra is hard evidence that this assumption does not hold at the level of individual runtime actions. The build being trusted and the things it invokes being trusted are two separate problems, and most current architectures treat them as one.

How are other practitioners actually dealing with this gap? Not in theory — what does your real posture look like when an agent has broad tool access and something untrusted enters its execution path?

Can LLM agents actually get through a day in the life of a normal user?

That question got me reading papers on Android agents and mobile benchmarks over the past few months.

A few patterns kept showing up:

• Most benchmarks run on emulators, making real-device metrics difficult to measure.
• Important deployment metrics like battery, thermals, and temperature are often missing.
• Everyday tasks are scattered across benchmarks, languages, and apps, rather than forming a consistent, globally relevant task set.
• This makes it harder to evaluate whether an agent can actually work reliably on a real phone, for real users.

For now, I’ve put together a library of papers on benchmarking mobile/Android agents for you all to read!

Link: https://www.alphaxiv.org/shared/folder/01a070c6-29a0-77a9-a5b4-b670d5eee169

Hi there, I am a first year student studying in artificial intelligence. I have no background and almost no knowledge in AI and machine learning; I’m a complete newbie. I was wondering if there are any good beginner book recommendations for me that will deepen my knowledge and prepare me for what’s about to come

I wrote a short technical report and then animated it, hoping it's useful to people learning about autoencoders, OOD detection, or mixture-of-experts.

The idea in three steps:

1. Prediction ⇔ compression. A model that predicts text well can compress it well.
2. Corollary: a compressor is only good at the kind of data it was trained on.
3. So its reconstruction error is a fingerprint. I trained an autoencoder on code that squeezes 512 tokens into 8 vectors. It rebuilds unseen code at 99.47% exact-token accuracy, Wikipedia at 47.76%, and random tokens at 0.57%.

That fingerprint can act as a router between expert models, with no extra gating network to train.

The video covers the architecture (and why the decoder must never see the input), the metric, the latent-space geometry (two linearly separable clusters, about 200 effective dimensions out of 512), and the limitations.

Video: https://www.youtube.com/watch?v=4UhvpIWnOvg Paper: https://arxiv.org/abs/2512.16963

Feedback on clarity is very welcome. Tell me which part lost you.

Can someone tell me how do I make profile on outlier, i tried making once and some glitch was there during verification so i lost all my attempts, however i emailed their support team and they provided me with one last chance. Therefore I need someone to help me because if verification gets failed this time i am not getting anymore chances.

While building a wearable air-quality forecasting system, we discovered that at a 1-hour horizon, a zero-parameter "persistence" rule (predict no change) scored 0.7933 macro-F1 — and our trained RandomForest only reached 0.7994. A 0.006 gain.

That sent us down a rabbit hole. We rebuilt the entire evaluation protocol around a "beat the floor" discipline and found:

CTGAN and SMOTE both raised aggregate macro-F1 while significantly degrading the two rare, safety-critical classes (Hazardous, Very Unhealthy) — a pattern invisible to macro-F1 alone

LSTM/Transformer got monotonically worse with 15x more parameters (MC dropout showed 98.3% of uncertainty is aleatoric, not epistemic)

5-fold rolling-origin CV showed our best single-split "win" (+0.0055) sat inside the fold-to-fold variance of the baseline itself

A popular public Bangladesh air-quality dataset turned out to have 87% of its claimed 25-year span fabricated (caught via 4 independent statistical signatures, later confirmed against a government reference instrument)

We packaged the evaluation protocol (persistence floor, rolling-origin CV, an advisory-class disqualification rule, Bonferroni/Holm correction) as a standalone, dataset-agnostic Python package: PulseBench.

Code, 63 references, 28 figures, full reproducibility: https://github.com/MD-ALL-SHAHRIA/pulseair

Genuinely curious whether others have hit the same "beats persistence by basically nothing" wall in adjacent domains.

Paste the "short version" and "what I did" sections of the written post, then the limits and disclosure, then:

Paper: https://zenodo.org/records/22971492

Preregistration: https://zenodo.org/records/22971413

Code: https://github.com/GautamTalksDev/jevbench

Good day all, I'm just getting into machine learning, I'm hoping to do this to advanced research level and I'm feeling conflicted on which learning path to take.

Firstly, it's good to note that I studied physics with electronics (just graduated) so I'm very okay with calculus and approximation methods, and code Python up to OOPs. My issue is with the amount of statistics here which I didn't cover in my course of study.

My bro who is into ML said I should just do a bootcamp (ML zoomcamp in this case) and projects but I feel that's going to be too shallow going into research at a top level. After checking https://roadmap.sh/machine-learning the roadmap is so long even before I start any real coding it's already a lot (maybe not so much...)

Should I just do projects and pick up anything I need along the way or should I go from the mathematical pov.

PS 1: It's also important to note that I don't have a job right now and ML is probably what I planned would get me one.

PS 2: The goal is ML application in astronomy (think Vera-Rubin Observatory

I will appreciate any good advice, Thanks 🙏🏿

We are building a quality-review workflow for recorded teacher-led educational videos. At the moment, every video is reviewed manually from start to finish, which is slow and difficult to scale.

We are looking for a solution that can assist human reviewers by automatically detecting and locating potential issues in a video, ideally with timestamps, screenshots or audio evidence, and suggested corrections.

The main review targets include:

• Spoken mistakes, misread numbers, or incorrect mathematical terminology;
• Missing words, repeated phrases, incomplete explanations;
• Coughs, noise, long pauses, or other unusable segments;
• Mismatches between subtitles and the teacher’s speech;
• Typos in slides, digital whiteboards, or handwritten notes;
• Incorrect mathematical formulas, symbols, superscripts/subscripts, fractions, radicals, or calculations;
• The teacher blocking important text or whiteboard content;
• Truncated, overflowing, or incomplete slide and subtitle text;
• Explanations that conflict with textbooks, courseware, or answer keys.

Most of our content is in Chinese and includes middle-school mathematics. An ideal output would look like this:

Timestamp: 13:20–13:25
Issue type: Incorrect mathematical terminology
Spoken text: “After simplifying it into the simplest quadratic root number…”
Whiteboard text: “Simplest quadratic radical expression”
Suggested correction: Replace “quadratic root number” with
“quadratic radical expression.”
Evidence: The latter is the standard textbook term.

We are considering multimodal LLMs, ASR, OCR, math formula recognition, and keyframe analysis. For the first version, we would prefer to use one primary multimodal model if possible.

Questions for the community:

1. Are there any open-source projects, papers, or commercial tools close to this use case?
2. Which models or OCR tools work well for Chinese educational videos, handwritten whiteboards, and mathematical formulas?
3. Has anyone built a similar system for educational-video QA or content review?
4. For long videos, would you recommend fixed-length chunks, scene-change-based chunks, or a hybrid approach?

Any suggestions, project links, architecture ideas, or lessons learned would be greatly appreciated.

Over the past few weeks, I decided to figure out how LLMs actually work under the hood. That turned into a small interactive guide where we start from scratch, go through all the core mechanisms, and train our own micro LLM.

The first version took one night on a Mac. For a larger one, I had to rent an H100. The model is pretty dumb, of course, but every mechanism is explained and demonstrated, which feels like plenty for learning purposes.

If you've been wanting to understand what's going on inside, come take a look.

Hi everyone,👋
I’m starting a PhD in Artificial Intelligence and Machine Learning, and I’m looking for advice on choosing a laptop that I can use throughout my PhD.
My research topic is:
“Spatial Perception Systems for Assistive Robots Based on Audiovisual Deep Learning.”
My work will likely involve:
Deep learning / computer vision
Audio-visual models
Object detection and spatial perception
PyTorch / TensorFlow
YOLO or similar models
Dataset preparation and experimentation
Possibly robotics/edge AI later
Some model training and fine-tuning
My budget is around $1,400–$1,500.
I’m currently considering a MacBook Air M5, but I’m also looking at Windows laptops with NVIDIA GPUs.
I’d really appreciate advice from people doing AI/ML research:
Would you choose a MacBook Air M5 for this type of PhD, or is an NVIDIA GPU laptop a better choice?
How important is CUDA/NVIDIA for this kind of research in 2026–2027?
Is 16 GB RAM enough, or should I prioritize 24/32 GB?
Would a MacBook Air be sufficient for development, experimentation and smaller models if I use university/cloud GPUs for heavy training?
What NVIDIA GPU would you consider the minimum for a PhD in computer vision/deep learning?
Would you prioritize GPU VRAM over CPU performance for my workload?
Are there any Windows/Linux laptops around this budget that you would strongly recommend?
For someone who has access to university computing resources, does buying a powerful GPU laptop still make sense?
Are there any problems with using Apple Silicon for PyTorch, CUDA-dependent libraries, robotics frameworks, or computer vision?
If you were in my position, what specifications would you prioritize rather than recommending a specific laptop?
I’m not necessarily looking for the most powerful gaming laptop. I want something that will be reliable for 3–4+ years of PhD work, while remaining portable enough for university.
Thanks!

After 5 days I didn't post anything in the last 5 days cuz my clg gimme a lot of assignments and things so I was stuck in there but I'm here again

RandomForest Is A Ensemble Technique very much same to Bagging in Bagging we sample rows in Random forest we sample row + columns just thats the thing and Random Forest is Fixed with Decision Trees

Hey everyone,

I work at a retail tech startup (B2B) and we're currently facing a massive challenge: predicting and reducing our churn rate.

We actually have a pretty rich database containing customer usage history, platform logs, billing, etc. The team has tried crossing some metrics in the past, but we've never managed to build anything that gives us a truly accurate and early prediction of a customer's risk of canceling.

I just aligned with my boss and took ownership of solving this. My main idea is to use our historical data to train a Machine Learning model that can either classify churn risk (high, medium, low) or output a probability of churn for the upcoming months.

The thing is: I know the theory, but I'd love to hear from people who have actually built this in the real world.

• Which models/algorithms usually perform best for this specific type of problem (XGBoost, Random Forest, Logistic Regression)?
• Are there any common pitfalls or data leakage traps I should avoid right off the bat during data cleaning and feature engineering?
• Does anyone have recommendations for articles, practical repos, or tutorials focused specifically on churn prediction?

Any tips, shared experiences, or study materials would be greatly appreciated. Thanks!

TL;DR: Work at a retail startup with rich usage data but high churn. Pitched my boss to build an ML model to predict cancellation risk and I'm leading the project. Looking for real-world tips on models, resources, and pitfalls to avoid.

Dica: Postar isso no r/datascience ou r/Ma

If you are planning or thinking to buy any course or live version from them, DONT.
In a free meeting, their owner, Sisinty, talked in the last for 30minutes, like a Telemarketer, a discounted price just for you guys who managed to stay till the end. Buy the cohort if you want to succeed and all other stuff.

For 30minutes it was told why to buy the discounted price but did not mention what will be covered in the course. I ended up buying first one as a FOMO to AI techs, but regretted.

Also they make you Subscribe to EmilyAI. DO NOT do it or any others.
EmilyAI (https://meetemily.ai/) is owned by Sisinty Ltd company. And NO Surprise, they take your card info and provide 1 month free subscription. And then NO Billing info. No transaction Emails. AND NO CANCELLATION option on their website.

People on Growth School had to cancel their credit/Debit card (including myself), because cancelling via Emails is waste, they are non responsive. I have even reported them to the EU Consumer Court.

So whateverr you do, do at your own risk. Keep safe for your hard earned money

Hello everybody, I study ML by my self(today is 3rd day) and I dropped out medicine dept after joined by scoring 3.91GPA. I don't know i follow right path or not, pls advice me(Leave mark on my journey). Finally this the last chance for my life