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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Explaining Temporal Graph Neural Networks via Feature-induced Information Flow
Ping Xiong, Thomas Schnake, Klaus-Robert Müller, et al.
Imagine you're trying to understand how a complex system, like a social network or an epidemic model, makes decisions based on events over time. You might use a type of neural network called an event-based temporal graph neural network (ETGNN). These networks are powerful, but they can be really hard to interpret. Current methods for explaining their decisions often miss important connections because they only look at part of the information flow, specifically the event-related embeddings. This can lead to misunderstandings about how different events influence each other and the overall outcome. This is what's called a lack of comprehensive explanation. To address this, the authors propose a new method that looks at the entire flow of information through all the variables associated with events. This means it considers not just the direct effects of events, but also how they interact with each other over time. By using a framework called the Normalized Relevance Measure (NRM), they can quantify how much each part of the network contributes to the final decision. This method also allows for a deeper analysis of how events relate to one another, which is crucial for understanding long-term dependencies in the data. In practical terms, this new approach leads to explanations that are not only more accurate but also easier for humans to understand. When tested on synthetic datasets and real-world political event networks, it consistently outperformed existing methods. For anyone building systems that rely on ETGNNs, this means you can now get clearer insights into how your models are making decisions, which is essential for trust and accountability in applications like social network analysis or epidemic tracing.
Graph Neural Networks Applications Across Domains: All Insights You Need
Abderaouf Bahi
Imagine you're trying to build a system that understands complex relationships, like social networks or drug interactions. You could use traditional models, but they often struggle to capture the nuances of relational data. This is where graph neural networks come in, designed specifically to handle data that has a relational structure. However, not all problems benefit from this approach, and sometimes the added complexity doesn't pay off. For instance, when data is too noisy or when relationships are too weak, these models can underperform, which is known as over-smoothing or over-squashing. This paper takes a step back and organizes the field of graph neural networks around a clear framework. It connects the theoretical underpinnings of these models to practical applications, examining twelve different domains where they are used. By doing this, it identifies common pitfalls, like the challenges posed by temporal graphs or the limitations of certain architectures in real-world deployment. The authors also highlight that the best-performing models in research settings often don't translate to success in practical applications. What this means for builders is that understanding the specific costs and benefits of using graph structures is crucial. The insights from this survey can guide you in making better design choices, ensuring that you select the right architecture for your specific needs, rather than just following trends in the latest research.
Forecasting With LLMs: Improved Generalization Through Feature Steering
Humzah Merchant, Bradford Levy
Imagine you're trying to predict future events based on past data, like forecasting sales or weather. The challenge is that many models can get stuck in their own biases, often looking too far ahead and missing the patterns that actually matter from the past. This is called look-ahead bias, and it can lead to poor predictions when the future doesn't match the model's expectations. Current methods often struggle to balance between using historical data effectively and making accurate future predictions, which is a common failure mode in forecasting tasks. What this paper does is explore how large language models (LLMs) can be applied to forecasting by examining their internal workings. The authors found that by focusing on specific features that represent time-awareness, they could reduce the look-ahead bias significantly. They used sparse autoencoders to analyze how these models process information over time, revealing that some features are more beneficial for making grounded predictions than others. By amplifying the right features, they were able to steer the models toward better reasoning based on historical data. In practical terms, this means that if you're building a forecasting system, you can leverage these insights to enhance your model's performance. By understanding and manipulating the temporal features within LLMs, you can create a more reliable forecasting tool that doesn't just guess based on future trends but is firmly rooted in historical context.
A Process Harness for Uplifting Legacy Workflows to Agentic BPM: Design and Realization in CUGA FLO
Fabiana Fournier, Lior Limonad
Imagine you're managing a complex business process, like loan approvals, where you need to balance strict rules with the flexibility to adapt to unique cases. Traditionally, you might rely on a rigid workflow engine that executes tasks in a predetermined way, but this can lead to inefficiencies when unexpected situations arise. For instance, if a customer has a unique request that doesn't fit neatly into the established process, the system might struggle to handle it appropriately, leading to delays or errors. This is what's called a lack of adaptability in workflow management. To address these challenges, the authors propose a solution that adds a new layer around the existing workflow engine. This layer, called a process harness, introduces three types of agents that work together to enhance the system's capabilities. The TaskAgent focuses on executing knowledge-intensive tasks, the DecisionAgent helps route cases based on specific criteria, and the FlowAgent manages the overall flow of the process, allowing for adjustments as needed. By doing this, the process harness maintains the structural authority of the original workflow engine while enabling more intelligent decision-making at critical points. The practical impact of this approach is significant: it allows organizations to modernize their workflows without completely replacing their existing systems. By integrating this agentic layer, businesses can achieve a balance between compliance with established rules and the flexibility to adapt to new situations, ultimately leading to more efficient and responsive operations.
HarmVideoBench: Benchmarking Harmful Video Understanding in Large Multimodal Models
Jiajun Wu, Haoyu Kang, Yining Sun, et al.
Imagine you're trying to build a system that can automatically identify harmful videos online. The challenge is that harmful content isn't always obvious; it can be subtle and layered, making it hard for models to detect. Currently, many systems just classify videos as harmful or not, which misses the deeper context and nuances of what makes a video harmful. This is what's called binary classification failure — it oversimplifies a complex problem and can lead to misjudgments about content that might actually be harmful in a more nuanced way. To tackle this, the authors created HarmVideoBench, a new benchmark that goes beyond simple yes-or-no answers. Instead of just asking if a video is harmful, it evaluates models on three different levels: what can be seen in the video, the meaning behind the clips, and the reasoning that goes beyond just the clips themselves. This multi-layered approach helps capture the complexities of harmful content better than previous methods. They also introduced a method called BCR, which helps models understand the context of harmful videos more effectively. By dynamically retrieving relevant information only when needed, BCR significantly boosts the performance of models on this new benchmark, raising their accuracy from 61.7% to an impressive 84.4%. For anyone building systems for content moderation, this means you can now evaluate and improve your models in a way that truly reflects their understanding of harmful content, rather than relying on surface-level assessments.
Learning Action Priors for Cross-embodiment Robot Manipulation
Dong Jing, Tianqi Zhang, Jiaqi Liu, et al.
Imagine you're trying to build a system that can understand both visual and language inputs while also performing actions based on that understanding. The challenge is that existing models often struggle with learning how to move or act because they start from scratch, relying solely on the data they see during training. This can lead to issues where the model doesn't effectively learn the timing and coordination needed for actions, especially when it has to adapt to different physical embodiments — this is what's called a lack of motion prior. To address this, the authors propose a clever solution: instead of jumping straight into training the model to align visual and language features with actions, they first pretrain the action module using motion data alone. This two-stage approach allows the model to learn the necessary motion dynamics before it even starts to deal with the complexities of visual and language inputs. In the first stage, the action module learns from unconditioned action trajectories, which helps it understand how to move without any distractions from visual or language data. Then, in the second stage, this learned knowledge is transferred to the full Vision-Language-Action training, allowing for better alignment and refinement. The results are promising. By using this method, the model not only converges faster but also performs significantly better on tasks where data is limited. This means that for builders working on similar systems, adopting this two-stage training could lead to more efficient and effective models, especially in real-world applications where data scarcity is a concern.
RevengeBench: Reverse Engineering Code-Space Policies from Behavioral Experiments
Babak Rahmani, Sebastian Dziadzio, Joschka Strüber, et al.
Imagine you're trying to understand how a player makes decisions in a game, but all you have are their actions. Traditionally, researchers would guess the underlying decision-making process based on what they see, which can be tricky and often leads to incomplete or incorrect conclusions. This is known as the inverse problem — figuring out hidden mechanisms from observable behavior. The challenge is that without controlled experiments, it's hard to get clear insights into how decisions are made, leading to what we call limited interpretability of behavior. Now, what if you could design specific scenarios to probe deeper into those decisions? This paper introduces a clever approach where a learner observes a player's actions and then creates custom opponents to elicit more informative responses. By doing this, the learner can reconstruct the underlying decision-making program as executable code. This method, called RevengeBench, uses a set of 75 policies generated by large language models across various game environments, allowing for a more structured way to analyze and understand player behavior. The results are promising: the reconstructed policies not only provide insights into the decision-making process but also lead to measurable advantages in competitive play, particularly for weaker models that struggle to counter strong opponents. This advancement opens up new avenues for understanding how agents make decisions and could significantly enhance the interpretability of AI systems in complex environments.
On-Policy Self-Distillation with Sampled Demonstrations Reduces Output Diversity
Andrei Liviu Nicolicioiu, Mohammad Pezeshki, Aaron Courville
Imagine you're trying to build a model that learns from its own past performances, using its own outputs as a guide. This is a bit like a student learning from their own previous tests, but it can lead to problems. When a model uses its own past successes to teach itself, it might become overly confident in certain strategies, ignoring other potentially useful approaches. This is what happens in self-distillation, where the model acts as both teacher and student. The downside is that while it can achieve high accuracy, it often loses the ability to generate diverse solutions, especially when faced with new or unexpected challenges. This paper dives into that issue, showing that the model's feedback can amplify its existing biases, leading to a lack of variety in its responses. The authors provide a theoretical framework to understand this behavior and demonstrate it through experiments on specific tasks. The practical takeaway is that while self-distillation can be effective, it may not be the best choice when you need a model that can adapt to a wide range of situations.
Real-Time Voice AI Hears but Does Not Listen
Martijn Bartelds, Federico Bianchi, James Zou
Imagine you're building a customer support system that uses voice AI to handle calls. You want it to understand not just what people say, but how they say it — their tone, emotion, and urgency. Currently, many voice AI systems focus primarily on the words spoken, often missing important emotional cues. For instance, they might end a call with someone who is crying, thinking everything is fine, or approve a transaction when the caller sounds scared. This disconnect happens even though the systems can recognize these emotions when asked directly. This is what's called the emotional intelligence gap of voice AI. It means that while the systems can identify distress or sarcasm, they often ignore these signals when making decisions, leading to potentially harmful outcomes. The paper suggests that simply prompting these systems to pay attention to vocal delivery doesn't fully solve the problem, as improvements are inconsistent. This highlights a significant limitation in current voice AI technology, indicating that developers should be cautious about relying on these systems in sensitive situations where tone and emotion matter.
Neglected Free Lunch from Post-training: Progress Advantage for LLM Agents
Changdae Oh, Wendi Li, Seongheon Park, et al.
Imagine you're building an AI that needs to make decisions over a long period, like a robot navigating a complex environment. You want to evaluate how well it's doing at each step, but traditional methods for scoring its performance can be really tough to implement. They often require a lot of human input or complex calculations that just don't scale well, especially when the environment is unpredictable or when actions can't be undone. This is what's called the challenge of step-level evaluation in agentic settings. Currently, many people rely on reward models that need to be trained specifically for each task, which can be a huge bottleneck. These models can struggle with long-horizon tasks where the consequences of actions aren't immediately clear, leading to inaccurate assessments of performance. This is known as the problem of ineffective reward modeling. What this paper introduces is a clever way to sidestep those issues by using reinforcement learning (RL) post-training. Instead of needing a separate reward model, they derive a new metric called progress advantage, which uses the log-probability ratio between the RL-trained policy and a reference policy. This means you can get a reliable performance signal without needing to train a dedicated model for each task. The results show that this method works well across different applications, consistently outperforming traditional confidence-based approaches and dedicated reward models. In practical terms, this means that if you're working on AI systems that need to evaluate their performance in real-time, you can use this new method to get accurate assessments without the overhead of additional training. It simplifies the process and makes it more efficient, which is a big win for developers in the field.
Same Evidence, Different Answer: Auditing Order Sensitivity in Multimodal Large Language Models
Akshay Paruchuri, Sanmi Koyejo, Ehsan Adeli
Imagine you're building a system that combines text and images, like a chatbot that can also analyze photos. You want it to give consistent answers regardless of how you present the information. However, current benchmarks often assume that the order of inputs doesn't matter, which isn't true. When you shuffle the order of questions or images, the model's answers can change significantly, leading to unreliable results. This inconsistency is a problem because it means the model might not be as robust as you thought, especially in real-world applications where input order can vary widely. This issue is known as order-invariance failure. To tackle this, the authors developed a new auditing tool called Facet-Probe. It evaluates models based on five different aspects of input order, helping to identify how much the order affects the model's responses. They used a Bayesian item-response model to separate the noise from the actual performance of the models, which allows for a clearer understanding of where the models struggle. Their findings showed that all 18 models they tested had significant order-related inconsistencies, with some flipping answers up to 50% of the time depending on input order. This work is important because it highlights a major gap in how we evaluate multimodal models. By proposing a new standard for reporting order-related performance, it encourages future research to focus on making models more robust to input variations. For builders, this means that relying on traditional evaluation methods might lead to deploying models that perform poorly in real-world scenarios, and they should consider these new metrics when assessing model reliability.
A cross-process welding penetration status prediction algorithm based on unsupervised domain adaptation in laser and TIG welding
Sen Li, Haichao Cui, Chendong Shao, et al.
Imagine you're working on a system that classifies the state of weld penetration in different welding processes. You might train a model on one type of welding, like TIG, but when you try to use it for another type, like laser welding, it often fails because the physical mechanisms are so different. This is a common problem known as domain shift, where a model trained in one context doesn't perform well in another. It can lead to inaccurate classifications and wasted resources, which is frustrating for builders trying to implement reliable systems across various welding techniques. Currently, many people rely on supervised learning, where models are trained on labeled data from a specific process. However, this approach breaks down when you need to transfer knowledge to a different process. The model struggles to adapt because it hasn't learned the relevant features for the new context. This is what's called domain shift, and it can result in poor performance and high relabeling costs when trying to adapt to new processes. To address this, the authors propose a new approach that uses unsupervised domain adaptation (UDA) combined with a gradual source domain expansion (GSDE) strategy. The idea is to allow the model to learn from both the original and new domains without needing extensive labeled data for the new process. By gradually expanding the source domain, the model can better capture the differences and similarities between the welding processes, leading to improved accuracy. In practical terms, this method allows builders to deploy models that can effectively monitor and classify weld penetration across different welding systems without the need for extensive retraining or relabeling. The results show that the proposed method achieves over 80% accuracy in cross-process scenarios, which is a significant improvement over traditional supervised methods, making it a valuable tool for those working in welding applications.
Model Forensics: Investigating Whether Concerning Behavior Reflects Misalignment
Aditya Singh, Gerson Kroiz, Senthooran Rajamanoharan, et al.
Imagine you're working with AI models that sometimes act in ways that raise red flags. You might see a model making a decision that seems wrong, but figuring out if it's truly misaligned or just confused can be tricky. Right now, most approaches focus on spotting these concerning behaviors, but that doesn't tell you why they happen. Sometimes, a model might take a shortcut not out of malice, but simply because it’s trying to be efficient. This is where the idea of model forensics comes in — it’s about digging deeper to understand the reasons behind a model's actions. The authors propose a straightforward two-step protocol for this investigation. First, they analyze the model's reasoning process, known as the chain of thought, to generate hypotheses about its behavior. Then, they tweak the model's prompts or environment to test these ideas. This method is not just about finding faults; it’s about understanding the model's intentions. They tested their approach in various scenarios where models acted in concerning ways and found that it could effectively reveal whether those actions stemmed from genuine misalignment or benign causes. While the protocol shows promise, the authors also recognize that there’s room for improvement. For instance, they found it challenging to confirm certain beliefs of the model without additional controls. Overall, this work lays a solid foundation for future research in model forensics, helping builders better understand and align their AI systems.
When Certainty Is an Artifact: Keyword Lexicon Blindness and the (Mis)Measurement of Rhetorical Stance
Bo Chen
Imagine you're trying to understand how public figures express their emotions through language. Researchers often rely on keyword counting to gauge certainty or negativity in their speech. However, this method can be misleading. For instance, a phrase like 'never absolutely totally confident' might be counted as high certainty, even though it conveys the opposite. This is where the problem lies: keyword lexicons can misinterpret the actual meaning of what speakers are saying. This misinterpretation is due to several failure modes, such as syntactic blindness, where the structure of the sentence is ignored, and polysemy blindness, where words with multiple meanings are misclassified. These issues can lead to incorrect conclusions about a speaker's psychological state based on flawed measurements. To address this, the authors propose using a more sophisticated approach that leverages large language models (LLMs) for semantic classification instead of simple keyword counting. This method reveals a more accurate picture of the speakers' emotional states and rhetorical stances. The key takeaway is that relying on keyword counts can lead to significant errors in understanding discourse, and using LLMs can provide a clearer, more nuanced view of language use.
Deviance-style normalization for jointly overdispersed counts
Akshay Balsubramani
Imagine you're working with data from sequencing-based biochemical assays, where you often end up with count matrices that are sparse and overdispersed. This means that some counts are much higher than others, and traditional methods struggle to handle this variability effectively. When you try to analyze this data, you might find that existing models either oversimplify the problem or fail to capture the nuances of the data, leading to inaccurate results. This is what's called overdispersion failure, where the model can't account for the variability in the counts properly. The authors of this paper propose a new approach that treats each sample's count vector as a fixed composition, governed by a single concentration parameter. This method, known as Dirichlet-multinomial (DM) deviance residualization, allows for a more nuanced analysis of the data while preserving the sparsity of the count matrices. It evaluates in constant time for each nonzero entry, which means it can be integrated into existing workflows without significant overhead. What sets this method apart from previous work is its ability to handle both joint and feature-wise count nulls under a unified framework, making it versatile for various applications. Practically, this means that if you're building tools for analyzing biochemical data, you can expect more accurate and efficient results with this new method, especially when dealing with complex datasets that exhibit overdispersion.
A welding penetration prediction model for laser welding process based on self-supervised learning using physics-informed neural networks
Sen Li, Xiaoying Liu, Xiaojian Xu, et al.
Imagine you're in a factory where laser welding is crucial for creating strong, defect-free joints. The challenge is predicting how deep the laser penetrates the material, which directly affects the quality of the weld. Traditionally, this requires a lot of high-quality labeled images to train a model, but gathering such data can be time-consuming and expensive. When you don't have enough data, the models can fail to generalize well, leading to poor predictions — this is what's called overfitting. Additionally, if the conditions change even slightly, the model might not perform as expected, which is a common issue in industrial settings. To tackle these problems, the authors developed SimPhysNet, a new approach that uses a self-supervised learning method. Instead of relying solely on labeled images, it leverages a large amount of unlabeled data by embedding physical principles into the learning process. This helps the model understand the underlying physics of the welding process, allowing it to extract meaningful features from the data. Furthermore, it employs a few-shot learning strategy, which means it can effectively learn from just a small number of labeled examples. This is particularly useful in scenarios where obtaining labeled data is challenging. The results are promising: SimPhysNet achieves a classification accuracy of 96.06% with only 200 labeled images, which is comparable to traditional methods that use much larger datasets. This advancement not only improves the efficiency of training models for laser welding but also opens the door for smarter automation in manufacturing processes, reducing the reliance on extensive labeled data.
The Unfireable Safety Kernel: Execution-Time AI Alignment for AI Agents and Other Escapable AI Systems
Seth Dobrin, Łukasz Chmiel
Imagine you're building an AI that can modify itself and interact with various tools and APIs. The challenge is ensuring that this AI doesn't go rogue or act in ways that could be harmful. Currently, many systems try to control AI behavior by placing restrictions within the AI's own environment, like using prompts or filters. However, this approach can fail because if the AI can modify its own code, it can also find ways to bypass these controls. This is what's called escapable AI systems, where the AI has too much freedom to act outside intended boundaries. The paper introduces a new way to handle this problem by creating a safety mechanism that operates outside the AI's own control. This mechanism, called the Unfireable Safety Kernel, ensures that any actions taken by the AI are checked against strict rules before they happen. It uses a combination of formal verification methods to guarantee that the AI cannot escape its safety constraints, even when it tries to modify itself. In practical terms, this means that during testing, the kernel successfully blocked all attempts to bypass safety measures, demonstrating its effectiveness in keeping the AI aligned with its intended purpose. Compared to previous methods, this approach provides a more robust framework for controlling AI behavior, especially in systems that are designed to learn and adapt over time. For builders, this means you can deploy self-improving AI systems with greater confidence that they will operate safely and as intended.
When Does Synthetic Data Augmentation Improve Score-Based Imbalanced Classification?
Zhengchi Ma, Pengfei Lyu, Anru R. Zhang
Imagine you're trying to build a model that can accurately classify rare events, like fraud detection or disease diagnosis. Often, the data you have is imbalanced, meaning you have many examples of one class (like legitimate transactions) and very few of another (like fraudulent ones). To tackle this, people often create synthetic examples of the minority class to balance things out. However, the real question is: does this actually help improve the model's performance in a meaningful way? Currently, many practitioners use synthetic data augmentation to address class imbalance, but they often run into issues. For instance, while adding synthetic examples can help the model learn better, it can also introduce biases if the synthetic data doesn't accurately reflect the true distribution of the minority class. This is what's called distributional error. Moreover, in well-specified models, the raw estimator already does a good job of ranking the classes, meaning that augmentation might not provide any real improvement — it could just reduce variance without addressing the underlying issues. This paper takes a closer look at these challenges and proposes a framework to understand when synthetic data augmentation can actually help. It breaks down the effects of augmentation into two parts: how it changes the effective class weighting and how it might differ from the true distribution of the minority class. The authors find that while augmentation can help in cases where the model is misspecified, it doesn't fundamentally improve performance in well-specified scenarios. They also provide bounds on how much improvement can be expected, depending on various types of errors. This means that for builders, understanding when and how to use synthetic data augmentation is crucial — it can help, but only under the right conditions.
Natural Ungrokking: Asymmetric Control of Which Rules Survive Pretraining
Juliana Li, Diya Sreedhar
Imagine you're training a language model to understand pronouns based on names. Initially, it learns that if it sees a girl's name, it should use 'she' for the next pronoun. However, as training continues, it can completely forget this rule, even though the training data still contains examples that support it. This forgetting happens because the model is influenced by how often it sees evidence for the rule during training. If it encounters competing patterns more frequently, it will prioritize those instead. This phenomenon is called natural ungrokking, where the model's ability to retain learned rules is dictated by the training data's statistics rather than its performance metrics. Once a rule is lost, attempts to reintroduce support for it don't help; the model simply won't recover the lost knowledge. This insight is crucial for anyone building language models, as it suggests that the training process can lead to unpredictable learning dynamics that aren't reflected in traditional loss metrics.
How Robust is OCR-Reasoning? Evaluating OCR-Reasoning Robustness of Vision-Language Models under Visual Perturbations
Yuxing Cheng, Yuan Wu, Yi Chang
Imagine you're building a system that relies on reading text from images, like receipts or documents. You want it to be accurate, but what happens when the images are blurry or distorted? In real life, visual corruption can lead to errors in reading text, which can mess up the entire reasoning process. This is a significant issue because if your model can't handle these imperfections, it might give wrong answers based on faulty data. This problem is known as robustness under visual degradation, and it's a critical area for improving OCR systems. Currently, many models are evaluated based on their performance on clean images, but this doesn't tell the whole story. When faced with real-world conditions, these models often struggle. For instance, they might perform well on clear documents but fail miserably when dealing with charts or handwritten notes that are slightly distorted. This is what's called a lack of robustness, and it can lead to significant errors in applications that rely on accurate text recognition. To address this, the authors created a new benchmark called OCR-Robust, which systematically evaluates how well models can handle visual perturbations. They tested 18 different models across various types of text inputs, from documents to charts, under different levels of visual degradation. The findings reveal that just because a model has high accuracy on clean data doesn't mean it will be reliable in the real world. In fact, some models showed a dramatic drop in performance when faced with challenging inputs like charts and tables. This insight is crucial for anyone building OCR systems, as it emphasizes the need to consider robustness in addition to accuracy when developing and deploying these models.
AI translation of literary texts is "fine", but readers still prefer human translations
Yves Ferstler, Adam Podoxin, Ty Brassington, et al.
Imagine you're a reader diving into a novel translated from another language. You want the experience to be immersive and engaging, but how do you know if a machine translation captures the essence of the original text? Currently, most evaluations focus on whether the translation is fluent or adequate, but they miss the emotional and literary impact that makes reading enjoyable. This is where things can go wrong: machine translations might seem fine on the surface, but they often lack the depth and clarity that human translators provide. This mismatch is what's called a failure of literary effect in machine translation. This paper takes a fresh approach by asking avid readers to compare human translations to those generated by a large language model. They evaluated excerpts from recent novels in different languages, focusing on how immersive and clear each translation felt. The results showed that while machine translations were generally acceptable, readers preferred human translations for their ease and immersive quality. Interestingly, readers often struggled to tell the two apart, indicating that machine translations can sometimes be quite good, but they still fall short in capturing the full literary experience. What’s new here is the introduction of a reader-centered evaluation dataset, which includes thousands of reader comments and judgments. This approach shifts the focus from traditional metrics to actual reader experiences, providing a more nuanced understanding of translation quality. For anyone building translation systems, this means that relying solely on automatic metrics might not be enough; understanding how readers perceive translations is crucial for improving the quality of machine-generated texts.
FedReLa: Imbalanced Federated Learning via Re-Labeling
Guangzheng Hu, Patricia Menéndez, Feng Liu, et al.
Imagine you're trying to train a machine learning model using data from many different users, but each user has a different amount of data and different types of data. This is a common scenario in federated learning, where privacy is key, but it leads to problems. When some classes of data are underrepresented, the model struggles to learn effectively, especially if the data is very unevenly distributed across users. This situation can cause the model to perform poorly, particularly on minority classes, which is what's called class imbalance and data heterogeneity. To tackle these issues, the authors propose a method called FedReLa. Instead of needing to know the overall distribution of classes, FedReLa uses a feature-dependent approach to re-label samples. This means it can adjust the labels based on the features of the data, helping to correct the model's decision boundaries. The beauty of this method is that it can be integrated with existing algorithms without adding extra communication costs, which is crucial in federated learning scenarios. In practical terms, this means that if you're building a system that relies on federated learning, you can expect better performance on minority classes and overall accuracy when using FedReLa. It significantly outperforms previous methods, making it a valuable tool for developers working with decentralized data.
Detect, Unlearn, Restore: Defending Text Summarization Models Against Data Poisoning
Poojitha Thota, Shirin Nilizadeh
Imagine you're building a large language model that summarizes text for users. You want it to provide accurate and unbiased summaries, but what if someone maliciously alters the training data during fine-tuning? This could lead to the model producing biased or harmful summaries, even if it seems to perform well on standard tests. This is a real risk, especially when fine-tuning on small, task-specific datasets where a few bad examples can have a big impact. This issue is known as training-time data poisoning, and it can be hard to detect because the model might still meet evaluation metrics while behaving poorly in practice. To address this, the authors propose a new approach that helps identify and fix these poisoning issues after the model has been trained. They found that poisoned data can leave behind noticeable patterns that can be detected, even when you don't have access to the original training data. Their method uses influence-function analysis and checks for semantic consistency to spot these problems. They also introduce new types of attacks that can distort facts and introduce biases without raising alarms in traditional evaluation methods. In their experiments, they show that their detection methods can achieve 85-92% precision across various models and datasets. Additionally, they found that they could restore much of the model's original performance after identifying and addressing the poisoning, with minimal loss in utility. This means that even if a model is compromised during fine-tuning, there are effective ways to recover it without needing to retrain from scratch, which is a significant improvement over previous methods.
TriViewBench: Controlled Complexity Scaling for Multi-View Structural Reasoning in MLLMs
Yu-Yang Chen, Lan-Zhe Guo
Imagine you're building a system that needs to answer questions about images, like identifying objects or understanding scenes. Current models can handle this to some extent, but they struggle when the tasks get more complex, especially when it comes to counting objects or understanding the overall scene. This is because they often miss important details or get confused by overlapping objects. For instance, they might undercount items that are partially hidden or overcount when multiple views create confusion about what’s what. This is known as occlusion blindness and cross-view identity confusion, respectively. To tackle these issues, the authors created TriViewBench, a new benchmark that tests how well these models can reason about visual information in a controlled way. They constructed a set of synthetic 3D scenes with varying complexity and asked models to answer questions about them. What they found was that all the models they tested performed similarly, with a clear hierarchy in their capabilities: they were much better at simple tasks than at more complex ones. For example, when asked to count objects, the models showed a significant drop in accuracy as the task complexity increased, with some tasks leading to an 80% drop in performance. This work is important because it not only highlights the limitations of current multimodal models but also provides a structured way to analyze where they fail. By using TriViewBench, builders can better understand the specific weaknesses in their models and work on improving them, especially in areas where reasoning about complex visual information is required.
Can Trustless Agents Be Trusted? An Empirical Study of the ERC-8004 Decentralized AI Agent Ecosystem
Xihan Xiong, Zelin Li, Wei Wei, et al.
Imagine you're building a system where AI agents need to interact and transact with each other across different organizations. The challenge is figuring out if these agents can trust one another, especially when they don't know each other. Currently, many systems rely on reputation scores or identity verifications, but these can easily be manipulated or may not reflect true activity. For instance, you might find that a lot of agents are just placeholders, not actually doing anything useful, which is a problem when you need to make decisions based on their trustworthiness. This situation is what's called a trust crisis in AI interactions. The ERC-8004 protocol was created to tackle this issue by establishing a permissionless trust layer that uses on-chain registries for Identity, Reputation, and Validation. However, this paper dives into the real-world application of this protocol and uncovers some serious flaws. They found that a significant number of registrations are just empty shells, and the reputation system is easily gamed. For example, in their study, they discovered that a large portion of reviewers were engaging in coordinated behavior to inflate reputations, which undermines the whole idea of trust. What this means for builders is that while ERC-8004 was designed to improve trust among AI agents, the empirical evidence suggests it needs significant revisions. The findings provide a clear baseline for future improvements, emphasizing the need for more robust mechanisms to ensure that reputation and identity truly reflect active and trustworthy agents. If you're working on AI systems that rely on trust, these insights are crucial for designing better protocols.
Why Multi-Step Tool-Use Reinforcement Learning Collapses and How Supervisory Signals Fix It
Yupu Hao, Zhuoran Jin, Huanxuan Liao, et al.
Imagine you're trying to build a system that can use tools to perform complex tasks, like scheduling meetings or fetching information. You might think that just training a model with reinforcement learning (RL) would be enough, but it often leads to problems. Sometimes, the model's performance can suddenly drop, a situation known as catastrophic collapse, where it fails to use tools correctly. This happens because the model gets confused by unexpected spikes in certain control signals, which disrupt its ability to execute tasks properly. The underlying capability to use tools is still there, but it gets hidden by the way the model is trained or the formats it encounters. To tackle these issues, the authors explore various supervisory signals, like off-policy supervision and hint-based guidance, applied in different training setups. They find that mixing supervised fine-tuning with RL helps stabilize the model's performance, making it more reliable in using tools. However, they also discover that when the model faces data that is different from what it was trained on, its performance can suffer. This research emphasizes the need to understand the failures of RL in tool use and shows how diverse training signals can help guide the learning process, ultimately leading to more robust models for complex tasks.
Privacy Vulnerabilities of Attention Layers in Tabular Foundation Models and Protection of High-Risk Queries
Tânia Carvalho, Maxime Cordy
Imagine you're using a model trained on synthetic data to make predictions based on user inputs. You might think this is safe since the data isn't real, but it turns out that when you provide context examples during inference, the model can inadvertently reveal whether specific records were part of its training data. This is a serious privacy issue because it allows attackers to determine if they have a 'membership' in the training set, which is what's called a Membership Inference Attack (MIA). Current defenses often rely on adding noise or retraining the model, which can degrade performance. However, this paper introduces a new attack method called AMIA that exploits the attention patterns of transformer models to reveal membership signals more effectively than traditional confidence-based methods. The authors also propose a defense inspired by $k$-anonymity principles that reduces the risk of leakage without sacrificing much predictive accuracy. In practice, this means that if you're building applications that rely on tabular models, you need to be aware of these vulnerabilities and consider implementing the proposed defense to protect sensitive information.
The Tatoxa System for Text Detoxification in Low-Resource Languages: The Case of Tatar
Ilseyar Alimova, Bogdan Monogov, Artyom Mazur, et al.
Imagine you're trying to create a safe online space where users can communicate without encountering abusive language. This is a big challenge, especially for languages that don't have a lot of resources or research behind them, like Tatar. Currently, many systems that detect harmful content are built for widely spoken languages, leaving smaller languages underserved. This can lead to situations where harmful content slips through the cracks, which is what's called a lack of support for low resource languages. Tatoxa steps in as a solution to this problem. It’s designed specifically for the Tatar language and aims to automatically identify and reduce abusive content. The system has been tested against both open-source and commercial models, and it shows better performance on key quality metrics. This means that it can more effectively keep online communities safe for Tatar speakers. Additionally, the authors have created a new dataset tailored for text detoxification in Tatar, which is essential for training and evaluating models in low resource settings. They found that using data from other languages, even closely related ones like Russian, doesn't work as well as training on native Tatar data. This insight is important because it highlights the need for dedicated resources for low resource languages, ensuring that they can be effectively supported in online environments.
Is Variational Monte Carlo Robust? Sharp Moment Thresholds and Heavy-tailed Stochastic Optimization
Philipp Grohs, Davide Nobile
Imagine you're trying to find the most stable state of a complex quantum system, like a molecule with many electrons. You could use a method called Variational Monte Carlo (VMC), which estimates the energy of different states to find the lowest one. However, this method can struggle when the underlying wave function has complicated nodal structures, leading to unreliable energy estimates. This is known as the problem of heavy-tailed estimators, where the estimates can be very erratic and not converge well. To tackle this, the authors propose a new approach called PS-Clip-VMC. Instead of using the raw estimates directly, this method clips the values of the local energy and gradient, which helps stabilize the optimization process. By doing this, they show that the new method can converge more reliably, even in cases where traditional VMC would fail. In practical terms, this means that when training neural networks like FermiNet on systems with many electrons, PS-Clip-VMC can provide more consistent and robust results compared to standard methods.
FORCE: Efficient VLA Reinforcement Fine-Tuning via Value-Calibrated Warm-up and Self-Distillation
Shuyi Zhang, Yunfan Lou, Hongyang Cheng, et al.
Imagine you're trying to build a robot that can understand both visual and language inputs and act on them. The challenge is that these models often hit a ceiling in performance because they rely on imitation learning from sub-optimal data. When you try to improve them using Reinforcement Learning (RL), it can be really inefficient — you might end up wasting a lot of time and resources because the model struggles to learn effectively from its experiences. This is especially true when the model's initial learning phase is unstable, leading to what’s called catastrophic unlearning, and when it doesn't explore enough to find good actions, which forces you to step in and guide it manually. This is what's known as sample inefficiency in RL. To tackle these issues, the authors propose a new approach called FORCE. The idea is to stabilize the learning process through a three-stage framework. First, it starts with a warm-up phase that helps the model adjust its learning based on high-quality data, which reduces the risk of the Q-function going off track. Then, during the main learning phase, this adjusted Q-function filters out low-value actions, ensuring that only the best options are considered for updates. This way, the model learns more effectively and efficiently. In practical terms, FORCE has shown to significantly boost the success rates of these models by 79% and speed up training by over 30%. This means that if you're building autonomous robots, you can expect them to perform better and learn faster without needing constant human oversight.
Dziri Voicebot: An End-to-End Low-Resource Speech-to-Speech Conversational System for Algerian Dialect
Dihia Lanasri, Fairouz Taki, Asma Kemmoum
Imagine trying to build a conversational system that can understand and respond in a specific dialect, like Algerian Dialect. This dialect poses unique challenges: there’s no standardized way to write it, people often switch between Arabic and French, and there aren’t many resources available to train models. As a result, existing speech technologies tend to overlook these dialects, making them less useful for speakers who rely on them. Currently, most speech systems are designed for high-resource languages, which means they often fail when faced with dialects that lack sufficient training data. This leads to poor recognition accuracy, misunderstandings, and ultimately, a frustrating user experience. This is what's called a resource bias problem, where the technology doesn't adapt well to the needs of diverse language speakers. To tackle these issues, the authors developed a modular conversational system specifically for Algerian Dialect. They created dedicated datasets for automatic speech recognition (ASR), natural language understanding (NLU), and text-to-speech (TTS) in the telecom domain. By fine-tuning existing models and integrating them into a single architecture, they aimed to improve the overall interaction quality. The ASR system uses a Whisper-based adaptation, while the NLU combines transformer embeddings with a dialogue framework, and a neural TTS system generates spoken responses from a newly collected dialectal corpus. The results show that this system performs well across all components, achieving low word error rates for ASR and high scores for intent classification and entity recognition in NLU. This work not only extends previous efforts in dialectal conversational systems but also provides a solid foundation for future developments in speech technologies for low-resource languages.
Hierarchical Reinforcement Learning for Neural Network Compression (HiReLC): Pruning and Quantization
Kamar Hibatallah Baghdadi, Kawther Guoual Belhamidi, Sara Belhadj, et al.
Imagine you're trying to make deep neural networks smaller and faster without losing too much accuracy. This is a common challenge because as you reduce the size of a model, you often end up sacrificing performance. Current methods can struggle with this balance, leading to either excessive accuracy loss or inefficient compression strategies. This is what's called the trade-off problem in model compression. What this paper introduces is a new way to tackle that trade-off. Instead of just compressing a model in one go, it breaks the process into two levels: low-level agents focus on specific parts of the model, like individual layers or blocks, while high-level agents manage the overall strategy. This means that each part of the model can be optimized independently, which helps in making smarter decisions about how to compress without losing too much accuracy. The key result is that this approach can achieve compression ratios of nearly 6 times while only experiencing minor accuracy drops in most cases. This is a significant improvement over traditional methods, making it a valuable tool for anyone looking to deploy efficient deep learning models in real-world applications.
Variable Bound Tightening for Nash Equilibrium Computation in Multiplayer Imperfect-Information Games
Sam Ganzfried
Imagine you're trying to figure out the best strategies for players in a game where they don't have complete information about each other's moves. This is a tough problem, especially when there are multiple players involved, like in poker. Traditionally, methods like counterfactual regret minimization work well for two-player games but struggle with more players, often failing to find the best strategies in a reasonable time. This is what's called convergence failure — the algorithms just can't guarantee that they will find the Nash equilibrium, which is the point where no player can benefit from changing their strategy if others keep theirs the same. The new approach in this paper tackles these issues by introducing a way to compute the Nash equilibrium more effectively in multiplayer games. It does this by solving a complex mathematical problem that reformulates the game in a way that makes it easier to find solutions. By deriving finite bounds on certain variables, the method strengthens the approximations used in the calculations, leading to faster and more reliable results. In practical terms, this means that the algorithm can solve challenging scenarios, like three-player Kuhn poker, much more efficiently than previous methods, although it still has limitations with the full game. Overall, this work represents a meaningful step forward in the field of game theory and algorithm design, providing builders with a more robust tool for tackling complex strategic interactions.
Autodata: An agentic data scientist to create high quality synthetic data
Ilia Kulikov, Chenxi Whitehouse, Tianhao Wu, et al.
Imagine you're trying to build AI models that can learn from the best possible data. Traditionally, creating high-quality training datasets is a manual and often flawed process. You might end up with data that doesn't represent the real-world scenarios your model will face, leading to poor performance. This is what's called data quality issues, and it can happen when the data is either too synthetic or not diverse enough to cover all use cases. Now, what if you had an AI agent that could act like a data scientist? Instead of relying on humans to curate datasets, this agent could learn to generate high-quality training and evaluation data on its own. This is where the paper's approach comes in. They introduce a method called Agentic Self-Instruct, which trains an AI to create better data by learning from its own performance. The idea is that by optimizing the agent's ability to generate data, you can significantly improve the quality of the datasets it produces. In practical terms, this means that when you deploy AI models, you can expect them to perform better because they are trained on data that is more representative of the tasks they will encounter. The experiments conducted show that this method outperforms traditional synthetic dataset creation techniques, making it a valuable tool for anyone looking to enhance their AI training processes.
SpeechEQ: Benchmarking Emotional Intelligence Quotient in Socially Aware Voice Conversational Models
Liang-Yuan Wu, Zih-Ching Chen, Tongshuang Wu, et al.
Imagine you're building a conversational AI that can chat with people just like a human would. A big part of that is understanding not just the words being said, but also the emotions and social cues behind them. This is where things get tricky. Current systems often evaluate emotional intelligence by looking at text alone or just the sound of speech, missing the bigger picture of how these elements work together in real conversations. This leads to problems like misunderstanding the emotional tone of a dialogue or failing to respond appropriately in a multi-turn exchange. These issues are known as 'modality shortcuts' and 'contextual amnesia.' To tackle these challenges, the authors introduce a new framework called SpeechEQ. This framework is designed to evaluate how well speech-language models understand and respond to emotional cues in conversations. It includes a dataset of over 2,200 dialogues that cover various emotional aspects, allowing for a more comprehensive assessment of AI's emotional intelligence. The findings reveal that while some models perform better than others, they still struggle with the nuances of human emotion, often defaulting to text-based interpretations. This means that if you're building a conversational AI, you need to be aware that current models might not fully grasp the emotional context, which can lead to misunderstandings in dialogue. In practical terms, this framework provides a new benchmark for evaluating emotional intelligence in AI, helping developers identify where their systems might fall short and guiding improvements in future models.
Taxonomy-aware deep learning for hierarchical marine species classification in underwater imagery
Dan Zimmerman, Dimitris A. Pados, George Sklivanitis
Imagine you're trying to identify different species of fish from underwater images. This is crucial for monitoring ocean health, but it’s tough because many species look alike, and the way we collect images can vary a lot. Current methods often fail when the conditions change or when the species are very similar, leading to misidentifications. This is known as domain shift and fine-grained visual similarity issues. To tackle these problems, the authors developed a new framework that takes into account the hierarchical structure of biological classification. Instead of treating all species equally, it uses a special loss function that weighs the importance of different taxonomic ranks and employs a smart inference method that minimizes risk based on this structure. This means that the model learns to classify species not just as individual entities but as part of a larger family tree, which helps it generalize better across different conditions. In practice, this new approach was tested on a dataset with 79 marine classes and showed a mean taxonomic distance very close to the top-performing solution. This indicates that it can effectively handle the challenges of species classification in real-world scenarios, making it a valuable tool for anyone involved in marine conservation and biodiversity monitoring.
Weave of Formal Thought
Alexandre Bouayad
Imagine you're building a tool that generates code automatically. You want it to not only sound fluent but also be syntactically correct, meaning it should follow the rules of the programming language. Currently, many models can produce code that looks good on the surface, but they often fail to ensure that the code is valid, leading to errors when you try to run it. This is a significant issue because if the generated code isn't valid, it can waste time and resources during development. This problem is known as syntactic validity failure, where the model outputs code that looks right but doesn't actually work due to structural issues. Existing methods try to enforce rules, but they often miss out on important details, like how to handle different contexts in the code, which is where they fall short. This paper introduces a new method called Weave of Formal Thought (WoFT) that combines rigorous checks for syntactic correctness with a learning approach that helps the model understand the structure of the code better. It uses a formal engine to validate the code while also training the model to incorporate grammar symbols directly into its output. The result is a model that not only generates code that is more likely to be correct but also learns to retain important structural information that other methods might overlook. Practically, this means that developers can rely on the generated code to be more accurate, reducing the time spent debugging and improving overall productivity.
The Inference-Compute Frontier and a Latency-Efficient Architecture for Limit Order Book Prediction
C. Evans Hedges
Imagine you're trying to predict stock market orders based on historical data. You might use various models, from simple decision trees to complex neural networks, but the challenge is figuring out how much computational power you need to minimize prediction errors. Traditionally, people have struggled to find the right balance between the complexity of their models and the accuracy of their predictions, leading to inefficiencies and missed opportunities. This is what's called the inference-compute frontier, and it can be tricky to navigate because not all models scale the same way with increased compute power. In this paper, the authors explore this frontier specifically for limit order book predictions, which are crucial for trading strategies. They discover that the relationship between predictive loss and the amount of compute used can be described by a power law, meaning that as you increase compute, you can expect diminishing returns on prediction accuracy. This insight helps clarify how to allocate resources effectively when building predictive models. However, they also find that when it comes to latency — the time it takes to make predictions — the relationship isn't as straightforward, indicating that simply throwing more compute at the problem won't always yield better results. To address these challenges, they introduce FastBiNLOB, a new model designed to mix features and temporal data in a way that's efficient for hardware. In tests, FastBiNLOB not only meets but exceeds existing benchmarks for prediction accuracy while operating at lower latency. This means that for builders in finance looking to optimize their trading algorithms, FastBiNLOB offers a compelling option that balances speed and accuracy better than previous state-of-the-art models.
InvestPhilBench: A Multi-Layer Dynamic Benchmark for Evaluating Large Language Model Procedural Reasoning in Expert Investment Philosophy
Mingguang Chen, Bo Qu
Imagine you're trying to build a system that helps investors make decisions based on complex frameworks. Currently, many systems use large language models to assist with this, but they often fail to accurately replicate the nuanced decision-making processes that expert investors use. This can lead to poor investment choices because the models might sound convincing but lack the depth of understanding needed for real-world applications. This is what's called procedural deficit — the models can generate fluent text but don't always follow the right reasoning steps to arrive at sound conclusions. To address this, the authors created InvestPhilBench, a benchmark that evaluates how well these models can reconstruct and apply expert investment frameworks. They developed a scoring system that includes various metrics to assess model performance, focusing on both fluency and procedural accuracy. The benchmark includes a wide range of investment principles and decision frameworks, allowing for a thorough evaluation of the models' capabilities. The results show that while the models achieve high scores in generating text, they still fall short in accurately following the procedural steps that expert investors would take. This means that for anyone building investment tools using language models, it's crucial to recognize that high fluency doesn't guarantee sound decision-making. The findings suggest that future work should focus on improving the procedural reasoning of these models to better support investment decisions.
Multi-Agent Goal Recognition with Team- and Goal-Conditioned Reinforcement Learning and Factorized Branch-and-Bound
Thiago Thomas, Gabriel de Oliveira Ramos, Felipe Meneguzzi
Imagine you're trying to figure out what a group of robots is trying to accomplish just by watching their movements. This can get really complicated, especially as the number of robots and possible goals increases. Traditional methods might look at every possible combination of robots and goals, which can take forever and is often impractical. This is what's called combinatorial explosion — the number of possibilities grows too fast to handle effectively. When you're in a real-world scenario, like monitoring drones or coordinating robots, you need a way to make sense of their actions quickly and accurately without getting bogged down in too many options. What this paper introduces is a clever way to narrow down the possibilities using a shared scoring model that considers both the teams of agents and their goals. Instead of checking every single combination, it uses a smart search strategy that cuts down the number of hypotheses it needs to evaluate. This means it can still find the best guess about what the agents are doing, but it does so much faster and with less computational effort. In practical terms, this is a big deal for anyone working with multi-agent systems. It allows for real-time decision-making in complex environments without sacrificing accuracy. The method not only matches the results of exhaustive searches but does so while saving a lot of time and resources, making it a valuable tool for builders in fields like robotics and surveillance.
Tensorion: A Tensor-Aware Generalization of the Muon Optimizer
Vladimir Bogachev, Vladimir Aletov, Alexander Molozhavenko, et al.
Imagine you're training a complex machine learning model, like one that processes images or videos. You want it to learn quickly and accurately, but traditional optimizers like Adam treat all the model's parameters as if they were just a long list. This can lead to inefficiencies, especially when the model has a more intricate structure, like tensors, which are multi-dimensional arrays. When the optimizer doesn't account for this structure, it can struggle with convergence, meaning it takes longer to find the best solution or gets stuck in suboptimal states. This is what's called inefficient optimization dynamics. To address these issues, Tensorion was developed. It’s an optimizer that recognizes the multi-dimensional nature of tensors and uses this understanding to improve the training process. By focusing on the tensor structure, Tensorion can optimize more effectively, leading to faster convergence and more stable updates. It does this by employing a linear minimization oracle that operates within a carefully defined tensor norm ball, ensuring that the optimization process remains tractable while still being effective. Compared to existing methods, Tensorion shows promising results, particularly in tasks that involve tensor-based data, like computer vision. It not only matches the performance of previous optimizers but also offers improvements in how quickly and reliably models can be trained. For builders, this means that if you're working with complex models that utilize tensor structures, Tensorion could be a significant upgrade over traditional optimizers, helping you achieve better results in less time.
Helpful or Harmful? Evaluating LLM-Assisted Vulnerability Patching via a Human Study
Giulian Biolo, Michael Tezza, Yuanjun Gong, et al.
Imagine you're a developer trying to fix security vulnerabilities in your software. It's a tough job that requires a lot of expertise, and often, developers might miss critical issues. Currently, many rely on manual debugging, which can be slow and prone to human error. This is where things can go wrong: developers might overlook subtle bugs or create patches that seem to work but don't actually secure the code. This is what's called superficial repairs, where the fix looks good on the surface but fails to address deeper security concerns. Now, with the rise of Large Language Models (LLMs), there's a new tool that could help. The idea is that these models can assist developers by quickly identifying and suggesting fixes for vulnerabilities. However, there's a catch: while LLMs can speed up the process, they might also introduce errors, like hallucinations or insecure code, if not carefully monitored. This paper investigates this balance by conducting a controlled experiment comparing LLM-assisted patching to traditional manual debugging. The researchers set up a web application to test this out, using hidden tests to ensure that the patches not only worked functionally but also met security standards. They found that while LLMs could help developers patch vulnerabilities faster, there was a significant risk of generating insecure code if the patches weren't thoroughly validated. This means that for anyone building software, relying solely on LLMs for security fixes could lead to serious vulnerabilities if proper checks aren't in place.
Improving Neural Network Training by Decoupling the Magnitude and Direction of Weight Vectors
Alexander Hägele, Alejandro Hernández-Cano, Atli Kosson, et al.
Imagine you're training a neural network, and you want it to learn effectively without running into issues that slow down or destabilize the process. Typically, optimizers like Adam and Muon treat the entire weight matrix as a single entity, which can lead to problems. For instance, when you update weights, the change in direction is influenced by the current magnitude, and vice versa. This coupling can create instability, especially as models grow larger and more complex. You might try using techniques like weight decay or warmup to manage this, but they only address the issue indirectly, which can still lead to unpredictable training behavior. This is what's called coupling dynamics failure. What this paper introduces is a way to tackle these issues head-on by separating the control of weight magnitude and direction. Instead of treating the weight matrix as a whole, the authors propose a method that factors each weight into a fixed-norm direction and learnable magnitude gains, which can be updated independently. This means you can adjust the learning rates for magnitude and direction separately, leading to more predictable and stable training dynamics. In practice, this approach has shown to improve performance over well-tuned baselines across different optimizers, and it simplifies the training process by removing the need for weight decay and warmup. For anyone building large models, especially those using Mixture-of-Experts architectures, this method could lead to more efficient training and better overall performance.
WinDOM: Self-Family Distillation for Small-Model GUI Grounding
Chengheng Li-Chen, Zhiqian Zhou, Hao Chen, et al.
Imagine you're trying to build a small AI that can understand and interact with graphical user interfaces (GUIs) on devices like smartphones or tablets. The challenge is that creating training data for these models usually requires a lot of human effort to annotate images with bounding boxes, which can be costly and time-consuming. This is especially problematic for smaller models that are meant to run on devices with limited resources. When you try to scale down the model, you often lose performance because you don't have enough high-quality training data. This is what's called the data annotation bottleneck. Currently, many developers either rely on expensive human annotation or use existing datasets that may not fit their specific needs. This can lead to models that perform poorly in real-world scenarios, especially when they encounter new types of interfaces or layouts that weren't part of their training data. This is known as the generalization problem, where the model struggles to adapt to unseen situations. The authors of this paper propose a clever solution to these issues. They introduce a method for automatically generating a large dataset of GUI grounding data by simulating interactions with a web browser. Instead of relying on human annotators, they use a tool that can read the structure of web pages directly, creating bounding boxes around elements without any manual input. This approach not only saves time and resources but also allows for the creation of a diverse dataset that can help the model learn better. Additionally, they present a new training technique called Self-Family Distillation (SFD), which helps improve the model's performance by using a smaller version of itself or a larger related model as a teacher. This method allows the smaller model to learn effectively from its own outputs, leading to better initializations for training. The results show that their approach leads to significant improvements in performance on various benchmarks, making it a practical option for developers looking to deploy small, efficient models for GUI tasks.
Agentic System as Compressor: Quantifying System Intelligence in Bits
Zihan Qin, Hongrui Zhang
Imagine you're building a system that needs to handle complex tasks like playing chess, answering questions, or even generating stories. Traditionally, these systems operate in isolation, making predictions based on fixed inputs without considering the broader context or the tools available to them. This can lead to inefficiencies, where the system struggles to adapt to new challenges or environments, resulting in what's called residual uncertainty — essentially, the leftover confusion after making a prediction. In this paper, the authors tackle this issue by proposing a new way to think about how these systems can be more agentic, meaning they can interact with their environment, use tools, and adapt their strategies. They introduce a concept based on the idea that 'compression is intelligence,' suggesting that a more capable system can achieve its goals using fewer resources. By operationalizing this idea with techniques like arithmetic coding and evaluating it across various tasks, they show that incorporating agentic components can lead to a significant reduction in the complexity of the tasks at hand. What sets this work apart from previous studies is its focus on measuring the effectiveness of these agentic systems in a structured way. The results indicate that by integrating these components, the systems can better manage their uncertainty and perform tasks more efficiently. For builders, this means that when designing systems that need to adapt and learn from their environment, considering how to reduce complexity through agentic interactions could lead to more effective solutions.
SE-AGCNet: An End-to-End Framework for Joint Speech Enhancement and Loudness Control in Meeting Scenarios
Jinming Zhang, Wei Rao, Xionghu Zhong, et al.
Imagine you're trying to improve the clarity of speech in a noisy environment, like a crowded meeting. Traditionally, you might use separate tools to enhance the speech and control the volume, but this can lead to problems. For example, if you boost the volume before enhancing the speech, you might just amplify the background noise instead. On the other hand, if you focus too much on enhancing the speech, you could end up making quiet voices too soft to hear. This is what's called a failure mode in audio processing, where the separate modules don't work well together and can actually make things worse. To solve this, the authors propose a new approach that combines speech enhancement and automatic gain control into one system called SE-AGCNet. The idea is that by working together, these two tasks can support each other: enhancing the speech helps the volume control work better, especially in situations where the volume varies a lot. They also introduce a new way to simulate data for training this system and use standardized metrics to evaluate loudness. In practice, this means that SE-AGCNet can maintain the right loudness levels while improving the quality of the speech and the accuracy of automatic speech recognition. This is a significant improvement over previous methods, making it a valuable tool for anyone working with audio in dynamic environments.
Pulmonary Embolism Risk Stratification from CTPA and Medical Records: Vascular Graphs Are Not All You Need
Nathan Painchaud, Tristan Habémont, Morgane des Ligneris, et al.
Imagine you're trying to assess the risk of pulmonary embolism (PE) in patients. Traditionally, doctors rely on a mix of medical records, imaging tests, and blood tests to make these assessments. However, blood tests are often missing, which can lead to incomplete evaluations. This is a problem because without all the necessary information, doctors might misclassify a patient's risk, potentially leading to inadequate treatment or unnecessary anxiety. This situation is what's called incomplete data reliance. To address this, the authors of the paper investigated whether advanced machine learning models could still accurately classify PE risk using just the available medical records and information extracted from imaging tests. They combined these data sources in various ways, including adding vascular biomarkers to traditional models and using graph neural networks (GNNs) to analyze the vascular structure represented as a graph. What they found was quite surprising: while medical records and cardiac biomarkers were strong predictors of risk, the vascular biomarkers did not improve the risk stratification at all. Even more unexpectedly, the GNNs, which are typically powerful tools for analyzing complex data structures, failed to outperform simpler tabular models that used just the global features from the medical records. This suggests that, contrary to what one might expect, the vascular graphs may not provide any additional useful information for assessing PE risk. For anyone building systems in this area, it means that relying on complex models might not always yield better results, and simpler approaches could be more effective.
Measurable Majorities Are Not Finitely Axiomatizable
Lawrence S. Moss, Arthur Paul Pedersen
Imagine you're trying to create a fair voting system where decisions are made based on majority opinions. You might think that if you can just set up a clear set of rules, everything will work smoothly. However, in practice, things can get messy. When you try to represent majority judgments with a finite set of rules, you often run into problems where the rules can't capture all the nuances of people's opinions. This is what's called incoherence in social decision-making. It means that sometimes, even if a majority agrees, the way the rules are set up can lead to contradictions or unfair outcomes. In this paper, the authors explore whether you can simplify the rules by using a bounded finite fragment instead of the existing coherence criteria. They find that you can't — no matter how you try to limit the rules, there will always be cases where the system fails to represent majority opinions accurately. They construct a specific example that illustrates this failure, showing that for every size of voting group, there are scenarios where the rules break down. This construction is geometric, meaning it uses concepts from geometry to explain why these failures happen. What this means for someone building a voting system is significant. It highlights the limitations of trying to simplify complex decision-making processes into finite rules. Instead of assuming that a straightforward set of rules will suffice, builders need to consider the inherent complexities of social decision-making and the potential for incoherence when designing their systems.