Papers for

data privacy teams

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Fast privacy accounting method speeds up random allocation sampling

Fast Privacy Loss Accounting for Random Allocation via Multiscale FFT

Abstract: In the random allocation sampling scheme each user's data is used in $k$ steps chosen randomly and uniformly from a sequence of $t$ steps. This scheme is known to improve on Poisson sampling in private optimization and in communication-efficient aggregation. The existing privacy loss distribution (PLD) accountant for this scheme runs in time quadratic in the inverse of the accuracy parameter $α$ (Feldman and Shenfeld, 2026). We give an algorithm, \emph{multiscale FFT}, that represents likelihood ratios on a grid that is uniform within each dyadic interval and computes the exact rounding of every pairwise sum using FFTs within each interval. It keeps the guarantees of the accountant and improves the dependence of its running time on $α$ from $O(α^{-2})$ to $O(α^{-1}\log(1/α))$. In addition, we demonstrate that rounding can be performed via the mean-preserving connect-the-dots projection of (Doroshenko et al., 2026). This reduces the errors that rounding introduces in the mean of the privacy loss and in the $χ^2$ divergence of the computed pair from the order of $α$ to $O(α^2/\log(t))$. In our experiments, our algorithm achieves speedups of several orders of magnitude at high accuracy and gives improved privacy bounds for DP-SGD with PREAMBLE.

Fri 30 OctMachine Learning
The gist
Keeping data private while using it in multiple steps is tricky, especially when users' data is randomly selected for these steps. The authors found a faster way to calculate how much privacy is lost during this process using a new technique combining grids and quick math tools called FFTs. Their method is much faster, especially when high accuracy is needed, and it reduces errors from rounding. This helps improve privacy guarantees for algorithms like DP-SGD used in machine learning.
Open → 2610.42117v1

Large language models learn to forget specific knowledge more precisely

What Should LLMs Forget: Reinforcement Unlearning of Knowledge Associations

Abstract: Large language models (LLMs) acquire extensive factual knowledge during pre-training, which may include sensitive, private, or copyrighted information, motivating the development of unlearning methods that selectively remove specific knowledge while preserving general capabilities. However, existing approaches typically optimize entire responses without explicitly identifying the knowledge to be forgotten, resulting in coarse and uncontrolled forgetting. To address this, we revisit the forgetting target of LLM unlearning and introduce Knowledge Association (KA), which characterizes the association between a query context and its target knowledge and is instantiated by the corresponding conditional predictive distribution, as the fundamental target of forgetting. Based on KA, we propose Knowledge Association Reinforcement Unlearning (KARU), a unified reinforcement learning framework that suppresses forgotten knowledge associations while preserving retained ones. Specifically, KARU derives complementary mechanisms from the KA-based formulation: token-level reward construction for finer-grained forgetting supervision, distribution-level regularization for precise knowledge suppression, and proximity-aware retain sampling to mitigate collateral degradation. Experiments across diverse LLMs on representative benchmarks demonstrate that KARU consistently improves forgetting effectiveness over existing baselines while maintaining comparable retention performance and general utility.

Fri 30 OctArtificial Intelligence
The gist
Large language models memorize lots of facts during training, including sensitive or private information. The paper points out that earlier ways of making models forget such information are too broad and uncontrolled. The authors propose a new way to identify and forget only the specific knowledge that should be removed, using a method called Knowledge Association Reinforcement Unlearning (KARU). This approach helps the models forget targeted facts better while keeping the rest of their useful knowledge intact.
Open → 2610.41616v1

BlindStep speeds up secure collaboration in data matching

BlindStep: A Secure One-Step Kernel for Privacy-Preserving Collaborative Reasoning

Abstract: A recurring step in two-party collaborative workflows combines a private candidate frontier with a partner's compatible evidence, scores the resulting candidates, and retains only a small frontier. Direct execution can expose intermediate candidates, local scores, or unauthorized evidence provenance. Existing MPC platforms and PSI protocols provide useful building blocks, but they do not define a unified post-alignment boundary for bounded-slot aggregation, fail-closed overflow handling, retained-frontier selection, and downstream disclosure. We present BlindStep, a fixed-shape MPC-online kernel for one such post-alignment step between two semi-honest parties. Given a frontend realizing the bounded-slot contract and an application enforcing the reveal policy $ρ$, BlindStep provides a per-invocation simulation-based guarantee in the $F_{\mathrm{align}}$-hybrid model: the kernel leaks only public setup parameters, fixed execution-shape metadata, a global overflow bit, and $ρ$-authorized Layer-2 disclosures. The guarantee excludes malicious security and multi-invocation composition, and treats frontend leakage and offline preprocessing separately. Within this kernel boundary, we implement six semi2k realizations in MP-SPDZ, crossing two sharing styles and three top-K strategies: H-variants compare over arithmetic shares, while B-variants convert packed ranking values to Boolean shares before selection. Under LAN, B-Queue is 6-7 times faster and uses about 40 times less communication than H-Queue at N = 256 and 2048. Against H-Sort on the same backend, B-Queue achieves speedups of 21 and 30 times and communication reductions of 204 and 290 times at N = 2048 and 8192, respectively. Under the evaluated N = 256, 100 ms RTT WAN profile, H-Sort becomes fastest, showing that round complexity can dominate backend choice for the measured MPC-online kernel.

Fri 30 OctCryptography and Security
The gist
When two people or groups try to combine their private information without revealing too much, they need a careful way to work together securely. The authors designed BlindStep, a special tool that helps two parties securely score and select the best matching items without exposing sensitive details in the process. They tested different methods and found some versions of BlindStep run much faster and require less communication than others, depending on the network conditions. This helps keep privacy intact while making the collaboration more efficient.
Open → 2610.41369v1

Continual unlearning method keeps large language models useful over time

Preserving Utility in Continual LLM Unlearning via Orthogonal Projections

Abstract: Unlearning concerns the task of removing the influence of a sensitive portion of the training data, such as protected, copyrighted or private text, from a model without retraining it from scratch. While unlearning requests happen continuously during a model's lifetime, the vast majority of LLM unlearning methods are ill-suited for iterated removal, yielding steep decay in forgetting and utility upon sequential unlearning. This decay stems from interference between successive updates, as each new deletion can undo earlier ones or push the model further along directions already degraded by them. To address this, we introduce Continual Orthogonal Projection (COP), a gradient-projection scheme that restricts each update to the orthogonal complement of activation subspaces cached from prior forget sets. This approach provably guarantees first-order non-interference with earlier deletions. COP stores only a low-rank basis per layer, requiring neither past gradients nor previous forget sets, and plugs into unlearning methods that update the model through gradient steps on a differentiable loss without modifying its objective. Experiments on standard LLM unlearning benchmarks (TOFU and RWKU) show that COP preserves utility across sequential requests without weakening forgetting, preventing the collapse of standard objectives and forgetting more effectively than continual-specific baselines.

Thu 29 OctMachine LearningComputation and Language
The gist
Sometimes language models need to forget certain information they learned, like private or sensitive details. However, when these forgetting steps happen many times, the model can lose its overall usefulness. The authors propose a new technique called Continual Orthogonal Projection (COP) that helps the model forget repeatedly without harming what it knows. This method carefully adjusts the model in directions that don’t interfere with previous forgetting, keeping it both private and helpful.
Open → 2610.40483v1

Optimal privacy spending improves private learning efficiency and accuracy

When to spend privacy: optimal allocation in private learning

Abstract: Privacy accounting bounds the cumulative privacy cost of Differentially Private Stochastic Gradient Descent but does not determine how to allocate a fixed budget across iterations. We formulate the complete Gaussian noise-variance schedule as an open-loop control under a composed zero-Concentrated Differential Privacy constraint, explicitly accounting for schedule selection. For expected quadratic terminal tracking, we prove that every local minimizer exhausts the certified budget, yielding an exact-budget simplex formulation. We introduce Privacy-Budget Adjoint Mirror Descent (PB-AMD), combining pathwise adjoint gradients with entropic updates that preserve positivity, charge floors, and the prescribed budget. Under regularity and coercivity assumptions, we establish existence and budget stability of optimal schedules, design-to-training utility stability, and deterministic, stochastic, and sample-average stationarity guarantees. A linear-quadratic reduction yields an explicit square-root allocation law. Experiments demonstrate tracking improvements over several allocation rules and predictive improvements over uniform allocation in a learning-rate restart setting, where learning-rate allocation performs similarly. Comparisons at a common stationarity tolerance show lower schedule-optimization times than projected gradient descent on the tested problems. The framework connects certified privacy accounting with optimization through nonlinear training dynamics.

Thu 29 OctMachine LearningArtificial Intelligence
The gist
Training machine learning models privately means adding noise to protect user data, but deciding how much noise to add in each step is tricky. The authors propose a way to figure out the best way to distribute a set privacy budget over all training steps to get the best learning results. They create a new method called Privacy-Budget Adjoint Mirror Descent that finds these optimal schedules efficiently and prove it works under certain conditions. Tests show this approach beats simple methods of dividing the privacy budget evenly across training.
Open → 2610.39954v1

Method improves synthetic data quality by optimizing variable order

A goodness of fit approach to select the optimal visit sequence for nonparametric data synthesis

Abstract: Synthetic data are a promising way to maintain privacy while disseminating research data, thereby enabling compliance with the open science principles. Popular methods for generating synthetic data include sequential synthesis, where each variable is generated conditionally on the preceding ones in a given order. This order, also called the visit sequence of the synthesizer, is known to affect the quality of synthetic data. This raises the question of the criteria that should guide its choice. In this work, we present a novel method to perform such selection based on a goodness of fit criterion, and show that it outperforms alternative structure-based methods, both in terms of synthesis quality and time complexity. The proposed method also has the advantage of being applicable to any type of data and any class of conditional distribution models.

Wed 28 OctMachine Learning
The gist
Synthetic data helps protect privacy when sharing research information. When making synthetic data, the order in which variables are created matters a lot. The authors introduce a new way to pick this order by checking how well the generated data fits the real data. Their method works better and faster than older approaches and can be used with any kind of data and model.
Open → 2610.38559v1

Decision unlearning performance varies with deletion and label changes

DecisionUnlearn-Bench: Unlearning Probabilistic Decisions under Changing Schemas

Abstract: Machine unlearning aims to reproduce the behavior of a model trained without designated data. For probabilistic decision models, this target also depends on the candidate options supplied at inference. We introduce DecisionUnlearn-Bench, an empirical framework that compares full, unlearned, and retain-only models across deletion granularities, label renderings, and candidate sets. Across 20 eligible model configurations on the BANKING77 dataset, full-to-oracle displacement increases consistently from example to association to class deletion. Replacing semantic option labels with opaque codes nearly eliminates the retrained oracle's recognition of deleted classes, even with successful acquisition of the full model, whereas changing the candidate set alters both the oracle and the measured unlearning progress. SimNPO satisfies the screening criterion in 19 of 20 configurations, but its gains vary substantially across seeds and deletion targets. Development tuning on the CLINC150 dataset does not establish a positive pooled effect across 48 intents. At approximately matched suppression, methods can differ markedly in oracle fidelity. Recovery experiments further distinguish initial forgetting from subsequent adaptation and show conclusions that depend on both architecture and metric. These results show that evaluating decision-model unlearning relative to a schema-specific retraining target, with separate reporting of effect size, utility, robustness, and recoverability.

