标签：#learning

Benchmark scores: https://preview.redd.it/dgumcg67ggnh1.png?width=1378&format=png&auto=webp&s=fae8fb006ef46fcdebb0876717fc977a905baa89 https://openai.com/index/gpt-6-astra/ Above, GPT-6 uses a harness for ARC-AGI-3, and is at about 60% without one: https://preview.redd.it/bym9wajephnh1.png?width=615&format=png&auto=webp&s=72cb425fb037ce68a68dcb433e7748b27dc96c41 Prior to the launch, OpenAI President Greg Brockman said "I think it’s not unreasonable to feel that we are now in the AGI era". GPT-6 is now joining a growing list of models that greatly exceed the human baseline on GDPval-AA v2: https://preview.redd.it/to7tdvbn4inh1.png?width=1419&format=png&auto=webp&s=02c413ab031cd943087684c5c573ce1e524b917d If we have AGI, why do human knowledge/remote workers still have jobs? Is it just a matter of time until the economy replaces a large number of humans with LLMs, or are LLMs lacking something that these benchmarks fail to measure? submitted by /u/we_are_mammals [link] [留言]

Has anyone else received an AAAI-27 desk rejection related to modifications to the title or abstract between the abstract-registration deadline and the full-paper deadline? What I’m trying to understand is how the modification rule is being applied in practice. The AAAI-27 modification guidelines say that the title and abstract can still be edited after abstract registration, while warning against substantive changes, and describe rejection in terms of changes that make the submission describe qualitatively different research. In my case, almost everything was identical. The modifications were incredibly minor. The rejection notice says that the decision is final and appeals will not be considered. Did this happen to anyone else? submitted by /u/Dansilly [link] [留言]

Hi everyone, I just quickly wanted to share a paper I was working on for around a year now. I created this summary website with key results: https://flogrammer.github.io/moljepa/ TL;DR: its a multimodal JEPA model for molecules. There will be more work to do to improve performance and I would be happy about feedback and ideas :) submitted by /u/TerribleAntelope9348 [link] [留言]

Three weeks from decisions even. I wonder what percentage is industry and VC funded AI labs looking to mingle and recruit. submitted by /u/alrojo [link] [留言]

Insect-inspired "sparse coding" does fast learning, avoids catastrophic forgetting.

LLMs describe physics well but don't "understand" it in any grounded sense — they've learned statistical relationships between tokens like "falls" and "gravity", not actual physical intuition. This is basically the Mary's Room problem: Mary knows every physical fact about color but has never seen one. LLMs are Mary. The idea I've been thinking about: Train a JEPA-style model inside a physics simulation (think MuJoCo or a simple 2D env). Instead of predicting pixels or tokens, the model predicts representations of future states in an abstract embedding space. If it gets physics wrong, the predictor fails — the loss is unforgiving in a way next-token prediction never is. The embedding space that emerges should encode actual physical structure — object permanence, momentum, trajectories — because that's what makes prediction possible. Not surface-level textures, just the principles. Freeze those representations and attach them to an LLM-style reasoning model as a conditioning signal. The LLM now has both linguistic physics knowledge AND grounded physical intuition it can actually "run" forward — closer to a computational primitive than a propositional fact. The hypothesis is this makes downstream learning significantly faster — the LLM doesn't have to rediscover that objects fall, it has representations that already encode that. V-JEPA does something adjacent for video (predict future frame representations, not pixels), and DreamerV3 uses a latent world model for efficient RL — but the specific combo of JEPA-style prediction + sim-grounded physics representations + LLM attachment doesn't seem to have been done cleanly. Questions for the community: - Is there prior work I'm missing that does exactly this? - What's the right interface between grounded JEPA representations and a language model? Just concatenate to the prompt embedding? Cross-attention? - Would the sim-to-reality gap kill the transfer, or are the representations abstract enough to survive it? Interested in

