Shao Tang

Compressing LLMs but worried about accuracy? 🎯 EoRA uses eigenspace low-rank approximation to compensate for errors—no retraining needed. A promising direction for scalable, task-adaptive LLMs. New paper from #NVIDIAResearch.

1

We (w/ Shansan Gong, Ruixiang ZHANG, Huangjie Zheng, Jiatao Gu, Navdeep Jaitly, Lingpeng Kong) released a family of 7B diffusion language models, DiffuCoder, that specializes on code generation, with a focus on understanding and improving masked diffusion models. A core analysis of DiffuCoder is the autoregressiveness (AR-ness) score, a novel metric that quantifies the causal patterns in decoding, revealing how diffusion models break from strict left-to-right generation for more flexible, non-linear code planning. Recent advances in autoregressive (AR) models dominate code generation, but diffusion-based LLMs (dLLMs) like DiffuCoder offer a promising alternative, especially for complex programming tasks. DiffuCoder explores how these models decode differently—showing less global AR-ness in code tasks compared to math—and how temperature affects both token selection and generation order, unlike traditional AR models. We also introduce coupled-GRPO, a post-training RL method with a coupled-sampling scheme, to reduce performance drops during accelerated decoding, boosting parallelism and efficiency. We use a self-improvement pipeline that leverages AR-ness analysis, coupled-GRPO optimization, and evaluation on benchmarks like AceCode-89k to refine decoding strategies. This approach enables DiffuCoder to navigate diverse code generation pathways and enhance performance with modest computational overhead. Looking ahead, we aim to further leverage Reinforcement Learning to steer code generation through these decoding patterns, with the discrete nature of AR-ness scores providing a foundation for search-based strategies—ideal for the sparse rewards of optimizing complex code structures. Check out our full paper and code for a deeper dive! Paper: https://lnkd.in/gVWU3BDJ Code: https://lnkd.in/gmXTZ_6n Models: https://lnkd.in/gTcKCDr9 #MachineLearning #AI #CodeGeneration #DiffusionModels #NLP

220

5 Comments

Parallelism with asynchronous off-policy learning will be the key to post-training with RL to expand beyond code and math reasoning.

9

Rachit Jain's walkthrough shows how to profile kernels with PyTorch tools, import traces into NVIDIA Nsight or Intel Advisor, and read the slanted ceilings that separate compute-bound from memory-bound regions.

5

In collaborative machine learning (CML), early contributors take on more risk and encourage participation from wait-and-see parties, but existing CML frameworks treat every party as if they join simultaneously. The #NeurIPS2025 paper of Jiangwei Chen, Nguyen Pham, Rachael Sim, Arun Verma, Zhaoxuan Wu, Chuan Sheng Foo, and Bryan Kian Hsiang Low proposes a time-aware CML framework that rewards parties not just for what they contribute, but when they contribute: •⁠ ⁠8 incentives extending fairness with time-aware notions that incentivize early participation while preventing low-quality early submissions. •⁠ ⁠2 reward distribution methods that theoretically satisfy all incentives and recover the #ShapleyValue in time-agnostic cases. •⁠ ⁠A practical recipe for constructing valuation functions and reward realization, with empirical validation on synthetic and real-world data. Find our more at our posters! #NeurIPS2025 Thu, Dec 4, Exhibit Hall C, D, E #1104 #EurIPS2025 Wed, Dec 3, Poster Stand #56 Paper: https://lnkd.in/g_yM6j39 #FederatedLearning

50

We developed an open-source AI tool to design concrete mixes that are stronger, more sustainable, and ready to build with faster—speeding up construction while reducing environmental impact. https://lnkd.in/gPCk8tCM But the impact of this AI tool is not just hypothetical! Amrize used Meta’s AI-based technologies to design a new low-carbon mix, and successfully deployed it in an at-scale slab-on-grade application at Meta's new data center in Rosemont, MN. Compared to the legacy mix, this new AI-designed mix is: 🦁 Stronger ⏱ Faster 🍃 Lower carbon ⏱ ️The ideal set time All this was achieved without needing any new materials, nor special equipment. Best of all, the AI is open-sourced. https://lnkd.in/g2KA7KZW This work was featured in a Meta engineering blog article published today! https://lnkd.in/gBU9HY8H

98

9 Comments

🤖RLAD Training LLMs to Discover Abstractions for Solving Reasoning Problems. 🔍 Motivation: How do we move large language models (LLMs) beyond pattern matching—toward algorithmic, abstract reasoning on hard problems? Most current RL post-training approaches create longer chains of thought, but they often drift into verbose or degenerate exploration, missing true reasoning depth. 📄 Solution: RLAD introduces 'reasoning abstractions'—concise, natural language descriptions of procedural and factual knowledge that guide models in learning successful reasoning strategies. The approach trains two LLMs: one to generate abstractions and another to solve problems using those abstractions, via a novel RL setup. Crucially, abstractions act as high-level subgoals or skills, helping models explore diverse solution paths and generalize to harder tasks. 🔑 Results: RLAD achieves up to 44% improvement on math reasoning benchmarks (AIME 2025, DeepScaleR Hard, AMC 2023) over state-of-the-art long chain-of-thought RL methods. Moreover, the benefits scale with more compute allocated to abstraction generation versus solution sampling—a key insight for practical deployment. 💡 Implications: Abstraction-driven training broadens the reasoning abilities of LLMs, unlocking new horizons for model interpretability, strategy diversity, and generalization across complex domains. This direction is especially relevant as scaling chain-of-thought length yields diminishing returns. (Attached: Original research PDF)

13

1 Comment