Wed 28 OctCryptography and SecurityArtificial Intelligence
The gist
Machine unlearning tries to make a model act as if it never saw certain data. This paper introduces a way to compare how well different methods remove learned information based on what options the model sees when making decisions. The authors show that changing the labels or which choices are available during testing can greatly affect how well the unlearning works. They also find that different unlearning methods perform differently depending on many factors like model type and what data is removed. Their results highlight the importance of evaluating unlearning in ways that consider the specific decision setting.
Open → 2610.38431v1

Robust attacks reveal if data belongs to a set despite noise

A Simple Presentation of Robust Membership Inference Attacks

Abstract: In a membership inference attack, an attacker is given the data of a particular individual, and tries to determine if that individual was included in a particular dataset, given some kind of statistics derived from the dataset or a model trained on the dataset. Roughly, a membership inference attack is robust if it succeeds even when the statistics are highly noisy, regardless of how that noise is introduced. We give a simple presentation of robust membership inference attacks for mean estimation, covering both multivariate Gaussian distributions and binary product distributions. We also give a summary of the literature on robust membership inference, covering history, extensions, and connections to other research areas.

Tue 27 OctCryptography and SecurityInformation TheoryMachine Learning
The gist
Sometimes, people want to know if a particular person's information was included in a big dataset, even if the data is mixed up or noisy. This paper explains a simple way to do this kind of membership attack, which still works well even when the data is very noisy. The authors focus on data that follows certain common patterns, like those that fit Gaussian or binary models. They also review earlier work on these attacks and how they connect to other research areas.
Open → 2610.36458v1

Approximate unlearning method speeds up data removal from prototype classifiers

Approximate Unlearning in Prototype-based-classifiers

Abstract: The recent data and AI regulations and governance needs have highlighted the need for removing specific data even from models trained on or with them. While retraining the entire model is a theoretically trivial solution, it is computationally expensive, thereby motivating research in Machine Unlearning. This paper introduces a robust approximate unlearning technique for the family of prototype-based classifiers called Generalized Learning Vector Quantization, aimed at removal of effects of specified samples, either due to deletion request or due to them being identified as noisy or corrupt. We first show the impact of the different sizes of the forget set, as well as the characteristics of the data in this set, on the unlearned model. To address the sources of instabilities detected in this unlearning method we propose an adapted version of this technique, such that the unlearning is robust to the characteristics of the forget set. Thereafter using the intrinsic interpretability property of GLVQ and appropriate metrics defined in unlearning literature, we show the efficacy (approximately 0 deviation of parameters and performance of unlearned model relative to retrained model) and efficiency (6X for smallest dataset to 10^(5)X in the largest dataset) of the proposed unlearning techniques compared to naive retrained, on six benchmark datasets for tabular data recommended by literature. Although in this work we investigated only binary class problems, the proposed robust unlearning strategy can be readily applied for removing sample effects from any trained GLVQ model, i.e., it does not require any modification in the training scheme of GLVQ.

Sun 25 OctMachine Learning
The gist
Sometimes, specific data needs to be removed from machine learning models, such as when users request deletion or when data is found to be incorrect. Retraining a model fully can be very slow, so this paper proposes a faster way to remove certain data's effects from a specific type of model called prototype-based classifiers. The authors show their method is almost as accurate as retraining the whole model but works much faster across several datasets. Their approach can handle different sizes and types of data for removal and does not need changes to how the original model is trained.
Open → 2610.34495v1

Data deletion changes which records influence trained models

Exact Unlearning After Data Curation

Abstract: Training pipelines often remove similar examples before fitting a model. Deleting a raw record can change that selection and admit an example that was excluded before. What must a service retain to reproduce training after such requests? We answer this question for a fixed rule in which earlier similar records block later ones. A limit on the total number of future deletions identifies exactly which records can still enter training. We use this boundary to build a summary of training statistics that can be repaired exactly after repeated deletions. The repaired summary is the same as rebuilding it on the surviving data with the remaining budget. We also construct finite-precision features for ridge regression, a linear learner with a penalty on coefficient size. With exact rational outputs, allowing one more deletion changes the required private information. It rises from zero to every private feature sign in the excluded candidates. An encoding attains this conditional private-information minimum on the constructed family throughout a sequence of requests. On 1,001 AskUbuntu development records, deleting an initially excluded record admits another record at 13 of 51 fixed similarity cutoffs. Exact membership repair passes 13,056 deletion-step checks. Two model-based semantic calibrations fail their fixed criteria, so the downstream task study is not run. The central result is a retention contract: the future deletions a service promises to support determine which excluded data can still be needed.

Sat 24 OctMachine LearningArtificial Intelligence
The gist
When training computer models, some similar data points are removed before learning. If you delete one record, this might allow another previously blocked record to be included instead, changing the model. The authors study exactly what information a service must keep to update the model correctly after such deletions. They build a method to track and repair training data summaries precisely, ensuring consistent model results after removing data. This work helps clarify how to handle data removal requests when some data is excluded due to similarity.
Open → 2610.33426v1

Improved bounds on list replicability for PAC learning classes

Near-Optimal List Replicability from Littlestone Dimension

Abstract: We study the list replicability number in the realizable PAC learning framework and prove that every concept class $H$ over a countable domain with Littlestone dimension $d$ and dual VC dimension $v^*$ satisfies \[ \mathrm{LR}(H)\leq 2^{O(d\min\{\log d,v^*\})}. \] This matches the worst-case lower bound of $2^{Ω(d)}$ up to a logarithmic factor in the exponent and exponentially improves the previous best upper bound $\mathrm{LR}(H)\le 2^{2^{O(d)}}$ of Bun, Livni, and Moran [FOCS 2020]. Unlike earlier bounds of $2^{O_ε(d^2)}$ for fixed accuracy $ε>0$ implied by the work of Ghazi, Golowich, Kumar, and Manurangsi [STOC 2021] and Lyu [STOC 2026], our bound is independent of $ε$. The $2^{O(d\log d)}$ bound follows from a new inductive framework for bounding list replicability that builds on the recent notion of irreducibility from differentially private learning. The $2^{O(dv^*)}$ bound follows from a simple globally stable learner that takes the majority vote of multiple empirical risk minimizers, with stability established using tools from stable regularity.

Fri 23 OctMachine Learning
The gist
This paper studies how to reliably reproduce learning results from limited data in a specific machine learning setting called PAC learning. It shows a much tighter limit, called the list replicability number, on how many possible solutions need to be considered to ensure replicability. The authors improve upon previous results by giving bounds that depend only on inherent complexity measures of the learning problem, and not on accuracy parameters. Their techniques involve new mathematical frameworks and stability ideas from privacy research.
Open → 2610.32853v1

Curvature aware clipping improves privacy preserving neural network training

Curvature-Aware Clipping: Mitigating Bias in DPSGD via Approximate Second-Order Information

Abstract: Differentially Private Stochastic Gradient Descent (DPSGD) has become the de facto standard for training deep neural networks with rigorous privacy guarantees. However, the utility of DPSGD is constrained by gradient clipping bias and DP noise. While existing work has tried to address these issues, the geometric misalignment caused by clipping bias remains a critical challenge. To bridge this gap, we propose a novel framework, Curvature-Aware Differentially Private Stochastic Gradient Descent (CA-DPSGD), which leverages approximate second-order information to construct an optimal, curvature-aware clipping space. CA-DPSGD integrates a rectified estimator for the curvature matrix and is coupled with an anisotropic noise mechanism to ensure privacy guarantees. Extensive empirical experiments demonstrate that our approach outperforms state-of-the-art clipping methods.

Fri 23 OctMachine LearningCryptography and Security
The gist
Training neural networks with privacy protection often requires limiting how big gradients can get, but this causes biases that hurt the learning process. The authors propose a new method that uses an approximate understanding of the shape or curvature of the training landscape to decide how to clip gradients more effectively. This approach also adds noise in a way that respects the privacy guarantees. Their experiments show that this method works better than previous ways to reduce clipping bias while preserving privacy.
Open → 2610.32175v1

Llm agents often recover deleted secret information from memory

AfterDeleteBench: Auditing Post-Deletion Information Persistence in LLM Agents

Abstract: Many LLM agents maintain external persistent memory and derive additional state from past interactions, such as summaries. Deleting an original memory record therefore need not remove information carried by its descendants. We introduce AfterDeleteBench, a controlled behavioral audit for this failure mode in fixed-weight LLM agents. For each synthetic secret, we compare an exposed-then-deleted agent with an otherwise matched agent that was never exposed to the secret, allowing post-deletion recovery to be attributed to the original exposure. In our primary setting, a single query recovers the deleted secret from Qwen2.5-7B-Instruct in roughly two thirds of cases, while matched never-exposed controls have zero recovery. Crucially, recovery does not require a surviving verbatim copy: when the complete secret string is absent and only separately stored components remain under a public composition rule, exact reconstruction succeeds in 62-99% of cases across Qwen, Mistral, and Phi-3. We also show that the response interface is part of the measurement system: target-bearing replies can be scored as failures when the requested format and parser are misaligned. Finally, we separate reconstruction from write-back and fresh-session recall. Provenance-aware closure eliminates observed recovery in the tested positive-baseline settings, whereas an exact-literal write filter blocks reinsertion but cannot erase information already present. Together, these results show that source deletion should be evaluated behaviorally at the level of the agent and its memory system, not only as a storage operation.

Thu 22 OctCryptography and SecurityComputation and LanguageMachine Learning
The gist
When information is deleted from a language model agent's memory, traces of that information often remain in related summaries or other derived data. The authors created a test called AfterDeleteBench to check if deleted secrets can still be recovered from the agent’s behavior. They found that many large language models can reconstruct deleted secrets just by querying them, even if the exact secret is not stored anywhere anymore. This shows that simply deleting the original data does not guarantee the information is really gone from the system’s memory. The authors suggest that deletion should be checked by testing how the agent behaves, not just by verifying the database is cleared.
Open → 2610.31366v1

Graph privacy release methods fail real-world privacy checks

Practical Auditing of Differentially Private Graph Release Mechanisms: Methodology, Toolkit, and Case Study