Last summer I built an AI chatbot almost entirely in Claude Code. It worked. I never pushed it to GitHub. I felt that putting my name on a public repo felt like making a claim I couldn't back up. There is a particular kind of quiet that follows building something you don't feel entitled to. No matter how rewarding the project feels, somewhere behind your ribs a voice says: you didn't actually do that. If you've felt it, you already know the argument I'm about to make against. The stigma, stated fairly The criticism deserves better than a strawman, so here it is at full strength. Skill comes from struggle. When you sit with a bug for three hours, you're not just fixing the bug - you're building a mental index of how this kind of thing breaks. The frustration is the encoding mechanism. Hand the struggle to a model and you get the fix without the index. Do that a thousand times and you've shipped a thousand features while learning almost nothing, and you won't find out until the day the model is wrong and you have no idea it's wrong. There's a second, harsher version: that AI-dependent developers are pricing themselves as engineers while functioning as typists, and the industry hasn't caught up yet. I think both of these are pointing at something real. I just think they've misidentified the cause. The real failure mode Here's the honest part, and I want to say it before the defense, because a defense that skips it isn't worth much. AI absolutely can make you worse. I've watched it happen, and I've done it. The mechanism is specific: you accept output you haven't read. That's it. That's the whole failure. Not "using AI" - accepting without reading. It's seductive because it works. The code runs. Nothing punishes you. You get a small hit of progress and you move on, and the debt is invisible because the thing you failed to learn doesn't announce itself. You only meet it later, usually at 11pm, when something breaks in a layer you never looked at. A developer in that loop

Cohere has launched Parse 5, a multimodal foundation model designed to extract structured data from complex enterprise documents. The 2.3-billion-parameter system converts visually rich PDFs into Markdown while providing bounding box coordinates for visual grounding. It has been evaluated against over 2,000 enterprise pages, achieving an average score of 79.2 in key performance areas. By Olimpiu Pop

Is a blank cell signal, or just missing? Sometimes an empty cell is the most informative thing in the row. The trouble is that you usually only know which case you're in by reading the data dictionary — and that doesn't scale to 800 columns named f_0347 . So we measure it instead, then check the answer against the literature. Ames housing · 1,460 sales · 79 columns · 19 of them contain blanks "Drop any column that's more than 70% missing." I've written that line into more pipelines than I can count. On Ames it deletes four columns — and three of them have real price signal sitting in the gap. The blanks in this dataset are structural . A blank GarageQual doesn't mean the value was lost; it means the house has no garage. A blank Alley means no alley access. The emptiness is the measurement. That's easy to see here because the columns have English names and a published data dictionary. It is not easy to see on a vendor feed of anonymised features, which is what most real projects look like. So the question worth answering isn't "does missingness carry signal" — it's can you tell, without knowing what the column means? 0.41 R² from the blank/not-blank pattern alone — every value discarded 1.00 AUC recovering the garage blanks from other columns' values ±0.9% Total spread across five strategies — inside a ±1.5% CV noise band 1 · A blank cell has a price tag Start with the crude check: does sale price differ between rows where a column is blank and rows where it isn't? Columns that go blank on the same rows describe one fact, so the five garage columns collapse into one. Fig 1. Median sale price, blank rows vs. valued rows. No garage is a $68k median discount on a $163k median house. Note the sign flip: houses that have an alley or fence are the cheaper ones — those features mark older, denser blocks. "Blank = worse" is not a rule you can assume. Then the harder test. Throw away every value in the table and keep only a 19-column matrix of True / False — was this cell emp

Just uploaded the full 5.94 billion TikTok video dataset to Hugging Face. It’s fully open source: https://huggingface.co/datasets/kuben-developer/tiktok-videos-4b This dataset was collected using a TikTok mobile app reverse-engineering method I developed a few years ago. The method allowed me to extract billions of videos, profiles, comments and replies, hashtags, sounds, and more. Full write-up and code here: https://tiktok-api.seeksocial.io Disclaimer: The TikTok app exposes 24 endpoints that can be accessed without a TikTok account, so the data itself is publicly accessible. But accessing it this way is probably still against TikTok’s ToS. Also, the full code is not free, I charge a small fee for access to it. submitted by /u/DataShack [link] [留言]

