标签：#mac

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

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] [留言]

Someone plugs in the HDMI cable. The room's display shows nothing, or shows 1024×768, or shows the desktop of whoever presented last week. After a minute of this, somebody says "just share your screen", and out comes AnyDesk or TeamViewer. It works. It is also the wrong shape for the problem, and noticing why turns out to be more interesting than it sounds. What remote desktop tools are actually for AnyDesk, TeamViewer and RustDesk exist to solve one problem well: reach a machine you are not near. Your parent's laptop. A server in a rack. A colleague's desktop three time zones away. Everything about their design follows from that. One person connects to one machine. That person takes the mouse. The remote screen is mirrored to them, and the whole session is framed as control — because when you are not in the room, control is the only way to do anything. Being fair about the privacy question, because it is the claim people reach for first and it is wrong: AnyDesk has a LAN mode , and in it a session goes directly between the two machines without the internet. RustDesk can be self-hosted entirely on your own infrastructure. Neither of these tools forces your screen through somebody's cloud if you configure them not to. If you have read that they do, that is not accurate. The mismatch is not privacy. It is shape. The relay, the account and the NAT traversal are not overhead — they are the product, and they are what makes reaching a machine in another country possible at all. Standing beside the machine, you pay for all three and use none of them. Where the shape stops fitting Stand in a room with four people and a Mac, and three things go wrong at once. It is one-to-one. Remote desktop is a session between two endpoints. Four people looking at one screen is not what it models, so three of them read over a shoulder. It mirrors, and mirroring is sometimes the wrong answer. Every tool in this category shows a screen that already exists. But the meeting-room problem is oft

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] [留言]

Please post your personal projects, startups, product placements, collaboration needs, blogs etc. Please mention the payment and pricing requirements for products and services. Please do not post link shorteners, link aggregator websites , or auto-subscribe links. -- Any abuse of trust will lead to bans. Encourage others who create new posts for questions to post here instead! Thread will stay alive until next one so keep posting after the date in the title. -- Meta: This is an experiment. If the community doesnt like this, we will cancel it. This is to encourage those in the community to promote their work by not spamming the main threads. submitted by /u/AutoModerator [link] [留言]

Originally published on tamiz.pro . We have collectively lost our minds over benchmarks. AgenticBench scores 90%? Great. Multi-Agent Hallucination Leaderboard rank #1? Impressive. Yet the moment you ship that same agent to a chaotic production environment with 14,000 SQL dialects, flaky APIs, and users who refuse to follow instructions, it collapses within hours. This is not a bug. It is a feature of how we evaluate these systems. The gap between benchmark performance and production reliability is the single most dangerous illusion in current AI engineering. Benchmarks measure capability ; production measures consequence . If you are building AI agents today, you are likely flying blind. Here is why your evaluation strategy is lying to you, and what actually happens when agents hit the wire. The Snapshot Fallacy Benchmarks are snapshots. They are static, curated, and deterministic. An agent tasked with answering a question from Wikipedia is doing retrieval and generation. In production, that same agent might be triggering a refund API while concurrently writing to a database. The problem is that benchmarks rarely account for statefulness . A chatbot that generates a perfect summary is qualitatively different from an agent that executes a five-step workflow where Step 3 depends on the output of Step 1, which was corrupted by a non-deterministic tool response in Step 2. Benchmarks usually test the trajectory in isolation. They do not test the persistence of the state across 10,000 concurrent requests. When you move from benchmark to production, you introduce temporal decay . The model context window fills. Tool schemas drift because the upstream API changed yesterday. Database schemas evolve. The agent you tested in January is functionally a different entity in June, yet your evaluation suite remains frozen in time. The Tooling Cliff The most common failure mode in production agents is not hallucination—it is tool failure . In a benchmark, if you ask an LLM to get_wea

LLM agents increasingly modify their own prompts, tools, middleware, resources, and execution harnesses at runtime. Such self-evolution can improve capability, but a successful mutation may leave persistent effects that cannot be safely reversed in states different from the one in which it was created. We introduce EvoUndo, a framework for representing, synthesizing, diagnosing, and independently verifying recoverability of model-generated self-modifications across counterfactual states. Across 600 unseen one-shot self-evolution tasks, we identify 197 capability-improving mutations that fail recoverability verification. Under the original recovery representation, conventional repair strategies recover 0/197 of these natural failures. Deterministic oracle analysis recovers 48/197 under the original recovery language L0, while the extended recovery calculus increases empirical oracle recovery to 191/197. A protocol-locked 2×2 grounding-by-expressivity intervention then separates two bottlenecks: exact state-address grounding increases successful recovery from 0/48 to 38/48 (79.2%) when the original language is sufficient, while extending the recovery language enables recovery on 142/143 (99.3%) failures in the oracle-defined S1 stratum. On the primary gpt-oss-120b backbone, adding exact-address diagnostics to the richer language reduces recovery to 133/143 (93.0%); a Qwen3.8-27B replication preserves the grounding and expressivity effects but not this negative interaction, indicating that the latter is model-dependent. These results indicate that reliable agent self-evolution requires co-designing verification, state grounding, witness semantics, and recovery-language expressivity rather than relying on iterative prompting alone. Paper: https://arxiv.org/abs/2608.28363 submitted by /u/AccomplishedLeg1508 [link] [留言]

Hi everyone, 2nd-year PhD candidate here staring down my first A* submission deadline (AAMAS 2027). I could really use some perspective on theory expectations, especially since I think I’ve methodologically painted myself into a corner. The setup My project started with a clean hypothesis: if architecture X is more robust than Y to perturbation A, and B is a strictly harder version of A, then the X > Y ordering should hold under B as well. I isolated three variables I suspected were driving the effect, ran experiments, and… got results that only partially support the hypothesis, with clear boundary conditions. Where I got stuck Trying to explain the “why” mathematically sent me down a theory rabbit hole. I ended up with two bad options: Claims tied to specific training outputs rather than structural/architectural properties, or Weak, hand-wavy speculations that feel like post-hoc rationalizations. I’m pretty sure I fell into HARKing.. I started building theory after seeing the results instead of deriving predictions beforehand. Furthermore, my codebase is built on an undocumented public repo, and I recently found a bunch of hidden parameters set to wrong values for my setting. I’m currently re-running everything, which is why I’m being vague about specifics. My “insights” from the first round are probably garbage. My actual questions For those who’ve reviewed for or published at AAMAS (or similar A* venues): how much formal theory is actually expected for an empirical MARL paper? Is “here’s the phenomenon, here’s the controlled experiments, here’s a plausible but incomplete theoretical sketch” a death sentence? If the theory ends up being training-dependent rather than structural, is that a sign I should pivot to a lower-tier venue, or can strong empirical characterization + limited theory still fly at A*? How do you recover from HARKing mid-project when you’re under pressure to publish in year 3/4 of a 4-year contract? Any advice on how to salvage the timeline or r