Abstract: Differential Privacy (DP) has become a prominent approach for protecting graph data releases, yet empirical auditing methodologies have largely been developed for tabular datasets and machine learning pipelines rather than graph-structured outputs. We present a methodology for empirically auditing DP graph release mechanisms, identifying two graph-specific audit design problems: canary construction and witness statistic selection. We combine these components with an established statistically certified testing procedure and implement the resulting methodology as an open-source Python toolkit. To demonstrate the approach, we audit a published state-of-the-art Node-DP graph release mechanism. Across a series of synthetic and real-world canary pairs, we obtain certified lower bounds on the privacy parameter {\varepsilon} that exceed the claimed value, yielding counterexamples sufficient to falsify the claimed guarantee for the audited implementation. The violations persist under progressively stronger restrictions on the input domain, including non-empty and connected graphs. We also show that witness selection can materially affect whether a violation is detected, highlighting the importance of evaluating a diverse battery of statistics when auditing DP graph release mechanisms.

Thu 22 OctCryptography and Security
The gist
Keeping graph data private is important but hard to check in practice. The authors studied how well privacy protections called differential privacy actually work for graph data. They created tests and a toolkit to check if the privacy guarantees hold up. Using this, they found that a top graph privacy method claimed to protect data was actually weaker than advertised under real testing. Their work shows that different ways of checking privacy can change what problems are found.
Open → 2610.31294v1

Protegrity PII model detects personal data fast with high accuracy

Protegrity-PII Technical Report

Abstract: We present Protegrity-PII, a new PII decision model for structured and unstructured text. Protegrity-PII achieves a typed recall of 0.915 with a precision of 0.907 on a new benchmark we propose, PII-SCOPE. Our model processes text in 0.49 seconds per million characters at \$0.0005 per million characters on a single RTX 6000 using batched inference. Due in part to the expansive nature of the entity type taxonomy used in training, Protegrity-PII achieves superior out-of-distribution generalization when benchmarked against a selection of state of the art models and datasets.

Wed 21 OctComputation and LanguageArtificial Intelligence
The gist
Personal Identifiable Information (PII) like names or addresses can be tricky to find in all kinds of text. The authors developed Protegrity-PII, a tool that spots PII in both clear and messy texts very accurately. It works fast, scanning a million characters in under half a second using a standard GPU. Because it was trained with many types of PII, it can recognize new or unexpected PII better than some other tools.
Open → 2610.30518v1

Private online prediction gets better with fewer mistakes

Private Online Prediction from Experts with Small Losses

Abstract: We consider online prediction from experts, a fundamental problem in machine learning, under differential privacy constraints. Existing private algorithms achieve near-optimal regret $\tilde{O}(\sqrt{T})$, where $T$ is the time horizon. However, this bound becomes suboptimal when $L^\star$, the cumulative loss of the best expert, is significantly less than $T$. In this work, we present the first differentially private algorithm with regret $\tilde{O}(\sqrt{L^\star})$, offering a substantial improvement in the low-loss regime. Our regret bound matches the non-private lower bound up to poly-logarithmic factors for constant privacy parameters, demonstrating that privacy incurs only a small cost in this setting. Our result assumes that the input sequence is oblivious, i.e., it is fixed in advance and independent of the algorithm's outputs. We also prove that an $\tildeΩ(\sqrt{T})$ regret is inevitable for adaptively generated inputs, even when $L^\star = 0$.

Wed 21 OctMachine Learning
The gist
Online prediction means choosing the best option by learning from experts, but keeping these predictions private is tricky. Earlier methods worked well overall but slowed down when the best expert made very few mistakes. The authors created a new method that stays private while doing almost as well as the best expert, even when that expert barely makes errors. This change means privacy doesn’t cost much extra in these cases, but only when the data is fixed ahead of time, not changing based on what the algorithm predicts.
Open → 2610.29575v1

Calliope finds topics in private ai conversations without embeddings

CALLIOPE: Private Insights into AI Use, Without Embeddings

Abstract: We introduce CALLIOPE, a top-down framework for discovering topic hierarchies in large corpora of unstructured data (e.g., LLM conversations), while supporting differential privacy (DP). Unlike traditional and even recent LLM-augmented approaches that ultimately rely on clustering vector embeddings, our framework leverages LLM capabilities directly for the entire pipeline. Experiments demonstrate that this approach provides better utility over existing (embedding-based) methods in the DP setting, especially in the high privacy regime. We evaluate the quality of CALLIOPE outputs using a variety of traditionally studied clustering metrics, as well as some novel utility metrics that we introduce.

Tue 20 OctMachine LearningArtificial IntelligenceComputation and Language
The gist
People often want to discover topics in large amounts of text, like conversations with AI, while keeping the data private. Traditional methods use number-based summaries called embeddings but can leak information when privacy is strict. The authors created CALLIOPE, a new approach that uses AI language understanding directly instead of relying on embeddings. This method offers better results, especially when strong privacy protections are required.
Open → 2610.28797v1

Safe AI advice must balance help and public risks

Fundamental Impossibility Results in AI Safety: Trading Off between Desiderata

Abstract: Is there a fundamental tradeoff between desiderata for safe AI systems, such as harmlessness and helpfulness? We answer by formalizing the interaction between AI systems and users as a game with three players: a defender and an attacker that are computationally or informationally bounded, and an AI that provides public advice and is less constrained. Our main result shows that there is a fundamental tradeoff in providing advice that helps the defender while advice remains public. We also consider whether the information that the AI shares can be manipulated to benefit only the defender and conclude with a discussion of how we can use these results in designing safer AI systems.

Mon 19 OctComputer Science and Game TheoryArtificial Intelligence
The gist
Sometimes, when AI systems give advice, they need to help good users while avoiding harm if bad users see that advice. The authors show that if AI advice is public, there is a basic tradeoff: it can’t be both fully helpful and fully safe. They model this as a game between defenders, attackers, and AI, showing limits on what AI can do. This insight can guide how safer AI systems are designed.
Open → 2610.27373v1

Kernel stein certificates improve privacy checks for specific tasks

Task-aware Kernel Stein certificates for Rényi differential privacy

Abstract: Rènyi differential privacy, based on Rènyi divergence, has become a notion of choice for privacy guarantees. However, outside the Gaussian setting, Rènyi divergence can be difficult to compute. In particular, Rènyi differential privacy guarantees that exploit task-specific information, as in Rènyi Pufferfish privacy, can be challenging. Here we use kernel Stein discrepancies based on escort distributions to provide certificates for Rènyi differential privacy. By designing the kernel to focus on the relevant privacy directions, we also derive task-aware privacy certificates. We provide exact identities for Gaussian and Laplace mechanisms and bounds for exponential mechanisms, with separate task-aware guarantees. A real data set example illustrates how the protected comparison set and the released subspace jointly determine the resulting certificates.

Fri 16 OctCryptography and SecurityMachine Learning
The gist
Protecting privacy when sharing data can be tricky, especially when using advanced privacy methods like Rènyi differential privacy. The authors develop a new way to check these privacy guarantees using mathematical tools called kernel Stein discrepancies. Their approach also customizes privacy checks to focus on what matters for the specific task, making the protection more precise. They show exact results for common privacy methods and illustrate how this works using real data.
Open → 2610.23798v1

Typed decision models often reveal private causes alongside results

TUPLE-Bench: Evaluating and Mitigating Privacy-Utility Trade-offs in Typed Decision Models

Abstract: Typed decision models often return more than a selected category. They also expose probabilities for each candidate and, sometimes, a separate confidence score. These fields support downstream decisions but may reveal information beyond a recipient's authorization. We introduce TUPLE-Bench (Typed decision models' Utility and Privacy Leakage Evaluation Benchmark), a benchmark of paired synthetic cases in which recipients may learn a coarse operational category but not its fine-grained cause. Across nine models, instructions to withhold the cause fail to protect it: 91.88%-99.93% of responses reveal the cause through direct selection or residual scores. Even when causes are excluded from the candidate set, full outputs enable 62.85%-75.35% recovery on held-out cases, compared with 51.04%-57.64% using only the selected category (50% chance). Full outputs also reduce mean downstream cost in all 27 model-task comparisons. However, confidence fields increase leakage without consistently reducing cost. We further introduce workflow-constrained privacy quantization (WCPQ), which reduces secret recovery while preserving the behavior and cost of specified downstream workflows. Our findings highlight the need to audit decision interfaces field by field and workflow by workflow.

Fri 16 OctCryptography and SecurityArtificial Intelligence
The gist
Many decision systems not only give a result but also show extra details like probabilities and confidence levels. The authors found that these extra details can accidentally reveal private information that was meant to be hidden. They tested a new method to reduce this privacy leak while keeping the system useful for its intended purpose. Their work shows it’s important to carefully check each part of a system’s output to protect sensitive information.
Open → 2610.23668v1

Confidence-weighted layerwise unlearning improves large language model forgetting

CoLU: Confidence-Weighted Layerwise Unlearning for Large Language Models

Abstract: Large language model (LLM) unlearning aims to forget certain information while preserving others, without retraining from scratch. SoTA methods such as NPO, SimNPO, and SatImp balance forgetting and retain through whole model fine-tuning, while FOM-UL explores selective layer updates. Prior works show that suppressing target information can damage retained knowledge. This trade-off can vary across layers even under the same unlearning loss. In this work, we propose Confidence-Weighted Layerwise Unlearning (CoLU), which combines a novel confidence-weighted forgetting and retain regularization while updating a single selected transformer layer, rather than the whole model for unlearning. To reduce CoLU compute cost, we further propose Brief Layer Screening (BLS), which uses a newly defined normalized forgetting-retention (NFR) score to first rank layers through a brief unlearning trials using a subset of forgetting dataset and fewer epochs. BLS pre-selects top-k ranked layer candidates, which will then be fully profiled using full data analysis. BLS is proven to reduce the runtime of CoLU by 60.2-79.7% with almost the same performance. On TOFU dataset, CoLU improves both forgetting and retention over NPO, SatImp, and GA-based FOM-UL in all six TOFU settings, and over SimNPO in five of the six settings. On MUSE Books and News datasets, CoLU achieves the highest retained KnowMem and the PrivLeak closest to zero among the compared SOTA unlearning methods. CoLU presents a new record performance in both unlearning and retain in most settings up to date. Moreover, across the measured settings, average CoLU GPU memory usage is 77.4% to 79.5% lower than full-model unlearning.

Thu 15 OctComputation and LanguageMachine Learning
The gist
Large language models sometimes need to forget specific information without losing everything else they know. Existing methods try to balance forgetting and remembering by adjusting the whole model, which can be costly and can harm what the model should keep. The authors introduce CoLU, which smartly picks one layer in the model to update, using confidence weights to improve forgetting targeted information while keeping the rest intact. They also created a way to quickly find the best layer to update, making the process much faster and more efficient. Their experiments show CoLU performs better than previous methods while using much less memory.
Open → 2610.22721v1

Efficient model finds personal data with high accuracy and low cost

Broad and Efficient PII Detection with Unified Labels