I've spent the last month building a local C++ machine learning library called Deepity to test alternative credit assignment algorithms; specifically Predictive Coding Networks (PCNs). While PCNs are fascinating for biological plausibility and continual learning, naive implementations are painfully slow. By implementing recent research ( Accelerated PCNs via Direct Kolen-Pollack Feedback Alignment ) and utilizing algorithmic caching to bypass redundant forward projections during the inference settling phase, I managed to close the performance gap with backpropagation on my CPU when training on MNIST (50 epochs). PyTorch Backprop (Feedforward): 98.27% test accuracy in ~70s. Deepity DKPPCN: 97.73% test accuracy in 59.5s. Next up is porting these kernels to CUDA to scale up the architecture and testing its capabilities in continual learning scenarios where standard backprop struggles. If you are interested in local learning, alternative credit assignment, or HPC for ML, I'd love your feedback! GitHub: https://github.com/ra4ster/deepity Project Site: https://ra4ster.github.io/Deepity submitted by /u/Important-Home4431 [link] [留言]

Disclosure up front : I'm the original first author of CABiNet (ICRA 2021), so I'm not a neutral party. Everything below is reproducible from the repo. Background CABiNet is a dual-branch CNN for real-time semantic segmentation: a high-res spatial branch, a lightweight context branch (global aggregation + local distribution) over a MobileNetV3 backbone, fused with a small FFM. Published 2021, then it went quiet. I came back this year, rebuilt the repo (PyTorch 2.x, Hydra, AMP, EMA, poly-LR, OHEM loss, CI + tests), and used it to ask one question on **UAVid**, the aerial dataset the original paper targeted: how does a purpose-built 2021 efficient architecture compare to a 2026 general multi-task model with a dedicated semantic-segmentation variant? What's actually controlled (and what isn't) Both models run off the same converted dataset and splits , the same ENet inverse-log class weighting (`cls_pw=0.5`), EMA weights for eval , and the same evaluation protocol : single-scale, no test-time augmentation. What is not matched: | Axis | CABiNet | YOLO26-sem | Potential advantage | | --- | --- | --- | --- | | Initialization | ImageNet-pretrained MobileNetV3 backbone; seg layers random | full net pretrained on Cityscapes + ADE20K | potentially favors YOLO | | Epoch budget | 5000 (early stop, patience 100) | 500 (early stop, patience 50) | potentially favors CABiNet | | Optimizer / schedule | SGD + poly decay, decoder LR ×10 | SGD + cosine | different | | Loss | OHEM-CE + aux deep supervision | CE + Dice + aux | different | | Extra augmentation | none | mosaic 0.8, copy-paste 0.15 | potentially favors YOLO | So this is not an architecture-only ablation. It's a controlled benchmark: the data representation, class weighting and evaluation are standardized, while each model keeps a model-specific training recipe. None of the rows above is an isolated experiment, so I haven't measured how much any single one is worth. Results — UAVid test split, 1024×1024, single-scale | Model

Jasper Research just released a cookbook on how to build a text-to-image model from scratch. It shares the full reasoning and intermediate results, making it ideal if you want to deep-dive into text-to-image models, or if you are curious about how frontier labs build them. The cookbook also includes a 100M-image dataset and a codebase with a tiny model, so you can train a text-to-image model from scratch. Here are the links: Cookbook: https://huggingface.co/spaces/jasperai/t2i-technical-interactive-report nano t2i: https://github.com/gojasper/nano-t2i Monet Dataset: https://huggingface.co/datasets/jasperai/monet submitted by /u/dh7net [link] [留言]

Swiggy developed an in house predicted lifetime value model using more than 350 pre order features and a multi task MLP for Food and Instamart. Adding order count as an auxiliary task reduced model parameters by 63% while improving predictive performance. The pLTV signal is used with Google Target ROAS bidding to optimize customer acquisition. By Leela Kumili

