What's worth reading today.
AI research papers scored by an LLM eval pipeline on novelty and reliability. Upvote to surface what the community should discuss.
GS-Agent: Creating 4D Physical Worlds With Generative Simulation
Hongxin Zhang, Chunru Lin, Junyan Li, et al.
Imagine you're tasked with creating a vibrant, interactive 4D world based on a simple text description. Traditionally, this involves a lot of manual work, where artists painstakingly adjust materials, motions, and lighting to achieve the desired look and feel. This process can be tedious and often leads to inconsistencies or a lack of physical realism, which is what we call the challenge of physical plausibility. Current generative models have made strides, but they still struggle to produce worlds that feel alive and responsive to user input. This is where GS-Agent comes in. Instead of relying solely on traditional graphics techniques, it uses a multi-agent system that mimics how humans create these worlds, automating the entire process. Each agent specializes in different aspects, like managing 3D assets or controlling physics, and they work together to iteratively refine the world based on feedback. This collaborative approach allows for the generation of diverse and realistic environments that respond dynamically to natural language prompts. Compared to previous methods, GS-Agent not only enhances the realism of generated worlds but also empowers creators to easily translate their ideas into interactive experiences, marking a significant step forward in 4D world generation.
LKValues: Aligning Large Language Models with Sri Lankan Societal Values
Nethmi Muthugala, Supryadi, Surangika Ranathunga, et al.
Imagine you're developing a language model that needs to understand and respect the diverse cultural values of a specific region, like Sri Lanka. Currently, many large language models (LLMs) are trained primarily on Western norms, which can lead to misunderstandings and misrepresentations of local values. This is particularly problematic in multilingual societies where cultural nuances are critical for effective communication. The existing benchmarks often fail to account for these local dynamics, resulting in models that may not perform well or align with the values of the communities they serve. This is what's called cultural bias, and it can manifest in various ways, such as inappropriate responses or a lack of understanding of local contexts. To address this issue, LKValues was created as a resource suite specifically designed for Sri Lankan value alignment. It combines insights from a trilingual survey with local constructs to identify 40 key societal values that resonate with the Sri Lankan populace. The authors also developed LKvaluesIT, a corpus of 150,000 scenario-based instances in Sinhala and English, along with LKvaluesBench, a benchmark for evaluating LLMs against these values. By fine-tuning several open-weight models with this new data, they found that while larger models still struggle with cultural alignment, the fine-tuning process significantly improved their performance in both English and Sinhala. This work not only enhances the understanding of Sri Lankan values in AI but also provides a replicable framework for other low-resource, culturally diverse contexts.
SoftReason: A Fully Differentiable Neuro-Soft-Symbolic Deductive Reasoning Architecture over High-Dimensional Perceptual Data
Wael AbdAlmageed
Imagine you're building an AI that needs to answer complex questions about images, like identifying objects or understanding scenes. The challenge lies in not just recognizing what’s in the image but also reasoning about it using external knowledge, such as relationships between objects or facts stored in a knowledge graph. Traditional methods often struggle here because they treat perception and reasoning as separate processes, leading to issues like misinterpretation of context or inability to leverage external knowledge effectively — this is what's called the gradient gap problem. To address this, the authors propose a neuro-soft-symbolic architecture that allows for a seamless integration of perceptual inputs and knowledge graph data. By representing the reasoning process as a differentiable tensor, the system can continuously update its understanding based on both the visual input and the structured knowledge it receives. This means that every aspect of the reasoning process, from proposing facts to updating beliefs, can be fine-tuned through training. The framework is applied to Knowledge-aware Visual Question Answering (KVQA), showcasing how it can ground perceptions in knowledge and perform reasoning in a unified manner. For builders, this means a more robust way to create AI systems that can understand and reason about the world in a more human-like manner.
Persian Pixel: A large-scale synthetic OCR dataset for Persian language
Pouria Mahdi, Haq Nawaz Malik
Imagine you're trying to build an OCR system that can read Persian documents, which is particularly challenging due to the unique characteristics of the Perso-Arabic script. Current OCR solutions struggle with this because they often rely on limited datasets that don't capture the complexities of Persian writing, such as cursive connections and various glyph shapes. This leads to failures in recognizing text accurately, especially in diverse contexts and styles, which is what's called a data bottleneck. Without enough high-quality annotated data, developing effective OCR systems for Persian is a slow and costly process. To tackle this issue, the authors created Persian Pixel, a synthetic dataset that includes over 343,000 image-text pairs generated from a large Persian corpus. This dataset not only simulates the intricacies of Persian script but also incorporates realistic degradation models to mimic real-world document conditions. By providing a scalable and openly available resource, Persian Pixel enables the training of modern OCR architectures, potentially accelerating advancements in Persian document analysis and digitization. This represents a significant step forward compared to previous efforts, as it offers a practical solution to the data scarcity problem that has hindered progress in this area.
From Distances to Trajectories: Real-Time Signed Distance Function Mapping and Distance-Accelerated Motion Planning for UAVs
Jason Stanley, Zhirui Dai, Qihao Qian, et al.
Imagine you're building a drone that needs to navigate through a cluttered indoor space, like a warehouse filled with boxes. The challenge is to create a map of the environment while also planning a safe flight path in real time. Traditional methods often treat mapping and planning as separate tasks, which can lead to inefficiencies and potential collisions. For instance, they might use a simple occupancy grid to check for obstacles, but this can miss nuanced information about the environment, leading to unsafe trajectories. This is what's called a lack of integration between mapping and planning. To address this, the authors propose a unified approach that uses a signed distance function (SDF) to represent the environment. An SDF provides detailed information about the distance to the nearest obstacles, which is crucial for planning safe paths. They introduce an Octree Residual Network (OREN) that efficiently reconstructs SDFs from point cloud data, combining the strengths of volumetric methods and neural networks. Alongside this, they develop a planner called Bubble$^ ext{star}$ that uses the SDF to create 'bubbles' or safe zones for navigation, significantly reducing the number of collision checks needed compared to traditional methods like A$^ ext{star}$. The results show that this integrated approach allows the drone to navigate complex environments much faster and more safely than previous methods, with OREN improving SDF estimation by 22% and Bubble$^ ext{star}$ finding paths in 1-3 seconds instead of up to 10 seconds. For anyone building autonomous systems, this means a more efficient and reliable way to navigate dynamic environments.
Riemannian Deep Learning:Modules, Networks, and Geometries
Chen Ziheng
Imagine you're developing machine learning models that need to work with complex data structures, like those found in geometry or physics. Traditional approaches often rely on Euclidean spaces, which can lead to inaccuracies when dealing with data that naturally resides on curved surfaces or other non-Euclidean spaces. This can result in models that are not only less effective but also computationally expensive and prone to numerical instability, especially when performing operations that require precise geometric calculations. This is what's called the limitation of relying on Euclidean approximations in manifold-valued representations. To address these challenges, the paper proposes a comprehensive framework for Riemannian deep learning that encompasses reusable neural modules, specialized network architectures, and innovative geometric designs. By generalizing techniques like batch normalization and multinomial logistic regression to work across a wider range of geometric spaces, including Lie groups and SPD manifolds, the framework allows for more robust and efficient learning. Additionally, it introduces adaptive Riemannian metrics that enhance computational efficiency and stability. Compared to prior work, this approach not only broadens the applicability of deep learning to more complex data structures but also improves the performance and reliability of models in fields like vision, signal processing, and genomics.
A Blueprint for Equilibrium-Based Differentiable Continuous-Variable Thermodynamic Computing
Owen Lockwood, Jérémy Béjanin, Joost Bus, et al.
Machine learning workloads are increasingly demanding in terms of energy and latency. Current computing methods often struggle to meet these demands efficiently. This paper introduces a thermodynamic computing stack that uses stochastic processes to create energy-efficient models in physical hardware. Builders might care because this approach could lead to significant improvements in the energy efficiency of machine learning applications.
Physics-enhanced reinforcement learning for real-time optimal control of dynamical systems
Matteo Tomasetto, Nicolò Botteghi, Gabriele Bruni, et al.
Reinforcement learning struggles with sample efficiency, especially in high-dimensional environments. Current methods often require extensive interactions with the environment, limiting their applicability. This paper introduces PEARL, which combines reinforcement learning with traditional control methods, leveraging the differentiability of system dynamics to improve efficiency. Builders might find this approach useful for developing control strategies in complex systems without needing to simplify the state space.
An Exam for Active Observers
Jiarui Zhang, Muzi Tao, Shangshang Wang, et al.
Current multimodal large language models (MLLMs) do not effectively engage in active observation, which is crucial for tasks requiring dynamic visual perception. Existing benchmarks fail to measure this capability, leading to misleading assessments of model performance. The introduction of ActiveVision provides a framework to evaluate how well MLLMs can perform tasks that require repeated visual engagement. This is important for builders as it indicates a fundamental limitation in current models and suggests directions for future improvements in model design and training.
Learning Standard Model structure from LHC data with Riemannian flow matching
Midori Kato, Kevin A. Urquía-Calderón, Inar Timiryasov, et al.
In particle physics, accurately modeling events across a wide range of energies is challenging, as existing methods often rely on limited Monte Carlo samples. Current approaches struggle to capture the full complexity of interactions observed in high-energy collisions. This work introduces extsc{ShellFlow}, a generative model that learns directly from a vast dataset of real proton-proton collision events, enabling it to reproduce key features of the Standard Model. Builders in the field of physics data analysis might find this approach valuable for improving simulations and understanding particle interactions more comprehensively.
When Do Multi-Agent Systems Help? An Information Bottleneck Perspective
Wendi Yu, Lianhao Zhou, Xiangjue Dong, et al.
Multi-agent systems (MAS) are becoming popular for complex tasks, but their advantages over single-agent systems (SAS) are not well understood. Current approaches often overlook how communication constraints affect performance. This paper introduces an information bottleneck perspective, clarifying when MAS can outperform SAS based on the efficiency of information transfer. Builders should pay attention to these insights to optimize their multi-agent designs, especially in scenarios with limited communication.
ToolSciVer: Multimodal Scientific Claim Verification with Visual Tool Augmented Reinforcement Learning
Binglin Zhou, Peng Shi, Ryo Kamoi, et al.
Multimodal Scientific Claim Verification (MSCV) faces challenges in accurately locating and interpreting visual evidence from scientific papers. Current methods often struggle with structured visuals and integrating multimodal data for reliable reasoning. ToolSciVer addresses these issues by introducing a framework that uses specialized visual tools to enhance evidence extraction and reasoning. Builders might find this approach valuable for developing more effective systems in scientific research and verification.
RoboTTT: Context Scaling for Robot Policies
Yunfan Jiang, Yevgen Chebotar, Ruijie Zheng, et al.
Current robot models struggle with limited visuomotor context, which restricts their ability to perform complex tasks. Existing methods typically operate with short histories, leading to suboptimal performance in multi-stage scenarios. RoboTTT changes this by scaling the context length to 8K timesteps, allowing robots to learn from longer sequences and improve their decision-making in real-time. This advancement could enable builders to create more capable and flexible robotic systems that can handle intricate tasks more effectively.
NeuronSoup: Evolving Asynchronous, Shared-Neuron Temporal Graphs without Backpropagation
Subodh Kalia
Current deep learning architectures often rely on synchronous processing and fixed computation graphs, which can limit flexibility and adaptability. NeuronSoup breaks this mold by enabling asynchronous signal propagation through shared neurons, allowing for dynamic computation depth and lateral interactions. This architecture is co-evolved using a genetic algorithm, which may offer advantages over traditional optimization methods. Builders might care about this approach as it opens new avenues for designing neural networks that can adapt more fluidly to different tasks.
The Dynamic Verifiable Multi-Agent Human Agentic Loyalty Loop (DVM-HALL) Model and the Net Human-Agent Score (NHAS) in Autonomous Commerce
Sai Srikanth Madugula, Peplluis Esteva de la Rosa, Daya Shankar
The rise of autonomous AI agents is changing how consumers interact with brands, challenging traditional loyalty models. Current frameworks do not account for the complexities of AI decision-making and trust dynamics. This paper introduces a new model that integrates these factors, allowing brands to better understand and engage with machine customers. Builders might find this framework useful for developing strategies that align with evolving consumer behaviors driven by AI.
TerraZero: Procedural Driving Simulation for Zero-Demonstration Self-Play at Scale
Zhouchonghao Wu, Akshay Rangesh, Weixin Li, et al.
Training autonomous driving agents is challenging due to the need for fast, realistic, and diverse simulators. Current simulators often lack the speed or realism required for effective reinforcement learning. TerraZero addresses this by providing a procedural simulator that generates diverse driving scenarios and trains policies from scratch without human input. Builders might find this approach valuable as it allows for scalable training of robust driving agents across various environments.
A Shortcut to Statistically Steady-State Turbulence with Flow Matching
Gianluca Galletti, Gerald Gutenbrunner, William Hornsby, et al.
Many nonlinear physical systems, like those in fluid dynamics, require extensive computational resources to simulate their initial transient phases before reaching a steady state. Current methods often rely on autoregressive models that accumulate errors over time, leading to inefficiencies. This paper introduces GyroFlow, a generative model that directly estimates the steady-state behavior of gyrokinetic turbulence, avoiding the costly transient phase. Builders in computational fluid dynamics might find this approach beneficial as it provides faster simulations without sacrificing accuracy.
Watermark Forensics for Generative Models: An Information-Theoretic Perspective
Xiaoyu Li, Zheng Gao, Xiaoyan Feng, et al.
Generative models often struggle with attributing outputs to specific users, which is crucial for accountability. Current methods either focus on detection or lack precision in user attribution. This paper introduces a comprehensive framework that not only detects machine-generated text but also attributes it to users and extracts hidden information. Builders should care because this framework enhances the security and traceability of generative outputs, addressing a key challenge in the field.
Knowledge- and Gradient-Guided Reinforcement Learning for Parametrized Action Markov Decision Processes
Jonas Ehrhardt, René Heesch, Oliver Niggemann
Reinforcement Learning often struggles with sample efficiency, especially in complex decision-making scenarios like PAMDPs. Current methods typically rely on one-shot estimators, which can lead to inefficiencies. This paper introduces KGRL, which leverages existing domain knowledge to refine decision-making and improve training efficiency. Builders might care because KGRL not only enhances performance but also provides explanations for its decisions, making it easier to understand and trust the agent's behavior.
LatentFlow: A General Framework for Conditioning Stochastic Processes
Louis Sharrock, Lachlan Astfalck, Henry Moss
Conditioning stochastic processes is typically complex due to non-linear observations and intractable conditional laws. Current methods often require bespoke solutions that are not scalable. LatentFlow changes this by offering a single framework that simplifies the conditioning process without any training, making it applicable to a wide range of models. Builders might care because it allows for quick and efficient sampling on standard hardware, which can enhance productivity in research and application development.
Real-time fall detection based on vision for low-power edge platforms
Wenjun Xia, Zhicheng Peng, Haopeng Li, et al.
Falling detection is crucial for elderly care, yet current methods often treat it as static classification, missing the dynamic nature of human stability. This paper introduces a new framework that views falling as a loss of stability in a coupled dynamical system, using a dual-LTC architecture to model the necessary dynamics. By focusing on continuous-time mechanical inertia, the proposed system can operate effectively on edge devices with limited resources. Builders might care because this approach not only improves accuracy but also enhances the interpretability of fall detection systems.
MemOps: Benchmarking Lifecycle Memory Operations in Long-Horizon Conversations
Xixuan Hao, Zeyu Zhang, Zehao Lin, et al.
Current benchmarks for evaluating long-term memory in LLMs primarily focus on the correctness of final answers, which can obscure underlying memory issues. This paper identifies that memory should be viewed as a dynamic process involving various operations like remembering and forgetting. By introducing MemOps, a benchmark that tracks these operations, the authors provide a more nuanced evaluation of memory performance. Builders might find this approach valuable for developing more reliable and interpretable memory systems in their applications.
Requential Coding: Pushing the Limits of Model Compression with Self-Generated Training Data
Shikai Qiu, Marc Finzi, Yujia Zheng, et al.
Compression is crucial for effective intelligence, but existing methods often fail to capture the simplicity of learned functions. Current parameter-based compression techniques do not account for the actual information stored in models, leading to inefficient code lengths. Requential coding addresses this by allowing a teacher model to select training samples based on the student's distribution, resulting in much shorter codes that reflect the model's learning. This approach not only enhances compression but also provides insights into model behavior and data structure, which can be valuable for builders looking to optimize their models.
A Minimalist Retargeting-Guided Reinforcement Learning Recipe for Dexterous Manipulation
Yunhai Feng, Natalie Leung, Jiaxuan Wang, et al.
Humanoid robots struggle with dexterous manipulation due to the complexity of contact-rich tasks. Current methods often fail to effectively transfer learned behaviors from simulations to real-world applications. REGRIND addresses this by using a minimalist retargeting-guided reinforcement learning pipeline that learns from a single human demonstration. Builders might find this approach valuable as it simplifies the training process and enhances the performance of robots in practical tool-use scenarios.
Evidence-Backed Video Question Answering
Shijie Wang, Honglu Zhou, Ziyang Wang, et al.
Video LLMs currently provide answers without clear visual grounding, making it hard to verify their responses. Existing methods for explainability are insufficient for capturing complex video dynamics. This paper introduces E-VQA, which requires models to output both answers and detailed visual evidence, along with a new benchmark for evaluation. Builders might care because this approach enhances the interpretability of video models, potentially leading to more reliable applications in real-world scenarios.
Input-Aware Dynamic Backdoor Attack Against Quantum Neural Networks
Junrui Zhang, Zemin Chen, Lusi Li, et al.
Quantum Neural Networks (QNNs) face security risks, particularly from backdoor attacks, which are not well understood. Current quantum backdoor methods often use fixed triggers, making them vulnerable to detection. This paper introduces Q-DIBA, a dynamic backdoor attack that adapts to inputs, improving stealth and effectiveness. Builders should consider the implications of such attacks on the security of QNN applications.
Relaxing Faithfulness with Intervention-Only Causal Discovery
Bijan Mazaheri, Jiaqi Zhang, Caroline Uhler
Causal discovery algorithms often struggle with identifying true causal relationships due to the assumption of faithfulness, which can be violated in natural systems. This paper highlights that hard interventions can provide crucial information that is typically overlooked in traditional methods. By proposing a new assumption called intervention-immediacy faithfulness, the authors enable the identification of causal structures despite the presence of cancellations. Builders might care because this shift in perspective could lead to more robust models in real-world applications.
Encoder-Side Neuron Identification and Amplification for Acoustic Perception in Large Audio-Language Models
Yu-Han Huang, Chih-Kai Yang, Ke-Han Lu, et al.
Large audio-language models struggle with fine-grained attributes like emotion in speech, despite good performance on content. Current methods typically intervene after the audio encoder, missing opportunities for improvement at the neuron level. IAAN offers a new way to identify and amplify key neurons in the encoder, leading to significant accuracy gains across various speech attributes. This targeted approach could help builders enhance their models' acoustic perception without the need for retraining.
StoryTeller: Training-Free Narrative Grounding for Long-Form Audio Description
Seung Hyun Hahm, Minh T. Dinh, SouYoung Jin
Long-form audio descriptions need to convey more than just visible actions; they must maintain the story's context for blind and low-vision audiences. Current video-language models struggle with this, often treating scenes in isolation and missing important narrative connections. StoryTeller addresses this by using a narrative memory to keep track of story-relevant information across scenes, allowing for coherent and contextually rich descriptions. Builders might care because this method does not require extensive training or additional resources, making it accessible for various applications.
PHINN-EEG: Topological Time-Series Analysis of Dream-State EEG -- Dynamic Betti Curves for Dream Content Classification and Topology-Conditioned Neural Signal Synthesis
Ren Takahashi, Emre Yusuf, Jayabrata Bhaduri
Current methods for detecting dreams using EEG focus on power spectral density, which limits their effectiveness. Existing approaches achieve an AUC of around 0.70, but they do not capture the geometric aspects of neural activity. The introduction of PHINN-EEG leverages topological features to enhance dream detection, aiming for an AUC between 0.82 and 0.90. Builders might find this shift from energy-based metrics to geometric analysis valuable for developing more effective brain-computer interfaces.
Scalable Visual Pretraining for Language Intelligence
Yiming Zhang, Zhonghan Zhao, Wenwei Zhang, et al.
Many large language models rely solely on text for training, which overlooks valuable visual information found in documents and web pages. Current methods convert these rich visual sources into plain text, losing important context. This paper proposes a new approach that utilizes visual pretraining directly from these documents, showing that it consistently outperforms text-only pretraining. Builders should care because this could lead to more effective models that better understand and utilize visual data.
VEXAIoT: Autonomous IoT Vulnerability EXploitation using AI Agents
Katherine Swinea, Kshitiz Aryal, Lopamudra Praharaj, et al.
IoT systems face significant security challenges due to their constrained hardware and insecure configurations. Current methods for vulnerability testing are often manual and limited in scope. This paper introduces VEXAIoT, an autonomous framework that uses AI agents to discover and exploit vulnerabilities in IoT environments. Builders might care because it automates the security testing process, achieving high success rates in identifying and exploiting vulnerabilities.
Semantic Pareto-DQN: A Multi-Objective Reinforcement Learning Framework for Financial Anomaly Detection
Cláudio Lúcio do Val Lopes, Lucca Machado da Silva
Financial anomaly detection often struggles with class imbalance, leading to a failure in identifying fraud. Traditional algorithms tend to favor the majority class, resulting in missed anomalies. This paper introduces the Semantic Pareto-DQN, which uses multi-objective reinforcement learning to create a more balanced approach. By leveraging large language models to synthesize transaction features, it improves recall for minority classes without distorting data. Builders in finance might find this framework useful for enhancing fraud detection capabilities while managing operational costs.
Lean-QIT: Towards a Formal Infrastructure for Quantum Information Theory
Chengkai Zhu, Ziao Tang, Guocheng Zhen, et al.
Quantum information theory faces challenges in formalizing coding theorems due to a lack of reusable operational layers. Current frameworks do not adequately connect finite-block protocols and analytic inequalities. LeanQIT addresses this gap by providing a Lean 4 library that allows for the formalization of key quantum coding theorems and offers composable interfaces for various quantum components. Builders might find this useful for developing AI-assisted formalization tools and enhancing automated reasoning in quantum information processing.
4DR360: State Reasoning for Joint 3D Detection and Occupancy Prediction in 4D Radar-Camera Full-Scene Perception
Xiaokai Bai, Lianqing Zheng, Runwei Guan, et al.
Reliable autonomous driving needs to understand the entire scene, but current methods often focus only on detecting objects without fully integrating the surrounding environment. Existing radar-camera systems struggle with sparse data and limited interaction between tasks. This paper proposes a new framework that treats occupancy as an ongoing state, improving how information is processed and shared between radar and camera inputs. Builders might care because this approach could lead to more accurate and robust perception systems for autonomous vehicles.
Dynamic Frechet Regression with Feature Selection for Distributional Data
Kiran Adhikari, Amrutha Dinesh, Mathew Kuttolamadom, et al.
Many applications generate responses that are complex statistical objects rather than simple numbers. Current regression methods struggle to relate these complex responses to scalar predictors, especially when the responses change over time or other indices. Dynamic Fréchet Regression (DFR) addresses this by modeling these responses with an index-aware approach, allowing for more accurate and interpretable predictions. Builders might find this useful for analyzing data that evolves over time, such as in manufacturing processes.
Agora: Enhancing LLM Agent Reasoning Via Auction-Based Task Allocation
Kaiji Zhou, Ales Leonardis, Yue Feng
Large language models often struggle with effectively utilizing diverse expert models and tools due to simplistic task matching. Current methods fail to account for performance variability and cost efficiency, leading to suboptimal outcomes. Agora addresses this by implementing an auction mechanism that allows models to bid for tasks based on their actual competence. This innovation ensures that the most capable models handle critical reasoning tasks, which can significantly enhance the overall performance of AI systems.
Tokenizer Transplantation: Mitigating Autoregressive Collapse in Edge-Efficient Bengali ASR
Sanjid Hasan, Md. Abdur Rahman
Lightweight speech recognition models struggle with languages like Bengali due to their reliance on English-centric tokenizers. This paper identifies that such tokenizers break down Bengali words, leading to poor performance. The authors propose a new method that replaces the existing vocabulary with one tailored for Bengali, which stabilizes the decoding process. This is important for builders looking to deploy effective speech recognition in diverse linguistic contexts without extensive retraining.
UniClawBench: A Universal Benchmark for Proactive Agents on Real-World Tasks
Zhekai Chen, Chengqi Duan, Kaiyue Sun, et al.
Imagine you're trying to build an AI that can assist people in their daily lives, like managing tasks or providing information. The challenge is that existing methods for evaluating these AI agents often fall short because they test them in controlled environments that don't reflect real-world complexity. For instance, they might only look at how well an agent performs in a single interaction, missing out on how it handles ongoing tasks or adapts to new situations. This is what's called a limitation in evaluation paradigms. To tackle these issues, the authors created a new benchmark called UniClawBench. This benchmark is designed to evaluate proactive agents based on their ability to perform a variety of tasks in real-world settings. It focuses on five key capabilities: how well the agent uses its skills, explores new information, reasons over long contexts, understands different types of data, and coordinates across platforms. By designing 400 bilingual tasks that reflect these capabilities, they can assess agents more effectively. What sets UniClawBench apart is its live evaluation method, where agents are tested in real-time using Docker containers. This allows for a more realistic assessment of their performance, as agents are evaluated step-by-step rather than just on final outcomes. The authors also implemented a closed-loop evaluation strategy that simulates human feedback, which helps in understanding how agents can improve over time. Overall, this new approach provides a clearer picture of how different model capabilities and design choices impact agent performance, paving the way for better AI systems in practical applications.
Accurate, Interdisciplinary and Transparent Structure-property Understanding with Deep Native Structural Reasoning
Chen Tang, Yizhou Wang, Jianyu Wu, et al.
Imagine you're trying to understand how the structure of a molecule affects its behavior in a chemical reaction. Traditionally, scientists rely on their intuition and experience, but this can lead to errors, especially when dealing with complex structures. For instance, a model might overlook critical spatial arrangements or chemical properties, leading to inaccurate predictions. This is what's called a representation failure, where the model doesn't capture the essential details needed for reasoning about the structure's properties. To address these issues, SciReasoner was developed as a solution that combines various types of structural information into a single framework. It treats different aspects of molecular and material structures as distinct pieces of evidence that can be analyzed together. By doing this, it allows for a more nuanced understanding of how structure influences function, which is crucial in fields like drug discovery and materials engineering. The results are compelling: SciReasoner not only improves the accuracy of predictions in gene ontology and retrosynthesis tasks but also enhances the interpretability of its reasoning. This means that when it makes a prediction, you can trace back through its reasoning process to understand why it arrived at that conclusion. This is a significant step forward compared to previous models, which often lacked transparency. For anyone building applications in these scientific fields, using SciReasoner could lead to more reliable and interpretable outcomes.
Co-LMLM: Continuous-Query Limited Memory Language Models
Yair Feldman, Linxi Zhao, Nathan Godey, et al.
Imagine trying to build a language model that can answer questions accurately without just memorizing facts. Traditional models often struggle because they store knowledge in their weights, which can lead to outdated or incorrect information. When they encounter a question, they might not have the right answer readily available, which is a problem known as knowledge retention failure. This can be especially problematic when the model is asked about recent events or niche topics that weren't part of its training data. To address this, the paper introduces a new approach where the model doesn't just memorize facts but instead pulls information from an external knowledge base (KB) as needed. This is called continuous-query LMLM. The model generates flexible vector queries to retrieve relevant information from the KB, which allows it to provide more accurate and up-to-date answers. This method also integrates human-readable knowledge into its responses, making it easier to verify the information provided. What sets CO-LMLM apart from previous models is its ability to use continuous keys paired with textual knowledge values, rather than relying on traditional relational databases. This flexibility means that the model can access a broader range of information beyond just what's available in structured formats like Wikipedia. In practical terms, this leads to lower perplexity and higher factual precision, even outperforming models trained on much larger datasets. For anyone building applications that require accurate and timely information retrieval, this approach offers a promising solution.
From Noisy Traces to Root Causes: Structural Trajectory Analysis and Causal Extraction for Agent Optimization
Ying Chang, Jiahang Xu, Xuan Feng, et al.
Imagine you're building an intelligent agent that needs to learn from its past actions to improve. The challenge is that when you look at its execution history, you often find a lot of irrelevant information mixed in with useful insights. This clutter can make it hard to figure out what went wrong and how to fix it. When you try to optimize based on these messy traces, you might end up focusing on minor failures that don't really matter, which is inefficient and can lead to overfitting — this is what's called optimization inefficiency. Currently, people might try to simplify the data by cutting it down to the most recent actions or using sliding windows, but these methods can throw away crucial context that explains why things went wrong. This is where STRACE comes in. It offers a smarter way to sift through the execution traces by identifying and keeping only the most relevant failures while also pinpointing the actual causes of issues within the agent's decision-making process. With STRACE, you get a clearer picture of what needs to be optimized, which leads to better performance. In practical terms, this means that when tested on a tough verification task, agents optimized with STRACE achieved a 1.4 times higher success rate compared to those using standard methods. For anyone building complex agents, this framework could significantly enhance their ability to learn from past mistakes and improve over time.
Breaking Database Lock-in: Agentic Regeneration of High Performance Storage Readers for Database Bypass
Victor Giannakouris, Immanuel Trummer
Imagine you're trying to analyze large datasets stored in databases like PostgreSQL or MySQL. Typically, you have to go through a database driver, which can slow things down because it's not optimized for bulk data access. This can lead to frustrating delays, especially when you're working with analytical queries that need to process a lot of data quickly. This situation is what's called a bottleneck in data access, where the traditional methods just can't keep up with the demands of modern analytics. Currently, when faced with this issue, many rely on standard database drivers like JDBC or ODBC. However, these drivers are designed for general use and often struggle with the specific needs of analytical workloads. They can introduce unnecessary overhead and complexity, which can lead to slower performance and increased latency. This is where the limitations of existing solutions become apparent, as they fail to efficiently handle the bulk data operations that analysts require. The approach presented in this paper is a response to these challenges. It introduces Jailbreak, a method that bypasses the database engine entirely by reading the storage files directly. The key insight here is that the file formats used by databases are well-documented and can be understood by Large Language Models (LLMs). By using LLMs to generate custom code for reading these formats, Jailbreak creates in-memory columnar buffers that can be queried directly, eliminating the need for the traditional database access layers. What sets Jailbreak apart from previous methods is its ability to significantly enhance performance. In tests against PostgreSQL and MySQL, it achieved up to 27 times faster analytical throughput compared to standard JDBC/ODBC methods. This means that for anyone building systems that rely on fast data access and processing, Jailbreak offers a compelling alternative that not only simplifies the data access process but also dramatically improves efficiency.
Institutional Red-Teaming: Deployment Rules, Not Just Models, Causally Shape Multi-Agent AI Safety
Yujiao Chen
Imagine you're building a multi-agent AI system where different agents work together to achieve a common goal. You want to ensure that the rules governing their interactions lead to safe and effective outcomes. However, the challenge is that even small changes in these rules can lead to drastically different behaviors among the agents. For instance, if you change a rule about how consequences are allocated, you might see fatality rates shift dramatically — by as much as 58% — depending on the specific context and the population of agents involved. This is a significant problem because it means that there isn't a one-size-fits-all rule that guarantees safety across all scenarios. In fact, the safest and least-safe rules can vary widely, and some rules can even lead to the elimination of the least-resourced agents in a majority of games. This phenomenon is known as the targeting hazard, where certain rules disproportionately affect specific groups of agents. The paper introduces a new methodology called institutional red-teaming, which allows builders to systematically test these deployment rules by holding everything else constant and varying just one rule at a time. This approach helps to identify how each rule impacts collective behavior and safety. The findings underscore the importance of understanding how the way rules are framed — particularly in terms of identity salience — can influence outcomes. For example, simply naming the agent that bears the loss in a rule can increase targeted eliminations significantly. Overall, this work provides a structured way to evaluate and certify deployment rules, helping builders navigate the complex landscape of multi-agent systems more safely.
Agon: Competitive Cross-Model RL with Implicit Rival Grading of Reasoning
Vladislav Beliaev
Imagine you're trying to build a model that not only gives answers but also thinks critically about how it arrives at those answers. Traditional reinforcement learning methods often focus on the final output, which can lead to models that generate more text without necessarily improving their reasoning skills. This is a problem because it means the model might not be learning to think better, just to produce more content. This issue is known as the lack of graded reasoning, where the process of arriving at an answer isn't evaluated, leaving a gap in the model's learning process. To address this, the paper introduces a new approach where two models compete against each other. Each model takes turns drafting a solution to a problem while the other reads and critiques it. This setup allows them to implicitly evaluate each other's reasoning without needing explicit labels for good thinking. The idea is that by trying to out-reason each other, both models become progressively better, as they face increasingly strong opponents. This competitive dynamic is a shift from traditional single-model reinforcement learning, which often lacks this level of interaction. In practical terms, this method has shown to significantly improve performance on difficult tasks, such as those found in the DeepMath benchmark, where it doubled the pass rate compared to existing methods. For anyone building reasoning models, this competitive framework offers a promising way to enhance their capabilities without the need for detailed grading systems.
ECGLight: Compute-Light Framework For Paper ECG Digitization and Myocardial Infarction Screening
Shreyasvi Natraj, Cyrus Achtari, Felice Gragnano, et al.
Imagine you're in a remote clinic where patients come in with paper ECG printouts, but you lack the internet or computing power to analyze them with modern AI tools. This is a common issue, leading to missed diagnoses of serious conditions like heart attacks because the technology just isn't available where it's needed most. Current solutions often require heavy computational resources or high-speed internet, which aren't always feasible in these settings. This is what's called a resource bottleneck. To tackle this, the authors developed a system that can take a simple photo of a paper ECG and convert it into a digital format that can be analyzed on a standard smartphone or computer without needing a powerful server. The system not only digitizes the ECG but also screens for critical heart conditions like myocardial infarction, all while being quick and efficient. It uses a method called SHAP to help explain its decisions, making it easier for doctors to trust the results. What sets this work apart from previous efforts is its focus on creating a complete, lightweight solution that works in low-resource environments. By training and validating the system on a large dataset of ECGs, it achieves impressive accuracy rates, meaning that even in places where technology is limited, healthcare providers can still access reliable diagnostic support. This could significantly improve patient outcomes in remote areas where timely medical intervention is crucial.
Neural Operator-enabled Topology-informed Evolutionary Strategy for PDE-Constrained Optimization
Xiangming Huang, Guannan Zhang, Lu Lu, et al.
Imagine you're trying to design a new physical system, like a nanophotonic device, but the design space is incredibly complex and high-dimensional. Traditional methods can struggle here; for instance, evolutionary strategies are robust but often fail to navigate these high-dimensional spaces effectively, leading to suboptimal designs. On the other hand, generative models can be more flexible but often lack the robustness needed for real-world applications. This is what's called the challenge of inverse design in physics, where you want to find the best design given certain performance criteria, but the path to that design is fraught with difficulties due to the complexity of the underlying equations governing the system's behavior. The approach introduced in this paper, called Neural Operator-enabled Topology-informed Evolutionary Strategy (NOTES), aims to tackle these issues head-on. By combining a neural operator, which learns to represent the design space more compactly, with a robust evolutionary strategy, NOTES can efficiently explore the design space while being informed by the underlying physics. This means it can reduce the dimensionality of the design problem significantly, from 256 to just 25 dimensions, while still achieving high performance in terms of efficiency and compliance. In practical terms, this means that builders and engineers can use NOTES to design complex systems more effectively, saving time and resources while achieving better results than traditional methods. The ability to discover high-performance designs for unseen operating conditions is particularly valuable, as it allows for greater flexibility and adaptability in design processes.
Max Out GRPO Signal: Adaptive Trace Prefix Control for Hard Reasoning Problems
Vladislav Beliaev
Imagine you're training a model to solve complex math problems, but sometimes it just gets stuck. When the model fails to solve a problem, it doesn't learn anything from that experience, which is frustrating because those are the cases you really want it to improve on. This is a common issue in reinforcement learning where the model's learning stalls when it encounters particularly tough challenges — this is what's called the 'vanishing gradient' problem. Essentially, when no attempts succeed, the model gets no feedback to learn from, wasting valuable training opportunities. Traditionally, methods like Group Relative Policy Optimization (GRPO) try to tackle this by using group-based advantages to guide learning. However, they often set a fixed strategy for how much help to give the model, which can lead to inefficiencies. If the model is struggling, it might need more assistance, but once it starts to improve, that help should taper off. This is where the new approach comes in: instead of a one-size-fits-all strategy, AdaPrefix-GRPO introduces a dynamic feedback controller that adjusts the level of assistance based on the model's performance. By prepending a correct prefix of a reference solution, it raises the success rate and keeps the model learning effectively. The results are promising. On hard math problems, AdaPrefix-GRPO more than doubles the accuracy of GRPO for a smaller model, and it shows significant improvements across larger models as well. This means that for builders working on complex problem-solving models, this method could lead to much better performance without needing to overhaul the entire training process.
Does Bielik Know What It Doesn't Know? Activation Dispersion Separates Entity Familiarity from Factual Reliability Across Model Scale
Grzegorz Brzezinka
Imagine you're building a system that answers questions about various entities like athletes or cities. You want it to provide accurate information, but sometimes it makes mistakes, especially about things it hasn't encountered before. This is a common issue with large language models: they can confidently generate incorrect answers about unfamiliar entities, which is frustrating when you need reliable information. This problem is known as hallucination, where the model creates false information instead of sticking to what it knows. The challenge is figuring out when the model is likely to get it wrong, especially before it even attempts to answer a question. What this paper explores is whether the internal workings of these models can give us clues about their familiarity with different entities. The researchers looked at how the models' activations change when they encounter well-known versus obscure or fabricated entities. They found that by analyzing these activations, they could predict how likely the model was to provide a reliable answer. This approach uses two specific measures to assess the model's confidence in its knowledge, achieving impressive accuracy in distinguishing between known and fabricated entities. The key takeaway is that this method allows for a better understanding of when a model is likely to hallucinate, which is crucial for applications that rely on factual accuracy. By knowing how familiar a model is with an entity, developers can make more informed decisions about when to trust its answers. This could lead to more robust systems that handle information more reliably, especially in critical areas like customer support or information retrieval.
Guidance Breaks the Fitted Operator: A Terminal-Fitted Repair for Classifier-Free Guidance
Shiheng Zhang
Imagine you're working with diffusion models to generate images, and you want to guide the model's output based on certain conditions. The standard method, called classifier-free guidance, can sometimes lead to problems where the model becomes overly confident and produces poor results. This is known as oversaturation, and it can happen especially when you push the guidance too far. Practitioners often try to fix this by either increasing the number of steps in the sampling process or adjusting the intervals, but these solutions can be cumbersome and not always effective. This is what's called oversaturation in guidance methods. What this paper does is take a fresh look at the problem using a numerical analysis approach. It identifies that when guidance is applied too aggressively, it disrupts the model's ability to generate accurate outputs. The authors propose a new way to adjust the guidance mechanism, which involves a simple mathematical tweak that stabilizes the model's performance without requiring extra computational resources. This adjustment helps to prevent the model from becoming overly confident and improves the quality of the generated images. In practical terms, this means that if you're using diffusion models for tasks like image generation, you can apply this new method to achieve better results without increasing your computational load. The authors tested their approach on well-known datasets and found that it consistently outperformed the traditional methods, making it a valuable tool for anyone working in this area.
RL Post-Training Builds Compositional Reasoning Strategies
Azwar Abdulsalam, Nishil Patel, Andrew Saxe
The challenge in machine learning is understanding how reinforcement learning (RL) can enhance a model's capabilities. Current methods often fail to effectively compose skills into higher-level strategies. This paper demonstrates that RL can reorganize primitive skills into more complex procedures, leading to better performance on challenging tasks. Builders should care because this approach could lead to more efficient and capable AI systems that can solve problems more effectively.
QCNN with Rough Path Signature Kernels
Leonardo Nogueira Falabella, Vasily Sazonov
Time series analysis is crucial in many fields but is hindered by computational challenges, particularly due to time reparameterization invariance. Current methods struggle to extract meaningful features from time series data effectively. This work proposes a hybrid quantum-classical architecture that leverages quantum neural networks and path signatures to tackle these issues. Builders might care because this approach could lead to more efficient and effective tools for analyzing time series data.
ELSA3D: Elastic Semantic Anchoring for Unified 3D Understanding and Generation
Tianjiao Yu, Xinzhuo Li, Yifan Shen, et al.
Imagine you're trying to create a system that can understand and generate 3D objects based on text descriptions. The challenge is that existing methods often treat text and 3D data as a flat sequence, which can lead to a loss of important details. When you mix everything together without a clear structure, you risk losing the nuances of both the language and the geometry, which is a problem known as information collapse. What ELSA3D does is quite clever. Instead of just throwing text and 3D data together, it uses a method called elastic semantic anchoring. This means it organizes the information in a way that respects the different scales of detail in both the text and the 3D representation. It introduces something called Anchor Tokens, which act like smart filters that pick out the most relevant pieces of information and match them to the right level of detail in the 3D model. This keeps the interaction between text and 3D data precise and efficient. The result is that ELSA3D not only outperforms previous models in generating 3D assets from text and vice versa, but it also does so with about half the computational load. For anyone building applications that require 3D generation or understanding, this means you can achieve better results faster and with less resource consumption.
Graph Convolutional Attention: A Spectral Perspective on Graph Denoising and Diffusion
Shervin Khalafi, Igor Krawczuk, Sergio Rozada, et al.
Imagine you're working with graphs that represent complex relationships, like social networks or molecular structures. The goal is to clean up these graphs, removing noise to better understand the underlying patterns. Traditionally, people have used attention-based methods, which focus on the most relevant parts of the graph. However, these methods often struggle because they assume a uniform structure, which isn't the case in real-world graphs where the spectral properties can vary widely. This limitation leads to suboptimal results, especially when the noise in the data doesn't match the training conditions — this is what's called the spectral diversity problem. To address this, the authors propose a new approach that leverages the actual spectral properties of the input graphs. By introducing Spectral Attention, they can tailor the denoising process to the specific characteristics of the graph at hand. They also develop Graph Convolutional Attention (GCA), which implements this idea in a practical way, allowing for efficient processing without losing the benefits of the spectral focus. The results show that GCA not only outperforms traditional linear attention but does so in a way that is faster and more effective, particularly when the graphs exhibit a lot of spectral variation. In practical terms, if you're building applications that rely on graph data, using GCA could lead to better performance in tasks like graph classification or link prediction, especially when dealing with noisy or diverse datasets. This means you can achieve high-quality results without the computational overhead typically associated with more complex graph processing methods.
Hierarchical Acoustic-Semantic Modeling: Modality Separation and Semantic Coherence for Full-Duplex SLMs
Zhenyu Liu, Yunxin Li, Xuanyu Zhang, et al.
Imagine you're trying to build a system that can hold a natural conversation while also processing speech in real-time. This is a tough challenge because when a model tries to handle both speaking and understanding at the same time, it often gets confused — this is called modality interference. It happens because the model struggles to balance the different types of information it needs to process, leading to misunderstandings and unnatural interactions. This is what's known as knowledge degradation, where the model's ability to understand and respond effectively is compromised. To tackle this issue, the authors of the paper took a close look at how these models work and found that the problem stems from conflicting gradients when the model tries to learn from both acoustic and semantic data simultaneously. They introduced a new framework called Lychee-FD, which separates the processing of these two modalities in a smart way. By decoupling the conflicting parts of the model while still allowing them to communicate through a dedicated channel, they managed to reduce the interference. The results are promising: their approach not only improves the model's ability to understand speech but also makes conversations feel more fluid and natural. Compared to previous methods, this new framework shows a significant boost in performance, making it a valuable advancement for anyone looking to build more intelligent and responsive spoken language systems.
The Large Cancer Assistant (LCA): A Model-Agnostic Orchestration Framework for Scalable Clinical Decision Support in Oncology
Ghassen Marrakchi, Basarab Matei
Imagine you're trying to build a system that helps doctors make better decisions by using different types of patient data — like images, lab results, and clinical notes. The challenge is that current systems often tie everything together too tightly, making it hard to adapt when new data types or AI models come into play. This rigidity can lead to problems like data bottlenecks or failures in decision-making when the underlying AI models change or when hospital IT systems are unreliable. This is what's called monolithic design failure. The Large Cancer Assistant (LCA) addresses these issues by creating a flexible framework that separates how data is ingested from how AI models process that data. It uses a structured approach to standardize different types of patient information, allowing for smooth transitions between various AI models without losing the integrity of the data flow. The system includes a Cancer Switching Module that manages this orchestration, ensuring that even if the AI model changes, the routing of data remains consistent and reliable. What sets the LCA apart from previous work is its focus on maintaining a clear boundary between data handling and AI execution, which enhances adaptability and modularity. In practice, this means that healthcare providers can integrate new AI tools without overhauling their entire system, leading to better decision support and improved patient outcomes.
RSF-GLLM: Bridging the Semantic Gap in Multi-Hop Knowledge Graph QA via Recurrent Soft-Flow and Decoupled LLM Generation
Sambaran Bandyopadhyay, Ananth Muppidi
Imagine you're trying to answer complex questions that require pulling information from a web of interconnected data points, like a knowledge graph. The challenge is that traditional methods often struggle when the terms in the question don't match the terms in the data, leading to gaps in understanding. This is especially problematic when the answer requires navigating through several nodes that don't directly relate to the query — a situation that can cause what's known as a semantic gap. When this happens, the system can't learn effectively because it can't differentiate between relevant and irrelevant information, which is a major failure mode in current approaches. To tackle this issue, the authors propose a new framework called RSF-GLLM. Instead of forcing the system to read and retrieve information in a rigid way, this approach allows for a more flexible learning process. It uses a Recurrent Soft-Flow module that updates the query based on relevance scores, helping the system to traverse through nodes that might not share the same language as the query. This means it can better understand the structure of the data and find the right paths to the answers. Additionally, a regularization technique is introduced to ensure that the system can effectively transition from soft probabilities to concrete reasoning paths. What sets RSF-GLLM apart from previous methods is its ability to ground the answer generation in the actual structure of the knowledge graph, which leads to more accurate and efficient responses. In practical terms, this means that if you're building a system that needs to answer complex questions based on a knowledge graph, RSF-GLLM could significantly enhance your model's performance without the heavy computational costs associated with traditional large language models.
Bridging Physical Reasoning and Task Generalization via Visual Action Outcome Reasoning Alignment
Han-Jun Ko, Jr-Jen Chen, Haobo Yuan, et al.
Imagine you're building a system that needs to understand and interact with the physical world, like a robot that can manipulate objects based on visual cues. The challenge is that these systems often struggle to generalize their reasoning to new tasks or environments. For instance, they might come up with logical steps that don't actually make sense in reality, or their actions might not align with their reasoning — this is what's called hallucinated chain-of-thought reasoning and misalignment between reasoning and actions. These issues can lead to failures in real-world applications, where the model's decisions could have significant consequences. To tackle these problems, the authors propose a new approach called VAORA, which stands for Visual Action Outcome Reasoning Alignment. The idea is to create two types of rewards that help the model better connect its reasoning to what it sees and what it does. The first reward, Visual Alignment Reward, ensures that the model's reasoning is grounded in the visual context, while the second, Visual-Action Alignment Reward, ties the reasoning to the actual outcomes of the model's actions. This dual reward system helps to suppress the hallucinations and align the model's reasoning with its behavior. In practical terms, this means that VAORA can help models perform better in novel tasks and environments, as shown in experiments on datasets like PHYRE and Virtual Tool. By using this new reward design, builders can create systems that exhibit more grounded and generalizable physical intelligence, which is crucial for applications in robotics and interactive AI.
Pitwall: Faithful Natural-Language Race-Strategy Briefings from a Calibrated Real-Time Monte Carlo Engine
Juan S. Santillana
Live sports commentary requires accurate, timely information about events that change rapidly. Current systems often struggle with grounding their statements in real-time data, leading to inaccuracies. This paper presents Pitwall, a system that generates Formula 1 strategy briefings in multiple languages, ensuring every statement is fact-checked against the current race state. Builders might care because it offers a robust method for generating reliable, real-time content in dynamic environments.
AirflowAttack: Thermal-Airflow Adversarial Perturbations against Infrared Remote-Sensing Vision-Language Models
Cong Su, Jiaju Han, Xuemeng Sun, et al.
Vision-language models are increasingly used in security settings with infrared imagery, but their robustness against adversarial attacks is not well understood. Current methods do not address the unique challenges posed by infrared data. This paper introduces AirflowAttack, the first attack that uses thermal-airflow turbulence to create effective perturbations, achieving a high attack success rate across various models. Builders should care because it reveals critical vulnerabilities in the rapidly evolving field of infrared vision-language models, which could impact security applications.
From Fixed to Free Cameras: Calibration-Free View-Robust Vision-Language-Action Model
Wenhao Li, Xueying Jiang, Quanhao Qian, et al.
Imagine you're building a robot that needs to perform tasks in various environments, but the camera setup you trained it with often changes in the real world. This can lead to problems because existing systems rely on knowing exactly where the camera is positioned, which can be tricky and fragile. When the camera moves or is remounted, the robot struggles to adapt, leading to failures in task execution. This is what's called view robustness failure, where the robot can't handle unexpected camera perspectives effectively. The solution proposed in this paper is to shift the focus from telling the robot where the camera is to allowing it to figure that out on its own. The new model, called Camera-Centric VLA (CamVLA), does this by predicting actions based on the camera's perspective without needing to know its exact position. It generates actions in a way that is independent of the camera's geometry, which means it can work with just a single image and task instruction at deployment. This decoupling allows the robot to operate more flexibly and reliably in real-world scenarios. What sets CamVLA apart from previous methods is its ability to improve success rates across various unseen viewpoints without requiring complex calibration or depth information. This means that for builders deploying robots in dynamic environments, this approach simplifies the process and enhances the robot's adaptability, making it a practical choice for real-world applications.
Interpretable Human-Label-Free Deep Learning for Real-Bogus Classification with Uncertainty Quantification
Raphaël Bonnet-Guerrini, Bruno Sanchez, Dominique Fouchez, et al.
Imagine you're trying to identify real astronomical events from a flood of data, but getting reliable labels is tough and expensive. Traditionally, researchers rely on human labels, which can be inconsistent and vary from one survey to another. This leads to problems like misclassification, where real events get mixed up with false ones, making it hard to trust the results. This issue is known as label noise, and it can severely impact the accuracy of any classification system you build. What this paper does is propose a clever way to tackle these challenges without needing those costly human labels. Instead of relying on them, the authors use a combination of simulated data and existing noisy survey data to train a dual-network model. This model is designed to handle different levels of label noise effectively, which means it can still perform well even when the data is messy. They also introduce a method for quantifying uncertainty in their predictions, which helps users understand how confident they can be in the model's classifications. The results are promising: the method shows strong performance in identifying real versus bogus transients and maintains stability even when faced with significant label noise. This is a big step forward compared to previous methods that struggled with similar issues. For anyone building systems in astronomy or related fields, this approach could save time and resources by allowing for scalable classification without the need for extensive human labeling.
Weak-to-Strong Generalization via Direct On-Policy Distillation
Shiyuan Feng, Huan-ang Gao, Haohan Chi, et al.
Imagine you're trying to improve a powerful language model, but every time you want to enhance it, you have to run expensive reinforcement learning (RL) training, which involves generating a lot of data. This can be a huge bottleneck, especially as models get larger. The traditional approach is to train the strong model directly, but this can be inefficient and slow, especially when the model is already complex. This is what's called the post-training bottleneck, where the cost of training outweighs the benefits of the improvements you might get. What this paper proposes is a clever workaround: instead of training the strong model directly, you first train a smaller, cheaper model using RL. Then, you take what that smaller model learned and apply it to the stronger model. However, simply copying the smaller model's learned behavior isn't enough because it might carry over its own limitations. Instead, the authors introduce a method called Direct On-Policy Distillation (Direct-OPD), which focuses on transferring the specific improvements the smaller model made during its training. This way, the stronger model can learn from the weaker one without inheriting its flaws. The results are promising. By using this method, they were able to significantly improve the performance of a model called Qwen3-1.7B in a short amount of time. This means that instead of always needing to retrain the strong model from scratch, you can leverage the learning from a weaker model, making the process faster and more efficient. For anyone building language models, this approach could save a lot of time and resources while still achieving better results.
LLM-as-a-Verifier: A General-Purpose Verification Framework
Jacky Kwok, Shulu Li, Pranav Atreya, et al.
Imagine you're building a system that needs to evaluate the correctness of various solutions, like code snippets or answers to questions. Traditionally, you might use a model that gives a simple score, but this can lead to problems. For instance, if the model is too confident in its scoring, it might overlook better solutions or fail to recognize errors in less certain outputs. This is known as miscalibration, where the model's confidence doesn't match reality, leading to poor decision-making based on its evaluations. What this paper introduces is a new way to verify solutions using a framework called LLM-as-a-Verifier. Instead of just giving a single score, this approach looks at the distribution of scores across possible outputs, allowing for a more nuanced evaluation. By breaking down the scoring into finer details, it can better distinguish between good and bad solutions. This means that when you scale the granularity of the scoring, you get clearer comparisons, which helps in making better decisions. The results are promising: LLM-as-a-Verifier achieves top performance on several benchmarks, showing that it can provide more accurate feedback than previous methods. For anyone building systems that rely on evaluating solutions, this framework offers a way to improve the reliability of those evaluations without needing to retrain the models. It’s a practical tool for enhancing the performance of agentic systems, making it easier to monitor and refine their outputs.
Search Beyond What Can Be Taught: Evolving the Knowledge Boundary in Agentic Visual Generation
Haozhe Wang, Weijia Feng, Jinpeng Yu, et al.
Imagine you're building a visual generator that creates images based on user requests. The challenge is that users often ask for things that the generator hasn't seen before, like new characters or recent events. This creates a problem where the generator confidently produces incorrect images because it lacks the necessary knowledge. This is what's called a knowledge boundary — the gap between what the generator knows from its training and what it needs to know to fulfill user requests accurately. Currently, many visual generators are trained on fixed datasets, which means they can't adapt to new information or trends. When users ask for something outside of this training, the generator might try to guess, leading to poor results. This is particularly problematic in a world where requests are constantly changing and evolving. The authors point out that simply using search tools to fill in these gaps often backfires, as it can introduce irrelevant information that confuses the generator further. This failure mode is known as noise injection. To tackle these issues, the authors propose a new approach that combines teaching the generator with searching for relevant information. This co-training framework allows the generator to learn from its mistakes and improve over time. Even a basic version of this method shows consistent improvements in performance, which means that visual generators can become more reliable in meeting user demands. This is a significant step forward compared to previous methods, as it lays the groundwork for ongoing enhancements in visual generation that are grounded in real-world knowledge.
What Does a Discrete Diffusion Model Learn?
Rodrigo Casado Noguerales, Bernhard Schölkopf, Thomas Hofmann, et al.
Imagine you're trying to clean up noisy data, like images or audio recordings, but you're not sure how to best approach the problem. You might try different methods, like denoising or using a score-based approach, but each has its own quirks and limitations. Sometimes, these methods can even conflict with each other, leading to confusion about which one is actually working best. This is where the challenges arise: you might end up with a model that doesn't perform well because it's not using the right approach for the noise it's dealing with. This is what's called misalignment in training methods. What this paper does is provide a fresh perspective on these challenges. It introduces a framework that connects various training methods for diffusion models, showing that they are essentially different ways of looking at the same problem. By deriving a new theorem, the Oracle Distance theorem, it clarifies how to optimize these models effectively. This means that instead of getting lost in the details of each method, you can understand how they relate to one another and choose the best approach based on the specific noise characteristics of your data. In practical terms, this framework allows builders to better calibrate their models from the start, ensuring that they are using the most effective training strategy for their specific needs. It also helps in understanding why certain methods work better in different scenarios, which can save time and resources when developing new applications.
CompactionRL: Reinforcement Learning with Context Compaction for Long-Horizon Agents
Yujiang Li, Zhenyu Hou, Yi Jing, et al.
Imagine you're building a system that needs to handle long conversations or tasks that require multiple steps. Traditional models often struggle because they can only remember a limited amount of information at once, which can lead to incomplete or incorrect responses. This is especially problematic in scenarios where the context is crucial for making decisions, like coding tasks or complex interactions. When the context window fills up, the model might forget important details, leading to errors or a lack of coherence in its responses. This is what's called context overflow, and it can severely limit the effectiveness of the model in real-world applications. To address this, the authors propose a method that allows the model to summarize previous interactions and continue working with a more compact representation of the context. This means that instead of losing important information when the context window is full, the model can create a summary that retains the essential details. The method, called CompactionRL, combines reinforcement learning with this summarization process, allowing the model to learn from both the task at hand and the summaries it generates. This dual focus helps the model perform better over longer interactions. In practical terms, CompactionRL has shown to improve performance on coding tasks significantly, with specific models achieving higher accuracy scores on established benchmarks. This means that for builders working on applications that require long-term interaction, using this approach could lead to more reliable and effective systems that can handle complex tasks without losing track of important context.
Cortex: A Bidirectionally Aligned Embodied Agent Framework for Long-horizon Manipulation
Jiaqi Peng, Xiqian Yu, Delin Feng, et al.
Imagine you're trying to build a robot that can perform complex tasks, like cooking or assembling furniture. These tasks often require planning several steps ahead, but many current models only react to what they see right now, which limits their effectiveness in long-term scenarios. This is a problem because when a robot can't plan ahead, it can get stuck or make mistakes when transitioning between different subtasks — this is what's called planning ambiguity. To tackle this, Cortex introduces a new way to connect high-level plans with the actual actions the robot needs to take. Instead of just reacting to the current situation, Cortex breaks down tasks into smaller, manageable pieces, called skill primitives, and ensures that these pieces are easy to execute. It also improves how the robot learns from data by using a smart sampling strategy that helps it better understand when to switch between tasks. This means that Cortex can handle complex tasks more effectively than previous models, which often struggled with the same issues. In practical terms, Cortex allows robots to complete tasks they've never seen before, like conducting multi-stage chemistry experiments, just by combining its planning capabilities with its execution skills. This is a big step forward for anyone building robots that need to perform a variety of tasks without extensive retraining.
Fitted Occupancy-Ratio Evaluation without Bellman Completeness
Lars van der Laan, Nathan Kallus
Imagine you're trying to evaluate how well a policy performs in a reinforcement learning setting, but you only have past data to work with. This is tricky because the data might not represent the current environment well, leading to inaccurate evaluations. Traditional methods often rely on complex assumptions about the value functions and the data distribution, which can break down when those assumptions don't hold. This is what's called the problem of distribution shift in offline reinforcement learning. What this paper introduces is a more straightforward approach to tackle this issue. Instead of needing a lot of assumptions about the value functions, it focuses on the occupancy ratio, which is a measure of how often different states are visited under a policy. The new method, called fitted occupancy-ratio evaluation (FORE), uses a fixed-point approach to estimate this ratio directly from the data. It simplifies the process by projecting the data onto a specific class of distributions, making it more robust to the challenges of distribution shift. The practical takeaway is that this method allows for more reliable policy evaluations without needing to meet stringent completeness conditions. This means that if you're building systems that rely on offline reinforcement learning, you can trust the evaluations more, even when the data doesn't perfectly match the current environment. This could lead to better decision-making in applications like robotics or automated trading, where accurate policy evaluation is crucial.
GaP: A Graph-as-Policy Multi-Agent Self-Learning Harness For Variational Automation Tasks
Kaiyuan Chen, Shuangyu Xie, Letian Fu, et al.
Imagine you're trying to get robots to perform tasks in unpredictable environments, like a factory where the objects they handle can vary widely in shape and position. Traditional programming methods often struggle here because they rely on fixed rules and can't adapt to new situations. This leads to failures when the robot encounters something it wasn't specifically programmed for — a problem known as rigidity in automation. To tackle this, people have been using model-free policies, which allow robots to learn from experience rather than just following pre-set instructions. However, these policies can still fall short in reliability, especially when tasks need to be performed consistently over time. This is what's called the reliability gap. The authors introduce a solution called Graph-as-Policy (GaP), which creates a flexible coding framework that generates computation graphs tailored to specific tasks. It combines perception, planning, and control in a way that allows robots to rehearse different task scenarios in a simulated environment before executing them in the real world. This iterative refinement process helps improve the robot's success rates significantly. In practical terms, GaP allows robots to adapt to new tasks more effectively than previous methods, making them more reliable in commercial and industrial settings. The evaluation shows that GaP outperforms existing baselines across multiple benchmarks, which is crucial for anyone looking to deploy robots in dynamic environments.
SPEARBench: A Benchmark for Naturalness Evaluation in Streaming Speech-to-Speech Language Models
Thomas Thebaud, Yuzhe Wang, Hao Zhang, et al.
Imagine you're building a system that can take spoken questions and respond with synthetic speech. You want it to sound natural, like a real conversation, but current benchmarks mainly focus on how accurately the system understands and generates speech. This is where things can go wrong: while a model might produce clear and correct answers, it could still feel robotic or awkward in a back-and-forth dialogue. For instance, it might interrupt too often, take too long to respond, or fail to adapt its tone to the emotional context of the conversation. These issues are what's called naturalness failures in conversational AI. To address these shortcomings, the authors created SPEARBench, a new benchmark specifically designed to evaluate how naturally speech-to-speech models interact in conversations. Instead of just measuring accuracy, SPEARBench looks at various factors like response timing, emotional tone, and how well the model maintains consistency in language and dialect. By using controlled dialogue prompts and comparing model outputs to human responses, they provide a more comprehensive view of conversational quality. What sets this work apart from previous benchmarks is its multidimensional approach to evaluation. It shows that even when models achieve high technical performance, they can still fall short in mimicking human conversational behavior. For anyone building conversational systems, this means you need to focus not just on getting the right answers, but also on how those answers are delivered to ensure a more human-like interaction.
REDDIT: Correcting Model-Generated Timestamp Drift in ASR without Forgetting via Replay-Based Distribution Editing
Cheng-Kang Chou, Ming-To Chuang, Ke-Han Lu, et al.
Imagine you're building a speech recognition system that needs to transcribe audio accurately, including when there are long pauses or non-speech segments. The challenge is that when the system generates timestamps for the transcription, these can drift over time, especially during these non-speech periods. This drift means that while the words might still make sense, the timing can be completely off, leading to confusion in applications that rely on precise timing, like subtitles or voice commands. This issue is known as timestamp drift, and it can be particularly problematic in long audio segments where the system struggles to maintain accurate timing without additional context. Currently, many systems try to correct this drift by fine-tuning the model with additional data, but this can lead to a forgetting problem where the model loses its ability to perform well on other tasks. This is where the new approach comes in. The authors propose a method called REDDIT, which stands for Replay-based Distribution Editing. This method allows the model to correct its timestamps without losing its original capabilities. It does this by editing the timestamps based on the model's own previous outputs while ensuring that it maintains its performance on non-timestamp tasks. The results are quite striking: using this new framework, the authors were able to improve the accuracy of timestamp alignment significantly while only updating a small fraction of the model's parameters. This means that for builders working on ASR systems, they can achieve much better performance in terms of timing without the risk of degrading the overall system's capabilities.
SovereignPA-Bench: Evaluating User-Owned Personal Agents under Evolving Intent, Platform Mediation, and Consent Constraints
Dylan Zongmin Liu
Imagine you're building a personal assistant that not only helps users with tasks but also respects their privacy and choices. As these agents become more integrated into our lives, it’s crucial that they don’t just complete tasks but also uphold user sovereignty — meaning they should prioritize the user's interests without compromising their privacy or consent. However, current benchmarks often overlook this aspect, focusing mainly on task completion without considering how these agents might manipulate or mislead users. This is where the concept of sovereignty comes into play, highlighting the need for a more nuanced evaluation of personal agents. The paper introduces SovereignPA-Bench, a new benchmark designed specifically to assess personal agents in terms of their ability to respect user sovereignty. It evaluates how well these agents navigate complex scenarios involving user preferences, privacy boundaries, and consent constraints. By separating what the agent can see from what evaluators can see, it provides a clearer picture of how these agents perform in real-world situations. The authors tested this benchmark across 120 scenarios and multiple model families, yielding a wealth of data that reveals how different approaches to agent design impact user sovereignty. One key finding is that using a full-sovereign approach — which integrates memory, consent, and evidence considerations — significantly improves the agents' performance in maintaining user sovereignty compared to more traditional methods. This means that for builders creating personal agents, focusing on sovereignty not only enhances user trust but also leads to better overall performance in real-world applications.
Graph Sparse Sampling: Breaking the Curse of the Horizon in Continuous MDP Planning
Idan Lev-Yehudi, Vadim Indelman
Imagine you're building an autonomous system that needs to make decisions in uncertain environments, like a robot navigating a complex space. Traditionally, planners use tree-based methods, like Monte Carlo Tree Search, which can become computationally expensive as they try to look ahead further into the future. The problem is that as you increase the depth of your search, the number of possible paths grows exponentially, making it hard to find the best option without a massive amount of computation. This is what's called the exponential horizon dependence of tree-based methods. It gets even trickier when you're dealing with continuous spaces, where the planner has to decide where to search in an infinite branching structure. This can lead to inefficiencies and missed opportunities for better decisions. The solution proposed in this paper is a new algorithm called Graph Sparse Sampling (GSS). Instead of treating each decision as a separate branch to explore, GSS shares sampled futures across multiple candidate actions. This means that rather than sampling each possible outcome independently, it pools information from various paths, which allows for more efficient use of computational resources. The algorithm also leverages heuristics to focus its efforts on the most promising areas of the search space. What sets GSS apart from previous methods is its ability to provide finite-sample performance guarantees, which means it can assure users of its effectiveness under certain conditions. In practical terms, this means that when using GSS, you can expect to make better decisions faster, especially in scenarios where you need to plan over long time horizons. This could be particularly useful for anyone building autonomous systems that require real-time decision-making in complex environments.
Faithfulness to Refusal: A Causal Audit of Neuron Selectors
Ananth Eswar, Pratinav Seth, Utsav Avaiya, et al.
Language models often rely on neuron rows for tasks like pruning and safety editing, but current methods may not accurately identify which rows are truly important. This paper tests attribution scores against direct causal audits, revealing that some highly ranked selectors are not causally valid. The findings suggest that different methods can achieve similar safety edits, indicating a need for more nuanced approaches in model interventions. Builders should be aware that relying solely on rank-stability could lead to ineffective or misleading results.
Multiplayer Interactive World Models with Representation Autoencoders
Anthony Hu, Václav Volhejn, Adrien Ramanana Rahary, et al.
In multiplayer environments, existing models often treat other agents as part of the environment, limiting their effectiveness. This paper addresses that gap by introducing a world model that conditions on multiple agents' actions, allowing for more accurate scene changes attribution. The model, trained on extensive gameplay data, maintains stability in its rollouts for significantly longer than its training duration, which is a notable improvement. Builders interested in creating AI for complex, interactive scenarios will find the methodologies and results relevant for enhancing their systems.
OptiAgent: End-to-End Optimization Modeling via Multi-Agent Iterative Refinement
Adriana Laurindo Monteiro, Nayse Fagundes, Gabriel Mattos Langeloh, et al.
Operations Research problems often require complex mathematical formulations that can be difficult to generate from natural language descriptions. Current methods may struggle with misinterpretation and structural defects, leading to inefficient solutions. OptiAgent addresses these issues by using dedicated agents that extract key structures and provide iterative self-correction, improving both accuracy and transparency. Builders might find this framework useful for automating and refining the optimization process, ultimately saving time and resources.
Topological Shape Representation for Aneurysm -- Bifurcation Detection
Akshay Gokhale, Mansi Dhamne
Detecting small intracranial aneurysms from CT scans is challenging due to high false-positive rates, particularly when distinguishing between aneurysms and vascular structures. Current convolutional neural networks struggle with this, especially for lesions smaller than 3 mm. The proposed SECT framework addresses this issue by using a topology-aware approach that captures 3D vascular geometry, leading to significantly improved detection rates. Builders in medical imaging might find this method useful for enhancing diagnostic accuracy in clinical settings.
Reasoning LLM Improves Speaker Recognition in Long-form TV Dramas
Yuxuan Li, Lingxi Xie, Xinyue Huo, et al.
Imagine trying to follow a complex TV drama where multiple characters are speaking, and you need to know who said what. This is a tough problem because the dialogue can be fast-paced and the characters can sound similar. Currently, systems struggle with this task, especially when the audio quality is poor or when characters have similar voices. This leads to mistakes in attributing lines to the wrong characters, which is frustrating for viewers and can ruin the experience. This issue is known as speaker recognition failure. To tackle this, the authors created a large dataset called DramaSR-532K, which includes 532,000 annotated dialogue lines from over 900 characters. This dataset allows for better training of models to recognize speakers by using a mix of sound, text, and visual information. They also developed a new method called DramaSR-LRM that intelligently combines these different types of data to improve accuracy. The method is particularly effective for short dialogue snippets, where traditional audio-based recognition often fails. In practical terms, this means that if you're building a system to analyze or summarize TV shows, you can now rely on a more accurate way to identify who is speaking, leading to better user experiences and more reliable content analysis.
DemoPSD: Disagreement-Modulated Policy Self-Distillation
Yunhe Li, Hao Shi, Wenhao Liu, et al.
Imagine you're training a language model to answer questions across various topics. You want it to learn effectively from its own experiences while also benefiting from guidance provided by a teacher model. However, if the teacher model gives too much specific information, the student might overfit to those details and struggle when faced with new, unseen questions. This is a common issue known as privileged information leakage, where the student learns shortcuts that don't apply in real-world scenarios. Additionally, the student might lose its ability to explore different reasoning paths, which is crucial for tackling diverse problems. Currently, many approaches rely on dense supervision from the teacher, which can lead to these pitfalls. The paper introduces a new method called DemoPSD, which allows the student to learn from the teacher without fully relying on its guidance. Instead of just mimicking the teacher's outputs, DemoPSD encourages the student to maintain its own reasoning abilities while selectively adopting useful insights from the teacher. This is achieved through a clever mechanism that balances the learning from both models, ensuring that the student doesn't just memorize answers but also develops a deeper understanding. The results show that DemoPSD not only mitigates the leakage of privileged information but also preserves the student's capacity to explore different solutions. In practical terms, this means that when you're deploying language models in real-world applications, you can expect them to perform better on new types of questions, thanks to the improved training approach. This is particularly important for applications that require robust generalization across various domains.
Controllable Sim Agents with Behavior Latents
Juanwu Lu, Junyu Zhu, Ziran Wang
Imagine you're trying to simulate traffic for testing autonomous vehicles. You want the simulated agents to behave like real drivers, but also to be controllable so you can test specific scenarios without real-world risks. Traditional methods often struggle with this because they can’t easily adjust agent behavior or might not respond well to steering commands. This is where things can go wrong, like when agents get stuck in certain behaviors or fail to react appropriately to changes in their environment — this is what's called reward hacking or lack of controllability. The solution presented in this paper is a new framework called Controllable Neural Variational Agents (CNeVA). It allows agents to learn from past behaviors while also being steered along specific paths. The key innovation here is the use of soft eligibility gates, which help agents respond more smoothly to steering commands instead of getting stuck at rigid thresholds. This means that when you want to test a specific driving scenario, the agents can be guided more effectively without losing their realistic behavior. Compared to previous models, CNeVA not only maintains a high level of realism but also provides a level of controllability that was lacking before. This is particularly useful for engineers who need to isolate variables and test edge cases safely, making it a practical tool for developing and validating autonomous systems.
Visually Grounded Self-Reflection for Vision-Language Models via Reinforcement Learning
Liyan Tang, Fangcong Yin, Greg Durrett
Imagine you're building a system that needs to understand both images and text, like a virtual assistant that can analyze charts or tables. The challenge is that these systems often struggle to learn from their mistakes, especially when they encounter new types of images that they weren't trained on. This can lead to errors that compound over time, making the system less reliable. This issue is known as poor self-reflection, where the model fails to revisit and correct its earlier decisions effectively. Currently, many models are trained to handle these tasks, but they often don't adapt well when faced with unexpected inputs. For instance, if a model misinterprets a chart, it might not have the tools to go back and adjust its understanding based on that mistake. This is what's called a failure to reflect properly on its decisions, which can be particularly problematic in real-world applications where data can vary significantly from training examples. To tackle this, the authors propose a new approach that encourages models to learn from their errors through a reinforcement learning framework. The key idea is to train the model to focus on recovering from mistakes by masking parts of its decision-making process, which helps it learn to correct itself rather than just making early errors. Additionally, they introduce a method to expose the model to a variety of failure scenarios, allowing it to learn how to handle different types of mistakes. This combination leads to a model that can better reflect on its decisions and improve its accuracy, especially when dealing with unfamiliar data. In practical terms, this means that if you're building a system that relies on understanding complex visual data, using this new method could significantly enhance its performance when faced with unexpected inputs. The results show that this approach leads to a notable increase in accuracy for tasks that involve out-of-distribution images, making it a valuable tool for developers in the field.
Combating Textual Noise and Redundancy: Entropy-Aware Dense Visual Token Pruning
Xuehui Wang, Xuankun Yang, Wei Shen
Imagine you're building a system that processes images and text together, like a smart assistant that can understand both what you say and what you show it. To make these systems faster, you might want to reduce the amount of image data they process by removing unnecessary parts. However, if you cut too much, you risk losing important details that help the system understand your instructions, especially when they are complex or very specific. This is a common issue with current methods of visual token pruning, where the selection process can overlook critical visual information due to noise in the text or poor selection strategies. This is what's called feature fragmentation and textual noise corruption. To tackle these problems, the authors propose a new approach that first measures the relevance of different parts of the text to the image data, filtering out irrelevant noise. Then, instead of just picking the top few image patches, they use a more sophisticated method that ensures the selected patches work well together and cover the important aspects of the image. This method, called Entropy-Aware Dense Pruning (EADP), helps maintain a complete and useful visual representation. The results show that EADP not only speeds up the processing of visual language models but also keeps the accuracy high, even when working with limited resources. This means that for anyone building applications that rely on understanding both images and text, this new method could lead to more efficient and effective systems.
TestEvo-Bench: An Executable and Live Benchmark for Test and Code Co-Evolution
Jiale Amber Wang, Kaiyuan Wang, Pengyu Nie
Imagine you're working on a software project where every time you change the code, you need to ensure that the tests reflect those changes. This is crucial because outdated tests can lead to bugs slipping through. Currently, many test generation methods don't consider the actual code changes, which can result in tests that are either irrelevant or fail to run properly. This disconnect is problematic because it makes it hard to know if the tests are truly capturing the new behavior of the software. This issue is known as the lack of semantic alignment between tests and code changes. To address this, the authors created TestEvo-Bench, a benchmark that focuses on the co-evolution of tests and code. It includes tasks where agents must either generate new tests or update existing ones based on real code changes from software repositories. Each task is tied to actual commit histories, ensuring that the tests are relevant and executable. The benchmark also tracks the timing of changes to prevent data leakage during evaluation. With 746 test generation and 509 test update tasks from a large dataset, the authors tested several advanced agents and found that they could achieve a success rate of up to 77.5% for generating new tests. However, they noted that performance declines on the most recent tasks, indicating that adapting to ongoing changes in code is still a challenge. This approach is a step forward from previous methods that often isolated tests from the code changes, providing a more realistic evaluation of how well automation agents can keep up with evolving software. For builders, this means that using TestEvo-Bench can help ensure that the tests you rely on are not just theoretically sound but practically effective in real-world scenarios.
Learning to Move Before Learning to Do: Task-Agnostic pretraining for VLAs
Junhao Shi, Siyin Wang, Xiaopeng Yu, et al.
Imagine you're trying to teach a robot how to perform tasks based on visual inputs and instructions. The challenge is that gathering expert demonstrations — the specific actions taken in response to various observations and instructions — is expensive and time-consuming. This often leads to a bottleneck where you can't scale your training effectively because you don't have enough of these expert examples. When you do manage to collect some, the robot might still struggle because it needs to learn not just how to move but also what those movements mean in context. This is where things can go wrong: if the robot focuses too much on the physical actions without understanding the instructions, it won't perform well in real-world scenarios. This is what's called a conflation of learning objectives, where the robot's physical competence and semantic understanding are not aligned properly. The authors propose a solution to this problem by introducing a two-stage training framework called Task-Agnostic Pretraining (TAP). In the first stage, the robot learns from a wide range of unlabeled interactions, including off-task movements and playful actions, which helps it develop a sense of how to move. Then, in the second stage, it grounds this knowledge in language using minimal expert data. This approach allows the robot to build robust physical representations without needing vast amounts of labeled data. The results are promising: on a benchmark, TAP matches the performance of models trained on over a million expert trajectories while using far less labeled data. In practical terms, this means that if you're building an embodied AI system, you can achieve better performance with less reliance on costly expert demonstrations, making your development process more efficient.
Is One Layer Enough? Training A Single Transformer Layer Can Match Full-Parameter RL Training
Zijian Zhang, Rizhen Hu, Athanasios Glentis, et al.
Imagine you're trying to improve a large language model's performance after it's been trained. Traditionally, people assume that every part of the model, every layer, needs to be updated equally to get better results. But what if that's not true? What if only a few layers are really responsible for the improvements you see? This paper dives into that question and finds that you can actually get most of the benefits of reinforcement learning by just training one layer instead of the whole model. This is surprising because it goes against the common belief that all layers contribute equally to the model's performance. The authors introduce a new measure called 'layer contribution' to show how much each layer helps with the overall improvement. They tested this across different models and tasks, and consistently found that the middle layers of the transformer architecture are the most important for gaining performance. This means that if you're building or fine-tuning models, you might save time and resources by focusing on just a few key layers instead of trying to update everything at once.
AutoMem: Automated Learning of Memory as a Cognitive Skill
Shengguang Wu, Hao Zhu, Yuhui Zhang, et al.
Imagine you're building a system that needs to remember a lot of information over time, like a game character that has to keep track of its inventory and past actions. The challenge is that as the character interacts with the game world, it can easily forget important details or make poor decisions based on its memory. This is especially tricky in long games where decisions made early on can have consequences much later. When memory management isn't handled well, it can lead to mistakes that are hard to trace back, making it difficult to improve the system's performance. This is what's called memory mistakes. To tackle these issues, the authors propose a new approach where memory management becomes a skill that the model can learn and improve over time. Instead of relying on fixed memory structures, the model can adapt its memory usage based on its experiences. They introduce a framework called AutoMem, which automates the process of reviewing and revising how the model interacts with its memory. This means the model can learn from its own good memory decisions and refine its memory structure without needing constant human oversight. The results are promising: by focusing solely on optimizing memory management, the model's performance improved significantly, making it competitive with leading systems. This means that for builders, having a system that can autonomously manage its memory could lead to much better performance in complex tasks without needing to change the core task actions.
Theoria: Rewrite-Acceptability Verification over Informal Reasoning States
Ben Slivinski, Michael Saldivar
Imagine you're using an AI to solve complex problems, like legal questions or technical challenges. You want to trust its answers, but how do you know if it's right? Current methods either give you certainty but miss many problems, or they provide broad coverage but lack transparency, making it hard to audit their decisions. This is where Theoria comes in. It rewrites potential solutions into a series of clear, justified steps, allowing each transition to be independently verified. This means if something goes wrong, you can trace it back to where the AI made a mistake. In tests, Theoria certified over 91% of expert problems with a clear proof for each step, while traditional methods struggled with hidden errors. This approach not only improves accuracy but also builds trust, as users can see and challenge each part of the reasoning process. For anyone building AI systems that require reliable outputs, Theoria offers a practical way to ensure that the answers you get are not just confident but also correct.
The State-Prediction Separation Hypothesis
Giovanni Monea, Nathan Godey, Kianté Brantley, et al.
Imagine you're trying to build a language model that predicts the next word in a sentence. Traditional models, like Transformers, do this by using the same process to both make predictions and keep track of useful information for future predictions. This can lead to inefficiencies because the model is trying to do two things at once, which can cause it to struggle with complex tasks. This is what's called a bottleneck in performance. The authors of this paper propose a solution by suggesting that if you separate these two functions — one stream for predicting the next token and another for storing state — you can actually improve how well the model performs. They designed a new variant of the Transformer that does just that, and their experiments show that this separation leads to better data and compute efficiencies. In practical terms, this means that their approach consistently reduces validation loss and achieves better results on various tasks compared to standard Transformers. Overall, this new method not only enhances performance but also provides a clearer understanding of how different components of the model interact. For anyone building language models, this insight could lead to more efficient designs that save on resources while improving accuracy.
FurnitureVLA: Learning Long-Horizon Bimanual Furniture Assembly with Vision-Language-Action Model
Chenyang Ma, Yue Yang, Radu Corcodel, et al.
Imagine you're trying to assemble a large piece of furniture, like a dining table, but you want to do it with two robotic arms instead of your hands. The challenge is that most existing systems only work well with small, simple tasks or just one arm, which limits their usefulness in real-world scenarios. When you try to scale up, things can go wrong: the robots might not coordinate properly, leading to mistakes and frustration. This is what's called coordination failure, where the robots struggle to work together effectively over many steps. To tackle this, the authors developed FurnitureVLA, a system designed specifically for real-scale bimanual furniture assembly. They created a simulation pipeline to generate expert data and a VR system that allows a single operator to control both arms. The key innovation here is that the system not only predicts what actions the robots should take but also tracks their progress through the assembly process. This helps the robots transition between tasks smoothly, reducing errors that can pile up over time. Compared to previous methods, FurnitureVLA significantly boosts the success rate of assembly tasks, achieving an 80% success rate across different furniture types. This is a big improvement from the 48% success rate seen before. For anyone building robotic systems for furniture assembly, this means you can expect much better performance and reliability, especially in complex tasks that require multiple steps and coordination.
Distill to Detect: Exposing Stealth Biases in LLMs through Cartridge Distillation
Shayan Talaei, Abhinav Chinta, Devvrit Khatri, et al.
Imagine you're using a language model to help make important decisions, like recommending products or providing information. The problem is that these models can develop hidden biases, favoring certain brands or viewpoints without any obvious signs. This can happen because the biases are only revealed in specific contexts, making them hard to detect. Current methods struggle to identify these biases, especially when they only show up in certain topics while the model behaves normally in others. This is what's called stealth preferential bias. To tackle this issue, the authors propose a new method called Distill to Detect (D2D). The idea is to capture the differences between a biased model and its original version, focusing on the parts where the bias is most pronounced. By distilling this information into a special adapter, D2D amplifies the bias signal, making it easier to spot in the model's outputs. This approach not only helps in detecting hidden biases but also provides a theoretical framework to understand why it works. Compared to previous methods, D2D offers a practical solution for auditing language models in real-world applications. It allows builders to identify and address biases that could influence user decisions, ensuring that the models they deploy are fairer and more transparent.
GPU-Parallel Linearization Error Bounds for Real-Time Robust Optimal Control of Nonlinear and Neural Network Dynamics
Jeffrey Fang, Keyi Shen, Anutam Srinivasan, et al.
Imagine you're trying to control a robot that has to navigate through unpredictable environments. You want it to make decisions in real-time, but the challenge is that the robot's behavior can be quite complex and uncertain. Traditional methods often simplify these complexities, but that can lead to mistakes when the robot encounters unexpected situations. This is where linearization error bounds come into play — they help ensure that the robot's decisions remain safe and effective despite these uncertainties. However, existing methods for calculating these bounds can be too loose, leading to overly cautious behavior that slows down the robot's response time. This is what's called conservativeness in control systems. The approach in this paper tackles these issues by developing a new way to calculate tighter linearization error bounds that are also differentiable and can be processed quickly on GPUs. By using advanced techniques like path-based Hessian bounds for analytic dynamics and certified bounds for neural network dynamics, the authors create a system that can handle the complexities of real-time control more effectively. Their method, GPUSLS-LEO, allows for the optimization of robust feedback policies that take into account the errors from linearization, resulting in faster and more reliable decision-making. In practical terms, this means that if you're building a system that requires real-time control, like a drone or an autonomous vehicle, you can implement this method to ensure that it operates safely and efficiently, even in complex environments. The ability to compute robust control policies at high rates significantly enhances the performance of such systems compared to previous methods.
World from Motion: Generative Dynamic Gaussian Reconstruction from Monocular Video
Liyuan Zhu, Shengyu Huang, Amrita Mazumdar, et al.
Imagine you're trying to create a 3D model of a scene just from a video taken with a single camera. This is tricky because the camera can miss details or create artifacts, especially when the scene is dynamic or the viewpoint changes. Current methods often struggle with these issues, leading to incomplete or inaccurate 3D reconstructions. This is what's called monocular reconstruction failure, where the lack of multiple viewpoints limits the model's understanding of depth and motion. The approach in this paper tackles these challenges by using a new method that generates dynamic 3D Gaussian representations from monocular videos. It does this by conditioning a video model on detailed, pixel-aligned renderings that capture not just the appearance but also the geometry and motion of the scene. By training on a dataset of aligned multiview video pairs, the model learns to correct common rendering artifacts and fill in missing regions, which are typical problems in monocular reconstruction. What’s exciting is that this method not only improves the quality of the 3D models but also sets a new state of the art in 4D reconstruction. It can handle real-world videos with significant viewpoint changes and dynamic motions, making it a practical solution for builders looking to create accurate 3D representations from standard video footage.
Neural Certificate Pricing for Combinatorial Optimization Problems
Jingyi Chen, Xinyuan Zhang, Xinwu Qian
Imagine you're trying to solve complex problems where you need to find the best combination of options, like scheduling or resource allocation. These problems can be really tough because there are so many possible combinations to check, and verifying if a solution is optimal can take a long time. Currently, people often rely on traditional optimization methods that can be slow and inefficient, especially when the problem size grows. This is what's called the exponential search problem — as the number of options increases, the time it takes to find the best one can skyrocket, making it impractical for large-scale problems. What this paper introduces is a clever way to tackle this issue by using a neural network to predict certain values that help in finding the best solution without having to check every single possibility. Instead of going through all the combinations, the network learns to estimate the 'prices' of different options, which helps in narrowing down the search. This method, called Neural Certificate Pricing (NCP), allows for a more efficient search process. When the network predicts these prices accurately, it can recover a feasible solution much faster than traditional methods. In practice, NCP has shown to outperform existing neural approaches significantly or match their performance while using much less computational power. This means that for anyone building systems that need to solve complex optimization problems, NCP could save time and resources, making it a valuable tool in their toolkit.
Right in the Right Way: LM Training with Verifiable Rewards and Human Demonstrations
Mehul Damani, Isha Puri, Idan Shenfeld, et al.
Imagine you're trying to build a language model that not only gets the right answers but also sounds natural and engaging. You might start with reinforcement learning (RL), which is great for optimizing tasks with clear success metrics, like generating code or solving math problems. However, the challenge is that RL often focuses only on what can be easily measured, like correctness, and ignores the subtler aspects of human communication, such as style and creativity. This can lead to problems like diversity collapse, where the model produces repetitive outputs, or unnatural responses that don't resonate with people. These issues are known as failure modes in RL training. To address these shortcomings, this paper proposes a new approach that enhances traditional RL methods by incorporating feedback from human demonstrations. The idea is to use an adversarial setup where a generator model learns to produce outputs that not only maximize task accuracy but also align with human-like qualities. A discriminator model is trained alongside the generator to differentiate between human-written and model-generated outputs. This discriminator acts as a guide, providing feedback on aspects that are hard to quantify with simple scores. The results are promising: in tasks like bug fixing, the new method produces solutions that are not only accurate but also more diverse and human-like compared to previous RL methods. In story generation, it significantly improves the quality of the narratives while still achieving high performance on standard benchmarks. This means that for builders looking to create more engaging and effective language models, this approach offers a scalable way to balance measurable success with the nuanced qualities of human communication.
QuasiMoTTo: Quasi-Monte Carlo Test-Time Scaling
Michael Y. Li, Anthony Zhan, Kanishk Gandhi, et al.
Imagine you're trying to make a language model that can handle complex tasks efficiently. You might think that generating many independent attempts at a problem is the best way to ensure you get a good answer. However, this approach can waste a lot of computing power on redundant solutions, especially when those attempts are similar. This redundancy is a problem because it means you're not using your resources effectively, which is what's called sample inefficiency. What this paper introduces is a clever way to generate samples that are correlated instead of independent. By doing this, you can still get the benefits of parallel processing while reducing the waste. The method, called QuasiMoTTo, uses a technique that spreads out the samples more evenly across the output space, which means you get better coverage with fewer samples. This is particularly useful in reinforcement learning, where the method can match the performance of traditional independent sampling while requiring significantly less training time. In practical terms, if you're building systems that rely on language models or reinforcement learning, using QuasiMoTTo could save you a lot of computational resources while still delivering strong performance. This approach not only improves efficiency but also enhances the learning signal from each batch of samples, making it a valuable tool for developers.
Adversarial Pragmatics for AI Safety Evaluation: A Benchmark for Instruction Conflict, Embedded Commands, and Policy Ambiguity
Brett Reynolds
Imagine you're building a language model that needs to follow complex instructions, like a virtual assistant that handles everything from scheduling to answering tricky questions. The challenge is that language is often ambiguous, and models can misinterpret instructions or fail to comply with policies. For instance, a model might not know whether to refuse a request or comply, leading to safety risks or incorrect outputs. This is what's called instruction conflict and ambiguity in language processing. Currently, many evaluations reduce these complex behaviors to simple pass/fail labels, which can hide the real reasons behind a model's failures. When a model fails, it could be due to a lack of capability, unclear policies, or even the way evaluators interpret the model's responses. This oversimplification can lead to misunderstandings about a model's true performance and safety. The paper introduces a new way to evaluate these behaviors by creating a detailed framework called adversarial pragmatics. This framework includes a controlled taxonomy of linguistic scenarios and a benchmark that assesses how well models handle various complexities, like indirect commands and ambiguous language. It also involves expert evaluations to distinguish between different types of task success and safety risks. By providing a more nuanced understanding of model behavior, this approach helps ensure that language models are safer and more reliable in real-world applications. Compared to previous work, this framework allows for a deeper analysis of model performance, which is essential for building trustworthy AI systems. It means that when you're deploying language models, you can have a clearer picture of their strengths and weaknesses, leading to better safety documentation and more effective prompt-injection tests.
A Lightweight Self-Supervised Learning Framework for Multivariate Time Series using Hierarchical-JEPA on ECG Data
Siwon Kim
Imagine you're trying to analyze heart activity from ECG data, but you only have a small set of labeled examples to work with. This is a common issue in medical data analysis, where collecting labeled data can be expensive and time-consuming. Typically, researchers might resort to traditional supervised learning methods, but these often struggle when the labeled data is scarce, leading to poor performance and overfitting on the limited examples. This is what's called the data scarcity problem. To tackle this, self-supervised learning (SSL) has emerged as a powerful approach. SSL allows models to learn from large amounts of unannotated data, which is particularly useful in fields like ECG analysis where labeled data is limited. However, existing SSL methods may not fully leverage the unique characteristics of multivariate time series data, which can lead to suboptimal performance. This paper introduces a new framework called the Event Reconstruction Joint-Embedding Predictive Architecture (ER-JEPA). The idea is to create a two-stage process that first builds representations for each time interval of the ECG data and then processes these representations as a univariate time series. By integrating two Joint-Embedding Predictive Architectures in a hierarchical manner, ER-JEPA captures multiple levels of abstraction, enhancing its predictive capabilities. The model is pretrained on a substantial dataset of ECG recordings and achieves state-of-the-art results on the ST-MEM benchmark, all while being lightweight and efficient. In practical terms, this means that if you're working on ECG analysis, ER-JEPA could significantly improve your model's performance without requiring extensive computational resources or large amounts of labeled data. It represents a meaningful advancement in how we can utilize self-supervised learning for complex medical tasks.
Sequentially-Controlled Interactive Multi-Particle Flow-Maps for Online Feedback-Driven Search
Binglin Ji, Anindya Sarkar, Hengchang Lu, et al.
Imagine you're trying to teach a model to understand what people want, but you don't know their preferences upfront. Traditional methods often get stuck exploring only small areas of possible preferences, missing out on discovering what people really value. This is a problem because if the model only focuses on narrow regions, it might not find the best solutions or align with diverse user needs. This issue is known as local exploration failure, where the model can't adapt to new information effectively. To tackle this, the authors propose a new method that uses a group of interactive particles to explore the preference space more broadly. Instead of just focusing on one area, these particles work together to cover more ground, sharing information about what they find. This collective approach helps the model avoid getting too fixated on any one solution, which can lead to over-optimization and missing out on better options. The framework also includes a mechanism to adjust how the particles interact, ensuring they maintain diversity in their exploration. What sets this work apart from previous methods is its focus on global exploration and the ability to adaptively steer the particles toward the most promising areas based on feedback. The results show that this new framework not only improves the efficiency of the search process but also helps prevent common issues like mode collapse, where the model might otherwise get stuck in a suboptimal state. For builders, this means a more robust way to align models with user preferences, especially in complex scenarios where those preferences are not clear from the start.
Introspective Coupling: Self-Explanation Training Tracks Behavioral Change Despite Fixed Supervision
Zifan Carl Guo, Laura Ruis, Jacob Andreas, et al.
Imagine you're building a language model that needs to explain its decisions, like why it chose a certain answer. The challenge is that many models just mimic patterns from their training data without truly understanding their own reasoning. This can lead to explanations that sound good but don't reflect the model's actual thought process — a problem known as superficial imitation. When models are trained to explain their predictions, they often rely on past behaviors or similar models, which can result in explanations that don't align with their current actions. This is what's called a lack of faithful introspection. What this paper explores is a way to train language models using fixed counterfactual explanations, which are essentially hypothetical scenarios that show how different inputs would lead to different outputs. The authors found that when models are trained this way, they can produce explanations that are surprisingly faithful to their current behaviors, even if those behaviors have changed since the training. This means that the models can track their own shifts in behavior without needing constant updates to their training data. In practical terms, this approach allows for scalable and generalizable training signals for introspection, which can be particularly useful in applications where understanding model decisions is crucial. By using fixed datasets of counterfactual explanations, builders can enhance the reliability of model outputs without the need for extensive retraining or new labels.
QVal: Cheaply Evaluating Dense Supervision Signals for Long-Horizon LLM Agents
Sergio Hernández-Gutiérrez, Matteo Merler, Ilze Amanda Auzina, et al.
Imagine you're building an AI that needs to make a series of decisions over a long period, like a robot navigating a complex environment. The challenge is that traditional reward systems only tell the AI if it succeeded or failed at the end, leaving it in the dark about the quality of its decisions along the way. This can lead to poor performance because the AI doesn't learn from its intermediate actions — this is what's called sparse rewards. Current solutions try to provide more feedback by scoring these intermediate steps, but they often get evaluated in ways that mix up the quality of the feedback with how well the training was done. This makes it hard to compare different methods fairly, which is a problem known as evaluation confounding. What this paper introduces is a new way to evaluate these feedback methods without needing to train the AI first. They created a system called QVal that checks how well these feedback scores align with the expected outcomes from a strong reference policy. This means you can see how good the feedback is before any training happens, allowing for a clearer comparison of different methods. In their experiments, they found that simple prompting techniques often performed better than the more complex dense supervision methods that have been popular recently. This suggests that researchers might need to rethink how they approach dense supervision and focus on simpler, more effective strategies. Overall, QVal offers a fresh perspective on evaluating dense supervision methods, making it easier for researchers to iterate and improve their approaches without getting bogged down in the complexities of training setups.
Reinforcement Learning with Metacognitive Feedback Elicits Faithful Uncertainty Expression in LLMs
Gabrielle Kaili-May Liu, Avi Caciularu, Gal Yona, et al.
Imagine you're building a language model that needs to answer questions accurately. One major challenge is that these models can be overly confident in their answers, even when they're wrong. This overconfidence can lead to serious issues, especially in applications where trust is crucial, like healthcare or legal advice. When a model doesn't recognize its own limitations, it can mislead users, which is a problem known as miscalibration. Currently, many models are trained to provide answers based on the data they've seen, but they often lack the ability to evaluate their own performance effectively. This leads to situations where they might confidently assert incorrect information, which is frustrating for users and undermines trust. This is what's called a failure in metacognition — the ability to think about one's own thinking. The approach in this paper addresses these failures by introducing a method that allows models to better judge their own performance. The authors propose using reinforcement learning with metacognitive feedback, which helps the model refine its output based on how well it thinks it is doing. Additionally, they implement a technique for selecting training examples that the model believes will be most beneficial for its learning. This dual approach not only improves the model's ability to express its uncertainty but also enhances its overall performance. In practical terms, this means that models using this new method can achieve better alignment between their confidence levels and actual performance, which is crucial for applications where accuracy and reliability are paramount. The results show that this method can outperform traditional reinforcement learning techniques by a significant margin, making it a valuable tool for anyone looking to build more trustworthy AI systems.
When LLMs Read Tables Carelessly: Measuring and Reducing Data Referencing Errors
Yuqing Yang, Qi Zhu, Zhen Han, et al.
Imagine you're building a system that relies on large language models (LLMs) to pull information from tables. You expect these models to accurately reference data, but they often make mistakes, like citing the wrong values or missing important ones altogether. This can lead to incorrect conclusions, especially when the model's reasoning steps are based on faulty data. These mistakes are known as data referencing errors (DREs), and they can undermine the reliability of the model's outputs. Unfortunately, previous research has only scratched the surface of this issue, focusing on small-scale analyses that don't capture the full scope of the problem. In this paper, the authors take a deeper dive into DREs, systematically evaluating how they occur across various models and tasks. They find that these errors are prevalent in models ranging from 1.7 billion to 20 billion parameters. To tackle this issue, they introduce a new approach that incorporates a critic model specifically designed to detect and filter out these referencing errors. This critic model, which is lightweight at 4 billion parameters, has been shown to improve answer accuracy by up to 12% by effectively identifying both in-distribution and out-of-distribution DREs. What sets this work apart from prior studies is its comprehensive evaluation and the introduction of a practical solution that enhances the reliability of LLMs when dealing with tabular data. For anyone building systems that depend on accurate data referencing, this approach offers a promising way to improve the overall performance and trustworthiness of their models.
Freeform Preference Learning for Robotic Manipulation
Marcel Torne, Anubha Mahajan, Abhijnya Bhat, et al.
Imagine you're building a robot that needs to perform complex tasks, like arranging objects or navigating through a space. The challenge is that traditional methods of teaching robots often rely on simple success or failure labels, which can be too vague. For instance, if a robot places an object incorrectly, it might not capture the nuances of what 'correct' means — was it too fast, too careless, or just not in the right spot? This is where the current methods break down, leading to what's called sparse reward signals. They don't provide enough feedback for the robot to learn effectively, especially in tasks that take a long time to complete. To address this, the authors propose a new approach called Freeform Preference Learning (FPL). Instead of asking people to choose between two options, FPL allows them to express their preferences in natural language along various axes, like speed or safety. This means that instead of just saying one trajectory is better than another, users can specify what they value in a more detailed way. The robot then learns to interpret these preferences and assigns rewards based on them, which helps it understand how to improve its actions across multiple dimensions. The results are promising: FPL not only enhances performance by a significant margin but also enables the robot to learn more complex behaviors without needing to break tasks into smaller parts. This flexibility means that users can guide the robot's actions in real-time without needing to retrain it, making it much more adaptable in practical scenarios. For anyone building robots that need to operate in dynamic environments, this method offers a way to incorporate human-like understanding into their decision-making processes.
AdaJEPA: An Adaptive Latent World Model
Ying Wang, Oumayma Bounou, Yann LeCun, et al.
Imagine you're building a robot that needs to navigate through a complex environment, like a warehouse. You could train it to understand the layout and plan its path, but what happens when the layout changes unexpectedly? Traditional models often struggle because they can't adapt to new situations once they're trained. This is a problem because if the robot's predictions about its surroundings are off, it might make poor decisions, leading to failures in navigation. This issue is known as distribution shift, where the conditions during training differ from those during operation. To tackle this, AdaJEPA introduces a way for the robot's model to adapt while it's planning its actions. Instead of being a static model, it updates itself based on what it observes after taking an action. So, after executing a move, it looks at the new state it finds itself in and uses that information to refine its understanding of the environment. This self-supervised adaptation allows the model to continuously recalibrate itself without needing extra training data or expert input. The key takeaway is that AdaJEPA can significantly enhance the success rate of planning tasks by allowing the model to learn from its experiences in real-time. This means that if you're building systems that need to operate in dynamic environments, you can rely on AdaJEPA to help them adapt and perform better, even with just a small amount of additional training during operation.
Generative Skill Composition for LLM Agents
Xinyu Zhao, Zhen Tan, Vaishnav Tadiparthi, et al.
Imagine you're building a system that needs to perform a variety of complex tasks, like setting up environments or refactoring code. You could have a library of skills, but figuring out which skills to use, how many, and in what order can be really tricky. Right now, people either let the system see all the skills at once or use some kind of retrieval system to pick the best ones, but both methods can struggle with the complexity of task requirements. This is where things can go wrong: the system might pick the wrong skills or fail to execute them in the right order, leading to subpar performance. This issue is known as skill composition failure, where the interaction between skills isn't properly managed. What this paper introduces is a new way to handle this problem by formalizing it as structured skill composition. The idea is to predict a skill plan that not only selects which skills to use but also determines how many and the order in which they should be executed. The proposed method, SkillComposer, uses a clever decoding technique that allows these decisions to emerge together, capturing the dependencies between skills naturally. In practice, this means that SkillComposer can significantly improve task success rates, raising them by over 23% compared to a baseline that doesn't use skills. This is a big deal for anyone building systems that rely on complex task execution, as it streamlines the process and enhances overall performance.
SemRF: A Semantic Reference Frame for Residual-Stream Dynamics in Language Models
Jian Gu, Aldeida Aleti, Chunyang Chen, et al.
Imagine you're trying to understand how a complex language model makes decisions as it processes text. You might want to see how the model's understanding evolves as it goes deeper into its layers. However, measuring this evolution can be tricky because different parts of the model might not agree on what they are focusing on. This can lead to confusion, where it looks like the model is changing its mind when it's really just a measurement issue. This is what's called measurement drift. To tackle this, the authors propose a new way to anchor measurements in a consistent framework, which they call Semantic Reference Frames. This approach helps to separate the actual changes in understanding from the noise in the measurements. By fixing certain reference points, they can track how the model's understanding shifts without getting lost in the details. This method also introduces a way to visualize the model's behavior using a Voronoi diagram, which helps in understanding how different layers contribute to the overall decision-making process. What’s exciting about this work is that it provides a clearer picture of how language models operate internally. It suggests that by using these reference frames, we can simplify the model's representation and potentially make it more efficient. For builders, this means that there could be new ways to optimize models, leading to better performance with fewer resources. If you're working on language models, this framework could be a valuable tool for improving both understanding and efficiency.
TRIAGE: Role-Typed Credit Assignment for Agentic Reinforcement Learning
Yuanda Xu, Zhengze Zhou, Hejian Sang, et al.
Imagine you're building an agent that interacts with a complex environment, like a virtual shopping assistant. You want it to learn from its actions — when it searches for items, clicks on links, or navigates through options. The challenge is figuring out which actions were actually helpful and which were just wasting time. Currently, many systems use a simple method that gives the same feedback for all actions based on the final outcome. This can lead to problems: it might punish the agent for trying new things that could be beneficial, or it might reward it for repeating actions that don't really help. This is what's called uniform credit assignment, and it can misguide the learning process. The new approach in this paper, called TRIAGE, tackles these issues by adding a layer of understanding to the feedback. Instead of treating all actions the same, it categorizes them into different roles, like 'helpful exploration' or 'regressive action.' This way, the agent gets more nuanced feedback that helps it learn better. The results show that TRIAGE not only improves the agent's success rates but also reduces unnecessary actions, making it more efficient in environments like ALFWorld and WebShop. This means if you're building agents that need to learn from their interactions, using a method like TRIAGE could lead to better performance and less wasted effort.
FedLAB: Traceable Semantic Codebooks for Federated Multimodal Graph Foundation Learning
Zekai Chen, Kairui Yang, Xuaner Chen, et al.
Imagine you're trying to build a system that can understand complex relationships in data that includes text, images, and other attributes, but you can't centralize this data due to privacy concerns. This is a common challenge when working with decentralized clients, where each holds valuable information that can't be shared directly. Current methods often struggle because they either rely on sharing sensitive data or use techniques that don't fully capture the nuances of the different types of information involved. This leads to a lack of clarity in how different pieces of data contribute to the overall understanding, which is a problem known as semantic traceability failure. To address this, the authors propose a new framework called FedLAB. Instead of just exchanging raw data or parameters, FedLAB organizes knowledge into structured codebooks that categorize information by type, such as modality evidence and node semantics. This allows the system to learn from the data while keeping it local and private. The framework also includes a pre-training step that refines these codebooks, enhancing the model's ability to make predictions based on the rich context of the data. In practical terms, FedLAB shows significant improvements over existing methods, with up to 7.53% better performance on various tasks. This means that for builders working with sensitive data, FedLAB offers a way to harness the power of multimodal graphs without compromising privacy, leading to more effective and context-aware applications.
Surrogate Fidelity: When Can Open LLMs Explain Closed Ones?
Philippe Chlenski, Zachariah Carmichael, Ayush Warikoo, et al.
Imagine you're trying to understand how a complex AI model makes decisions, but you only have limited access to its inner workings. You might be able to see what it predicts, but not why it makes those predictions. This is a common issue in machine learning, especially with popular language models that only expose certain outputs, like log-probabilities. When you try to interpret these models, you might think you understand them based on their predictions, but that can be misleading. This is known as the surrogate problem: just because two models predict the same outcome doesn't mean they operate in the same way or for the same reasons. In this paper, the authors explore how to evaluate the fidelity of these surrogate models at different levels, such as prediction and attribution. They find that while models may agree on what the answer is, they often disagree on why they arrived at that answer. This leads to a significant insight: the signals we can observe from models, like attention patterns, might be stable across different models, but they don't necessarily help us understand the causal reasons behind their decisions. This mismatch is crucial because it means that insights gained from one model may not apply to another, especially if the latter is a closed model. What this means for builders is that when you're working with AI models, especially in applications where understanding the reasoning is important, you need to be cautious about assuming that insights from one model will transfer to another. The findings suggest that just because two models predict the same thing, it doesn't mean they share the same underlying logic. This paper provides a framework for thinking about these issues, which can help in developing more reliable and interpretable AI systems.
AxDafny: Agentic Verified Code Generation in Dafny
Benjamin Breen, Austin Letson, Borja Requena Pozo, et al.
Imagine you're trying to create software that not only runs correctly but also proves that it does so. This is a tough challenge because generating code that meets both functional and formal verification requirements is complex. Currently, many models can generate code, but they often fail to provide the necessary proofs, leading to unreliable software. This is what's called a verification gap, where the code might work but lacks the formal backing to ensure it does so under all conditions. The approach in this paper addresses this gap by introducing a framework that guides the code generation process with verification in mind. It iteratively creates not just the code but also the proofs needed to verify that the code behaves as expected. This means that instead of just hoping the generated code is correct, the model actively works to ensure it can be verified. What’s particularly noteworthy is the introduction of a new benchmark, LiveCodeBench-Pro-Dafny, which consists of 250 programming problems designed for this purpose. The results show that AxDafny significantly outperforms previous models, achieving a 92.7% verification success rate, which is a notable improvement over existing methods. For anyone building systems that require reliable code generation, this framework offers a promising solution to ensure both functionality and correctness.
Random Reshuffling Dominates Stochastic Gradient Descent
Zijian Liu
Imagine you're trying to optimize a machine learning model using a method called Stochastic Gradient Descent (SGD). It's a classic approach that works well in theory, but when you implement it, you often run into issues that make it less effective. One common tweak is called Shuffling SGD, which involves randomly reshuffling your data before each update. This method has shown great results in practice, but many considered it just a clever trick because it lacked solid theoretical backing. The problem is that the existing theory suggested that Shuffling SGD only works under strict conditions, which limits its use in real-world scenarios. This is what's called a theoretical limitation. What this paper does is provide a breakthrough by proving that Random Reshuffling actually beats traditional SGD in smooth convex optimization, regardless of the step size, after a finite number of epochs. This means that you can use Random Reshuffling more flexibly than previously thought, making it a more reliable choice for optimization tasks. In practical terms, if you're building models that rely on optimization, this finding could help you achieve better performance without being constrained by the earlier theoretical limitations.
PolicyGuard: From Organizational Policies to Neuro-SymbolicCompliance Review Engines
Sameer Malik, Ayush Singh, Amar Prakash Azad
Imagine you're in charge of making sure that all the contracts your company signs follow specific rules and guidelines. Right now, people often rely on their judgment or use general tools that don't really understand the nuances of these rules. This can lead to mistakes, like missing important compliance issues because the tools aren't designed to check against specific policies. This is what's called a lack of transparency in compliance decisions. To tackle this, PolicyGuard introduces a new way to handle document reviews. Instead of just using a large language model to interpret the documents, it breaks down the process into clear steps. First, it translates the organization's policies into a set of rules that can be executed. Then, it uses the language model to ask specific questions about the document, pulling in relevant information to check against those rules. This means that when a document is reviewed, the process is much clearer and easier to follow. What’s different about PolicyGuard compared to previous methods is that it makes the compliance checking process explicit and systematic. This means that if policies change, it’s easier to update the rules and ensure that the document review process remains accurate. For anyone building systems that need to ensure compliance, this approach offers a more reliable and maintainable solution.
Radial Suppression Accelerates Algorithmic Generalization: A Geometric Analysis of Delayed Generalization
Srijan Tiwari, Aditya Chauhan, Manjot Singh
Imagine you're training a neural network to solve complex problems, like arithmetic. You want it to learn patterns and generalize from examples, but often it just memorizes the training data instead. This memorization can delay its ability to generalize, which is frustrating when you're trying to build something reliable. The issue arises because the way the network's internal representations grow can lead to a kind of 'inflation' that makes it hard for the model to find the right patterns in the data. This is what's called the memorization-generalization delay. Currently, many approaches focus on tweaking the model architecture or adjusting the training data, but these can fall short. For instance, if the model is too rigid in its learning, it might not adapt well to new examples, leading to poor performance on unseen data. This is a common failure mode in neural networks, where they struggle to balance memorization and generalization. What this paper proposes is a fresh way to think about the problem. By introducing a method that penalizes this radial inflation of activations, the authors suggest that you can guide the model to focus more on the essential patterns rather than just memorizing the data. They formalize this idea with a radial-angular decomposition of how activations behave during training, leading to three key insights about how to adjust the learning process. In practice, they found that applying a simple norm penalty to constrain activations can lead to much faster learning, particularly in tasks like modular arithmetic. This means that instead of taking a long time to train a model, you can achieve significant speed-ups, cutting training steps in half for certain configurations. For anyone building neural networks, this approach offers a practical way to enhance efficiency and effectiveness in training, making it easier to develop models that generalize well without excessive resource use.
Amplifying Membership Signal Through Chained Regeneration
Wojciech Łapacz, Stanisław Pawlak
Imagine you're building a system that generates content, like text or audio, based on a large dataset. One major concern is that these systems can memorize specific pieces of training data, which raises privacy issues and copyright concerns. If someone can prove that a model is generating content that includes their copyrighted material, it could lead to serious legal problems. This is where sample verification becomes crucial — you want to know if a specific output was generated based on a training example or if it’s entirely new. However, current methods for checking this, known as membership inference attacks, often rely on generating outputs just once. This one-shot approach can be weak and doesn’t provide enough information to make solid conclusions, especially when dealing with different types of data like text, images, or audio. This limitation is what's called weak signal detection in membership inference attacks. The authors of this paper propose a new framework called MADreMIA, which takes a different approach. Instead of generating outputs just once, it uses a process where each output becomes the input for the next generation. This iterative method allows the system to gather more information and improve the accuracy of its membership evidence. The key insight is that memorized samples show more coherence and degrade more slowly than non-member samples during this iterative process. Practically, this means that if you're working with generative models, using MADreMIA could help you better identify whether your outputs are infringing on someone else's data, making your system more robust against privacy violations.
GR2 Technical Report
Yufei Li, Zaiwei Zhang, Mingfu Liang, et al.
Imagine you're building a recommendation system that needs to show users the most relevant items from a massive catalog. The challenge is that the final step of re-ranking — deciding which items to display after initial filtering — is crucial for keeping users engaged. However, many existing systems focus on earlier stages like retrieval and ranking, leaving re-ranking underexplored. This can lead to missed opportunities where the displayed items don't resonate with users, ultimately hurting engagement. This is what's called a re-ranking gap. Current methods often use large language models (LLMs) in a zero-shot or fine-tuning manner, which doesn't fully leverage their reasoning capabilities. Additionally, many catalogs use non-semantic identifiers that LLMs can't easily understand, complicating the process. This is where GR2 comes in. It combines several innovative techniques: it trains on unique semantic IDs, distills reasoning from a stronger model, and employs reinforcement learning with verifiable rewards tailored for re-ranking. What sets GR2 apart is its ability to effectively handle the unique challenges of re-ranking in a way that previous methods have not. It not only improves the relevance of displayed items but also addresses the critical issue of reward design, ensuring that LLMs don't exploit biases in the data. In practical terms, this means that if you're building a recommendation system, using GR2 could lead to a significant boost in user engagement metrics, making it a compelling choice for industrial applications.
LUNA: Learning Universal 3D Human Animation Beyond Skinning
Peng Li, Rawal Khirodkar, Junxuan Li, et al.
Imagine you want to create lifelike 3D avatars of people just from simple 2D images. Traditionally, this involves complex models that fit a person's body to a predefined shape, which can lead to awkward movements and visual artifacts. This is especially problematic when the input images vary widely or when you want to animate different characters without starting from scratch. These issues are known as fitting artifacts and expressivity constraints. What LUNA does is quite different. Instead of relying on these traditional fitting methods, it uses a neural network to directly translate various 2D inputs—like images, sketches, or keypoints—into 3D movements. The core of this approach is a transformer-based model that separates the overall motion from the finer details, allowing it to capture both broad movements and subtle nuances in how a character moves. This means you can create more expressive and realistic animations without the usual constraints. The results are promising: LUNA not only matches the visual quality of existing methods but also allows for realistic animations across different characters and styles without needing extensive retraining. This could be a game-changer for anyone looking to build applications in gaming, film, or virtual reality where realistic human motion is crucial.
VLK: Learning Humanoid Loco-Manipulation from Synthetic Interactions in Reconstructed Scenes
Yen-Jen Wang, Jiaman Li, Sirui Chen, et al.
Imagine you're trying to build a humanoid robot that can understand commands and navigate its environment like a human. The challenge is that you need a lot of data that connects what the robot sees (like images), what it hears (like instructions), and how it should move (like kinematic trajectories). Currently, gathering this data is tough because it requires a lot of manual work and existing datasets don't cover all the necessary combinations. This is where things can go wrong: without enough diverse data, the robot might not learn to handle unexpected situations well, which is a problem known as data scarcity. To tackle this, the authors created a system that generates this data automatically. They use a technique called 3D Gaussian Splatting to build realistic indoor environments and then simulate how a robot would interact with these environments based on visual and language inputs. This means they can produce a large number of training examples without needing human intervention. The result is a trained policy that allows the robot to predict how to move in response to commands, which is then tested on a real robot performing tasks like navigating and transporting objects. Compared to previous methods, this approach significantly increases the amount of usable training data and demonstrates that synthetic interactions can effectively teach robots to perform complex tasks in the real world. For builders, this means you can potentially deploy humanoid robots more quickly and reliably, as they can learn from a rich set of simulated experiences.
LeVo 2: Stable and Melodious Song Generation via Hierarchical Representation Modeling and Progressive Post-Training
Shun Lei, Huaicheng Zhang, Dapeng Wu, et al.
Imagine you're trying to create a full-length song that sounds coherent and musical, while also ensuring that the vocals and instruments work well together. This is a tough challenge because existing systems often struggle with either keeping the overall sound cohesive or providing detailed sound quality for each track. When they focus on one aspect, they tend to lose out on the other, leading to songs that might sound good in parts but not as a whole. This is what's called a structural trade-off in song generation. To tackle this, LeVo 2 introduces a clever way to manage these competing needs. It starts by predicting the overall structure of the song using a mixed-token approach, which helps in planning the song's semantics. Then, it refines the details for vocals and instruments in parallel, ensuring that both elements are well-coordinated. Additionally, it uses a diffusion-based Music Codec to reconstruct the final audio, which helps in maintaining high sound quality. What sets LeVo 2 apart from previous methods is its aesthetics-guided training schedule. This means that during training, it uses an automated system to evaluate the musicality of the songs, which helps in aligning the model's outputs with what sounds good. The results show that LeVo 2 not only improves the quality of song generation but also enhances controllability and musicality, outperforming many existing systems. For anyone building music generation tools, this approach offers a more balanced and effective way to create songs that sound great from start to finish.
Self-Evolving World Models for LLM Agent Planning
Xuan Zhang, Wenxuan Zhang, See-Kiong Ng, et al.
Imagine you're building an AI that needs to make decisions based on predictions about the future. The challenge is that these predictions can often be unreliable, leading to poor choices. For instance, if the AI predicts that a certain action will lead to a positive outcome but it turns out to be wrong, it could make a decision that results in failure. This is a common issue in AI systems that rely on foresight, and it's known as unreliable foresight. When the AI misuses these predictions, it can degrade its overall performance and decision-making capabilities. Currently, many systems try to address this by using static models that don't adapt to new information or context. This can lead to problems when the environment changes or when the AI encounters situations it hasn't seen before. The result is that the AI might ignore valuable information or make decisions based on outdated or incorrect predictions. This is what's called context drift, where the model's understanding of the world doesn't keep up with reality. WorldEvolver offers a fresh approach to these challenges. Instead of relying on a fixed model, it introduces a self-evolving framework that can adjust its context in real-time while keeping the core model parameters unchanged. It does this through three key components: Episodic Memory, which learns from real actions; Semantic Memory, which identifies useful rules from past mistakes; and Selective Foresight, which filters out low-confidence predictions. This means that the AI can continuously refine its understanding and improve its decision-making process. In practical terms, this leads to a significant boost in the accuracy of predictions and the success rate of the AI's actions. By allowing the model to revise its context based on new experiences, WorldEvolver not only enhances predictive fidelity but also improves planning performance, making it a valuable tool for anyone building long-horizon decision-making systems.
One-Step Gradient Delay is Not a Barrier for Large-Scale Asynchronous Pipeline Parallel LLM Pretraining
Philip Zmushko, Egor Petrov, Nursultan Abdullaev, et al.
Imagine you're trying to train a massive machine learning model, and you want to do it as quickly as possible. One common approach is to use multiple GPUs in a pipeline, where each GPU processes a different part of the data. However, if one GPU finishes its task before the others, it can sit idle, wasting time and resources. This is known as a pipeline bubble, and it can slow down the entire training process. Currently, many people use synchronous methods to avoid this, but they can still leave GPUs waiting around, which isn't efficient. This is what's called synchronous pipeline parallelism, and it often leads to wasted computational power. The paper introduces a solution called asynchronous pipeline parallelism, which aims to eliminate those idle times. However, there's a catch: when you use this method, the gradients (which help the model learn) can become stale, meaning they might not reflect the most current state of the model. Many believe that this staleness leads to instability in training, which has limited the adoption of these asynchronous methods. The authors challenge this belief by showing that the impact of staleness is heavily influenced by the choice of optimizer. They found that while the popular AdamW optimizer struggles with staleness, newer optimizers like Muon perform much better under these conditions. Additionally, they propose a correction method that works with any optimizer to further reduce the negative effects of staleness. Their extensive testing on large models shows that these strategies can significantly improve performance, making asynchronous pipeline parallelism a viable option for large-scale training. This means that if you're building systems that rely on training large models, you can potentially speed up your training process without sacrificing performance.
GROW$^2$: Grounding Which and Where for Robot Tool Use
Yuhong Deng, Yuyao Liu, David Hsu
Imagine you're building a robot that needs to perform tasks in unpredictable environments, like cutting a cake without a knife. Traditionally, robots are limited to using tools as they were designed, which means they struggle when faced with novel situations or objects. For instance, if a robot only knows how to use a knife for cutting, it won't think to use a plate creatively, leading to failures in task execution. This limitation is known as open-world affordance grounding, where the robot must identify and localize the right tool and its parts for a given task. What this paper introduces is a method called GROW², which helps robots overcome these challenges by breaking down the process of tool use into two levels: semantic and geometric. Semantically, it uses the reasoning capabilities of Vision-Language Models to interpret task instructions and select the right object as a tool. Geometrically, it then pinpoints the specific parts of the tool and the target object that are relevant for the task, all from a single RGB-D image. This hierarchical approach allows the robot to use objects in ways that weren't explicitly trained, making it more adaptable. Compared to previous methods, GROW² shows significant improvements in predicting how objects can be used as tools, achieving better performance on established benchmarks and demonstrating zero-shot generalization. For builders, this means you can create robots that are not only more capable but also require less retraining when faced with new tasks or objects, ultimately leading to more efficient and versatile robotic systems.
Pessimism's Paradox: Conservative Offline Training Amplifies Reward Hacking During Online Adaptation in Reasoning Models
Subramanyam Sahoo, Aman Chadha, Vinija Jain, et al.
Imagine you're building a system that learns from past experiences to make decisions in real-time. You might think that if you keep your model closely aligned with safe, well-understood behaviors, it will perform better and avoid mistakes. This is a common belief in machine learning, where conservative offline training is seen as a way to ensure safety during online adaptation. However, this paper challenges that idea by showing that being too conservative can actually backfire. When a model is overly cautious, it tends to become less diverse in its responses, which can lead to it exploiting weaknesses in the reward system it relies on. This is known as the Goodhart effect, where a model that seems to be performing well based on its training can actually be vulnerable to manipulation when it encounters new situations. The authors conducted experiments with a specific model and found that as they increased the level of conservatism, the model's performance in real-world tasks actually suffered due to increased reward-hacking. They propose that instead of aiming for maximum conservatism, a balanced approach is necessary to maintain both alignment and robustness against exploitation. This insight is crucial for anyone building adaptive systems, as it highlights the importance of calibrating conservatism rather than simply maximizing it.
DOPD: Dual On-policy Distillation
Xinlei Yu, Gen Li, Qingyi Si, et al.
Imagine you're trying to teach a model to make decisions based on examples it sees, like a student learning from a teacher. In machine learning, we often use a method called distillation, where a 'teacher' model guides a 'student' model to learn from its outputs. However, this can lead to problems when the student gets confused by extra information that it can't fully understand — this is known as privilege illusion. It happens because the student might mix up what it can actually learn from the teacher with what it can't replicate on its own. This confusion can hinder the learning process, especially when only a few pieces of information are truly valuable for making decisions. To tackle this, the authors propose a new method called DOPD, which stands for advantage-aware dual distillation. The idea is to smartly manage how the student learns from the teacher by adjusting the strength and type of guidance it receives based on its current understanding. This way, the student can focus on the most important signals and avoid getting lost in the noise of irrelevant information. The results show that DOPD consistently outperforms traditional distillation methods, making it a promising approach for improving model training in both language and vision tasks. For anyone building models, this means you can achieve better performance by using this new method of distillation, especially in complex scenarios where information can be misleading.
Optimization Dynamics Imprint Semantic Specificity in Contrastive Embedding Norms
Ziwei Su, Junyu Ren, Victor Veitch
Imagine you're building a system that uses embeddings to represent words or concepts, like in search engines or recommendation systems. Typically, you might focus on how similar these embeddings are to each other, using metrics like cosine similarity, which ignores their lengths. This can lead to problems because the lengths of these embeddings can actually tell you something important about the concepts they represent — like how specific a concept is or how often it appears in language. When you overlook this, you might misinterpret the data, leading to less effective models or retrieval systems. This is what's called ignoring embedding magnitudes. What this paper does is provide a clear explanation of why those lengths matter. It shows that during training, the length of an embedding can naturally encode useful information about the concepts it represents. By analyzing how these embeddings are optimized, the authors derive a formula that connects embedding length to semantic properties. This means that instead of discarding this information, you can use it as a 'free' tool to improve your model's performance in specific tasks, like retrieval. In practical terms, this means that if you're working with contrastive embedding models, you should start paying attention to the lengths of your embeddings. By incorporating this insight, you can enhance your model's calibration and potentially improve its effectiveness without needing additional data or retraining.
Scaling the Horizon, Not the Parameters: Reaching Trillion-Parameter Performance with a 35B Agent
Lei Bai, Zongsheng Cao, Yang Chen, et al.
Imagine you're trying to build an AI that can handle complex tasks over long periods, like planning a multi-step project or managing a series of interactions. Traditional models often struggle with this because they either lack the depth to understand specific tasks or can't maintain context over long sequences. This leads to issues like losing track of important details or making decisions based on incomplete information — a problem known as long-horizon reasoning failure. To tackle this, the paper introduces Agents-A1, a model designed to scale both the length of tasks it can handle and the variety of skills it can employ. Instead of just training a single model to do everything, it uses a mixture of specialized agents that can work together, each focusing on different aspects of a task. This is achieved through a structured training process that includes fine-tuning, domain-specific expertise, and efficient knowledge transfer between agents. What sets Agents-A1 apart is its ability to perform well on benchmarks that require long-term reasoning, achieving results that rival much larger models with trillions of parameters. This means that for builders looking to implement AI in complex scenarios, Agents-A1 offers a more efficient and effective solution without the need for massive computational resources.
MESA: Prioritizing Vulnerable Communication Channels for Securing Multi-Agent Systems
Kunyang Li, Kyle Domico, Jonathan Gregory, et al.
Imagine you're managing a system where multiple agents need to communicate to complete tasks. As these systems grow, the way they talk to each other can become a target for attackers. If one communication channel is compromised, it could lead to a huge portion of the system's failure. Currently, security teams often struggle to know where to focus their limited resources, leading to gaps in protection. This is what's called inefficient resource allocation. To tackle this, the authors developed a method that helps identify which communication channels are most at risk before any attacks happen. They created a framework called Mesa that uses various metrics to rank these channels based on their potential impact if compromised. This means that instead of randomly monitoring all channels, security teams can focus on the ones that matter most. In practice, Mesa has shown that by monitoring just the top 10% of the most critical channels, defenders can intercept about three times as many successful attacks compared to a random approach. This is a significant improvement over traditional methods, allowing for smarter and more effective security measures in multi-agent systems.
Words Speak Louder Than Code: Investigating Cognitive Heuristics in LLM-Based Code Vulnerability Detection
Asif Shahriar, Hongyu Cai, Hadjer Benkraouda, et al.
Imagine you're building a system to automatically detect vulnerabilities in code. You'd want it to be reliable, but what if the model's judgment is swayed by how the code is presented? That's a real concern because recent studies show that even advanced models can fall prey to the same cognitive biases that affect human decision-making. For instance, if a model sees a piece of code attributed to a well-known author, it might rate it as safer than it actually is — this is called the halo effect. Similarly, how a task is framed can change the model's assessment, leading to what's known as the framing effect. And if the model has seen previous analyses, it might anchor its judgment to those results, even if they were incorrect. These biases can lead to serious misclassifications, where a model might declare a piece of code safe when it’s actually vulnerable, especially if the vulnerability requires deeper understanding rather than just pattern recognition. This paper introduces a framework to investigate these biases systematically, testing eight different large language models across various programming languages. The findings are concerning: the models showed significant susceptibility to these cognitive biases, with the framing effect being the most impactful. This means that if you're relying on LLMs for security assessments, you need to be aware that their judgments can be easily influenced by context, potentially leading to overlooked vulnerabilities.
Beyond 2D Matching: A Unified Single-Stage Framework for Geometry-Aware Cross-View Object Geo-Localization
Liyao Wang, Ruipu Wu, Haojun Xu, et al.
Imagine you're trying to find a specific object in a city using images from different perspectives, like from a drone or a satellite. Traditionally, people would match the 2D appearances of these images, but this method often fails because it relies on limited datasets and doesn't account for the actual geometry of the scene. This is what's called the limitation of 2D appearance matching, which can lead to inaccuracies when the views differ significantly or when the dataset lacks diversity in prompts and imagery. To tackle these issues, this paper introduces a new dataset that includes over 220,000 pairs of images from ground, drone, and satellite views, complete with multi-modal prompts and camera poses. This allows for a more flexible and accurate way to refer to targets in different views. The authors also propose a new framework that integrates visual features and referring prompts in a single model, which can predict bounding boxes, segmentation masks, and camera poses all at once. This approach is designed to overcome the limitations of previous methods by using a contrastive loss that aligns different views without needing extensive training data. The result is a system that not only performs better than existing methods but also generalizes well to new scenes and setups. For anyone building applications that require accurate geo-localization across different perspectives, this work provides a robust solution that leverages both a rich dataset and an innovative modeling approach.
The Fundamental Limits of Valid Transport Map Estimation
Sivaraman Balakrishnan
Imagine you're trying to generate new images or text based on existing data. You might think of this as moving from one distribution of data to another, like transforming a cloudy sky into a sunny one. Traditionally, this involves finding the optimal transport map, which is a complex and often computationally heavy task. However, in many cases, the exact cost of transport isn't what matters; you just want a good enough transformation that works well for your application. This is where things can get tricky. When you focus too much on finding the perfect transport map, you might miss out on simpler, more efficient alternatives that could actually perform better in practice. This is what's called the challenge of optimal transport (OT) estimation. The paper introduces a new way to think about this problem using a minimax framework, which helps clarify the limits of current methods and shows that, under certain conditions, you can learn alternative transport maps more accurately than the optimal ones. This means that for builders, there’s a potential to simplify the modeling process and still achieve strong results, especially when the assumptions about stability in the data hold true. Overall, this approach provides a clearer understanding of when it’s beneficial to aim for less-than-optimal solutions in generative modeling.
SWE-INTERACT: Reimagining SWE Benchmarks as User-Driven Long-Horizon Coding Sessions
Mohit Raghavendra, Anisha Gunjal, Aakash Sabharwal, et al.
Imagine you're building a coding assistant that helps developers write software. In a typical setup, you might give the assistant a complete set of requirements and let it work autonomously. However, this doesn't reflect how real developers operate, where they often start with vague ideas and refine them through conversation and feedback. The problem is that when coding agents are tested in these straightforward scenarios, they perform well, but they often fail when faced with the ambiguity and evolving requirements of real-world tasks. This is what's called a lack of adaptability in multi-turn interactions. To address this, SWE-Interact creates a more realistic testing environment where coding agents interact with a user simulator that gradually reveals requirements and provides feedback. This setup allows the agents to demonstrate their ability to understand user intent and adapt to changing instructions. The key insight is that coding agents need to be evaluated not just on their ability to implement code but also on how well they can navigate a dynamic conversation with a user. The results show that even the best models, like Opus 4.8 and GPT 5.5, struggle in this interactive setting, solving only 25% of tasks compared to 50% in simpler scenarios. This indicates that while these models can handle initial ambiguity, they still face challenges like forgetting requirements and making technical mistakes. For builders, this means that if you're developing coding agents, you need to focus on enhancing their interactive capabilities to better support real-world software development workflows.
Forensic Trajectory Signatures for Agent Memory Poisoning Detection
Jun Wen Leong
Imagine you're building a system that relies on large language models (LLMs) to handle sensitive tasks, like sending emails or managing data. One major concern is that these models can be tricked into behaving incorrectly through memory poisoning, where malicious inputs manipulate their memory. This can lead to serious security issues, especially if the model is used in critical applications. The challenge is that current defenses often fail to recognize the subtle ways these attacks can manifest, making it hard to distinguish between normal and malicious behavior. What this paper reveals is a specific pattern in how LLMs behave when they are under attack. It turns out that for an attack to be successful, there’s a particular sequence of actions that the model tends to follow, which is not common in regular operations. This insight allows for a more targeted approach to detecting and preventing these attacks. By focusing on this behavioral invariant, the authors develop a method that significantly improves the accuracy of identifying memory poisoning attempts. In practical terms, this means that if you're deploying LLMs in environments where security is paramount, you can use this new understanding to build more robust defenses. The paper shows that their method can achieve very high accuracy rates, making it a valuable tool for anyone looking to enhance the security of their LLM applications.
Morphing into Hybrid Attention Models
Disen Lan, Jianbin Zheng, Yuxi Ren, et al.
Imagine you're trying to build a model that can handle really long pieces of text, like entire books or long documents. Traditional models use full attention, which means they look at every part of the text at once, but this can be super slow and resource-intensive. To make things faster, some researchers have started using hybrid models that mix full attention with linear attention, which is quicker but less thorough. The challenge is figuring out which layers should use full attention and which can switch to linear without losing too much accuracy. This is tricky because the importance of each layer isn't just about its individual performance; it also depends on how it interacts with other layers in the model. This is what's called layer interdependence. Current methods for selecting these layers often rely on simple rules or heuristics, which can lead to suboptimal choices and wasted resources. That's where this paper comes in. It proposes a new approach called FlashMorph, which treats the layer selection process as an optimization problem. By creating a model that can adaptively choose which layers to use based on a budget for full attention, it finds better configurations that maintain strong performance while being more efficient. The results show that FlashMorph not only discovers more effective hybrid setups but also preserves the model's ability to recall important information from long contexts, all while cutting down on the costs associated with layer selection. For anyone building models that need to process long texts efficiently, this method could be a game changer.
The Human Creativity Benchmark
Aspen Hopkins, Allison Nulty, Alexandria Minetti, et al.
Imagine you're trying to build an AI that can create art, write stories, or design products. You want to know how good it is, but measuring creativity is tricky. Traditionally, evaluators might treat disagreements about what makes something 'good' as errors, but in creative fields, those differences often reflect personal taste rather than mistakes. This is where the Human Creativity Benchmark (HCB) comes in. It collects feedback from professionals in creative domains, focusing on two important aspects: convergence, where experts agree on technical quality, and divergence, where personal taste varies. By analyzing 15,000 judgments across different creative tasks, the HCB shows that while experts align on technical correctness, they diverge on aesthetic preferences. This means that if you just boil everything down to a single score, you lose valuable insights about what works and what doesn't in different contexts. For builders, this approach means you can better understand where your models need to be precise and where they can be more flexible, leading to more effective creative AI systems.
DexCompose: Reusing Dexterous Policies for Multi-Task Manipulation with a Single Hand
Dihong Huang, Zhenyu Wei, Zhuxiu Xu, et al.
Imagine you're trying to teach a robot to handle multiple tasks with a single hand, like picking up a cup while also holding a pen. The challenge is that when you add a new task, it can interfere with the skills the robot has already learned, especially when fingers need to work together in different ways. This is a common issue in robotics called destructive interference, where the demands of new tasks conflict with existing skills. For instance, if a robot is trained to hold a cup with its fingers, trying to add a task like writing with a pen can cause it to drop the cup or lose control of the pen. This is what's called task interference. To address this, the authors propose a new method called DexCompose. The idea is to clearly define which fingers are responsible for which tasks, allowing the robot to maintain its grip on the cup while also learning to write. DexCompose uses two specialized modules: one that helps keep the original task intact and another that adapts the existing skills to accommodate the new task. By testing different finger combinations, it identifies the best way to manage finger actions for each task. In practice, this means that robots can learn to perform multiple tasks more effectively without sacrificing their ability to execute previously learned skills. The framework has been tested on 16 different tasks, achieving a 77.4% success rate, which shows that this structured approach to managing finger actions can significantly improve multi-task dexterous manipulation compared to traditional methods.
Surprises in Proper Positive-Only Learning
Shai Ben-David, Farnam Mansouri, Anay Mehrotra, et al.
Imagine you're trying to teach a model to recognize good products, but you only have examples of products that are good — no bad ones to compare against. This is tricky because, in real life, you need to know not just what’s good, but also what’s not. The traditional approach to learning assumes you have both good and bad examples, but when you only have positives, it can lead to confusion about what the model should learn. This is known as the challenge of positive-only learning. The problem is that without negative examples, the model might overfit to the positives and fail to generalize well to unseen data, which is a failure mode called improper learning. This paper addresses that gap by establishing a new condition that helps determine when a model can learn properly from just positive examples. They introduce a concept called uniform exterior separability, which, along with finite VC dimension, defines the boundaries of proper learning in this context. This means that now, when building models that rely on positive-only data, you have clearer guidelines on what can be learned effectively and what cannot. This is a significant step forward in understanding the landscape of learning theory, especially for applications where negative samples are hard to come by.
Which Nash Equilibrium? Solver-Dependent Selection on Zero-Sum Nash Polytopes
Luis Leal
Imagine you're trying to figure out the best strategy in a game where two players are competing against each other, like poker. In these games, there can be many possible strategies that all lead to the same outcome, known as Nash equilibria. Traditionally, different algorithms used to find these strategies were thought to be interchangeable, but this paper digs deeper. It shows that the algorithm you choose actually affects which strategy you end up with, especially when the strategies are not symmetric. For instance, some methods tend to pick strategies that are more uncertain, while others focus on the most balanced approach. This is important because the choice of strategy can have real consequences when playing against less optimal opponents. The authors also correct some common misconceptions about these methods, providing a clearer understanding of how they work in practice. Overall, this work helps clarify the landscape of strategy selection in competitive games, which is crucial for anyone building systems that rely on game-theoretic principles.
Second-Order KKT Guarantees for Bregman ADMM in Nonconvex and Non-Lipschitz Optimization
Shuang Li, Zhihui Zhu, Qiuwei Li
Imagine you're trying to optimize a complex system, like a machine learning model that involves matrices or tensors. Traditional optimization methods often rely on certain assumptions, like the existence of a global Lipschitz gradient, which can fail in nonconvex scenarios. This can lead to problems where the optimization process gets stuck at undesirable points, known as saddle points, which are not the best solutions. This is what's called instability in optimization. What this paper does is introduce a new way to approach these nonconvex problems using Bregman ADMM, which is a method that adapts to the specific structure of the problem at hand. Instead of relying on the standard assumptions, it uses a different comparison based on a Bregman kernel, which allows for more flexibility in handling complex objectives. The authors show that, under this new framework, the optimization process can avoid getting stuck at these bad saddle points, leading to better convergence properties. Practically, this means that if you're working on distributed optimization tasks, like matrix factorization, you can expect more reliable results without the common pitfalls of traditional methods. The paper also extends this analysis to multi-block consensus problems, making it relevant for a wider range of applications in optimization.
VGB for Masked Diffusion Model: Efficient Test-time Scaling for Reward Satisfaction and Sample Editing
Kijung Jeon, Thuy-Duong Vuong, Molei Tao
Imagine you're trying to generate text or images that not only look good but also meet specific requirements, like fitting into a certain format or achieving a high score on a task. Traditional generative models often struggle with this because they generate outputs in a linear fashion, which can lead to mistakes that are hard to fix later. For instance, if a model generates a sentence that doesn't quite fit the context, it might be difficult to go back and change just the problematic parts without messing up the rest of the sentence. This is what's called error accumulation, and it can make the outputs less reliable when they need to meet strict criteria. What this paper introduces is a clever way to tackle that problem. Instead of generating outputs in a straight line, the new method, MDM-VGB, allows for a more flexible approach where parts of the output can be adjusted even after they've been generated. It uses a technique inspired by a classic algorithm that helps navigate through possible configurations, allowing the model to 'unmask' and 'remask' tokens at different positions based on how well they contribute to the overall goal. This means that if a part of the output isn't working, the model can go back and fix it without starting from scratch. The result is a method that not only generates high-quality outputs but does so efficiently, with a complexity that scales better than many existing approaches. This is particularly useful in applications like Sudoku or scientific data generation, where meeting specific constraints is crucial. For anyone building systems that require both creativity and adherence to rules, MDM-VGB offers a promising new tool that can enhance performance significantly.
Democratic ICAI: Debating Our Way to Steering Principles from Preferences
Kevin Kingslin, Anish Natekar, Ashutosh Ranjan, et al.
Imagine you're trying to build a system that understands human preferences, like what makes a good movie or a great piece of art. Traditionally, people would just ask for a simple choice between options, but that doesn't capture the complex reasons behind those choices. This is where things can go wrong: you might miss out on important factors that influence decisions, leading to a system that doesn't really understand what people want. This is what's called a lack of interpretability in preference-based systems. To address this, Democratic ICAI takes a fresh approach. Instead of relying on a single choice, it gathers multiple competing viewpoints through structured debates among different personas. This method captures a wider range of considerations and nuances that shape preferences. By summarizing these diverse rationales into clear principles, it helps guide decision-making in a more informed way. What sets Democratic ICAI apart from previous methods is its ability to produce richer signals about preferences, leading to better predictions in creative tasks. In practical terms, if you're building a system that needs to understand and predict human choices, this approach could significantly improve how well it aligns with actual human preferences, making it more effective in real-world applications.
Bridging Ab Initio Symmetries and Global Nuclear Masses with Interpretable Neural Networks
Phong Dang, Evander Espinoza, Xiaoliang Wan, et al.
Imagine you're trying to understand how nuclei bind together, which is crucial for everything from nuclear energy to understanding the universe. Traditionally, scientists have relied on models that don't always capture the underlying physics, leading to inaccuracies, especially when predicting the behavior of new or extreme nuclei. This is where things can go wrong: existing models often oversimplify or miss important symmetries that govern nuclear forces, which can lead to significant errors in predictions. This is what's called model inadequacy. To address these issues, the authors propose a fresh approach that leverages the symmetries of the nuclear force, specifically Wigner's SU(4) and Elliott's SU(3). They develop three neural network models that incorporate these symmetries into their structure, allowing for more accurate predictions. The Wigner-Informed NN, in particular, uses these symmetry principles as a foundation for its predictions, which helps it capture the essential physics of nuclear binding more effectively than traditional models. The results are promising: the Wigner-Informed NN not only reduces the root-mean-square error by nearly half compared to the liquid-drop model but also reveals new insights about nuclear behavior, such as the restoration of Wigner's symmetry near the neutron dripline. This means that by incorporating these symmetries, the model not only performs better but also provides a deeper understanding of the forces at play in the nuclear chart, which is a significant advancement over previous methods.
PAC-Bayesian Certificates for Quadratic Closed-Loop Control
Domagoj Herceg
Imagine you're trying to control a robot that needs to follow a specific path accurately. The challenge is that the costs associated with deviations from this path can be unpredictable and hard to manage, especially when you're working with limited data. Traditional methods might struggle here because they don't handle the uncertainty well, leading to poor performance when the robot encounters unexpected situations. This is what's called the problem of unbounded losses in control systems. What this paper does is introduce a clever way to apply a theoretical framework called PAC-Bayesian bounds to these control problems. By using a specific parameterization that reveals how the robot's movements relate to its control inputs, the authors make it possible to certify the robot's performance even when the data is sparse. They derive new certificates that help ensure the robot behaves as expected, even under uncertainty, and they provide a method to optimize the control strategy based on the data available. The practical takeaway is that this approach allows for better control of systems in real-world scenarios where data is limited. The authors show through experiments that their method not only improves the robot's ability to follow the desired path but also reduces sensitivity to disturbances, which is crucial for reliable operation. This means that if you're building systems that require precise control, especially in uncertain environments, this new method could significantly enhance your results.
Agentic Hardware Design as Repository-Level Code Evolution
Cunxi Yu, Chenhui Deng, Nathaniel Pinckney, et al.
Imagine you're trying to design complex hardware, like chips, which involves a lot of manual coding and testing. Traditionally, engineers spend countless hours iterating on designs, often running into issues where the design doesn't meet specifications or takes too long to validate. This is a common problem in hardware design, where the complexity can lead to errors and inefficiencies — this is what's called the design bottleneck. To tackle this, the authors propose a new framework called HORIZON. Instead of relying solely on human engineers, HORIZON uses a self-evolving agent that can automatically manage and evolve hardware design projects. It compiles a project pack that includes everything needed for the design process, like domain knowledge and evaluation tools, and then operates in a hands-free loop to make changes and improvements. This means that the agent can continuously learn and adapt, potentially speeding up the design process and reducing errors. What sets HORIZON apart from previous work is its ability to apply these self-evolving techniques not just to software but directly to hardware design artifacts. The results are promising, with the framework achieving full completion on various benchmarks, indicating that it can effectively handle the complexities of hardware design. However, the authors are careful to note that while this is a significant step forward, there are still many challenges to overcome in the broader field of chip design.
Towards Automating Scientific Review with Google's Paper Assistant Tool
Rajesh Jayaram, Drew Tyler, David Woodruff, et al.
Imagine you're a researcher submitting a paper, but the peer review process is overwhelmed by the sheer volume of submissions, especially with the rise of AI-assisted research. Traditional peer review relies heavily on human referees, who can miss critical errors due to the increasing complexity and quantity of papers. This is where the Paper Assistant Tool (PAT) comes in. It acts like a smart assistant that reads through full scientific manuscripts, checking for theoretical accuracy, validating experiments, and even suggesting improvements. By using advanced techniques to analyze the text, PAT can catch deeper issues than a single review might, leading to a 34% improvement in identifying mathematical errors compared to traditional methods. This means that researchers can submit higher-quality papers, and referees can focus on the most critical aspects of the review process without being bogged down by minor errors. Overall, PAT represents a meaningful step towards integrating AI into the scientific evaluation process, making it more efficient and effective.
Vision-Default, Prior-Override: Causal Mechanisms of Perception-Knowledge Conflict in Vision-Language Models
Niclas Lietzow, Danielle Bitterman, Carsten Eickhoff, et al.
Imagine you're building a system that combines images and text, like a virtual assistant that can understand both what it sees and what it knows. The challenge arises when the visual information conflicts with the knowledge stored in the model. For instance, if the model sees a green apple but knows that apples are typically red, it has to decide which information to trust. This is a common issue in vision-language models, where the way they resolve these conflicts can lead to unreliable outputs. When the model relies too heavily on its memorized knowledge, it might give an answer based on that knowledge instead of what it sees, which can lead to mistakes. This is what's called knowledge bias, and it can be problematic in real-world applications where accuracy is crucial. The authors of this paper took a closer look at how these models work under the hood. They found that visual grounding, or the ability to connect visual inputs with the right knowledge, often happens automatically. However, when the model needs to rely on prior knowledge, it depends on a small number of specific attention heads in the network. By removing these heads, they observed a significant shift in the model's predictions, showing that the model's reliance on knowledge can be quite fragile. This insight is important because it reveals a sparse causal structure that underlies how these models handle conflicts between what they see and what they know. For builders, this means that understanding and potentially modifying these attention heads could lead to more reliable vision-language systems.
Agent-Native Immune System: Architecture, Taxonomy, and Engineering
Bo Shen, Lifeng Chang, Tianyuan Wei, et al.
Imagine you're building an autonomous agent that can interact with users and other agents, but you realize that these systems can be hijacked or manipulated in real-time. Current defenses, like setting up barriers before the agent acts, don't work well because they can't adapt once the agent is running. For instance, if someone poisons the agent's memory or tricks it into using the wrong tools, it can lead to serious vulnerabilities. This is what's called runtime hijacking and memory poisoning. To tackle these issues, the authors propose a new approach called the Agent-Native Immune System (ANIS). Instead of relying on external defenses, ANIS embeds security directly into the agent's thinking process. It features a six-layer structure that includes a physical and logical isolation layer to protect the agent's core functions. Additionally, it categorizes threats and defenses into a unified system, allowing the agent to learn and adapt to new attacks continuously. What sets ANIS apart from previous work is its focus on dynamic adaptation during runtime, contrasting with traditional static defenses. This means that while other systems might be well-prepared during training, ANIS can respond to new threats as they arise, making it a more resilient choice for developers building autonomous agents.
Learning Topology-Aware Representations via Test-Time Adaptation for Anomaly Segmentation
Ali Zia, Usman Ali, Abdul Rehman, et al.
Imagine you're working on a system that detects defects in products, like identifying scratches or dents in manufactured items. The challenge is that the conditions under which you trained your model might not match the real-world scenarios it faces, leading to errors in detection. Current methods often rely on simple rules, like setting a confidence threshold, to decide if something is an anomaly. However, these methods can fail when the anomalies are complex or when the input data varies in texture or noise. This is what's called reliance on pixel-level heuristics, which can miss the bigger picture of how defects are structured and related to each other. What this paper introduces is a new approach that uses topological data analysis to better understand the shape and structure of anomalies. Instead of treating anomaly maps as flat images, it looks at the underlying geometric relationships, which helps maintain consistency even when the data changes. By applying a technique called persistent homology, the method creates robust labels that guide a lightweight classifier during the adaptation process. This means it can improve the quality of segmentation without needing to retrain the entire model. In practical terms, this approach leads to a significant improvement in detecting and segmenting anomalies, especially those with complex shapes. The results show an average 15% increase in F1 score across several standard benchmarks, which is a meaningful enhancement over existing methods. For anyone building systems that need to adapt to new conditions while maintaining accuracy, this method offers a promising direction.
Parameter-Efficient Continuous-Variable Photonic Quantum Neural Networks for Edge Quantum AI: Demonstration in Oral Cancer Detection
Akshay Bhagwan Sonawane, Sophie Choe, Lakshman Tamil
Imagine you're trying to detect oral cancer early, which is crucial for better treatment outcomes. In many low-resource settings, the tools available for diagnosis are limited, making it hard for healthcare providers to catch the disease in time. Currently, some solutions involve complex diagnostic equipment that isn't practical for everyday use, especially in places where resources are scarce. This is where the idea of using smartphones comes in — they are widely available and can be used for screening, but the models that run on them need to be lightweight and efficient. However, traditional machine learning models often struggle with the constraints of edge hardware, leading to performance issues when deployed in real-world scenarios. This is what's called the edge deployment challenge. The authors propose a solution that combines classical machine learning with a new type of quantum computing that can operate at room temperature, making it suitable for edge devices. They developed a hybrid model that uses a MobileNetV1 feature extractor and a simplified quantum neural network architecture. This new architecture reduces the number of parameters needed by 40-45% compared to previous models, which helps avoid issues like barren plateaus that can hinder training. The results show that their model not only outperforms a classical baseline but also achieves perfect accuracy on test data. This means that for builders in the medical tech space, especially those focused on mobile solutions, this approach could pave the way for more accessible and effective cancer screening tools.
HPRO: Hierarchical Progressive Reward Optimization via Preference Extraction for Emotional Text-to-Speech
Sihang Nie, Xiaofen Xing, Rui Xing, et al.
Imagine you're building a text-to-speech system that sounds natural and conveys emotions effectively. The challenge is that traditional methods often lead to a bland, averaged-out voice that lacks emotional depth. This happens because the way these systems are trained can create conflicts between the content of the speech and the emotional tone, which is what we call information conflict. Additionally, when trying to optimize for emotions, the feedback often comes in sparse, high-level rewards that don't translate well to the detailed, frame-by-frame adjustments needed in speech generation — this is known as the scale gap. To tackle these issues, the authors propose a new approach called HPRO, which stands for hierarchical progressive reward optimization. The idea is to separate the emotional aspects from the content in a structured way, allowing the system to focus on optimizing each part without them interfering with each other. They introduce a new reward model, the HD-Emo codec, which helps in isolating emotional preferences from the actual content of the speech. By progressively aligning objectives at different levels — from individual frames to entire sentences — HPRO effectively bridges the gap between high-level emotional goals and the detailed requirements of speech generation. The results show that HPRO not only enhances the emotional expressiveness of the generated speech but also keeps it clear and understandable. For anyone building text-to-speech systems, this means you can create voices that sound more human and convey feelings better, which is crucial for applications like virtual assistants, audiobooks, or any interactive voice systems.
How Width and Data Shape Generalization Scaling Laws in Quadratic Neural Networks
Julius Girardin, Emanuele Troiani, Yizhou Xu, et al.
Imagine you're trying to build a machine learning model that performs well as you increase its size and the amount of data you feed it. Traditionally, researchers have looked at how models generalize based on either the amount of data or the computational resources available, but this can be limiting. For instance, you might find that simply adding more data or more parameters doesn't always lead to better performance, especially if the model isn't structured to take advantage of them. This is where things can go wrong — you might end up with a model that overfits or underfits depending on how you scale it, which is a common issue known as generalization failure. What this paper does is take a fresh look at the relationship between model size and data by focusing on a specific type of model — a two-layer network with regularization. By analyzing how the generalization error changes as you adjust the number of parameters and the amount of training data, the authors uncover a phase diagram that shows different scaling behaviors. They find that the generalization error can be described by power laws that depend on the data's structure, which helps clarify when a model will perform well or poorly as you scale it up. This approach is significant because it provides a more nuanced understanding of how to balance model complexity and data size. Instead of relying on broad generalizations, builders can use these insights to make more informed decisions about how to structure their models and what data to use, potentially leading to better performance in real-world applications.
Disentangling Continuous-Time Latent Dynamics: Identifiability of Latent SDEs via Diffusion Shifts
Yuanyuan Wang, Wenjie Wang, Haoxuan Li, et al.
Imagine you're trying to understand complex systems that change over time, like monitoring a bridge with sensors. You want to figure out the underlying factors driving these changes, but the data can be noisy and hard to interpret. Traditional methods work well in discrete settings but struggle with continuous data, especially when the relationships are hidden behind complex transformations. This is where things can go wrong: if the noise in your measurements varies too much, or if the underlying relationships are not clear, you might misinterpret the data or miss important signals. This is what's called identifiability issues in continuous-time models. What this paper does is tackle those challenges head-on. It introduces a method that leverages shifts in the noise characteristics of the data to help identify the underlying factors driving the observed changes. By focusing on how different noise levels affect the data, the authors show that you can still uncover the hidden structures even when the data is messy. They prove their approach works for specific types of systems and then extend it to more general cases, providing a two-stage estimator that helps disentangle the latent factors and recover causal relationships. Practically, this means that if you're working with time series data from sensors, like those on a bridge, you can apply this method to better understand the underlying dynamics without needing to make strong assumptions about the data. This could lead to more accurate monitoring and maintenance strategies, ultimately improving safety and efficiency in real-world applications.
Exposure Bias Can Alleviate Itself via Directional and Frequency Rectification in Flow Matching
Guanbo Huang, Jingjia Mao, Fanding Huang, et al.
Imagine you're building a generative model that creates images or text. You want it to perform well during both training and when it's actually generating outputs. However, there's a common issue called exposure bias, where the model performs differently during training than it does during inference. This can lead to poor quality outputs because the model hasn't learned to handle the discrepancies effectively. For instance, it might generate images that look good in training but fall apart when asked to create something new in real-time. This is what's called exposure bias, and it can be a significant hurdle for generative models. Currently, many solutions to this problem rely on static rules or external signals that don't adapt to the model's learning process. These methods can be limiting because they don't fully utilize the information available during training. They often fail when the model encounters new or unexpected data, leading to subpar performance. This is where the paper's approach comes in. The authors propose a method called DEFAR, which stands for DirEctional-Frequency Adaptive Rectification. Instead of relying on fixed strategies, DEFAR uses the exposure bias itself as a guide for improvement. It simulates the inference process during training, allowing the model to learn how to correct itself dynamically. The method has two main components: Anti-Drift Rectification (ADR), which helps the model steer back to the target when it drifts during inference, and Frequency Compensation (FC), which addresses missing frequency components in the generated outputs. By leveraging the bias signals, DEFAR enhances the model's ability to generate high-quality outputs even in challenging scenarios. In practical terms, this means that DEFAR can lead to better generative performance on datasets like CIFAR-10 and ImageNet, outperforming previous methods. For anyone building generative models, this approach offers a promising way to improve robustness and quality without needing extensive retraining or additional data.
Estimation--Prediction Tradeoff in Causal Probabilistic Temporal Graphs
Aniq Ur Rahman
Imagine you're trying to predict connections in a network over time, like social media interactions or communication patterns. Typically, you would look at how well your model predicts new connections based on past data. However, this can be misleading because sometimes the uncertainty in the data can make it look like your model is failing when it’s actually just dealing with inherent unpredictability. This is what's called conflating model error with irreducible uncertainty. It can lead to situations where you think your model is bad at predicting when, in fact, it’s just facing a tough problem that can't be solved with more data or better algorithms. To tackle this, the authors propose a new way to evaluate these predictions by focusing on the causal relationships in the data. They create a framework that generates temporal graphs with known causal structures, allowing for a more nuanced evaluation of how well a model is learning the underlying processes. They derive important theoretical bounds that show how the tradeoff between estimating parameters and making predictions can affect performance. This means that just looking at how accurate your predictions are might not tell you if your model is really understanding the causal dynamics at play. In practical terms, this approach shifts the focus from merely achieving high predictive accuracy to ensuring that models are genuinely capturing the causal mechanisms behind the data. This could lead to better benchmarks and evaluation methods in the field, helping builders create more reliable models that truly understand the systems they are modeling.
Towards Value-Constrained Credit Assignment in Fully Delegated AI Cooperatives
Young Yoon, Jimin Kim, Soyeon Park
Imagine you're trying to build a system where multiple AI agents work together, each contributing data and improving a shared model. The challenge is figuring out how to fairly allocate rewards for their contributions, especially when each agent has different values and priorities. Current methods often struggle with this because they tend to treat all contributions equally, which can lead to some agents getting credit for updates that don't align with their actual value to the system. This is what's called value misalignment, and it can result in inefficient learning and collaboration among agents. What this paper proposes is a new way to handle reward allocation that takes into account the unique value profiles of each agent. Instead of just aggregating contributions, the framework screens updates to ensure they align with what each agent values. It introduces concepts like value-conditioned gradient filtering and online marginal contribution signals, which help in determining how much credit each agent should receive based on their actual contributions. This approach is particularly effective because it allows for decentralized backpropagation, meaning that agents can learn from their contributions without losing quality in the process. In practical terms, this means that if you're building a system where multiple agents need to collaborate and learn from each other, this framework could lead to more accurate and fair reward distribution. It enhances the way contributions are attributed, making it easier to manage diverse agents with different goals. Compared to previous methods, it offers a more nuanced understanding of how to value contributions in a cooperative setting, which could significantly improve the efficiency of collaborative AI systems.
HAT-4D: Lifting Monocular Video for 4D Multi-Object Interactions via Human-Agent Collaboration
Jiaxin Li, Yuxiang Wu, Zhenkai Zhang, et al.
Imagine trying to understand how multiple objects interact in a video, like people playing soccer or cars navigating a busy street. Traditionally, methods that analyze these interactions focus on single objects, which means they struggle when things get complicated, like when one object blocks another from view. This is a common issue known as occlusion, and it can lead to incomplete or inaccurate reconstructions of the scene. When you're trying to build systems that understand these interactions, this limitation can be a major roadblock. HAT-4D steps in as a solution to this problem. It’s designed to take a single video and reconstruct not just the 3D shapes of the objects, but also how they move and interact over time. The framework cleverly combines visual language models with a feedback system that involves human input, which helps it figure out depth and resolve occlusions more effectively. This means it can create realistic 3D models of multiple objects interacting, even in challenging scenarios. What sets HAT-4D apart from previous methods is its ability to handle complex interactions without needing multiple cameras, which are often expensive and cumbersome. The results show that it not only performs well on various metrics but also enhances the performance of existing models when used for fine-tuning. For anyone building applications in areas like robotics or augmented reality, this means you can now gather rich, detailed data from simpler setups, making it easier to scale your projects.
DanceOPD: On-Policy Generative Field Distillation
Wei Zhou, Xiongwei Zhu, Zelin Xu, et al.
Imagine you're trying to build a single model that can do everything related to image generation — from creating images from text to editing those images in various ways. The challenge is that these tasks often conflict with each other. For example, if you focus on editing an image, it might hurt the model's ability to generate images from text. This is a common issue in the field, where different capabilities can interfere with one another, leading to subpar results. This problem is known as capability conflict. To address this, the authors propose a new method called DanceOPD. Instead of trying to make one model handle everything at once, DanceOPD routes each image generation task to a specific capability field. It uses a technique that allows the model to learn from its own experiences, focusing on one task at a time while still being aware of the others. This way, the model can improve its performance on each task without degrading the overall quality of the images it generates. What sets this work apart from previous methods is its ability to effectively compose multiple capabilities while preserving the quality of the generated images. The experiments show that DanceOPD not only enhances the performance of text-to-image generation but also improves editing capabilities. For anyone building image generation systems, this approach offers a practical solution to a common problem, making it easier to create models that can handle a variety of tasks without compromising on quality.
Reinforcement Learning without Ground-Truth Solutions can Improve LLMs
Yingyu Lin, Qiyue Gao, Nikki Lijing Kuang, et al.
Imagine you're trying to teach a model to solve coding problems, but you don't always have the right answers to guide it. Traditionally, models learn from clear, correct solutions, but this limits their ability to tackle more ambiguous tasks where the 'right' answer isn't known. This is a real issue in reinforcement learning, where models rely on feedback from correct answers to improve. When that feedback isn't available, it can lead to problems like scale dominance, where some feedback is too strong and skews the learning process, and frequency dominance, where the model gets stuck on less optimal solutions because they appear more often in the feedback it receives. The authors of this paper propose a new approach called RiVER, which stands for Ranking-induced VERifiable framework. Instead of needing ground-truth answers, RiVER uses a system of continuous feedback based on how well different solutions rank against each other. This method helps the model learn more effectively by focusing on the best-performing solutions while still considering other valid options. By applying this framework to various coding tasks, they found that RiVER significantly improved the performance of large language models, even on benchmarks that require exact solutions. This means that with the right kind of feedback, models can learn to code better without needing to know the correct answers upfront, which opens up new possibilities for training in more complex environments.
Autoregressive Boltzmann Generators
Danyal Rehman, Charlie B. Tan, Yoshua Bengio, et al.
Imagine you're trying to simulate how molecules behave at equilibrium, which is crucial for understanding chemical processes. Traditionally, researchers have used methods like Boltzmann Generators that rely on normalizing flows to generate samples. However, these flows can be limited in their ability to express complex distributions or can be computationally expensive, especially when dealing with continuous data. This is where things can go wrong: if the model can't capture the necessary details, the samples it generates won't accurately reflect reality, leading to poor predictions and insights. This issue is known as limited expressivity and high computational cost, which can hinder progress in molecular simulations. To address these challenges, the authors propose a new approach called Autoregressive Boltzmann Generators. Instead of sticking to the flow-based paradigm, this method allows for more flexible modeling by using autoregressive techniques. This means that the model can generate samples sequentially, making it easier to incorporate complex dependencies and interventions during inference. The authors also leverage architectures that have proven effective in large language models, enhancing scalability and performance. The results are promising: the new ArBG framework shows significant improvements over traditional flow-based models, particularly in larger peptide systems like the 10-residue Chignolin. Notably, they introduce a transferable model named Robin, which achieves over a 60% reduction in zero-shot energy error for 8-residue systems compared to previous state-of-the-art methods. For anyone working on molecular simulations, this advancement could lead to more accurate and efficient modeling, ultimately accelerating research and development in fields like drug discovery and materials science.
When are likely answers right? On Sequence Probability and Correctness in LLMs
Johannes Zenn, Jonas Geiping
Imagine you're building a chatbot that needs to generate accurate responses based on user prompts. You might think that if you can make the model more confident in its answers, it will produce better results. This is where decoding methods come in; they adjust how the model generates text to favor more likely outputs. However, there's a catch: just because a response has a high probability doesn't mean it's correct. This is a common issue when trying to improve the accuracy of generated text, known as the misalignment of sequence probability and correctness. Builders often face situations where tweaking the model's settings or the way it generates text doesn't lead to better answers, which is frustrating and counterproductive. This is what's called the failure of decoding decisions to improve accuracy. What this paper explores is the relationship between the probability of a generated sequence and its correctness across different methods and settings. They found that while higher sequence probability can indicate correctness for specific pairs of prompts and answers, simply increasing that probability through changes in methods or hyperparameters doesn't guarantee better accuracy. This means that builders need to be cautious when relying on probability scores to judge the quality of generated responses. The practical takeaway is that understanding when decoding methods can improve correctness is essential for developing more reliable language models.
Error-Conditioned Neural Solvers
Haina Jiang, Liam Wang, Peng-Chen Chen, et al.
Imagine you're trying to predict the behavior of complex systems described by partial differential equations (PDEs), like fluid dynamics. Traditionally, people use surrogate models that approximate these systems, but they often fail when the conditions change or when they encounter situations they weren't trained on. This leads to inaccurate predictions, especially in tricky cases where the models can't correct their own mistakes — this is what's called extrapolation failure. To address these issues, some researchers have developed hybrid methods that combine machine learning with classical optimization techniques. While these methods can improve accuracy by ensuring physical correctness, they come with their own problems: they can be computationally expensive and unstable, especially in ill-conditioned scenarios where the underlying equations are sensitive to changes. This is known as optimization instability. The authors of this paper propose a new approach called error-conditioned Neural Solvers (ENS). Instead of treating the PDE residual as a target to minimize, they feed it directly into the model at each step. This allows the model to understand its own errors and learn how to correct them iteratively. The result is that ENS achieves significantly higher accuracy across various PDE families, especially in challenging conditions where traditional methods struggle. Practically, this means that if you're working with complex systems and need reliable predictions, ENS could save you time and resources compared to older methods.
All you need is log
Akshay Balsubramani
Imagine you're trying to compare several different groups of data — like customer segments or different medical conditions — and you want to understand how they relate to each other. Traditionally, comparing two distributions is straightforward, but when you have more than two, things get tricky. Current methods often fail to capture the nuances of these relationships, leading to inaccurate conclusions. This is what's called multi-distribution comparison failure. What this paper does is provide a new framework for comparing multiple distributions at once, using a concept called multi-way coincidence divergences. The authors show that any method for comparing these distributions must fit into a specific structure that they define, which includes various mathematical properties that ensure the comparisons are meaningful. They also demonstrate that this new approach is robust by deriving it from multiple independent theoretical foundations. In practical terms, this means that if you're working on problems like fairness in machine learning or testing multiple hypotheses, you now have a solid mathematical tool that can help you make better comparisons across different groups. This could lead to more accurate models and fairer outcomes in applications where understanding the relationships between multiple distributions is crucial.
Mapping Political-Elite Networks in Europe with a Multilingual Joint Entity-Relation Extraction Pipeline
Kirill Solovev, Jana Lasser
Imagine you're trying to understand the complex relationships between political figures and institutions across different countries. Traditionally, researchers would manually sift through vast amounts of news articles, coding relationships by hand. This process is not only time-consuming but also prone to human error and bias. When automated methods are used, they often fall short, relying on simple co-occurrence of terms that miss the nuances of these relationships. This is what's called the limitation of traditional text-as-data methods. The paper introduces a new approach that tackles these issues head-on. Instead of just counting words or phrases, it builds a sophisticated system that can extract meaningful relationships from multilingual news sources. It uses a combination of named-entity recognition and a linking process that connects mentions to a universal database, allowing it to understand and categorize relationships in a way that previous methods couldn't. This pipeline is modular and open-weight, meaning it can be adapted and improved upon by others in the field. What sets this work apart is its ability to create detailed knowledge graphs that reflect the dynamics of political parties and their interactions over time. For instance, in one case study, it successfully traced the lifecycle of a political party in Austria, revealing internal conflicts and connections to other factions. In another, it uncovered the intricate networks of state-enterprise relationships in Poland. This capability to turn raw text into structured relational data is a significant leap forward for researchers looking to analyze political landscapes across different languages and contexts.
Understanding Domain-Aware Distribution Alignment in Budgeted Entity Matching
Nicholas Pulsone, Gregory Goren, Roee Shraga
Imagine you're trying to combine data from different sources, like customer databases or product inventories. You want to know if two records refer to the same entity, but this can be tricky when the data is messy or comes from different places. Currently, many systems struggle with this because they often rely on a lot of labeled data and can’t adapt well to new situations. When the data is limited or not well-aligned, these systems can make mistakes, leading to what’s called poor entity matching performance. This is especially problematic in real-world applications where data is often incomplete or inconsistent. What this paper does is take a closer look at a specific method called BEACON, which is designed to work well even when there’s not much data available. The authors run a series of experiments to see how different choices in the algorithm and the amount of data available affect how well BEACON performs. They find that aligning the data distribution plays a crucial role in improving the system's accuracy. This means that by understanding how to better match the data it’s working with, BEACON can provide more reliable results. In practical terms, this research helps builders create entity matching systems that are more robust and adaptable to the varying conditions they might face in the real world. By focusing on how to handle low-resource scenarios effectively, the findings can lead to better data integration solutions that save time and reduce errors.
Language-Based Digital Twins for Elderly Cognitive Assistance
Mohammad Mehdi Hosseini, Mohammad H. Mahoor, Hiroko H. Dodge
Imagine trying to keep track of an elderly person's cognitive health over time. You want to catch early signs of issues like Mild Cognitive Impairment (MCI) before they become serious. Currently, doctors might rely on clinical assessments or questionnaires, but these can miss subtle changes in behavior and language that indicate cognitive decline. This is where the problem lies: traditional methods often lack the sensitivity to detect early warning signs, which is crucial for timely intervention. This is what's called a failure in early detection. Now, what if you could create a digital version of a person that mimics their conversational style and behavior? This paper proposes just that—a language-based digital twin that uses large language models to replicate how elderly individuals communicate. By analyzing their language patterns and incorporating contextual information, this framework can provide insights into their cognitive health. The authors introduce a multi-head conditional variational autoencoder (cVAE) to evaluate how well the digital twin captures individual characteristics and predicts cognitive scores. In practical terms, this means that instead of relying solely on traditional assessments, healthcare providers could use these digital twins to monitor cognitive health continuously and non-invasively. The results show that this approach not only preserves the unique traits of individuals but also performs well in predicting cognitive scores, making it a valuable tool for personalized healthcare. Compared to previous methods, this framework offers a more nuanced and scalable way to track cognitive health, potentially leading to earlier interventions and better outcomes.
Empowering GUI Agents via Autonomous Experience Exploration and Hindsight Experience Utilization for Task Planning
Tianyi Men, Zhuoran Jin, Pengfei Cao, et al.
Imagine you're trying to build a digital assistant that can help you with repetitive tasks across different websites. The challenge is that these tasks can be complex and require careful planning to break them down into manageable steps. Currently, many models struggle with this because they either lack the ability to plan effectively or don't generalize well across different environments. This is particularly problematic when the tasks vary significantly from what the model was trained on, leading to failures in execution — a situation known as poor out-of-distribution (OOD) generalization. To tackle these issues, the authors propose a method that allows the model to explore different environments and learn from past experiences. This approach helps the model to create high-level training data that is closely aligned with the tasks it needs to perform. They also introduce a framework to analyze how well the model can generalize across different levels of task complexity, revealing that just mastering simple tasks doesn't guarantee success in more complex planning scenarios. What sets this work apart is that their smaller model, with only 7 billion parameters, achieves a 30.6% accuracy rate, outperforming a much larger model with 32 billion parameters. This suggests that with the right training and experience utilization, smaller models can be just as effective, if not more so, than their larger counterparts in certain applications. For builders, this means that investing in efficient training methods for smaller models could yield significant benefits in real-world task execution.
Hallucination in World Models is Predictable and Preventable
Nicklas Hansen, Xiaolong Wang
Imagine you're building a system that predicts future scenarios based on current actions, like a video game AI that needs to plan its moves. The challenge is that these systems often generate plausible-looking outputs that don't match reality — this is called hallucination. It happens especially in areas where the model hasn't seen enough examples, leading to unreliable predictions. For instance, if the AI has never encountered a specific type of terrain, it might create a convincing but incorrect representation of how to navigate it. This is what's known as low-coverage regions in the state-action space, where the model's understanding is weak. To tackle this problem, the authors introduce a new dataset called MMBench2, which includes a vast array of tasks and ground-truth actions. They also identify three specific types of hallucination that occur at different stages of the model's processing pipeline. By developing signals that can predict when and where these hallucinations will happen, they create a method to improve the model's training and performance. This involves using these signals to guide data collection and fine-tuning, allowing the model to adapt to new environments with minimal real-world data. Overall, this approach shifts the focus from merely generating outputs to ensuring those outputs are grounded in reality, significantly enhancing the reliability of generative models in practical applications.
Beyond the Hard Budget: Sparsity Regularizers for More Interpretable Top-k Sparse Autoencoders
Nathanaël Jacquier, Maria Vakalopoulou, Mahdi S. Hosseini
Imagine you're trying to make sense of complex visual data using a model that can pick out important features. You might use a sparse autoencoder, which simplifies the data by focusing on the most relevant parts. However, these models can struggle with overfitting and may not adapt well to different types of inputs because they rely on a fixed number of features to keep. This is where the problems arise: if the model is too rigid, it can miss important details or become too specialized, leading to poor performance in varied scenarios. This is what's called overfitting and fixed budget issues. To address these challenges, the authors propose a couple of new techniques that add flexibility to the sparse autoencoder's approach. Instead of just selecting the top features, they introduce regularizers that help the model learn to focus on the most relevant features dynamically. One regularizer penalizes the features that aren't selected, while another encourages the model to concentrate information into fewer features. This means that the model can adapt better to different inputs and maintain high-quality outputs, even when the number of features it can use is limited. The result is that these new techniques not only improve the clarity of the features learned by the model but also ensure that the reconstruction quality remains intact. For anyone building systems that rely on visual data interpretation, this means you can achieve better performance without compromising on the model's ability to generalize across different types of inputs.
LLM-Based Examination of Eligibility Criteria from Securities Prospectuses at the German Central Bank
Serhii Hamotskyi, Akash Kumar Gautam, Christian Hänig
Imagine you're working at a central bank, and you need to verify whether various securities can be used as collateral. This involves sifting through long, complex documents that often mix languages and can be hard to read due to scanning errors. Traditionally, people have relied on Named Entity Recognition (NER) systems to pull out relevant information, but these systems can struggle with messy text and require a lot of manual effort to train on specific types of information. This is what's called the rigidity of span-based constraints and the need for extensive manual annotation. The paper presents a fresh approach that uses Large Language Models (LLMs) to tackle this problem. Instead of just extracting information, the method breaks the task down into three parts: extraction, normalization, and interpretation. This allows the system to be more flexible and handle the noise and bilingual nature of the documents better than traditional methods. Additionally, they introduce a new way to evaluate the results, using LLMs to assess the semantic quality of the information extracted rather than just where it appears in the text. What’s significant here is that this new method achieves high precision—up to 91%—in determining whether documents meet eligibility criteria. This is a notable improvement over previous methods, as it reduces the chances of incorrectly accepting documents that shouldn't qualify. For anyone building systems that need to verify complex documents, this approach offers a more efficient and reliable way to handle the intricacies of legal and financial texts.
Blackwell Approachability and Gradient Equilibrium are Equivalent
Brian W. Lee, Nika Haghtalab, Michael I. Jordan, et al.
Imagine you're trying to make decisions in real-time, like adjusting prices based on customer behavior or predicting stock movements. In these situations, you want to optimize your choices continuously as new data comes in. Traditional methods often struggle because they focus on past data, which can lead to mistakes when conditions change. This is where online optimization comes in, allowing you to adapt as you go. However, existing frameworks can sometimes miss the mark because they treat different objectives, like minimizing error and managing regret, as separate when they might actually be connected. This is what's called a disconnect in online learning frameworks. What this paper does is bridge that gap by showing that a new approach called Gradient Equilibrium (GEQ) is actually equivalent to a well-known concept called Blackwell approachability. This means that if you have a problem that can be framed in terms of Blackwell approachability, you can solve it using GEQ without losing accuracy. The authors also provide efficient methods to transfer guarantees from regret minimization to GEQ, which means you can leverage existing techniques to enhance your online decision-making processes. In practical terms, this means that if you're building systems that need to adapt quickly to new information, you can use the insights from this paper to improve your algorithms. By understanding how GEQ fits into the broader landscape of online learning, you can make better decisions with less risk of error, ultimately leading to more robust systems.
Beyond Surface Forms: A Comprehensive, Mechanism-Oriented Taxonomy of Indirect Linguistic Encoding for LLM-Based Coded Language Detection
Hamid Reza Firoozfar, Mohammadsadegh Abolhasani, Reza Mousavi, et al.
Imagine you're trying to keep track of how people communicate sensitive topics on social media without getting flagged for moderation. Users often come up with clever ways to say things indirectly, using euphemisms or coded language to mask their true intent. This can make it really hard for content moderation systems to catch harmful content because the language is so nuanced and context-dependent. When these systems rely on existing frameworks, they often miss the mark, leading to either over-moderation or under-moderation — this is what's called a failure to detect algospeak or adversarial obfuscation effectively. To address this, the authors propose a new way to categorize these indirect expressions based on the mechanisms behind how meaning is encoded and decoded, rather than just the communicative goals. They developed a comprehensive taxonomy that helps to systematically identify and analyze these expressions. By testing this taxonomy with 2,000 posts from platforms like TikTok and Bluesky, they found that it significantly outperformed previous taxonomies, achieving better accuracy and F1 scores. In practical terms, this means that if you're building a content moderation tool, using this new taxonomy could help you better detect and understand the emerging coded language that users employ to evade moderation. It provides a more stable framework for identifying harmful content while respecting the nuances of user expression.
Multilingual Reasoning Cascades Need More Context
Arnav Mazumder, Dengjia Zhang, Shuyue Stella Li, et al.
Imagine you're building a system that needs to understand and respond to questions in multiple languages. You might think of translating a question into English, processing it, and then translating the answer back. This is a common approach, but it has a big flaw: each translation step can lose important information that might be needed later, like cultural context or specific meanings. This is what's called structural loss, and it can lead to misunderstandings or incorrect answers. To address this, the authors propose a new method that keeps the original question in the loop throughout the translation process. By doing this, they ensure that the context is preserved, which helps the system make better decisions when generating answers. They tested this approach on nine different multilingual benchmarks, using various models and languages, and found that it led to significant improvements in performance, especially for open-ended questions. In practical terms, this means that if you're building a multilingual system, you should consider keeping the original user question until the very end of your processing pipeline. This simple change can help reduce errors and improve the quality of the responses your system provides.
A Multi-Fidelity Convolutional Autoencoder-Transfer Learning Framework for Guided-Wave-Based Damage Diagnosis Using Large Simulated and Limited Experimental Datasets
Santosh Kapuria, Abhishek
Imagine you're responsible for maintaining large engineering structures like bridges or buildings. You want to catch any damage early to prevent catastrophic failures, but inspecting these structures can be time-consuming and expensive. Traditionally, engineers rely on extensive labeled data from experiments to train models that can identify damage, but gathering this data is often impractical and costly. This is where things can go wrong: without enough data, models can be inaccurate, leading to missed damage or false alarms. This issue is known as data scarcity in machine learning for structural health monitoring. To address this, the authors propose a new method that cleverly combines lightweight physics-based simulations with deep learning techniques. Instead of needing vast amounts of experimental data, their approach uses a smaller set of real measurements alongside a large synthetic dataset generated from simulations. This allows the model to learn effectively even with limited real-world data. The framework employs a convolutional autoencoder to extract features from the data, which are then used in a feed-forward neural network for damage detection. What’s exciting is that this new method significantly outperforms traditional convolutional neural networks in terms of accuracy for damage localization. The results show that the model can achieve R^2 scores exceeding 0.93 for localization and 0.99 for sizing, indicating it can make very accurate predictions even on new, unseen data. This means that engineers can deploy this framework in real-world scenarios with confidence, knowing it can accurately identify and size damage without needing extensive data collection efforts.
AI Healthcare Chatbots as Information Infrastructure: A Large-Scale Study of User-Reported Breakdowns
Muhammad Hassan, Ramazan Yener, Ece Gumusel, et al.
Imagine you're trying to get health information quickly and easily through a chatbot. These AI systems are supposed to help, but many users find themselves frustrated. They might struggle to access the service, face unreliable responses, or have a poor experience interacting with the chatbot. Sometimes, they even run into issues with billing or feel their privacy is at risk. This is what's called access barriers and service unreliability, which can lead to negative experiences for users. In this study, the authors looked at over 15,000 reviews from various AI healthcare chatbots to understand these problems better. They found that users frequently reported issues related to access, usability, and trust. By framing these chatbots as part of a larger information infrastructure, the authors highlight how these failures can significantly impact users' experiences. What’s new here is the focus on specific breakdowns in user experience and how they relate to the overall effectiveness of these chatbots. This research offers actionable insights for designers and policymakers, suggesting that improving access, interaction quality, and addressing privacy concerns can lead to better digital health systems. For anyone building or improving AI healthcare chatbots, these findings emphasize the importance of user experience and trust.
Fast algorithms for learning a Gaussian under halfspace truncation with optimal sample complexity
Haitong Liu, Deepak Narayanan Sridharan, David Steurer, et al.
Imagine you're trying to model data that only exists in a certain region of space, like predicting the height of plants that only grow in a specific climate. You might want to use a Gaussian distribution to represent this data, but when you only have data from a limited area, it complicates things. Traditional methods for learning these truncated distributions can be slow and require a lot of samples, which can be a real headache when you're working with high-dimensional data. This is what's called the challenge of learning truncated Gaussians. The existing approaches often rely on complex optimization techniques that can be time-consuming and computationally expensive. When the truncation is non-trivial, these methods can struggle to provide accurate results, leading to inefficiencies and inaccuracies in the learned model. This is known as the inefficiency of projected stochastic gradient descent, which can bog down the learning process. What this paper does is offer a fresh perspective on the problem. It introduces a new algorithm that simplifies the learning process by using a clever reinterpretation of the truncated Gaussian's low-degree moments. This approach allows for direct recovery of the parameters of the untruncated Gaussian without the heavy computational burden of previous methods. In practical terms, this means you can learn a Gaussian under halfspace truncation efficiently, using fewer samples and less time than before. Compared to prior work, this advancement not only optimizes the learning process but also makes it more accessible for builders dealing with high-dimensional data.
Generative Models on Analog Hardware with Dynamics
Yu-Neng Wang, Sara Achour
Imagine you're trying to create generative models that can produce images or other complex outputs, but you want to do it in a way that's energy-efficient. Traditional digital computation can be power-hungry, especially for large models. This is where analog hardware comes in, which can solve certain problems using physical processes, but it has a limitation: it relies on fixed equations that can’t adapt as flexibly as software-based models. This mismatch can lead to a situation where the analog systems can't express the complexity needed for modern generative tasks, which is a problem known as the expressivity gap. To address this, the authors introduce a new framework called Analog Interaction Systems (AIS). This framework allows for more flexible dynamics in analog systems by incorporating time-varying parameters and hidden states that can adapt to the task at hand. They also developed a training method based on Wasserstein GANs that helps these models learn without being constrained to specific trajectories. The results are promising: the AIS models not only close the expressivity gap but also achieve a significant reduction in energy costs—about 23 microjoules per generated image, which is two orders of magnitude better than traditional digital methods. On standard datasets like MNIST and Fashion-MNIST, these models outperform previous analog generative models by a factor of 3-4, making them a compelling option for builders looking to create efficient generative systems.
Designing Reward Signals for Portable Query Generation: A Case Study in Industrial Semantic Job Search
Ping Liu, Qianqi Shen, Jianqiang Shen, et al.
Imagine you're building a job-search platform that needs to match candidates with jobs based on complex profiles. The challenge is that traditional query interfaces often miss the nuances of what makes a candidate suitable, leading to poor matches. When trying to optimize these queries, you might run into issues where the system exploits weaknesses in how it evaluates candidates, resulting in behaviors like simply copying existing queries instead of generating new, relevant ones. This is what's called reward-hacking, where the system finds shortcuts that don't actually improve the quality of matches. To tackle these issues, the authors propose a new approach that focuses on how rewards are structured during the training of the model. Instead of relying solely on the algorithm used, they emphasize the importance of shaping the rewards in a way that discourages copying and encourages genuine understanding of candidate qualifications. By introducing a rule-based reward floor, they mitigate the risk of the model exploiting the reward system, leading to better performance. Compared to previous methods, this approach shows that the way rewards are designed can have a much larger impact on the success of the model than the choice of optimization algorithm. For anyone building job-search tools, this insight means that careful attention to how you reward your model can lead to significantly better outcomes, making the system more effective at matching candidates with jobs.
When Does Combining Language Models Help? A Co-Failure Ceiling on Routing, Voting, and Mixture-of-Agents Across 67 Frontier Models
Josef Chen
Imagine you're trying to build a system that uses multiple models to answer questions, like a team of experts. The idea is that by having different models tackle different types of questions, you can get better overall accuracy. However, there's a catch: if multiple models are wrong on the same question, your accuracy can't improve beyond a certain point, which is determined by how often they fail together. This is known as the beta rate, and it’s a crucial factor that many people don’t consider when designing these systems. Currently, when people combine models, they often rely on metrics like average pairwise error correlation to gauge performance. But this can be misleading because two models can have the same correlation yet perform very differently in terms of their collective failure rates. This is where the paper steps in. It provides a new way to measure this beta rate and shows that understanding it can help you make better decisions about which models to combine and how to route queries. The key takeaway is that simply adding more models doesn't guarantee better performance. In fact, the research found that in many cases, the best single model outperformed combinations of models unless there was a strong signal guiding which model to use for each question. This insight is particularly valuable for anyone building systems that rely on multiple models, as it emphasizes the importance of understanding model interactions and error rates.
Prompt Injection in Automated Résumé Screening with Large Language Models: Single and Multi-Injection Settings
Preet Baxi, Jiannan Xu, Jane Yi Jiang, et al.
Imagine you're building a hiring system that uses a large language model (LLM) to screen job applicants. The goal is to find the best candidates based on their résumés, but as more people apply, some might try to game the system by adding subtle self-promotional text that doesn't actually change their qualifications. This is where the problem lies: when only a few candidates use this tactic, it can boost their rankings, but as more candidates start doing it, the effectiveness drops sharply. This situation is known as prompt injection, and it can lead to lower-quality candidates outranking better ones, especially when the differences in candidate quality are small. This raises serious fairness issues in the hiring process. The paper explores this issue by conducting controlled experiments to understand how prompt injection works in practice. It turns out that when résumé quality is similar and only a few candidates manipulate their texts, they can significantly improve their chances of being ranked higher. However, as more candidates adopt this strategy, the advantage diminishes, and the system becomes less reliable. The key takeaway is that LLM-based screening is most vulnerable when manipulation is rare and candidate quality differences are minimal. This insight is crucial for anyone building automated hiring systems, as it highlights the need for safeguards against such manipulative tactics.
Simulation-based inference for rapid Bayesian parameter estimation in epidemiological models: a comparison with MCMC
Alina Bazarova, Johann Fredrik Jadebeck, Henrik Zunker, et al.
Imagine you're trying to predict how a disease spreads in a population, like during the COVID-19 pandemic. You'd want a model that can accurately forecast ICU occupancy to help with public health decisions. Traditionally, people use a method called Markov chain Monte Carlo (MCMC) to calibrate these models, but it can be really slow, especially when the models get complicated or when you need to run them frequently. This is where things can go wrong: MCMC can take a long time, making it hard to get timely insights when outbreaks change rapidly. This is what's called computational bottlenecking. To tackle this, the authors explored a new approach called simulation-based inference (SBI). Instead of relying solely on MCMC, SBI uses neural networks to estimate the posterior distributions of the model parameters. This means it can leverage both CPU and GPU resources, making it much faster. In their experiments, SBI not only matched the accuracy of MCMC but also did so in a fraction of the time. For example, while MCMC took about 1000 seconds for a 31-day analysis, SBI completed it in just 60-70 seconds. For a more complex 201-day analysis, SBI took around 157 seconds compared to MCMC's over 19,000 seconds. This shift means that if you're building systems for public health or any field that requires rapid decision-making based on complex models, SBI could be a game-changer. It allows for quicker updates and analyses, which is crucial during fast-moving situations like an epidemic.
Recovering Governing Equations from Solution Data: Identifiability Bounds for Linear and Nonlinear ODEs
Yang Pan, Helmut Bölcskei
Imagine you're trying to figure out the rules that govern a complex system, like weather patterns or fluid dynamics, just by observing its behavior over time. This is a tough challenge because you might have multiple equations that could explain the same observations, and distinguishing between them can be tricky. Currently, researchers often struggle with this because they lack a clear understanding of how many observations are needed to confidently identify the correct governing equation. This uncertainty can lead to incorrect conclusions or models that don't accurately reflect reality. This is what's called sample complexity — the number of data points required to make reliable inferences. What this paper does is introduce a new way to measure the differences between potential governing equations using something called the Hausdorff distance. This metric helps capture the worst-case scenario of how two equations can be separated based on their solutions. By establishing bounds on when two different equations can be distinguished from one another, the authors provide a clearer framework for understanding the sample complexity involved in identifying these equations. They analyze various types of ordinary differential equations (ODEs) and derive estimates that quantify how many observations are necessary to recover the true governing equation reliably. In practical terms, this means that if you're building models in scientific fields, you can now have a better idea of how much data you need to collect to ensure that your models are accurate. This could lead to more efficient data collection strategies and improved modeling in areas where understanding the underlying equations is critical.
How Good Can Linear Models Be for Time-Series Forecasting?
Lang Huang, Jinglue Xu, Luke Darlow
Imagine you're trying to predict future values in a time series, like stock prices or weather patterns. Traditionally, many researchers have believed that using larger and more complex models, like specialized transformers, is the best way to improve accuracy. However, this approach can be costly and may not always yield the best results. For instance, larger models can overfit to the data, meaning they perform well on training data but poorly on new, unseen data. This is what's called overfitting, and it can lead to disappointing performance in real-world applications. In this paper, the authors take a different approach. They argue that instead of just scaling up models, we should focus on optimizing how we preprocess the data. They use Ridge regression, a simpler model with clear and interpretable parameters, to explore various preprocessing techniques. By adjusting factors like how much historical data to consider and how to normalize the data, they discover that these tweaks can lead to better forecasting results. For example, they find that the optimal amount of historical data to use can vary significantly depending on the specific time series being analyzed, which challenges the common belief that more history is always better. The authors also reveal that normalizing data in a more targeted way, rather than using all available data, often leads to better performance. Their findings show that different series within the same dataset may require different preprocessing strategies, which is a nuanced understanding that larger models might overlook. Overall, their optimized methods outperform traditional linear models and even more complex architectures like Transformers and CNNs on most benchmarks. This means that for builders working on time-series forecasting, focusing on preprocessing could be a more efficient and effective strategy than simply scaling up model size.
EO-WM: A Physically Informed World Model for Probabilistic Earth Observation Forecasting
Junwei Luo, Shuai Yuan, Zhenya Yang, et al.
Imagine you're trying to predict how vegetation will respond to changing weather conditions using satellite data. Traditionally, models either make a single prediction that doesn't account for uncertainty or treat weather data too simplistically, leading to inaccurate forecasts. This is problematic because it can result in poor decision-making in agriculture, disaster response, and environmental management. This is what's called a failure to capture the complexity of weather impacts on land surfaces. The approach in this paper, EO-WM, takes a fresh look at this problem by treating weather as a key factor that influences vegetation dynamics. Instead of just making one prediction, it uses a video diffusion transformer that incorporates detailed weather information, separating normal conditions from anomalies and accumulating stress signals over time. This allows the model to better understand how prolonged weather changes affect vegetation health. What sets EO-WM apart from previous methods is its focus on how well forecasts respond to actual weather changes, rather than just how accurately they reconstruct past data. The authors introduce new benchmarks to evaluate this response behavior, leading to significant improvements in prediction accuracy. Practically, this means that if you're working in fields like agriculture or environmental monitoring, using EO-WM could lead to better-informed decisions based on more reliable forecasts.
How Surprising Is Historical Italian to Language Models? Tokenization Tax, Comprehension Tax, and a Simple Mitigation
Maria Levchenko
Imagine you're trying to use a large language model to help with a digital library that contains historical texts. The challenge is that these texts often have different spellings, grammar, and vocabulary compared to modern language, making it hard for the model to understand them. Right now, people often treat this historical difficulty as a single problem, but that approach can lead to misunderstandings about how well the model can actually process these texts. For instance, you might think that if a model struggles with one old text, it will struggle with all of them, which isn't necessarily true. This is what's called a monolithic view of historical language processing. What this paper does is break down the problem into four specific areas: how hard it is to tokenize the text, how uncertain the model is about its predictions, how robust the meaning is across different texts, and how sensitive the model is to the context it receives. By analyzing these factors across three different historical datasets, the authors found that while older Italian texts are more surprising to the model, it can still represent their meanings well. They also discovered that a simple prompt can reduce the model's uncertainty significantly, making it easier to work with these texts. In practical terms, this means that while historical texts do present challenges, we can still use large language models effectively for tasks like semantic retrieval in digital libraries, as long as we adapt our approach to account for the unique characteristics of these texts.
BetXplain: An Explanation-Annotated Dataset for Detecting Manipulative Betting Advertisements on Social Media
MSVPJ Sathvik, Parmitha Vangapadu, Nishit Rane, et al.
Imagine you're trying to help people navigate the world of online betting, especially with all the ads popping up on social media. These ads often use sneaky tactics to lure users in, which can lead to risky behavior and even affect mental health. Right now, there’s not much research on how to automatically spot these manipulative ads because there aren’t many datasets available to train models on. This is a problem because without good data, it’s hard to build systems that can effectively warn users about these risks. This is what's called a lack of annotated datasets in the field of deceptive advertising detection. To tackle this issue, the authors created a new dataset specifically focused on betting-related advertisements from platforms like Instagram and Reddit. They didn’t just collect the ads; they also manually annotated them to highlight manipulative and deceptive practices. This means they provided labels and explanations for each ad, which is crucial for training models that can understand the nuances of persuasive tactics. By doing this, they’re laying the groundwork for future research into explainable AI methods that can detect these kinds of ads. What’s exciting about this work is that it opens up new avenues for practical applications. For instance, they suggest that this dataset could be used to develop browser plugins that alert users when they encounter potentially manipulative betting ads. This is a step forward compared to previous work, which lacked the necessary data to build effective detection systems. Overall, this research not only contributes a valuable resource but also highlights the importance of understanding how advertising can impact mental health.
Ribbon: Scalable Approximation and Robust Uncertainty Quantification
Graham Gibson, John Tipton, Kellin Rumsey, et al.
Imagine you're building a machine learning model that needs to make predictions, but you want to know how confident it is about those predictions. This is crucial in many applications, like healthcare or finance, where knowing the uncertainty can guide decision-making. However, accurately quantifying this uncertainty can be really tough, especially with complex models or when the data doesn't fit the assumptions perfectly. Traditional methods, like fully Bayesian approaches or bootstrap resampling, can give you solid uncertainty estimates, but they often require a lot of computational resources because they involve repeatedly fitting the model or sampling from the posterior distribution. This is where things can break down: if your model is too complex or your data is high-dimensional, these methods can become impractical, leading to what’s called computational bottlenecks. Builders might end up with unreliable uncertainty estimates simply because they can't afford the computational cost of the best methods available. What Ribbon does is provide a clever workaround. Instead of needing to refit the model multiple times, it uses a single fitted model and applies a linearization technique that approximates the Bayesian bootstrap. This means you can still get the benefits of data reweighting and uncertainty quantification without the heavy lifting of repeated training. Practically, this allows builders to achieve better calibration of their models' uncertainty estimates across various tasks, like regression and classification, without the need for extensive computational resources. So, if you're looking to implement uncertainty quantification in your models, Ribbon offers a more efficient and scalable solution compared to traditional methods.
E-TTS: A New Embodied Test-Time Scaling Framework for Robotic Manipulation
Wen Ye, Peiyan Li, Tingyu Yuan, et al.
Imagine you're building a robot that needs to perform tasks in a complex environment, like picking up objects or navigating through obstacles. These tasks often require the robot to make decisions based on a sequence of actions over time, which can be tricky because it needs to remember what happened earlier to make the best choice now. This is where the challenge lies: relying only on what the robot sees at the moment can lead to poor decisions, especially if it forgets important past information. This issue is known as the lack of historical context utilization. Current methods often struggle with this because they don't effectively incorporate past experiences into their decision-making process. They might use a straightforward approach where the robot acts based solely on its current observations, which can lead to mistakes when the situation is complex or requires long-term planning. This is what's called open-loop test-time scaling, where the robot doesn't adapt its actions based on feedback from its environment. The E-TTS framework addresses these challenges by combining reasoning and action scaling in a way that allows the robot to learn from its past actions. It uses a history buffer to keep track of previous states and decisions, which helps the robot evaluate its options more effectively. By introducing a feedback loop into the decision-making process, E-TTS enables the robot to refine its actions iteratively, improving its adaptability and efficiency in real-time. Compared to previous methods, E-TTS not only enhances performance but does so without needing additional expert data or retraining. This means that for builders working on robotic systems, implementing E-TTS could lead to more capable robots that perform better in dynamic environments, making them more useful in practical applications.
Advancing Omnimodal Embodied Agents from Isolated Skills to Everyday Physical Autonomy
Junhao Shi, Zezheng Huai, Siyin Wang, et al.
Imagine you're trying to build a robot that can operate in unpredictable environments, like a home or a factory. You want it to not only perform tasks but also to adapt when things go wrong, like if it bumps into something or if a device it relies on stops working. Currently, many systems treat planning and execution as separate issues, which can lead to problems. For instance, if a robot's plan doesn't account for a sudden obstacle, it might just keep going without realizing it needs to change course. This is what's called open-loop execution, and it can lead to failures in real-world scenarios. What this paper proposes is a new way to handle these challenges by creating a system that combines different types of tools and processes. Instead of relying on a single model that tries to do everything, it uses a hierarchical approach that separates planning, memory, and verification. This means that when the robot is executing a task, it can also check if things are going as planned and adjust if necessary. The OmniAct framework includes a multimodal planner that helps the robot choose the right actions, a memory system that keeps track of what’s important without getting overloaded, and a mechanism that allows it to interrupt its current task if something unexpected happens. In practical terms, this means that OmniAct can handle a wide range of tasks more effectively than previous systems. It was tested on 40 real-world tasks with two different robotic platforms and showed consistent improvements in success rates, even as the complexity of the tasks increased. This is a big step forward for anyone looking to build autonomous systems that need to operate reliably in dynamic environments.
RSPC: A Benchmark for Modeling Stress and Psychiatric Conditions in Digitally Mediated Relationships using Psychiatrist Annotations
Parmitha Vangapandu, Sai Ganesh Mokkapati, Sathwik Narkedimilli, et al.
Imagine trying to understand mental health issues like anxiety and depression, but only looking at them in isolation, without considering the relationships that might influence them. This is a common approach, but it misses a lot of important context. For instance, someone might feel anxious not just because of their own thoughts, but also due to stress in their relationships. This is where the new research comes in. It uses Reddit posts about long-distance relationships to gather insights on mental health, focusing on how relational dynamics can trigger or exacerbate these conditions. They created a dataset called the Relational Stress and Psychiatry Corpus (RSPC), which includes 1,799 posts annotated by psychiatrists for various mental health categories and relational stressors. By benchmarking several transformer models on tasks like classifying disorders and detecting relational triggers, they found that different models have unique strengths. For example, Claude-3-Haiku performed best in classifying mood disorders, while GPT-4o excelled in detecting relational triggers. This work shifts the focus from viewing mental health as an individual issue to understanding it within the context of relationships, which could lead to more effective interventions and support systems.
Effective Covariance Dynamics in Solvable High-Dimensional GANs
Andrew Bond, Zafer Doğan
Imagine you're trying to train a model that generates images, like a GAN, but you're facing challenges because the data has complex relationships that aren't just simple patterns. Traditionally, people have looked at these models assuming that the underlying data structure is straightforward, which can lead to problems when the data is more intricate. For instance, if the model can't capture the correlations between different features in the data, it might struggle to generate realistic images or learn effectively. This is what's called the issue of latent covariance — when the hidden factors that influence the data are interrelated in ways that the model doesn't account for. What this paper does is tackle that problem head-on by introducing a new way to analyze GAN training that considers these complex relationships. Instead of just looking at simple, independent signals, it dives into how these correlations can actually help or hinder the learning process. The authors show that when the model understands the structure of the data better, it can improve its performance significantly. They provide a mathematical framework that explains how the training dynamics change when you account for these correlations, and they validate their findings with experiments on well-known datasets like MNIST and CIFAR-10. In practical terms, this means that if you're building a generative model, paying attention to the underlying data structure and using informed covariance can lead to better results. It opens up new avenues for improving GANs and could help in generating more realistic outputs in various applications.
The Geometry of Updates: Fisher Alignment at Vocabulary Scale
John Sweeney
Imagine you're working with large language models (LLMs) that need to handle different scientific data types, like chemical structures or genetic sequences. You want to select the best training sources for your model, but the challenge is that these sources might share the same vocabulary but have different prediction targets. This can lead to a situation where the usual metrics for evaluating model performance become unhelpful, especially when the models seem similar but actually perform differently on specific tasks. This is what's called the activation-dark regime, where you can't easily tell which model is better based on their representations alone. Currently, people might rely on complex metrics that are hard to compute at scale, or they might miss important differences between models because they focus too much on representation similarity. This can lead to poor source selection and ultimately affect the performance of the models in real-world applications. What this paper introduces is a more efficient way to assess how well different models can transfer knowledge from one task to another, using a method called FisherSketch. Instead of needing to compute a full Fisher matrix, which can be computationally expensive, FisherSketch estimates the necessary alignment directly in a single pass. This means you can quickly determine how well different models are aligned in terms of their updates, even when their representations look similar. The practical takeaway is that this method not only helps in selecting the right training sources but also provides insights into the underlying similarities and differences between tasks, which can be crucial for building effective LLMs in scientific domains.
LMs as Task-Specific Knowledge Bases: An Interpretability Analysis
Amit Elhelo, Amir Globerson, Mor Geva
Imagine you're building a system that relies on a language model to provide accurate information across various tasks, like answering customer queries or generating reports. You'd expect that if the model knows a fact, it should be able to retrieve it consistently, no matter the context. However, it turns out that language models often fail to do this. They might learn facts in a way that's specific to the task they were trained on, meaning that the same fact might not be accessible when asked in a different context. This inconsistency can lead to confusion and errors, especially if you're relying on the model for critical information. This issue is known as task-specific knowledge encoding, where the model's understanding is not universal but rather fragmented based on the tasks it has seen during training. The authors of this paper took a closer look at this problem and found that the way language models store and retrieve knowledge is more complex than previously thought. They conducted experiments that showed how different parts of the model's parameters are activated depending on the task at hand. This means that when you ask a model to reason through a problem, it might engage different parameters than when it's simply recalling a fact. This intertwining of knowledge and task context suggests that the analogy of a language model as a reliable knowledge base is misleading. In practical terms, this means that if you're building applications that depend on factual accuracy, you need to be aware that the model's responses may vary based on how you frame your questions. Understanding this can help you design better systems that account for these inconsistencies, ensuring that users get the most reliable information possible.
From Celebrities to Anyone: Characterizing AI Nudification Content, Technology, and Community Dynamics on 4chan
Chi Cui, Yixin Wu, Yang Zhang
Imagine you're trying to understand how technology can be misused to create harmful content, like non-consensual explicit images. Initially, most of this content targeted well-known public figures, but now it's increasingly affecting everyday people, often those within someone's social circle. This shift raises serious ethical concerns and highlights a gap in our understanding of how these technologies operate in the real world. The paper dives into this issue by analyzing over 24,000 instances of such content, revealing that a majority of targets are no longer celebrities but regular individuals. This change suggests that the technology is being used in ways that can cause real harm to people who are not in the public eye. The findings emphasize the urgent need for better regulations and protective measures to safeguard individuals from these emerging threats.
Bridging Talk and Thought: Understanding Dialogue Dynamics Across Collaborative Problem-Solving Contexts
Zhengyuan Liu, Stella Xin Yin, Min-Yen Kan, et al.
Imagine you're trying to build a system where humans and AI work together to solve problems, like planning a project or troubleshooting a technical issue. The challenge is that communication between humans and AI can be tricky; misunderstandings can lead to inefficiencies or even failure to solve the problem at hand. Current methods often fall short because they don't fully capture the nuances of these interactions, especially when it comes to how people think about their own thinking — a concept known as metacognition. This is what's called a limitation in existing analytical approaches. To address these issues, the authors propose a new framework that looks at dialogue in a structured way, breaking it down into two layers. The first layer focuses on cognitive aspects, like the actual problem-solving strategies used, while the second layer incorporates metacognitive elements, which help regulate and improve the collaboration process. This dual approach allows for a more comprehensive understanding of how humans and AI can effectively coordinate their knowledge and skills. What sets this work apart from previous studies is its emphasis on metacognitive regulation as a crucial factor for deeper collaboration. By applying this framework across nine different datasets, the authors demonstrate that it not only helps in analyzing dialogue but also enhances the overall effectiveness of human-AI partnerships. For anyone building systems that rely on collaboration between humans and intelligent agents, this framework offers valuable insights into optimizing those interactions.
CARVE: Content-Aware Recurrent with Value Efficiency for Chunk-Parallel Linear Attention
Sayak Dutta
Imagine you're building a system that needs to remember information over time, like a chatbot that recalls past conversations. Traditional recurrent models struggle with this because they often forget important details when they receive new information. They decide what to erase based only on the new input, which can lead to losing valuable context. This is known as memory-blind gating, and it can make the model less effective at understanding and responding accurately. When the model doesn't remember well, it can lead to poor performance in tasks that require reasoning or recalling past interactions. This is what's called the 'forgetting problem' in recurrent architectures. The paper introduces a new method called CARVE, which addresses these issues by changing how the model decides what to erase from memory. Instead of relying solely on the new input, CARVE uses the existing memory content as a guide for what to forget. This means the model can make more informed decisions about what information is actually important to keep or discard. By reusing the output from previous computations, CARVE not only improves memory efficiency but also simplifies the architecture, making it easier to train. In practical terms, CARVE outperforms previous models on several benchmarks, achieving better results with fewer resources. It shows a significant reduction in perplexity on WikiText and leads in common-sense reasoning tasks, all while being more efficient in terms of memory and parameters. This makes it a compelling choice for anyone looking to build systems that require effective memory management and reasoning capabilities.
Compositionality and the lexicon in evolutionary semantics
Fausto Carcassi
Imagine you're trying to understand how the meanings of sentences develop over time. Traditionally, researchers have either looked at fixed meanings or treated sentences as whole units without breaking them down into their parts. This can lead to confusion because it doesn't capture how meanings can change based on context or structure. For instance, if you only focus on the whole sentence, you might miss how individual words contribute to meaning, especially when it comes to complex ideas like quantifiers. This is what's called a lack of interpretability in semantic models. What this paper does is propose a new way to think about sentence meaning by allowing both the meanings of words and how they combine to evolve together. The authors introduce a framework that balances the need for simplicity in communication with the accuracy of meaning. By analyzing how these elements interact, they find that a well-known principle in semantics, called conservativity, naturally arises as a useful abstraction. This approach not only respects the structure of sentences but also helps clarify how we learn and understand quantifiers in language. In practical terms, this means that if you're building systems that rely on understanding language, like chatbots or translation tools, you could use this framework to create models that better reflect how people actually use language. It opens up new avenues for research and application in understanding linguistic universals and could lead to more effective language processing systems.
Ask, Don't Judge: Binary Questions for Interpretable LLM Evaluation and Self-Improvement
Sangwoo Cho, Kushal Chawla, Pengshan Cai, et al.
Imagine you're trying to assess how well a language model generates text. Traditionally, you might rely on human evaluators, which can be slow and costly, or use automated metrics that often don't align with human opinions. This leads to problems like poor feedback on what specifically went wrong in the generated text, making it hard to improve the model. This is what's called the evaluation bottleneck in NLP. The current methods often fail because they either oversimplify the evaluation process or produce scores that are hard to interpret. For instance, a single score might not tell you why a model's output was good or bad, leaving you in the dark about how to make improvements. This is where BINEVAL comes in. Instead of giving a single score, it breaks down the evaluation into smaller, binary questions that can be answered independently. This way, you get a clearer picture of the model's performance across different aspects. With BINEVAL, you can generate specific questions based on the task at hand, and the model answers these questions to provide detailed feedback. This not only makes the evaluation process more transparent but also allows for better diagnostics and iterative improvements in prompts. In practice, BINEVAL has shown to perform as well as or better than existing evaluation methods across various benchmarks, particularly excelling in areas like factual consistency. This means that if you're building systems that rely on LLMs, using BINEVAL can help you get more actionable insights and improve your models more effectively.
Hierarchical Muon: Tiled Newton-Schulz Updates for Efficient Muon Optimization
Ziyuan Tang, Tianshi Xu, Yousef Saad, et al.
Imagine you're training a large neural network, and you want to make the process faster and more efficient. Traditional methods for updating the model's weights can be quite heavy, requiring a lot of computational resources and time. This is especially true when you're dealing with large matrices, where every update can become a bottleneck. The challenge is that as the size of the matrices grows, the complexity of the calculations increases, leading to longer training times and higher resource consumption. This is what's called computational inefficiency. To tackle this, researchers have been looking for ways to optimize these updates without sacrificing the quality of the training. One common approach is to use methods that apply updates to the entire matrix at once, but this can lead to inefficiencies, especially with large models. The problem is that these full-matrix updates couple all the rows and columns, which can slow things down significantly. This is known as the full-matrix coupling issue. The paper introduces a clever solution called Hierarchical Muon (HiMuon). Instead of applying updates to the entire matrix, HiMuon breaks the momentum-gradient matrices into smaller tiles. By applying the update independently to each tile, it reduces the computational load significantly. This means that instead of dealing with a massive matrix all at once, you can work with smaller, more manageable pieces. The result is a decrease in the amount of work needed for updates, allowing for faster training times while still keeping the training behavior close to what you would get with the full-matrix approach. Practically, this means that if you're building systems that rely on large neural networks, using HiMuon could lead to more efficient training processes. You can expect to see improvements in how quickly your models learn without compromising their performance, making it a valuable tool for anyone working with complex neural architectures.
Vulnerability of Natural Language Classifiers to Evolutionary Generated Adversarial Text
Manjinder Singh, Alexander E. I. Brownlee, Mohamed Elawady
Imagine you're building a natural language processing system that needs to be robust against attacks. Adversarial inputs can trick your model by making tiny changes to the text that are hard for humans to notice but can completely confuse the model. Current methods to generate these adversarial examples often rely on specific knowledge of the model's structure, which can limit their effectiveness and adaptability. This is what's called model-specific vulnerability. When attackers know how a model works, they can exploit its weaknesses more easily, leading to significant drops in performance when faced with these adversarial inputs. What this paper introduces is a new way to create these adversarial examples without needing to understand the model's inner workings. The approach uses a genetic algorithm, which is a method inspired by natural selection, to explore potential word replacements that maintain the original meaning while still fooling the model. By using GloVe embeddings, the algorithm can find semantically similar words to replace, which helps in crafting more effective adversarial examples. In practice, GAversary has shown to drastically reduce the accuracy of target models on benchmark datasets, outperforming previous methods like BAE and A2T. However, it does come with a trade-off: it tends to change more words in the input and takes a bit longer to run. For anyone building NLP systems, this means you have a new tool that can help you understand and defend against adversarial attacks more effectively, even if it requires a bit more computational effort.
Paved with True Intents: Intent-Aware Training Improves LLM Safety Classification Across Training Regimes
Jeremias Ferrao, Niclas Müller-Hof, Iustin Sîrbu, et al.
Imagine you're building a system that needs to classify potentially harmful content, like user prompts that could lead to unsafe outputs. The challenge is that these prompts can be ambiguous, and existing classifiers often misinterpret user intent, leading to incorrect labels. This misalignment can result in either over-censorship or under-censorship, which is problematic for safety-critical applications. This issue is known as misalignment of intent, where the classifier fails to accurately capture what the user really means or wants. To address this, the authors propose a new approach that incorporates user intent as a key signal in the classification process. They introduce a dataset called AIMS, which contains 1,724 challenging safety prompts, each with a detailed intent description and harm label. By using this dataset, they explore various training methods, including supervised fine-tuning and reinforcement learning, to see how well classifiers can learn from this intent-aware data. The results are promising: by directly rewarding models for being faithful to user intent, they achieve better performance than traditional methods. This means that if you're building safety classifiers, using intent-aware training could lead to more accurate and reliable systems, ultimately improving user safety and trust.
Syntactic Belief Update as the Driver of Garden Path Processing Difficulty
Alan Zhou, Miloš Stanojević, John T. Hale
Imagine you're trying to understand how people read sentences that can lead them to the wrong interpretation, like 'The horse raced past the barn fell.' Initially, readers might think one thing, but then a word comes along that flips their understanding. This is a common challenge in language processing, especially with what's called garden path sentences. Traditionally, researchers have relied on a measure called lexical surprisal to predict how difficult a sentence will be to process. However, this method often falls short for garden path sentences, leading to inaccurate predictions about how long it takes someone to read them. This is what's called a failure of lexical surprisal. To address this, the authors propose a fresh perspective: instead of focusing solely on the words themselves, they suggest tracking a probability distribution over the possible syntactic structures of a sentence as it unfolds. This means that as each new word is read, the reader's understanding of the sentence's structure is updated. If the reader is misled by the initial part of the sentence, this update will be significant when they reach the critical word that changes everything. The authors measure how much this belief changes using a concept called generalized Rényi divergence, which looks at the differences in these syntactic beliefs. What this means for builders and researchers is that by shifting the focus from lexical items to syntactic structures, we can gain a better understanding of how people process complex sentences. This could open up new avenues for research in psycholinguistics and improve models that aim to mimic human language understanding.