Abstract: Personally Identifiable Information (PII) detection models must efficiently find identifiers across diverse contexts while maintaining a low false-positive rate (FPR) on high-volume traffic. Recent detectors increasingly rely on complex architectures that raise deployment cost, yet many are fine-tuned on only a few synthetic datasets that limit their coverage. Combining public datasets is challenging because their taxonomies differ, and even after categories are mapped to a common schema, labels can disagree on what counts as a detection, producing inconsistent training and evaluation signals. To address these problems, we present a practical 141M-parameter encoder-based detector trained on 1.12 million examples from 77 public datasets, relabeled under a detailed definition of broad contextual detection for 12 structured PII categories. Evaluated on the AI4Privacy and Nemotron-PII benchmarks at a low-FPR operating point, our model achieves the highest recall against larger baselines in 11 of 14 comparisons under our labels and 9 of 14 under the original labels. Its largest recall gains include useful additional coverage, such as multilingual disclosures and IP addresses embedded in URLs. It achieves this with 2-10x higher throughput and 94-97% less peak GPU memory than the baselines, delivering leading detection performance at substantially lower cost.

Thu 15 OctComputation and LanguageCryptography and Security
The gist
Finding personal information like names, IP addresses, or IDs in text is tricky because sources differ and labeling can be inconsistent. The authors addressed this by combining many datasets into one big, consistent training set with clear rules on what counts as personal data. They trained a model that not only finds more sensitive information, including cases in different languages and tricky formats, but also does so using much less computing power. This makes it practical to detect personal information quickly and reliably in large amounts of data.
Open → 2610.22597v1

Local privacy method counts small network patterns with optimal accuracy

Subgraph Counting with Local Node Differential Privacy

Abstract: We study the problem of approximately counting subgraphs under local node differential privacy (LNDP), a recently introduced model that enforces strong privacy guarantees in analyses of distributed social networks. We design a noninteractive $(\varepsilon,0)$-LNDP algorithm that, given any public $k$-node template graph $H$, counts occurrences of $H$ in a sensitive undirected $n$-node graph with additive error $O(n^{k-\frac{1}{2}}/\varepsilon^{k-1})$, for any constant $k$. We complement this algorithm with a lower bound showing that every noninteractive $(\varepsilon,δ)$-LNDP algorithm for counting copies of any $k$-node template graph with maximum degree greater than $1$ must have error $Ω(n^{k - \frac{1}{2}})$. Thus, our algorithm achieves optimal error for counting constant-size subgraphs, up to $\mathrm{poly}(1/\varepsilon)$ factors. Our results substantially expand the types of network statistics known to be approximable under LNDP: prior work considered only functions of the degree distribution. In addition, our lower bound yields the first known $\mathrm{poly}(n)$ gap between central and local node differential privacy when accuracy is required for all input graphs. Previous separations either only involved $\mathrm{poly}(1/\varepsilon)$ factors or only applied to promise problems.

Thu 15 OctData Structures and AlgorithmsCryptography and Security
The gist
Counting small patterns in social networks helps understand connections, but sharing this data can threaten privacy. The authors developed a new method that protects individual users' connections while still counting these patterns accurately. They prove their method is about as good as possible and show that protecting privacy this way is harder than traditional methods. This improves on previous work which only handled simpler statistics about networks.
Open → 2610.22278v1

Benchmark reveals limits of forgetting edges in graph neural networks

Lethe: Link Inference Attacks For Evaluation of Edge Unlearning Methods

Abstract: Graph Unlearning (GU) aims to remove the influence of specific training data from a Graph Neural Network without retraining anew. While most methods address removal of nodes and features, Edge Unlearning (EU), aiming at forgetting edges, has recently attracted dedicated attention as a standalone problem due to the hardness of completely removing the impact of an edge in the model. Despite this, no dedicated benchmark for EU exists besides isolated evaluations on feature-rich datasets such as Cora and Citeseer where GNNs exploit node features rather than graph structure. As such, we show two systematic limitations in existing evaluations: dedicated EU methods can be slower than retraining anew, and accuracy metrics are uninformative due to the negligible impact of edge removal. To address this gap, we introduce Lethe, the first comprehensive benchmark for Edge Unlearning, featuring 15 methods and 8 datasets. Our benchmark emphasizes large graphs, introduces evaluation tasks of varying difficulty, and proposes empirical measures based on link inference attacks rather than proxy accuracy metrics. We provide a comprehensive empirical analysis, demonstrate the shortcomings of current evaluations, and release Lethe as a reproducible, extensible benchmark.

Thu 15 OctMachine Learning
The gist
Forgetting the effect of specific edges in graph-based AI models is hard and important for privacy or updates. The authors point out that current tests are incomplete and sometimes misleading. They created Lethe, a new system to fairly compare methods for erasing edges' impact in large graphs. Lethe uses tougher challenges and a new way to check how well the forgetting works by trying to guess deleted links. This helps better measure and improve edge unlearning techniques.
Open → 2610.21869v1

Data-free probes reconstruct parts of neural network factors for private learning

Spectrum Is Not Enough: A Random-Matrix Account of Data-Free Preconditioning for Differentially Private Learning

Abstract: Data-free preconditioning builds the Kronecker factors of KFAC from synthetic probes instead of private data. DP-KFC validates a probe by matching the eigenvalue decay of the private factors; we turn this criterion into a random-matrix account of what a probe can reconstruct. A single dichotomy organizes it: in the factorization $ A \otimes G $, the error-signal factor $ G $ and the architecture-determined bulk of the activation factor $ A $ are reconstructible without data, while only the data-induced spikes of $ A $ are not. We prove the $ G $ half is data-insensitive up to an explicit error-energy bound, with zero violations over a full training trajectory across four modalities and a natural-image benchmark. We locate the failure boundary at a Baik-Ben Arous-Péché threshold: a bulk-only probe suffers an exact damage $s^2/(1-s^2)$ from a data-induced spike, which becomes invisible once it exceeds $(d/n)^{1/4}$, confirmed on an injected-spike surrogate. Holding the probe spectrum fixed and varying only its eigenbasis, we show that spectral-shape matching is neither sufficient nor the operative object: a probe with a near-exact matched spectrum (log-ratio dispersion $0.02$) still inflates the residual $2 \times $-$90 \times $ when its eigenvectors are random. A closed-form whitened-volume law explains this and predicts the within-spectrum ordering of the critical volume, though not its cross-dataset magnitude. Downstream, per-layer tuning does not transfer to accuracy and the headroom is a small oracle-minus-white gap. Under a privacy mechanism the source ordering survives while learning does, then inverts at a noise cross-over where the flat probe overtakes the matched ones.

Thu 15 OctMachine Learning
The gist
Training neural networks privately can be tricky because it uses sensitive data. The authors study a way to prepare certain internal computations—called preconditioning—without using private data, by analyzing synthetic probes. They found that some parts of these computations can be reliably recovered from synthetic probes alone, while others depend heavily on real data. Their work explains when and why this method works or fails, using advanced math about matrix patterns.
Open → 2610.21312v1

Fairness aware screening improves federated learning under attack

FUSE: Fairness-aware Update Screening against Byzantine Exploitation in $q$-Fair Federated Learning

Abstract: Client-level fair federated learning, in the form of $q$-fair federated learning ($q$-FFL), agnostic federated learning, or tilted empirical risk minimization, has emerged as an attractive solution to equalize utility across heterogeneous clients. This paradigm grants high-loss clients greater relative influence, while a central server aggregates their loss-weighted updates into a single shared model. Yet, the Byzantine robustness of $q$-fair federated learning has been largely neglected, leaving the server unable to tell legitimate fairness-induced amplification from malicious update scaling. To address this critical gap, we formalize the problem of Byzantine-robust $q$-fair federated learning under an \emph{update-only interface}, in which the server observes nothing but the fairness-scaled client updates. Our analysis under shared class-conditional label skew shows that fairness scaling preserves the nonnegative class-mixture structure of honest updates, while replacing their unit-sum constraint by a client-dependent radial scale. Moving beyond magnitude-based screening, we show that this warped geometry supplies two complementary tests, one radial and one structural, that a single norm cannot provide. We then introduce FUSE, a structure-aware robust aggregator that uses a small trusted labeled dataset for coefficient recovery, scale and cone-consistency screening, and post-screening step-size control. Across four benchmarks and seven Byzantine attacks, FUSE improves seed-wise worst-attack accuracy over the strongest baseline on each benchmark by 3.9--30.1 percentage points, while largely preserving the influence of the high-loss honest clients that fairness is meant to protect.

Wed 14 OctMachine LearningArtificial Intelligence
The gist
Federated learning lets many devices work together to train a shared model, giving more influence to devices with worse performance to make the system fairer. The authors point out that this fairness approach can be exploited by malicious devices that exaggerate their updates to harm the shared model. They study how to detect these attacks when the server only sees scaled updates influenced by fairness. Their method, FUSE, uses a small trusted dataset and the geometric shape of honest updates to identify and reduce the impact of malicious ones, improving accuracy while still helping less well-performing clients.
Open → 2610.20264v1

Federated multi agent system improves collaboration and privacy over rounds

PFedMA: Who Should Join Next as Federated Multi-Agent Orchestration Evolves?

Abstract: Federated Multi-Agent Systems (FedMAS) offer a promising paradigm for collaborative reasoning among LLM-based agents while keeping raw client data decentralized. However, reliable multi-round collaboration remains challenging. Agent selection must take into consideration evolving task requirements and the agent's historical reliability, while privacy rules must adapt to changing collaboration contexts and meet the client's personalized needs. To address these challenges, we propose PFedMA, a federated multi-agent framework for feedback driven multi-round collaboration under heterogeneous privacy requirements. Across rounds, PFedMA maintains historical capability and reliability states to guide agent selection, evaluates task responses before aggregation, and refines subsequent queries according to accumulated collaboration feedback. PFedMA enables bidirectional local to global and global to local private rule evolution across heterogeneous clients. Clients generalize locally updated privacy rules and selectively incorporate globally maintained rules, thereby facilitating cross-client privacy rule evolution while preserving personalized constraints. Extensive experiments across reasoning, privacy sensitive, and adversarial settings show that PFedMA improves task performance, reduces measured privacy leakage, and improves system robustness.

Wed 14 OctArtificial Intelligence
The gist
When multiple AI agents work together without sharing raw data, it’s hard to pick the best agents each time. The authors propose PFedMA, a system that remembers each agent’s past performance and privacy settings to choose who joins next. It also lets clients update their privacy rules locally while learning from others, keeping their data safe and personalized. Their tests show PFedMA helps the agents work better together, keeps privacy risks lower, and makes the system more reliable.
Open → 2610.19458v1

Private learning of markov chains with optimal sample use

Differentially Private Learning of Markov Chains: Near-Optimal Sample Complexity for Item and User Level Privacy

Abstract: Sequential data such as documents, conversations, and trajectories are naturally partitioned across users, motivating privacy guarantees that protect each user's entire trajectory. We initiate the study of privately estimating the transition matrix of a discrete ergodic Markov chain from N independent trajectories of length T, with arbitrary initial distributions, under maximum row-wise ell 1 error. Besides N, T, and the number of states, our bounds depend on the minimum stationary probability and the pseudo-spectral gap, which govern state coverage and mixing. Under item-level privacy, we give upper and lower bounds that separate the costs of sampling, state occupancy and mixing, and privacy. Under user-level privacy, we reduce the problem for sufficiently long trajectories to private product distribution estimation. Along the way, we establish optimal user-level private bounds for estimating products of discrete distributions, which may be of independent interest. In the user level setting, our bounds are nearly tight in the large T regime, whereas in the item-level setting, our bounds as tight up-to a non-private term.