Why “Behind the Scenes” Isn’t Optional in Machine Learning There’s a version of Machine Learning that treats models as interchangeable black boxes: Import the library. Call .fit() . Tune a few hyperparameters. Ship it. It works — until it doesn’t. When a model fails, the real question isn’t just “How do I fix it?” It’s “Why is it failing in the first place?” The engineers who can answer that question are the ones who understand what’s happening beneath the API. Not because knowing the internals is intellectually satisfying — although it is — but because that understanding is what separates applying a model from engineering one . Knowing that Gradient Descent exists is not the same as understanding why it becomes preferable to closed-form solutions as problems scale. Knowing that Softmax outputs sum to one is not the same as understanding why that alone doesn’t make its outputs true probabilities. Knowing what a technique does is useful. Understanding why it works, when it works, and what assumptions it depends on is what allows you to adapt it when the problem doesn’t look like the textbook example. And you can’t meaningfully customize something you don’t understand. That’s the idea behind #MLUnboxed — a series where I’ll break down Machine Learning and Statistics concepts, including many that are already well documented, but without stripping away the mechanics that make them work. The goal isn’t to reinvent established ideas. It’s to understand them deeply enough to use them intelligently. This series is for people who already know the “what” and are ready to spend more time with the “why.” If that sounds like you, let’s get into it.

We needed to know where the open-source AI-detection field actually stands, so we ran every notable open detector through the same protocol. Setup: - Public data only: Jabarian & Imas 2025 (NBER), Liang 2023 TOEFL essays, a 1,060-text frontier set (GPT-5.x, Claude Opus 5, Gemini 3.x), 5,000 pre-LLM (2018) FineWeb pages as human pool - Every model gets its threshold set on the same 6,930 human docs to a matched 0.5% FPR - Then measure recall per group: raw AI, humanizer-paraphrased AI, frontier models What surprised us: - 4 of 6 models effectively can't reach 0.5% FPR. MAGE scores >0.9999 on 26% of ordinary human web text. The old OpenAI RoBERTa detector lands at AUC 0.31 - worse than coin flip on modern generators. - Humanizer-paraphrased text is where everything collapses: best model catches 42%, second best 4%. - All models flag non-native essays at a higher rate than they flag native essays. This is a fundamental flaw in the entire class of models, not just one. model ROC-AUC raw AI humanized AI frontier models tropa-mini 0.968 93.2 % 41.6 % 33.6 % desklib/ai-text-detector-v1.01 0.875 83.9 % 4.0 % 1.8 % SuperAnnotate/ai-detector 0.824 0.5 % 1.4 % 0.6 % Hello-SimpleAI/chatgpt-detector-roberta 0.571 0.8 % 0.4 % 0.2 % yaful/MAGE 0.507 —* —* —* roberta-large-openai-detector 0.313 0.0 % 0.1 % 0.0 % More information and data on HF \ recall at matched 0.5% FPR; * MAGE can't reach 0.5% FPR at any threshold (flags 26% of human web text with score >0.9999)** Disclosure: one of the six is ours - we run a hosted detector and released this one as open weights (Apache-2.0). All datasets and the methodology are in the model card, so you can rerun everything: huggingface.co/wasitaigeneratedcom/ai-text-detector-small submitted by /u/grumpyp2 [link] [留言]

Hi r/MachineLearning , Stjepan from Manning here, posting with the mods’ permission. We’ve recently released GPU Programming with Triton by Harshwardhan Fartale in early access. It’s a practical guide to speeding up machine learning training and inference by writing custom GPU kernels in Python with Triton. The book explains how to identify operations worth optimizing, build and benchmark kernels, fuse operations to reduce memory traffic, implement common parallel and reduction patterns, and improve performance through tiling, vectorization, and better memory access. The goal is to help ML practitioners move beyond framework-level optimization when a model has a stubborn bottleneck. I’d love to hear from the community: Which part of your ML workload would you most like to accelerate with a custom kernel—and what currently stops you from writing one? Real use cases, benchmarks, failed experiments, questions, and skeptical takes are all welcome. We’ll give a free ebook to the five comments that contribute the most to the discussion. The giveaway will remain open for 48 hours, after which we’ll announce the winners here. Book: https://hubs.la/Q04w2PtF0 50% off with code for the community: MLFARTALE50RE Full disclosure: I’m posting on behalf of Manning. Honest criticism is just as welcome as enthusiasm. Thank you for having us. Cheers, Stjepan submitted by /u/ManningBooks [link] [留言]