Google Antigravity exposes the critical flaw in autonomous AI agent architectures: trust based governance at scale. Antigravity represents a major shift in how developers work. Instead of writing code line by line, you delegate entire tasks to autonomous agents that can modify files, run tests, browse the web, and execute changes across your codebase in parallel. The problem? These agents operate on trust, not proof. One developer reported: On Day 3, an agent confidently refactored a utility function and silently deleted a critical edge case check. This is not a bug. This is the inevitable result of autonomous agents operating without cryptographic authority validation. When you have three agents working asynchronously across different files, two critical questions emerge: how do you enforce what each agent is authorized to do, and when multiple agents coordinate on shared resources, how do you maintain isolation between their operations? Policy based guardrails do not work at this scale. I have solved both problems through complementary cryptographic architectures. For individual agent authorization, my 13 layer cryptographic governance system validates AI agent authority mathematically before execution. For multi agent coordination, my YIN COLLAB architecture implements Agent Specific Compliance Tokens with per agent privacy isolation maintaining cryptographic boundaries preventing cross contamination. Every action carries immutable proof of authorization. Every decision boundary is pre validated cryptographically. 26 USPTO patents. 2,330 claims. Validated with 640x timing resistance and 500 plus concurrent agent support with sub 15ms latency. Mathematical proof, not policy promises. For developers using Antigravity, Cursor, or any autonomous agent platform: the question is whether you can prove mathematically that unauthorized operations are impossible and that multi agent coordination maintains isolation. Because as agent orchestration becomes the dominant development paradigm, the liability surface expands exponentially. One misconfigured agent with access to production systems is an organizational failure. One agent leaking sensitive data to another agent through shared context is an architectural vulnerability. Making it mathematically impossible for agents to violate boundaries is the only governance model that scales. Autonomous agents are the future of software development. Cryptographic governance is the only way to make that future safe. https://lnkd.in/ejPREk9D #GoogleAntigravity #AIGovernance #AutonomousAgents #Cybersecurity #AIAgents #DeveloperTools #CryptographicSecurity #ZeroTrust #AICompliance #SoftwareDevelopment #TechInnovation #AIEthics

2

In physical autonomy, evaluating a plan based on its semantic plausibility guarantees failure. The architectural requirement is proving that an action is safe under bounded uncertainty. Language models generate plans through token prediction, a probabilistic process optimized for semantic coherence rather than physical safety. When those plans activate motors and servos, failure modes shift from hallucinated text to physical collision, drift, and hardware damage. The mismatch is structural: token prediction cannot validate the real-time state space. Autonomous systems fail due to accumulated sensor error, dynamic overshoot, and latency-driven desynchronization. A model that proposes "move the gripper 15cm left" cannot verify whether that instruction violates joint limits, exceeds payload capacity, or intersects an obstacle that appeared moments earlier. Scaling model parameters improves pattern recognition, not constraint enforcement. Safe autonomous architecture pairs probabilistic cognition with deterministic execution controls. Four boundaries enforce that separation: ↳ State reconciliation gate: The control system continuously reconciles intended motion with measured reality using proprioception, vision, and Inertial Measurement Unit (IMU) telemetry at control-rate frequencies (10–1000 Hz+, depending on the embodiment). If the measured state diverges beyond tolerance, the system halts or replans. ↳ Deterministic feasibility gate: A validation engine gates every proposed motion through deterministic checks before execution—forward kinematics for reachability, inverse dynamics for torque limits, and collision checks (e.g., swept-volume constraints). If any constraint fails, the gate rejects the motion unconditionally. ↳ Independent safety interlocks: Firmware-level circuit breakers and emergency-stop logic override model outputs when sensors detect force spikes, proximity violations, or thermal limits. These mechanisms operate independently of the probabilistic stack; a crashed inference server cannot disable them. ↳ Platform decoupling: The autonomy stack must treat physical embodiment as a swappable dependency. Architectures that bind the reasoning layer directly to proprietary hardware interfaces create structural fragility. When vendors deprecate interfaces, tightly coupled stacks break. Hardware abstraction layers are load-bearing constraints, not optimization targets. This separation builds on established engineering foundations. Traditional motion planning and control already rely on deterministic methods such as RRT* and Model Predictive Control (MPC) to enforce feasibility. Generative models add valuable intent synthesis, inferring semantic goals from ambiguous instructions, but the final arbiter of safe execution must remain verifiable. Architects must treat the large language model as an untrusted planner, requiring deterministic evidence before committing any actuator. #SystemsArchitecture #EnterpriseAI #AIGovernance

5

2 Comments

IBM just published their roadmap for bringing first-class PyTorch support to the Spyre Accelerator, fully ecosystem-first. Instead of building a custom fork, they’re extending torch.inductor with tile-based layouts, multi-core work division, and scratchpad optimizations so Spyre’s dataflow architecture plays nice with PyTorch’s compiler. Key pieces: • SuperDSC → KernelTile IR (KTIR) as a community-aligned spec for other dataflow accelerators • Full out-of-tree device registration with <5% overhead • vLLM integration with a new Spyre attention backend (no sequence-length constraints) • Layered testing + contributions back (OpenReg primitives, KTIR spec, CI patterns) This is the kind of thoughtful work that makes new hardware actually usable for real PyTorch teams, especially in healthcare AI where you need reliable, portable inference on diverse accelerators. Full technical note: https://lnkd.in/gnvg-r7F #PyTorch #AIInfrastructure #Hardware #MachineLearning

6

Claude just released a memory import tool: https://lnkd.in/eM8c7Gf5 You paste a prompt into ChatGPT (or whatever you're using), it spits out your context — preferences, projects, how you work — and you drop it into Claude's settings. That's it. Claude picks it up from there. The switching cost has always been the real barrier. Not the AI itself, just the fact that you've spent months building context somewhere else. This is Anthropic admitting that out loud and actually doing something about it. Quiet release. Worth knowing about.

2