Wed 14 OctCryptography and Security
The gist
Understanding sequences like user journeys or conversations often involves models called Markov chains. Protecting the privacy of entire user sequences while learning these models is challenging. The authors studied how to estimate such chains privately, balancing accuracy, data size, and privacy levels. They provide nearly the best possible bounds on the amount of data needed to learn Markov chains both at the level of individual items and entire user sequences.
Open → 2610.19335v1

Targeted removal of sensitive facts improves language model forgetting

Decouple to Forget: Semantic Mediation for Sensitive Unlearning in Large Language Models

Abstract: Machine unlearning for large language models seeks to remove specified knowledge while preserving general capability, yet current methods often treat an entire response as the unit of forgetting. This coarse granularity causes unnecessary utility loss when the forget target is only a small set of sensitive facts embedded within otherwise benign explanations. In this paper, we introduce Decouple to Forget (D2F), a targeted unlearning method inspired by semantic mediation that separates sensitive factual content from non-sensitive meaning and surface expression. For each example to be forgotten, D2F extracts a fact-level "mediator" representation from the answer, identifies which parts are sensitive, and removes only those parts while leaving the rest of the structure intact. We then generate counterfactual answers grounded in this mediator that preserve non-sensitive content but exclude sensitive facts, employing preference-based contrastive optimization to reduce the likelihood of information leakage while maintaining helpfulness and fluency. Experiments across various benchmark datasets show that D2F achieves a better balance between forgetting and retention than strong baseline methods. Our code is available at https://github.com/JingyueCong/D2F.

Tue 13 OctComputation and Language
The gist
Sometimes large language models need to forget certain sensitive facts without losing their overall ability to respond well. Existing methods often erase entire answers, which throws away useful information unnecessarily. The authors present a new approach called Decouple to Forget, which identifies and removes only the sensitive parts of an answer while keeping the rest intact. This helps language models forget just the sensitive facts while maintaining fluency and helpfulness.
Open → 2610.17654v1

Data portability should put individuals in control of their own data

Data Portability Revisited: Toward the Human-Centric, AI-Driven Data Ecosystems of Tomorrow

Abstract: This Article critically examines the contemporary regulatory framework and discourse surrounding data portability in the United States. Using recent regulatory developments in the European Union as an illustration, this Article suggests that although data access and portability are identified as vital issues in multiple policy instruments, in its current iteration, at least, legal conceptions of portability continue to reinforce the interests of service providers and data controller enterprises rather than individual end users. This Article argues that a paradigm shift toward a more human-centric data approach to data governance must occur, under which data would be recognized as fundamental to an individual's identity in a digital age. Therefore, it should be placed in the hands of individuals rather than service providers or data controller enterprises. This Article considers technical and market trends in the European Union that reveal and facilitate such a change. It suggests that regulatory frameworks should better align with these technological and market developments to encourage change-inducing trends among market actors. In short, this Article identifies a transformative approach to data portability that empowers individuals with the freedom and ability to aggregate their data in secure personal spaces under their control or dominion. Such a human-centric perspective on data portability is crucial in building Artificial Intelligence (AI)-powered applications for individual consumers that can pave the way for the human-centric, AI-driven data ecosystems of the future.

Sun 11 OctArtificial Intelligence
The gist
Current laws about data portability mostly protect companies that own and manage your data rather than you. The authors argue that data belongs to people themselves, as it is a key part of their identity in the digital world. They discuss how new rules and technologies in the European Union show a path toward letting people gather and manage their data safely on their own. This could help build smarter AI tools focused on individual needs in the future.
Open → 2610.15503v1

Method helps AI forget specific knowledge and admit what it does not know

Decoupling Knowledge Forgetting and Refusal Learning in MLLM Unlearning

Abstract: Current evaluations of multimodal unlearning typically focus on whether a model stops outputting target information. This surface-level criterion, however, masks two critical failure modes. First, knowledge suppression techniques often induce confabulation, leading the model to hallucinate facts about the unlearned subject. Second, refusal training merely alters observable behavior without erasing the underlying knowledge; such models might decline open queries but still identify correct answers under multiple-choice probing. To overcome these limitations, we propose Forget-Aware Self-Distillation (FASD). This method is designed to achieve honest ignorance, a state where the model genuinely loses the target knowledge and learns to acknowledge its absence. FASD separates these goals into two complementary channels. The behavior channel distills appropriate refusals from an ignorance-prompted copy of the model itself. Crucially, target tokens are masked from the teacher distribution to avoid accidentally reteaching the forgotten concepts. Simultaneously, the knowledge channel directly suppresses ground-truth answer spans independently of the model's generated responses. Experiments demonstrate that FASD successfully unlearns target knowledge, prevents information leakage in open-ended tasks, and preserves performance on retained data. The resulting model not only forgets the specified information but accurately recognizes the boundaries of its own knowledge. Code and data will be released upon publication.

Sat 10 OctArtificial IntelligenceComputation and LanguageInformation Retrieval
The gist
AI models sometimes need to forget certain information, but simply blocking answers can make them guess wrong or hide knowledge without truly forgetting it. The authors created a method called Forget-Aware Self-Distillation that helps AI not only lose specific facts but also honestly say it doesn’t know them. This approach uses two parts: one that teaches the AI to refuse to answer and another that removes the actual knowledge inside it. Their tests show the AI forgets correctly and avoids lying or guessing when asked about the forgotten topics.
Open → 2610.14605v1

New strategy improves private prompt tuning accuracy and speed

DP-ES: Differentially Private Evolution Strategies for Prompt Optimization

Abstract: Token-level differentially private (DP) prompt optimization methods such as DP-OPT can become unstable under tight privacy budgets: on GSM8K, DP-OPT obtains $49.5\pm28.5\%$ across 30 runs, and a logged search trajectory reveals prompt-template drift and noise-sensitive irreversible choices. We diagnose these as structural consequences of greedy token-by-token construction over privately aggregated counts. We then propose DP-ES (Differentially Private Evolution Strategies), a structurally cleaner alternative that maintains a population of full prompts, mutates them via LLM calls that never access the private dataset, and spends privacy only on sampled-Gaussian evaluation; deterministic or Gumbel-smoothed selection is post-processing. Under a conservative $(\varepsilon\leq1.0,δ=10^{-5})$ guarantee, DP-ES achieves 88.1% on GSM8K (+38.6 pp over DP-OPT, approximately 9 times lower standard deviation), 99.7% on MedQA, 73.5% on BANKING77, and 86.8% on Alpaca. It is also 2.5 times faster in wall-clock time and uses 3.3 times fewer logged private-data call groups than DP-OPT. Selection and population ablations, implementation-level noise checks, and a 200-profile exact-match memorization stress test complement the formal guarantee. Scope: Our experiments establish optimization robustness under DP noise, especially where prompt structure is critical; end-to-end validation on genuinely sensitive, non-saturated deployment data remains future work.

Mon 5 OctCryptography and SecurityComputation and Language
The gist
Optimizing prompts for AI models while keeping data private is tricky and can lead to poor results with existing methods. The authors found that previous techniques had problems due to how they built prompts one token at a time under privacy constraints. They propose a new method called DP-ES that treats prompts as whole units and uses mutation and selection steps without directly querying private data often, improving both accuracy and stability. This new approach works better on several test datasets and is also faster and uses less private data access.
Open → 2610.06236v1

Agentic language models can identify anonymized interview subjects online

AgentDoxx: Agentic Re-identification of Anonymized Text with Web Search

Abstract: As Large Language Models (LLMs) gain tool use capabilities such as web search, they can retrieve and cross-reference public information, creating privacy risks beyond memorization. One manifestation is re-identification: linking an anonymized interview transcript to a named individual. Yet without ground-truth identities, the coverage of such attacks and the protection offered by a defense cannot be reliably measured. We introduce AgentDOXX, an evaluation suite of 822 synthetic interview transcripts grounded in public information about real individuals with known identities. We evaluate fifteen configurations of open-weight and proprietary models, isolating the effect of web search, and analyze their search trajectories to distinguish retrieval-driven from parametric identifications. Ground-truth identities reveal that re-identification risk is distributed across an agent's execution: retrieval and parametric recall both contribute, with open-weight models identifying 15-28% of transcripts without search; identification succeeds in over 88% of cases once the target appears in a retrieved result; entity masking leaves at least one attacker successful on 85.3% of a stratified sample; and privacy instructions suppress naming but not retrieval, with configurations scoring 0% accuracy yet retrieving the subject in up to 62% of transcripts. We further show that observed attack trajectories can provide supervision for localizing identifying spans, offering a path toward attack-informed anonymization.

Sun 4 OctCryptography and SecurityArtificial IntelligenceComputers and Society
The gist
This paper shows that advanced language models using web search can often figure out who is behind anonymized interview transcripts by looking up public information. The authors created a collection of fake interviews linked to real people to test how well different models can do this re-identification. They found that even without searching the web, some models could guess identities from memory, and searching greatly increased success. Efforts to hide identities or give privacy warnings helped less with web searches than expected. Their work suggests that tracking the search process could help highlight sensitive information that puts identities at risk.
Open → 2610.05586v1

Private learning improves sample efficiency for component based models

Private Component-by-Component Learning