Hi all, I recently read this paper: Julien Guinot, Alain Riou, Elio Quinton, Gyorgy Fazekas. Steering dense music retrieval with open-vocabulary concept discovery. https://arxiv.org/abs/2608.08757 There is multiple model where you can get embedding from Song and Text so that you can search song by text. The challenges is when you get a result that don’t really respect your query, for example you search: - POP viola with female vocalist And as a result you usually get POP song with female vocalist because they are usually very common in you library, instead the Viola tend to disappear being uncommon. But the power of MIR isn’t exactly search to specific song even if uncommon ? Here the idea of the paper is to get the compressed embbeding layer, make it sparse again and be able to identify for some common words exactly which neuron are activated try to avoiding overlapping with other neuron. Then you can improve the value of let’s say the Viola neurons and then bring back to the compressed embbeding space. This is not mine, is only explanation, what I did is in the past a Distilled version of LAION CLAP called DCLAP that is around 7 million parameters and can efficiently run on CPU: - https://github.com/NeptuneHub/AudioMuse-AI-DCLAP The following the paper I also trained a SAE for DCLAP : - https://github.com/NeptuneHub/AudioMuse-AI-SAE So if you’re interested you can take a look at let me know. Are all free and opensource. Finally if you want to see both of them in action I used both the model for AudioMuse-AI , a software dedicated to sonic analysis and automatic playlist creation (with various model): - https://github.com/NeptuneHub/AudioMuse-AI If you have any feedback, suggestion, idea, please let me know ! submitted by /u/Old_Rock_9457 [link] [留言]

Mithil Vakde trained a small transformer from scratch in 1.5 hours on a rented RTX 5090. The compute cost came to about 67 cents. The model scored 44% on the ARC-AGI-1 public eval, one point behind TRM's 45% and in the same band that left DeepSeek R1, o3-mini, and Gemini 2.5 Pro behind when the TRM paper ran the comparison ( arXiv 2510.04871 ). This is the third post in his ARC series. The previous result went viral and drew public scrutiny from researchers including Lucas Beyer, Jeremy Howard, and Rohan Anil. The new one raises the score, cuts the cost, and answers every objection in a long appendix. What the model does Each puzzle becomes a sequence of tokenized grids. The transformer trains on those sequences from scratch at test time, using both the train puzzles and the eval puzzle inputs, with the eval labels hidden. Test-time training is not a loophole here. ARC is a meta-learning benchmark built around skill acquisition, and Chollet's original paper frames the whole thing as a measure of how efficiently a system gains new skills ( arXiv 1911.01547 ). The architecture got a 2026 refresh: 8 layers, SwiGLU, RMSNorm, the NorMuon optimizer, 3D RoPE, and per-task embeddings. Inference augments each test input with color and dihedral permutations, inverts the augmentations, and submits the two most common outputs. The biggest change is the loss function. Previous versions trained on input and output tokens. This one trains on output tokens only, which makes the approach supervised. Score went from 40% to 44%. Vakde admits he does not fully understand why, and the training loss got worse even as scores improved. His guess is finite model capacity. The ablations back him up on what carries the result: drop the 3D RoPE and the score falls to about 24%, drop the per-task embeddings and it falls to about 24%. Representations, not compute, are doing the work. The lineage it joins None of these systems pretrain. They learn from the benchmark's roughly thousand examples: S

Why did I sign up to review when it’s not reciprocal? Am I an idiot? Am I dumb to sacrifice some of my precious time outside of work to review these papers when I don’t even have to? Yes. I tell myself I’m giving something to the community. But all I’m really doing is pissing off the authors as I reject their papers. I really wanted to accept one of them too. But, it wasn’t as well done as I’d hoped. Strong reject. Nobody made me sign up. Nobody even asked me personally. They sent a lovely form email that goes to everyone who’s published there. I let feeling important convince me to do it. How dumb of me! At least it’s only a couple of papers and a small amount of my time. And I’m learning something new reading stuff slightly outside my direct field, that I would never normally read otherwise. And I get to hone the skill of critical reading, thinking, and generally understanding how a paper should (or should not) be put together. Maybe it was a good idea after all. How does everyone else feel about non-reciprocal reviewing? I imagine those that agree to do it are in the minority. submitted by /u/OptimalOptimizer [link] [留言]