Abstract: We study differentially private learning problems in the realizable setting, where a hypothesis is specified by $k$ components. A direct iteration of private component learners is obstructed by a simple difficulty: an approximate choice of the next component may destroy exact realizability of the labeled sample, even when the next component is locally accurate. We restore realizability using the LabelBoost procedure of Beimel, Nissim, and Stemmer [SODA '15, Algorithmica '21] and recycle data through two alternating reservoirs. The resulting learner, for a target privacy $\varepsilon$, pays only $\widetilde O(\sqrt{k}/\varepsilon)$ overhead relative to the active sample requirement of a single component learning step at target accuracy $Θ(α/k)$. For learning $d$-dimensional halfspaces over a finite coordinate grid of size $L$, exact realizability makes the direct component-depth objective quasi-concave. Instantiating the framework with the IPConcave algorithm of Nissim, Tsfadia, and Yan [SODA '26] and with the quasi-concave optimizer of Cohen, Lyu, Nelson, Sarl'os, and Stemmer [STOC '23] yields a realizable sample complexity of $\widetilde{O}\left(\frac{1}{\varepsilon α}\cdot \min\{d^{2.5} \log^*L, \:\: d^{2.5} + d^{1.5} 2^{\log^*L}\}\right),$ which improves on the previously known bound of $\widetilde{O}\left(\frac{1}{\varepsilon α}\cdot\min\{\frac{1}α\cdot d^{5.5}\log^*L,\:\: d^{2.5}2^{\log^*L}\}\right).$ We also apply the framework to Boolean compositions: given proper private learners for classes $H_1,\ldots,H_k$, we obtain a proper private learner for $G(H_1,\ldots,H_k)$ for any fixed Boolean function $G:\{0,1\}^k\to\{0,1\}$. Compared with the closure theorem of Alon, Beimel, Moran, and Stemmer [COLT '20], this reduces the overhead on a common component sample bound from $\widetilde O(k/\varepsilon)$ to $\widetilde O(\sqrt{k}/\varepsilon)$.

Sun 4 OctMachine LearningCryptography and Security
The gist
This paper tackles how to build private learning models composed of multiple parts while keeping data privacy. The authors solve a problem where small mistakes in learning each part can ruin the overall model’s accuracy. They use a technique called LabelBoost to fix these problems and recycle data efficiently. Their approach reduces the amount of private data needed to learn models with many parts, improving over earlier methods. They also show their methods work well for learning geometric shapes and combinations of simpler models.
Open → 2610.05102v1

Users can influence AI models through deletion request behavior

Modeling Deletion Requests in Machine Unlearning

Abstract: Machine unlearning is seen as a promising approach to enable users to exercise the "right to erasure" in the context of AI models. We ask how users might influence the behavior of models when exercising this right. We define two types of behaviors that users might adopt when requesting the deletion of their data: adaptivity and collectivity. Drawing connections between the goals of users in this context and results in stochastic optimization, we demonstrate theoretical gaps between the potential effects of groups of users who do and do not display these behaviors. We then show how techniques from data valuation might be used to design deletion requesters that can significantly alter model behavior in realistic settings. In experiments on computer vision tasks, we demonstrate the differential effects of different models of user behavior and attempt to isolate the impacts of adaptivity and collectivity.

Sat 3 OctMachine LearningCryptography and SecurityComputers and Society
The gist
When people ask AI systems to delete their personal data, how they make those requests can change how the AI learns or forgets. The authors identified two ways users might ask for deletion: working alone or together and adapting based on responses. They found that these different behaviors can lead to different effects on the AI’s learning, especially when many users are involved. Using methods from data importance measurement, the authors showed how deletion requests could strategically shape model behavior in real-world image recognition tasks.
Open → 2610.04310v1

Auditing privacy of synthetic gene data improves attack detection rates

Auditing the Privacy of Synthetic Gene Expression Data: A Unified Weighted-Distance Framework for No-Box Membership Inference

Abstract: Synthetic gene expression data is increasingly proposed as a privacy-preserving substitute for controlled-access genomic repositories, but its safety depends on empirical auditing. Membership inference attacks (MIAs) provide that audit by testing whether a patient's gene expression profile was used to train a generative model. We report a red-team study on synthetic gene expression data derived from bulk RNA-seq profiles in The Cancer Genome Atlas, released by the ELSA Health 2026 Challenge. We unify five no-box attacks under a single weighted-distance framework in which each variant differs only in how it weights genes: uniformly (baseline), by variance, by synthetic-versus-reference KL divergence, by spectral residualization removing dominant principal components, and by curated pathway membership. Against a conditional variational autoencoder, spectral residualization raises AUC from 0.8251 to 0.8951 and TPR at 1% FPR from 0.3842 to 0.5970 on pan-cancer TCGA. Biological pathway priors did not transfer across targets.

Fri 2 OctCryptography and Security
The gist
Synthetic gene data is made to protect patient privacy but can sometimes reveal if a patient’s information was used in creating it. The authors studied attacks that try to find out if specific patient data was included in training a model generating synthetic gene data. They combined five attack methods into one framework that adjusts how much each gene matters and found that removing common patterns in data improved detection significantly. Using biological knowledge about gene pathways did not help across different data targets.
Open → 2610.04060v1

Differential privacy training improves muon accuracy with inner momentum averaging

Inner Momentum for Differentially Private Muon

Abstract: Differentially private training clips each per-example gradient before adding noise. This clipping is radial for each example, yet unequal clipping factors can distort the relative singular-vector geometry of their average. Muon is particularly exposed to this effect, since its update is an approximate polar factor UV^T that depends only on the singular vectors that clipping can shift. To curb this degradation, we propose averaging each sampled example's Muon gradient over the current model and a short history of recent models before clipping. The clipped batch matrix then separates into a common rescaling and a covariance residual R between sampled gradients and clipping values, with ||R||_F <= sigma_lambda sigma_G, bounding the clipping-induced distortion directly. We further show that a finite Newton-Schulz iteration preserves the polar factor of its input under these spectral conditions, confirming that our correction survives orthogonalization. In private GPT-2 fine-tuning on E2E and DART at epsilon in {1, 2, 4, 8}, DP-Muon-IM improves BLEU and ROUGE-L over DP-Muon in every seed-matched comparison, and non-private diagnostics show 2-4% lower pre-noise polar error.

Fri 2 OctMachine LearningCryptography and Security
The gist
Training AI models with privacy guarantees involves adding noise and limiting how much each example can influence the model. The authors found that a specific training method called Muon suffers when each gradient (direction of learning) is clipped differently, causing distortions. To fix this, they average gradients over recent models before clipping, which reduces distortion and helps keep the model’s updates more accurate. Their approach, tested on language models, showed better performance under privacy constraints than previous methods.
Open → 2610.02738v1

Privacy guarantees improve for gradient descent on noisy objectives

Differential Privacy of Gradient Descent on Perturbed Objectives

Abstract: Objective perturbation adds a random linear term to a regularized empirical risk and releases the exact perturbed minimizer. We study the finite computation obtained by releasing the $N$-th iterate of deterministic gradient descent on $w\mapsto F(w;S)+\langle z,w\rangle$, where $z\sim\mathcal N(0,σ^2I_d)$ is drawn once before optimization. For strongly convex and smooth objectives with Lipschitz Hessian, we prove an explicit condition under which the map $z\mapsto w_N$ is a $C^1$-diffeomorphism on the bounded domains used in the privacy argument, with a quantitative lower bound on the smallest singular value of its Jacobian. This permits a direct change-of-variables analysis of the finite iterate. For generalized linear models, the resulting privacy-profile bound has no explicit ambient-dimension factor once the iteration condition holds, and its finite-iteration correction decreases geometrically. By letting the free truncation parameter grow slowly with $N$, we recover the corresponding exact-minimizer certificate in the limit. We also bound the expected excess empirical risk by $dσ^2/(2μ)$ plus a geometrically decreasing optimization term, and transfer the result to population risk without an additional multiplicative condition-number factor in the leading statistical terms.

Fri 2 OctMachine LearningCryptography and Security
The gist
When machines learn from private data, they need to keep individual data points safe. This paper looks at a way to do this by adding random noise to the learning process and releasing the results after some steps of a common training method called gradient descent. The authors show conditions when this process keeps privacy well and how the privacy improves as the training progresses. They also explain how this method keeps the learning accurate while still protecting data.
Open → 2610.02716v1

Peg-tab improves privacy by fixing copied records in synthetic tables

PEG-Tab: Sampling-Time Record Repair and Release Control for Tabular Synthesis

Abstract: Pretrained tabular generators can reproduce training records even when aggregate utility remains high. When retraining is unavailable or too costly, sampling and release are the remaining intervention points. We present PEG-Tab (Post-Training Energy Guidance for Tabular Synthesis), a post-training repair and release-control framework for frozen tabular generators. For each generated row, a generator-native operator creates two alternatives. A shared calibrated score compares the three candidates, favours lower-risk records, and applies a final release check. We instantiate this interface for GReaT, CTGAN, TVAE, and TabDDPM without updating their parameters. Across five datasets and four generator families, PEG-Tab reduces mean Near Copy from $0.078$ to $0.027$ and lowers aggregate Exact Copy to zero. Relative to a $3\times$ post hoc filter, it retains higher utility in 12 of 16 transfer settings and Pareto-dominates the filter in eight. Gains are concentrated in copy and proximity-related risks.

Wed 30 SeptMachine Learning
The gist
Sometimes computer programs that create fake but realistic tables copy real data too closely, which can risk privacy. The authors developed PEG-Tab, a tool that checks and repairs these copied or very similar records after the program has finished training. PEG-Tab picks safer versions of each generated row without retraining the entire program, lowering privacy risks while keeping the table useful. They tested this approach on different generators and datasets and found it reliably reduces duplicate or copied rows with little harm to data quality.
Open → 2609.39630v1

Multilingual system tags personal data faster and more accurately than before

Strong Multilingual Privacy Tagging at Encoder Speed

Abstract: Privacy redaction must remove personal information while preserving relationships expressed in text. We develop a multilingual named-entity tagger with fine-grained distinctions supporting varied redaction policies and methods for cheaply learning additional distinctions. We fine-tune a multilingual encoder with an affine span-tagging head on frontier-model annotations in 35 languages, replay mapped human gold with coverage-aware masking so unannotated types are not treated as negatives, and repair subword boundaries with a learned +/-1-character adjustment. On 1,283 human-gold test segments in seven languages, best measured redaction F1 is 88.8, against 69.1 for published GLiNER2 with 11 unrepresentable types excluded from its task (68.8 without that exemption), 67.8 for GLiNER2 adapted to the new training data, 57.3 for Microsoft Presidio and 35.8 for the best published OpenAI Privacy Filter fine-tune. Adding about 50,000 annotated training sentences and increasing human-gold replay improves exact typed-span F1 from 74.5 to 76.3 on Ont3, our 31-type frontier-annotated NER evaluation of 1,201 development segments. Mapped-gold replay alone raises human-gold F1 by ten points without loss on frontier-annotated text; boundary adjustment adds 1.7 exact typed-span F1 points on Ont3. Local LLMs fitting on a single 96-GB GPU underperformed as prompted annotators and frozen encoders, with encoding 30-95 times slower than XLM-R inference and prompted annotation roughly 180-1,100 times slower in the evaluated configurations. The encoder architecture delivers 4.9 times GLiNER2's CPU throughput. We release code, prompts and training recipes, with data-acquisition scripts and source links.

Tue 29 SeptComputation and Language
The gist
Finding and hiding personal information in text is important to protect privacy, but it can be tricky to do well across many languages. The authors created a new tagging system that quickly and precisely identifies different types of personal data in 35 languages, doing a better job than previous tools. Their method uses advanced language models fine-tuned with human-reviewed data and clever tricks to avoid errors. It runs much faster than competitors and can be extended cheaply to recognize new kinds of personal info.
Open → 2609.38630v1

Privacy safe counterfactual explanations for graph neural networks

Where Privacy Belongs: Placement Diagnosis and Certified Selection for Private Counterfactual Explanations on Graphs

Abstract: Counterfactual explanations for graph neural networks (GNNs) find the minimal intervention that flips a node's prediction--but computing one requires reading sensitive graph structure, and releasing it discloses that structure. Both existing placements fail. Privatizing the graph before explaining corrupts the target on exactly the borderline nodes needing recourse, manufacturing spurious flips that flip the privatized graph but not the true one. Explaining on the clean graph and perturbing the released explanation resists certification: re-auditing the standard heuristic shows an implied full-release budget of 573--753 on Cora and 256 on CiteSeer--orders of magnitude beyond its advertised budget--with worst-case single-entry leakage at AUC 1.0. We propose PrivCFS, which replaces certification-by-optimization with certification-by-construction: counterfactual selection over a fixed, data-independent candidate universe--edge interventions from a public prior graph, feature interventions from a public schema--whose no-op semantics give neighboring graphs the same output support. A validity-gated, clipped utility of global sensitivity $Δu \le 1$ released through the exponential mechanism gives pure $\varepsilon$-DP for the complete released object, composable over queries--to our knowledge the first such guarantee on graphs. Privacy noise is the cheapest stage: at $\varepsilon$=8 the release retains 94--97% of its support-restricted non-private optimum on the recourse population and 83--95% on the general one; the optimal edge-inference audit attains AUC 0.50 on average and 0.59 worst-pair, versus the heuristic's worst entry 1.0; and transfers to a 15K-node graph at 0.96 valid rate. The dominant cost is a measurable, monotone price in public disclosure, readable off one table before any budget is spent--turning explanation privacy from an accounting risk into a purchasable decision.

Tue 29 SeptMachine Learning
The gist
Graph neural networks make predictions based on graph data, but explaining those predictions can expose sensitive connections in the graph. Existing methods either hide the graph too much or reveal too much, causing problems or privacy leaks. The authors propose PrivCFS, a method that safely selects explanations from fixed, public options, ensuring privacy while maintaining explanation quality. Their approach includes a strong privacy guarantee and works well on real graphs without leaking sensitive information.
Open → 2609.37667v1

Language models forget facts by cutting reasoning links

Making LLMs Truly Forget: Deep Unlearning by Searching, Selecting, and Severing Knowledge Paths

Abstract: While an unlearned language model may no longer recall a fact directly, the fact often remains recoverable through multi-hop reasoning over related knowledge. Most existing unlearning techniques overlook this vulnerability, targeting facts in isolation while leaving their supporting knowledge intact. To achieve true forgetting, we propose a general deep unlearning framework compatible with existing unlearning algorithms. Our approach adaptively explores both explicit responses and latent internal representations to discover valid reasoning paths, compiles them into a confidence-aware supporting subgraph, and we apply a graph minimum cut to sever all recovery paths while preserving unrelated knowledge. To rigorously evaluate deep unlearning, we introduce a model-specific pipeline that extracts and completes knowledge graphs from raw text, filtering them by calibrated model confidence to reflect what the model genuinely retains. Comprehensive experiments demonstrate that selectively unlearning supporting knowledge yields substantially deeper forgetting than superficial methods while preserving model utility, highlighting that genuine unlearning requires breaking the relational structures that enable factual reconstruction.

Mon 28 SeptMachine Learning
The gist
Sometimes when you teach a language computer model to forget a fact, it can still guess that fact by connecting related ideas. The authors show that to really erase a fact, you have to break the links the model uses to reason it out. They create a way to find all the reasoning paths inside the model and then cut them so the fact cannot be recovered. Their method makes the model forget more deeply without losing other knowledge.
Open → 2609.34442v1

Secure distributed computation over hierarchical networks with heterogeneous data

Hierarchical Secure Distributed Linearly Separable Computation with Arbitrary Heterogeneous Data Assignment

Abstract: This paper studies secure distributed linearly separable computation over a three-layer hierarchical network, where clustered users communicate with a central server through relays. The server aims to recover Kc linear combinations of K intermediate outcomes, where each intermediate outcome is a separable function of one dataset. We consider a more general setting with arbitrary heterogeneous data assignment across users, where ''arbitrary'' means that the data assignment is given in advance (which can be in any form) and ''heterogeneous'' means that the users may hold different numbers of datasets. Under this assignment, each user computes the intermediate outcomes of its assigned datasets and sends masked messages to its associated relay. The relays subsequently process and forward the received messages to the server. We impose two security constraints: (i) security against server, requiring the server to learn only the desired task function without gaining any additional information about users' inputs; and (ii) security against relays, ensuring each relay learns nothing about users' inputs. Moreover, the server or any relay may collude with a subset of users. For Kc=1, the underlying computation reduces to distributed gradient coding. We propose a secure scheme tolerating user dropouts and user collusion, achieving the optimal two-layer communication rates in one regime and order-optimal communication rates within a factor of 2 in the other regime. For Kc>1, we extend the proposed construction to multi-dimensional linearly separable tasks under the no-dropout setting.

Sun 27 SeptDistributed, Parallel, and Cluster Computing
The gist
This paper looks at how to safely perform calculations using data spread across many users connected through a three-layer network (users, relays, server). The goal is for the server to get only the final computed results and not learn anything else about individual users’ data, while relays should also learn nothing about the data. The authors handle cases where users hold different amounts and types of data and develop methods that still work even if some users stop responding or try to mislead. Their work extends from simple single-result computations to more complex multiple-result tasks.
Open → 2609.33092v1

Agent framework improves sensitive data redaction without retraining

ASIRF: An Agentic Framework for Context-Dependent Sensitive Information Redaction

Abstract: Sensitive information is defined by domain and intent, not a universal category, yet redaction systems such as privacy filters and named-entity recognizers fix a taxonomy at training time, requiring retraining for each new domain. We introduce ASIRF (Agentic Sensitive Information Redaction Framework), which retrieves domain-specific definitions based on the input's domain from a flexible knowledge base at inference time, needing no retraining to adapt. Two architectures, a three-call multi-agent pipeline and a single-agent variant, are evaluated across ten small open-weight models and eight datasets, including out-of-distribution fictional domains, against the OpenAI Privacy Filter (OPF) as a trained-classifier baseline. With only a few dozen expert-authored definitions per domain and no training data, ASIRF's recall exceeds OPF's in 68 of 80 model-domain combinations (85 percent), by at least one of the two architectures, with shortfalls confined mostly to OPF's training-distribution domains.

Thu 24 SeptArtificial IntelligenceInformation RetrievalMachine Learning
The gist
Sensitive information varies depending on where it appears and why it matters, but current systems must be retrained for each new situation. The authors propose ASIRF, a system that uses expert rules about what counts as sensitive in each setting without needing to learn anew. ASIRF works through flexible knowledge and can handle many types of data, including fictional or unfamiliar ones. It outperforms a common trained filter in most tests without using any training examples.
Open → 2609.29191v1

New method improves identifying training data in large language models

Detecting Pretraining Data in Large Language Models from a Free-Energy Perspective

Abstract: Detecting pretraining data in large language models is challenging because high likelihood can reflect either training exposure or strong generalization. In the joint space of prediction loss and predictive entropy, a likelihood-only detector uses a horizontal boundary and can mistake predictable non-members for members. Motivated by this, we introduce an inclined boundary that evaluates prediction loss relative to predictive entropy. Our analysis shows that entropy correction can preserve the expected membership signal while reducing its variance, thereby improving standardized member--non-member separation. We further extend the mean--variance analysis to the more general setting with a nonzero mean entropy gap. Interestingly, this entropy-adjusted score admits a Helmholtz free-energy interpretation, leading to Energy Transfer Detection (ETD), which views pretraining data detection from a macroscopic residual free-energy transfer perspective. Extensive experiments show that ETD achieves the best average detection performance, improving average AUROC by up to 3.5\% and TPR@5\%FPR by up to 5.1\%, while remaining robust across diverse settings.

Fri 18 SeptMachine LearningArtificial IntelligenceComputation and Language
The gist
It can be hard to tell if a language model like ChatGPT has seen a certain text before or if it is just very good at predicting similar texts. The existing methods sometimes get confused by texts that look predictable but weren’t in the training data. The authors came up with a new way to detect if a model was trained on specific data by looking at the relationship between how surprising the model finds a text and how well it predicts it. Their new approach improves the accuracy of detecting training data and gives a better way to measure it using ideas from physics.
Open → 2609.21888v1

Statistical auditing method measures identity risk of released text

Conformal Privacy Auditing: Calibrated Re-identification Attacks with Statistical Guarantees

Abstract: Empirical identity leakage from released text is increasingly driven by attackers that combine large language models (LLMs) with auxiliary knowledge to link documents to individuals. Existing audits typically report success rates for specific attack pipelines but lack finite-sample statistical guarantees, while training-time protections such as differential privacy are difficult to translate into release-time decisions for individual natural-language documents. We introduce Conformal Privacy Auditing(CPA), a distribution-free calibration framework that provides a statistical certificate of re-identification risk for each released document against LLM-empowered adversaries. CPA outputs a conformal ambiguity set of candidate identities that is guaranteed to contain the true identity with user-chosen confidence under exchangeability, together with an interpretable leakage proxy derived from set size. CPA supports both logit-access and sampling-only attackers, enabling audits of open-source models and proprietary API models in a unified framework. Across multiple release benchmarks and attacker configurations, CPA achieves calibrated coverage and reveals sharp shifts in certified identifiability as auxiliary knowledge, LLM augmentation, and release mechanisms vary, providing a statistically grounded basis for reporting and comparing release-time linkage risk across attacker configurations, datasets, and release mechanisms alike.

Fri 18 SeptCryptography and SecurityComputation and Language
The gist
Text documents released online can reveal who wrote them when attackers use powerful language AI and extra information to guess identities. The authors created a method called Conformal Privacy Auditing that gives a statistical guarantee on whether an identity guess is correct for each document. This method works with different kinds of AI models and helps figure out how risky it is to share certain texts. It shows when the chance of being identified goes up or down depending on how the text is prepared and what extra information attackers have.
Open → 2609.21340v1

Machine unlearning improves forgotten knowledge without changing model weights

Test-Time Unlearning via Sparse Autoencoder

Abstract: Machine unlearning aims to remove specific knowledge from a trained large language model (LLM) without retraining from scratch. Existing methods modify model weights via gradient ascent and its advances. While effective on certain benchmarks, these weight-based approaches exhibit a sharp forget-utility trade-off, where stronger forgetting of target knowledge can degrade model utility, and unlearned knowledge may reappear under post-unlearning fine-tuning or prompt attacks. We propose ARIA (autoencoder-gated inference-time unlearning), a test-time unlearning method that leaves model weights intact and gates access to unwanted knowledge only when generation enters a forget-related state. ARIA uses sparse autoencoder (SAE) latents to train a lightweight linear detector, then applies an interpretable intervention on triggered states with negligible test-time overhead. Empirical evaluations on TOFU, R-TOFU, and WMDP show that ARIA improves the forget-retain trade-off over weight-based baselines across both a thinking model (DeepSeek-R1-Distilled-Qwen-1.5B) and an instruction model (Gemma-3-1B-it), e.g., reducing WMDP-cyber forget-set accuracy significantly while keeping MMLU within 1% of the pre-unlearning model. We further introduce three post-unlearning adversarial attacks targeting weight-space and decoding-space recovery, and find that ARIA remains robust under all three, with forgetting changing by less than 1% under attack. A feature-level case study leveraging the interpretability of ARIA suggests that some retain degradation may reflect response styles underlying the unlearning data rather than leakage of the targeted knowledge itself, highlighting a potential source of bias in unlearning task construction.

Mon 14 SeptMachine LearningComputation and Language
The gist
Removing specific information from large language models without fully retraining them is tough because changing the model weights can hurt their overall performance. The authors propose a new method called ARIA that doesn’t change the model itself but blocks unwanted knowledge only when the model starts to generate that information. This method uses a special tool called a sparse autoencoder to detect when to intervene, which keeps the model working well while forgetting the right things. The authors tested their method on several models and showed it forgets more accurately and resists attempts to recover the forgotten data.
Open → 2609.16229v1

Scalable data influence estimation improves model predictions and interpretation

Data Attribution at Scale via Influence Matrix Estimation

Abstract: Data attribution seeks to quantify how individual training examples shape a model's predictions and underpins problems including data valuation, machine unlearning, and model interpretability. Despite having a long line of work, computationally scalable methods often struggle to predict the effect of removing training data in neural networks due to their non-convex nature. To overcome this challenge, metagradient-based methods such as MAGIC (Ilyas and Engstrom, 2025) differentiate each prediction through the entire training run and compute its exact influence with respect to the training data, but require a separate run for every prediction. To reduce this cost, we cast budgeted attribution as estimating a large influence matrix from a small number of measurements. We show that the measurements most appropriate for recovering this matrix differ from those best suited for attribution itself. We then present two algorithms, MAGE and SPELL, suited for reconstruction and attribution respectively, that run on existing metagradient machinery at no extra cost. Empirical studies demonstrate strong performance over existing baselines across training scales and measurement budgets.

Mon 14 SeptMachine Learning
The gist
Understanding how each training example affects a machine learning model’s predictions is important but computationally expensive, especially for neural networks. The authors look at this problem and find a way to estimate a big matrix that captures these effects using fewer calculations. They introduce two new methods that work efficiently with existing tools and show better results on different sizes of data and compute budgets. This helps make data attribution more practical for tasks like understanding models or removing training data without retraining.
Open → 2609.15044v1

Pimento enforces privacy guarantees for natural language queries

PIMENTO: A Privacy Framework for Querying Text

Abstract: Currently, there are two state-of-the-art, complementary privacy guarantees: contextual integrity (CI) for what may flow, and differential privacy (DP) for what may be inferred. Yet neither maps cleanly onto natural language, leaving existing approaches unable to provide these guarantees for analytics over unstructured text. We address this gap with Pimento, a framework that takes three forms of natural language: text corpus, queries, and privacy policies; and grounds them into a relational database, creating a common substrate on which both guarantees can be enforced formally. With this design, we not only provide end to end privacy guarantees, but also improvement to utility through three key contributions: DP aware Text-to-SQL, which searches for correct queries requiring the least DP noise; CI aware Text-to-SQL, which compiles natural language policies into executable CI rules over the database; and a new privacy definition we call contextual differential privacy, which redefines the traditional DP neighborhood under CI, and yields a tighter smooth sensitivity bound. Across new benchmarks, Pimento selects the best query in 75.3% of cases (upto +45 points over baselines) and achieves zero leakage under correct policy grounding. To our knowledge, Pimento is the first framework to provide formal privacy guarantees for natural language analytics under CI, DP, and their composition.

Sun 13 SeptCryptography and Security
The gist
Handling privacy for queries made on text data is tricky because existing privacy methods don’t fit well with natural language. The authors introduce Pimento, a framework that converts text, queries, and privacy rules into a database format so these privacy rules can be checked and enforced accurately. Pimento combines two major privacy ideas—contextual integrity and differential privacy—making it possible to have stronger privacy protection for text analytics. Their system also improves accuracy by carefully choosing queries that require less noise to maintain privacy.
Open → 2609.14745v1

Stochastic gradient methods with clipping and noise converge reliably

Almost Sure Convergence Analysis of Stochastic Gradient Methods with Clipping and Additive Noise

Abstract: Stochastic gradient descent (SGD) with gradient clipping and additive noise has become a standard technique for training machine learning models, particularly in applications requiring robustness or privacy guarantees. However, clipping introduces a bias in stochastic gradients, while additive noise introduces additional variance, making the long-run behaviour of individual optimization trajectories difficult to characterize. In this work, we prove that SGD with clipping and additive Gaussian noise (SGD-CN) converges almost surely (a.s.) under smoothness and uniformly bounded stochastic-gradient noise assumptions, provided the step sizes satisfy some standard decaying conditions. Our analysis extends to momentum variants such as the stochastic heavy ball and Nesterov's accelerated gradient, where we show that careful energy constructions yield similar guarantees. These results provide stronger theoretical foundations for understanding the pathwise behaviour of clipped stochastic gradient methods and suggest that, despite the bias and noise introduced by clipping and perturbation, the algorithm remains stable in both convex and nonconvex regimes.

Thu 10 SeptMachine Learning
The gist
Training machine learning models often uses a method called stochastic gradient descent, where small steps improve the model based on random samples. Adding clipping (cutting off very large steps) and noise can help make training more robust and private but complicates how the learning progresses. The authors show that despite these complications, the method still converges to good solutions under reasonable conditions. They also demonstrate that similar convergence holds for related methods that add momentum, helping us understand the stability of these popular training techniques.
Open → 2609.12119v1

Neural network spectra predict privacy risks from membership inference attacks

Predicting Privacy Leakage from Weight Spectral Density

Abstract: Membership inference attacks (MIAs) are widely used to audit the privacy disclosure risk of machine learning models, however current state-of-the-art attacks require training computationally expensive shadow models, making large-scale privacy evaluation impractical. In this work, we investigate whether inexpensive spectral metrics derived from the heavy-tailed self-regularisation framework can serve as proxies for MIA vulnerability. We evaluate several WeightWatcher spectral metrics on image and tabular classification tasks and compare their relationship with MIA privacy leakage against conventional measures of generalisation. Across datasets, stable rank exhibits a strong positive correlation with overall MIA success, while Log alpha-Norm shows a consistent negative correlation with MIA vulnerability at the low false-positive regime. These associations are observed to be stronger than those obtained using the generalisation gap. The results indicate that neural network spectra may contain information about privacy leakage that is not fully captured by conventional measures of overfitting, motivating spectral analysis as a promising direction for scalable privacy auditing.

Thu 10 SeptMachine LearningCryptography and SecurityNeural and Evolutionary Computing
The gist
Machine learning models can unintentionally reveal information about the data they were trained on, a problem measured by special attacks called membership inference attacks (MIAs). These attacks usually need a lot of extra work to test privacy risks. The authors found that by looking at certain patterns (called spectral metrics) in the model’s weights, they can estimate how vulnerable the model is to these privacy attacks without doing expensive tests. This new approach could help people check the privacy of many models more easily and quickly.
Open → 2609.11780v1

Differential privacy leaves subgroup risks in synthetic text data

Subgroup Membership Inference Audits of Differentially Private Synthetic Text

Abstract: Synthetic data releases are increasingly proposed in the literature as a means of sharing realistic data replicas in lieu of sensitive private datasets. Even when the worst-case privacy leakage of such releases is bounded by means of differential privacy (DP), in practice a residual risk remains. Membership inference attack (MIA) audits are conducted to empirically quantify this risk. However, existing methods only measure average-case risk for randomly drawn records, which might conceal the risk to vulnerable subgroups. To highlight this issue, we define a subgroup-targeted membership inference game in which the target pool is an explicit parameter, and instantiate it with an audit of 32 proxies under three scenarios with different levels of attacker knowledge, across four datasets, three generators (DP-SGD fine-tuning, API-based prompting, and activation steering), and five privacy budgets. The audit shows that synthetic releases leak subgroup membership and that prior attacks systematically underestimate this leakage. DP is effective at the aggregate level: it substantially reduces average leakage at every budget we test. Three observations temper this picture. First, the remaining leakage is concentrated rather than spread out: under DP, a tenth of the records carries roughly 40% of it. Second, the protection DP delivers in practice is uneven: within its worst-case guarantee, the noise removes more of the measured leakage from random records than from high-risk ones---and a merged-pool audit that scores both record types against shared negatives confirms this at the record level. Third, \emph{which} records leak proves to be a property of the release mechanism rather than of the record alone, so record-level risk cannot be assessed independently of the release.

Wed 9 SeptCryptography and SecurityArtificial Intelligence
The gist
Sharing synthetic data can protect individual privacy, but some groups in the data might still be at risk of being identified. The authors study how well privacy methods actually protect these smaller groups when people try to figure out if specific records were used to create the synthetic data. They find that even when overall privacy looks good, some records leak more information, especially within certain subgroups, and this varies depending on how the synthetic data was made. So, privacy protection is uneven and depends on both the data and the method used to create it.
Open → 2609.09848v1

CUNO improves graph model unlearning for large data deletions

CUNO: Curriculum and Preference Optimization for Stable Graph Unlearning under Mass Deletion

Abstract: Graph unlearning removes the influence of designated training data from a trained graph model without retraining from scratch. However, existing methods suffer a sharp drop in model utility under large deletion ratios (mass deletion), a phenomenon we refer to as catastrophic unlearning. We find that a key cause is the uniform treatment of all deleted samples, which is particularly damaging in graph learning: structural dependencies cause different nodes to play vastly different roles in the learned model, yet existing methods apply the same forgetting operation to the entire forget set. Based on this insight, we propose CUNO, a curriculum-based graph unlearning framework that removes the forget set progressively, ordering samples by their estimated unlearning difficulty across multiple stages. CUNO further employs a distribution-level negative preference optimization (NPO) objective at each curriculum stage that steers the model away from its original behavior on the current forget subset while preserving retained performance. Our theoretical analysis shows that the curriculum design is most beneficial when the forget set spans a wide range of unlearning difficulty, a condition naturally satisfied under mass deletion. Comprehensive experiments confirm that CUNO consistently mitigates catastrophic unlearning: at 20% deletion, it retains 74% of the original utility compared to 26-53% for existing methods, and maintains more than half the original utility even at 50% deletion. Our code is publicly available at https://anonymous.4open.science/r/cuno-D4FF.

Tue 8 SeptMachine LearningArtificial Intelligence
The gist
When parts of data need to be removed from a graph-based AI model, simply forgetting them all at once often harms the model’s performance badly. The authors show that treating all deleted data equally misses the fact that some nodes in a graph are more important than others. They introduce CUNO, a step-by-step way to remove data, focusing first on easier-to-forget parts while guiding the model away from old behaviors on deleted data. Tests show this approach keeps the model working much better even when up to half the data is removed.
Open → 2609.08244v1