diff --git a/WEBSITE.md b/WEBSITE.md index c459d77efea2a..f17e1937a10e2 100644 --- a/WEBSITE.md +++ b/WEBSITE.md @@ -5,7 +5,7 @@ and is not included in the generated website. ## Current scope: academic homepage -The homepage uses a compact biography followed by a linked research map. Its six +The homepage uses a compact biography followed by a linked research map. Its seven selected publications are grouped into coding-agent evaluation, test oracles, AI-system testing, and AIOps. Edit `src/data/research.ts` to update map membership and publication groups together. The map describes thematic connections, not a diff --git a/_bibliography/papers.bib b/_bibliography/papers.bib index f48f570c5e003..a96ab7fbc785f 100644 --- a/_bibliography/papers.bib +++ b/_bibliography/papers.bib @@ -198,3 +198,129 @@ @inproceedings{yu2022automated pdf={https://arxiv.org/pdf/2206.06550.pdf}, slides={MetaIC_slides.pdf} } + +@article{fang2026openrca, + abbr={arXiv}, + title={OpenRCA 2.0: From Outcome Labels to Causal Process Supervision}, + author={Fang, Aoyang and Yang, Yifan and Shang, Jin'ao and Lu, Qisheng and Xu, Junjielung and Wang, Rui and Zhang, Songhan and Zhang, Yuzhong and Yu, Boxi and He, Pinjia}, + journal={arXiv preprint arXiv:2606.27154}, + year={2026}, + selected={false}, + topic={AIOps}, + arxiv={2606.27154}, + url={https://arxiv.org/abs/2606.27154}, + pdf={https://arxiv.org/pdf/2606.27154}, + abstract={Root cause analysis (RCA) poses a holistic test of LLM agentic capabilities, such as long-context understanding, multi-step reasoning, and tool use. However, existing datasets suffer from a fundamental gap: they label only the root cause, not the propagation path connecting it to the observed symptom, which largely simplifies the task to naive pattern matching. To support rigorous evaluation, we introduce PAVE, a step-wise labeling protocol that leverages known interventions from fault injection to reconstruct causal propagation paths. The mechanism is forward verification: reasoning from cause to effect rather than inferring backward from symptoms. Applying PAVE yields OpenRCA 2.0 (500 instances), the first cross-system RCA benchmark with step-wise causal annotations for LLM agents. Across 11 frontier LLMs, recovering the exact root-cause set succeeds in only 20.7% of cases on average. To locate where this difficulty lies, we relax the criterion and find what we call the ungrounded diagnosis: agents identify at least one correct root-cause service in 76.0% of cases, but ground that service in a verified causal propagation path to the observed symptom in only 61.5%. Outcome-only evaluation hides this failure mode; step-wise causal ground truth is the missing piece for trustworthy LLM-based RCA agents.} +} + +@article{zhang2025cleanet, + abbr={arXiv}, + title={CLEANet: Robust and Efficient Anomaly Detection in Contaminated Multivariate Time Series}, + author={Zhang, Songhan and Lai, Yuanhao and Zheng, Pengfei and Yu, Boxi and Tang, Xiaoying and Fu, Qiuai and He, Pinjia}, + journal={arXiv preprint arXiv:2510.22619}, + year={2025}, + selected={false}, + topic={AIOps}, + arxiv={2510.22619}, + url={https://arxiv.org/abs/2510.22619}, + pdf={https://arxiv.org/pdf/2510.22619}, + abstract={Multivariate time series (MTS) anomaly detection is essential for maintaining the reliability of industrial systems, yet real-world deployment is hindered by two critical challenges: training data contamination (noises and hidden anomalies) and inefficient model inference. Existing unsupervised methods assume clean training data, but contamination distorts learned patterns and degrades detection accuracy. Meanwhile, complex deep models often overfit to contamination and suffer from high latency, limiting practical use. To address these challenges, we propose CLEANet, a robust and efficient anomaly detection framework in contaminated multivariate time series. CLEANet introduces a Contamination-Resilient Training Framework (CRTF) that mitigates the impact of corrupted samples through an adaptive reconstruction weighting strategy combined with clustering-guided contrastive learning, thereby enhancing robustness. To further avoid overfitting on contaminated data and improve computational efficiency, we design a lightweight conjugate MLP that disentangles temporal and cross-feature dependencies. Across five public datasets, CLEANet achieves up to 73.04% higher F1 and 81.28% lower runtime compared with ten state-of-the-art baselines. Furthermore, integrating CRTF into three advanced models yields an average 5.35% F1 gain, confirming its strong generalizability.} +} + +@article{lin2026agenteval, + abbr={arXiv}, + title={Mining Workflow Graphs for Black-Box Boundary Testing of Conversational LLM Agents}, + author={Lin, Liting and Yu, Boxi and Zhang, Yuzhong and Briand, Lionel and Niland, David-Paul and Muñoz, Emir}, + journal={arXiv preprint arXiv:2607.06873}, + year={2026}, + selected={false}, + topic={AutomatedTesting}, + arxiv={2607.06873}, + url={https://arxiv.org/abs/2607.06873}, + pdf={https://arxiv.org/pdf/2607.06873}, + abstract={Conversational LLM agents can cause real-world harm when their internal workflows fail, such as completing a transaction without confirmation. Testing these state-dependent failures is difficult because critical boundaries, such as identity checks and confirmation gates, are hidden behind multi-turn conversational prerequisites, rendering them inaccessible to standard tests. We present AgentEval, a black-box testing framework that discovers and stresses these stateful boundaries. AgentEval interacts with an agent to mine a conversational workflow graph, a model of its behavior. Instead of prompting blindly, AgentEval uses this graph's structure to enumerate specific guards and prerequisites as test targets, replaying the conversational path to a boundary before applying a perturbation. AgentEval then executes each test, determining whether it passes or fails using only the conversation turns. We benchmark AgentEval against a privileged, white-box auditor with access to the agent's underlying source code, which AgentEval never sees. On four tau-3-bench agents, AgentEval successfully generates tests covering 23--38 distinct boundaries per agent; ablation studies attribute the gain to the graph's structure: 23 distinct boundaries versus 12 with a prompt-only baseline, at lower duplicate and false-alarm rates.} +} + +@article{xu2026bespec, + abbr={arXiv}, + title={BeSpec: Behavior-Level Specification Alignment for Code Generation}, + author={Xu, Qinghua and Wang, Guancheng and Yu, Boxi and Briand, Lionel}, + journal={arXiv preprint arXiv:2607.02949}, + year={2026}, + selected={false}, + topic={CodeAgents}, + arxiv={2607.02949}, + url={https://arxiv.org/abs/2607.02949}, + pdf={https://arxiv.org/pdf/2607.02949}, + abstract={LLMs have made substantial progress on automated code generation from natural-language descriptions of desired behavior (intent). Most existing methods improve generated programs through execution-guided code refinement: they generate a candidate solution, execute it, and patch the implementation using feedback, while leaving the underlying specification unchanged. This workflow implicitly assumes that the LLM's understanding of the intent is already correct and complete. In practice, however, intents are often ambiguous or underspecified. As a result, even a capable model may produce a correct implementation of the wrong intent, making specification mismatch a central bottleneck. This paper presents BeSpec, a behavioral model-based approach to specification alignment. BeSpec treats the task description as partial evidence about the intended behavior of the correct program. It first builds an explicit behavioral model, which are checkable properties that valid outputs must satisfy. BeSpec then generates candidate programs, executes them on probe inputs, and compares their observed behavior with the predicted behaviors. When observed behavior does not match the predicted behaviors, BeSpec either refines the specification or rejects the candidate program. We evaluate BeSpec with three LLMs on four benchmarks: CodeContests, xCodeEval, APPS, and the contamination-free LiveCodeBench. Against nine baselines, BeSpec achieves the highest Pass@1 and average pass rate across all settings, improving average Pass@1 over the strongest baseline by 8.1%--25.3% relative across the three LLMs. A failure analysis shows that after alignment, most remaining errors stem from algorithmic difficulty rather than misunderstood specifications, while ablation studies confirm that each major component of BeSpec contributes positively.} +} + +@article{cao2026omnifocus, + abbr={arXiv}, + title={OmniFocus: Query-Guided Modality-Balanced Token Compression for Omni-Modal Large Language Models}, + author={Cao, Shijie and Zhang, Qingyu and Yu, Boxi and Zhang, Yuzhong and Cao, Boxi and Lu, Yaojie and Lin, Hongyu and Han, Xianpei and Sun, Le}, + journal={arXiv preprint arXiv:2607.03050}, + year={2026}, + selected={false}, + topic={MultimodalAI}, + arxiv={2607.03050}, + url={https://arxiv.org/abs/2607.03050}, + pdf={https://arxiv.org/pdf/2607.03050}, + abstract={Omni modal large language models (OmniLLMs) have attracted wide attention for their ability to jointly process audio and video, but they generate large token sequences under audio-visual inputs, leading to substantial inference cost. Existing audio-visual token compression methods often rely on unimodal guidance, overlooking the temporal locality of query-relevant evidence in audio-visual inputs and implicitly assuming that the two modalities share a temporally aligned information density distribution. We propose OmniFocus, a training-free query-guided token compression method for OmniLLMs that performs independent importance estimation for video and audio, enabling a modality-symmetric compression design that preserves modality-specific salient evidence while maintaining audio-visual alignment, thereby mitigating the modality bias issue that can arise from unimodal-guided compression. Experiments on the Qwen2.5-Omni model family across four audio-visual benchmarks show that OmniFocus maintains strong compressed performance at low token retention ratios and outperforms existing baselines on several major benchmark scores at 25% token retention. On DailyOmni with Qwen2.5-Omni-7B at 25% token retention, OmniFocus maintains 59.40 accuracy while delivering up to 1.38x prefill speedup relative to the full-token baseline, highlighting a favorable practical accuracy-efficiency trade-off.} +} + +@article{li2026trace, + abbr={arXiv}, + title={TRACE: Trajectory-Based Safety Patch Learning for LLM Post-Training Realignment}, + author={Li, Changyue and He, Jiaming and Yuan, Youliang and Wu, Jialin and Yu, Boxi and Huang, Zhicong and He, Pinjia}, + journal={arXiv preprint arXiv:2607.16242}, + year={2026}, + selected={false}, + topic={TrustworthyAI}, + arxiv={2607.16242}, + url={https://arxiv.org/abs/2607.16242}, + pdf={https://arxiv.org/pdf/2607.16242}, + abstract={Fine-Tuning-as-a-Service (FTaaS) platforms let users train large language models (LLMs) on customized tasks, but this pipeline could erode models' safety alignment. In practice, service providers need to recover models' safety without re-running full alignment, or destroying the utility gained from customized tasks. A line of existing work refers to model parameter merging, which adds a safety patch on the fine-tuned model parameters to shift the model away from unsafe tendencies. However, this merging-based paradigm is fundamentally bottlenecked by task-safety update entanglement: downstream task updates and the safety patch often overlap in their dominant directions, so the merge strength is intrinsically hard to calibrate. If the safety vector is scaled too weakly, harmful components could still dominate, preventing the model from returning to a safe region; if it is scaled too aggressively, it suppresses task-relevant directions and degrades utility. To solve this problem, we shift the focus of merging-based methods from designing online merging operators to offline patch learning, and seek a safety patch that minimally interferes with task-relevant directions while retaining decisive control over unsafe behaviors. We propose TRACE, a trajectory-based safety patch learning framework that (i) simulates harmful tuning trajectories to generate progressively corrupted states, and (ii) optimizes a plug-in patch to recover safety while maintaining utility across varying corrupted base states. Across six benchmarks and two models, TRACE consistently dominates the safety-utility frontier. TRACE reaches nearly 100% safety on all settings, while maintaining comparable utility to the undefended fine-tuned model.} +} + +@article{zheng2026adr, + abbr={arXiv}, + title={Combinatorial Synthesis: Scaling Code RLVR via Atomic Decomposition and Recombination}, + author={Zheng, Jiasheng and Cao, Boxi and Yu, Boxi and Zhang, Yuzhong and Cao, Jialun and Lu, Yaojie and Lin, Hongyu and Han, Xianpei and Sun, Le}, + journal={arXiv preprint arXiv:2605.31058}, + year={2026}, + selected={false}, + topic={CodeAgents}, + arxiv={2605.31058}, + url={https://arxiv.org/abs/2605.31058}, + pdf={https://arxiv.org/pdf/2605.31058}, + abstract={Reinforcement Learning with Verifiable Rewards (RLVR) has recently emerged as the cornerstone for shaping the remarkable coding abilities of Large Language Models (LLMs). However, the scalability of RLVR is severely constrained by the scarcity of sufficiently challenging verifiable code tasks that target near the model's edge of competence. Prior studies often rely on heuristic seed expansions for data synthesis, which severely limits both novelty and difficulty. Consequently, the training value of such data fails to scale proportionally with the size of its synthesis. To this end, we propose Atomic Decomposition and Recombination (ADR), a novel framework that generates verifiable code tasks via decomposition into atomic elements and controlled recombination, thereby enabling the generation of genuinely novel and challenging verifiable code tasks. Experiments and analysis demonstrate that ADR achieves superior originality, difficulty, diversity, and test quality over existing baselines, and consistently delivers greater improvements in code ability across RLVR in diverse downstream domains, including algorithmic programming, tool usage, and data science. Our work sheds light on a new paradigm for novel code task synthesis and scalable RLVR training.} +} + +@article{yu2026rt4chart, + abbr={arXiv}, + title={Retromorphic Testing with Hierarchical Verification for Hallucination Detection in RAG}, + author={Yu, Boxi and Zhang, Yuzhong and Lin, Liting and Briand, Lionel and Muñoz, Emir}, + journal={arXiv preprint arXiv:2603.27752}, + year={2026}, + selected={false}, + topic={TrustworthyAI}, + arxiv={2603.27752}, + url={https://arxiv.org/abs/2603.27752}, + pdf={https://arxiv.org/pdf/2603.27752}, + abstract={Large language models can still hallucinate in retrieval-augmented generation (RAG), producing claims that are unsupported by or conflict with the retrieved context. Detecting such errors remains challenging when faithfulness is judged solely against the retrieved context: many existing detectors return holistic answer-level scores, while others target open-domain factuality or fail to provide evidence-grounded diagnostics. We present RT4CHART, a retromorphic testing framework for context-faithfulness assessment. RT4CHART decomposes an answer into independently verifiable claims, performs hierarchical local-to-global verification against the retrieved context, and assigns each claim one of three labels: entailed, contradicted, or baseless. It further maps these claim-level decisions back to specific answer spans and returns explicit context-side evidence, enabling fine-grained auditing rather than opaque scoring. We evaluate RT4CHART on RAGTruth++ (408 samples) and our re-annotated RAGTruth-Enhance (2,675 samples). RT4CHART achieves the best answer-level hallucination-detection F1 score among the evaluated baselines. On RAGTruth++, it attains a precision of 0.845, a recall of 0.718, and an F1 score of 0.776, representing an 83% relative improvement over the strongest baseline. It also achieves a span-level F1 score of 47.5% on RAGTruth-Enhance. Ablation studies show that claim-based local processing drives most of the observed improvement, while global verification provides selective benefits across datasets. Finally, our re-annotation identifies 1.68X more hallucination cases than the original labels, suggesting that commonly used benchmarks substantially underestimate the prevalence of hallucination.} +} + +@article{yu2021maskgan, + abbr={Neurocomputing}, + title={Mask-guided GAN for robust text editing in the scene}, + author={Yu, Boxi and Xu, Yong and Huang, Yan and Yang, Shuai and Liu, Jiaying}, + journal={Neurocomputing}, + volume={441}, + pages={192--201}, + year={2021}, + selected={false}, + topic={ComputerVision}, + doi={10.1016/j.neucom.2021.02.045}, + url={https://doi.org/10.1016/j.neucom.2021.02.045} +} diff --git a/_news/announcement_9.md b/_news/announcement_9.md new file mode 100644 index 0000000000000..8c743e1a3b886 --- /dev/null +++ b/_news/announcement_9.md @@ -0,0 +1,8 @@ +--- +layout: post +date: 2026-09-12 +inline: true +related_posts: false +--- + +New on the site: recent preprints on [RAG hallucination detection](/publications/#yu2026rt4chart), [conversational agent testing](/publications/#lin2026agenteval), [code specification alignment](/publications/#xu2026bespec), and [causal root-cause analysis](/publications/#fang2026openrca). See the [updated publication list](/publications/) for all recent work. diff --git a/_planning/scholar-update-2026-09-12.md b/_planning/scholar-update-2026-09-12.md new file mode 100644 index 0000000000000..752d2f984a6cd --- /dev/null +++ b/_planning/scholar-update-2026-09-12.md @@ -0,0 +1,40 @@ +# Scholar publication reconciliation + +Source profile: https://scholar.google.com/citations?user=Tat3jMQAAAAJ&hl=en +Checked: 2026-09-12. All 22 profile rows were expanded and reviewed. + +## Deduplication + +The profile lists three versions of arXiv:2501.10711: the original 274-benchmark +survey, the 572-benchmark revision, and the ICML position paper. Keep the existing +`cao2025` record and citation anchor for this single work. The website therefore +contains 20 distinct works after adding nine missing records, rather than copying +all 22 Scholar rows. No changes were made to the Scholar profile itself. + +## Added records and primary metadata sources + +| Key | Source | Status | +| ---------------- | -------------------------------------------- | ---------------------------------- | +| fang2026openrca | https://arxiv.org/abs/2606.27154 | 2026 preprint | +| zhang2025cleanet | https://arxiv.org/abs/2510.22619 | 2025 preprint | +| lin2026agenteval | https://arxiv.org/abs/2607.06873 | 2026 preprint | +| xu2026bespec | https://arxiv.org/abs/2607.02949 | 2026 preprint | +| cao2026omnifocus | https://arxiv.org/abs/2607.03050 | 2026 preprint | +| li2026trace | https://arxiv.org/abs/2607.16242 | 2026 preprint | +| zheng2026adr | https://arxiv.org/abs/2605.31058 | 2026 preprint | +| yu2026rt4chart | https://arxiv.org/abs/2603.27752 | 2026 preprint | +| yu2021maskgan | https://doi.org/10.1016/j.neucom.2021.02.045 | Neurocomputing 441, 192-201 (2021) | + +The eight arXiv records use full authors in citation-author order, exact titles, +publication years, paper URLs, and abstracts from their abstract pages. Formatting +commands in abstracts are converted to plain text. No conference acceptance is +inferred. Preserve the spelling of author names in each source record. + +The Mask-guided GAN record was checked against the Scholar article detail and +Crossref title, full authors, DOI, journal, volume, pages, and year. Its source +abstract in Scholar is truncated, so it is not imported as a complete abstract. + +RT4CHART is included among selected works and linked from the research map; the +other additions have contextual summaries in Research and full publication +records. The new news item is dated as a website update, not as paper acceptance. +Citation counts are deliberately not stored because they change over time. diff --git a/src/components/ResearchMap.astro b/src/components/ResearchMap.astro index 1c6678a8f79b2..dcd96189cc532 100644 --- a/src/components/ResearchMap.astro +++ b/src/components/ResearchMap.astro @@ -45,7 +45,10 @@ import { projects } from '../data/site';
{empiricalResearch.title}

- LightAD examines model choice, preprocessing, and efficiency in log anomaly detection. + LightAD, OpenRCA 2.0, and CLEANet examine model efficiency, causal diagnosis, + and robustness to contaminated data.

diff --git a/src/data/research.ts b/src/data/research.ts index 80009253404b7..ca8aec030f3f0 100644 --- a/src/data/research.ts +++ b/src/data/research.ts @@ -5,14 +5,18 @@ export const researchGroups = [ question: 'What does a passing benchmark establish?', description: 'Strengthening tests and examining the reliability of benchmark results.', projects: ['swe-abs', 'utboost'], - related: [{ name: 'Benchmark design', href: '/publications/#cao2025' }], + related: [ + { name: 'BeSpec', href: '/publications/#xu2026bespec' }, + { name: 'Code RLVR synthesis', href: '/publications/#zheng2026adr' }, + { name: 'Benchmark design', href: '/publications/#cao2025' }, + ], }, { id: 'test-oracles', title: 'Constructing test oracles', question: 'How can we test without a known answer?', description: 'Using relations between programs and executions to detect inconsistencies.', - projects: ['retromorphic-testing'], + projects: ['rt4chart', 'retromorphic-testing'], related: [], }, { @@ -21,7 +25,11 @@ export const researchGroups = [ question: 'Which changes should an AI system respond to?', description: 'Controlled transformations reveal errors in vision and language systems.', projects: ['rome', 'tin'], - related: [{ name: 'MetaIC', href: '/publications/#yu2022automated' }], + related: [ + { name: 'AgentEval', href: '/publications/#lin2026agenteval' }, + { name: 'TRACE', href: '/publications/#li2026trace' }, + { name: 'MetaIC', href: '/publications/#yu2022automated' }, + ], }, ]; @@ -29,7 +37,11 @@ export const empiricalResearch = { id: 'aiops', title: 'AIOps & empirical evaluation', question: 'When is a simpler model enough?', - description: 'Studying accuracy, preprocessing, and computational cost in log anomaly detection.', + description: + 'Studying causal evaluation, data contamination, and efficiency in operational AI systems.', projects: ['lightad'], - related: [], + related: [ + { name: 'OpenRCA 2.0', href: '/publications/#fang2026openrca' }, + { name: 'CLEANet', href: '/publications/#zhang2025cleanet' }, + ], }; diff --git a/src/data/site.ts b/src/data/site.ts index 5a48558e0da72..91bbdfac72f7a 100644 --- a/src/data/site.ts +++ b/src/data/site.ts @@ -11,6 +11,22 @@ export const site = { }; export const projects = [ + { + id: 'rt4chart', + paper: 'yu2026rt4chart', + name: 'RT4CHART', + year: '2026', + venue: 'arXiv', + question: 'Which claims in a RAG answer are supported by the retrieved context?', + summary: + 'Retromorphic testing with claim-level, local-to-global verification identifies unsupported or contradictory claims in RAG answers and links them to answer spans and context-side evidence.', + method: + 'RT4CHART decomposes an answer into independently verifiable claims, checks them against the retrieved context, and assigns each claim an entailed, contradicted, or baseless label. Hierarchical verification maps these decisions back to answer spans with explicit supporting evidence.', + finding: + 'On RAGTruth++ (408 samples), RT4CHART reports precision of 0.845, recall of 0.718, and F1 of 0.776. It also reports span-level F1 of 47.5% on the re-annotated RAGTruth-Enhance dataset (2,675 samples). These results measure faithfulness to retrieved context, rather than open-domain factual correctness.', + topic: 'Trustworthy AI', + links: [{ label: 'Preprint', href: 'https://arxiv.org/abs/2603.27752' }], + }, { id: 'swe-abs', paper: 'yu2026sweabs', diff --git a/src/lib/publications.ts b/src/lib/publications.ts index bda0b886fd43c..d00d9966f94b4 100644 --- a/src/lib/publications.ts +++ b/src/lib/publications.ts @@ -13,6 +13,8 @@ const topics: Record = { AutomatedTesting: 'Automated testing', TrustworthyAI: 'Trustworthy AI', AIOps: 'AIOps', + MultimodalAI: 'Multimodal AI', + ComputerVision: 'Computer vision', }; const localResource = (value: string) => /^https?:\/\//.test(value) ? value : `/assets/pdf/${value}`; diff --git a/src/pages/publications.astro b/src/pages/publications.astro index ab6efd1daa92a..cd7592957582d 100644 --- a/src/pages/publications.astro +++ b/src/pages/publications.astro @@ -24,7 +24,7 @@ const topics = [...new Set(publications.map((p) => p.topic))]; >Find a publication @@ -44,7 +44,7 @@ const topics = [...new Set(publications.map((p) => p.topic))]; class="publication" id={p.id} data-topic={p.topic} - data-search={`${p.title} ${p.authors.join(' ')} ${p.venue} ${p.year}`.toLowerCase()} + data-search={`${p.title} ${p.authors.join(' ')} ${p.venue} ${p.year} ${p.abstract}`.toLowerCase()} >
{p.year}
@@ -59,7 +59,8 @@ const topics = [...new Set(publications.map((p) => p.topic))]; ))}

- {p.venue} / {p.topic} + {p.venue === 'arXiv' ? 'arXiv preprint' : p.venue}{' '} + / {p.topic}

{p.links.length > 0 && ( diff --git a/src/pages/research.astro b/src/pages/research.astro index f2664e332653c..12feda68d625b 100644 --- a/src/pages/research.astro +++ b/src/pages/research.astro @@ -14,7 +14,7 @@ const themes = [ title: 'Constructing test oracles', description: 'For many programs, specifying the right answer is harder than running the program. My work explores relations between executions and between programs as a way to detect failures without enumerating correct outputs.', - projects: ['retromorphic-testing'], + projects: ['rt4chart', 'retromorphic-testing'], }, { id: 'ai-systems', @@ -100,6 +100,19 @@ const themes = [ ); })} + {theme.id === 'coding-agents' && ( + + )} {theme.id === 'coding-agents' && ( )} + {theme.id === 'ai-systems' && ( + + )} {theme.id === 'ai-systems' && (
)} + {theme.id === 'aiops' && ( + + )} )) } +
+
+

Multimodal AI & visual computing

All publications +
+
+

+ OmniFocus (2026 preprint) studies query-guided + audio-visual token compression, estimating importance independently for each modality while + preserving their alignment. Earlier work on mask-guided GANs (Neurocomputing 2021) uses text-body, outline, and shadow masks to guide scene text editing + while preserving style and background. +

+
+
diff --git a/tests/site.test.mjs b/tests/site.test.mjs index 94fd5a6d3b0cc..494f40181e483 100644 --- a/tests/site.test.mjs +++ b/tests/site.test.mjs @@ -60,6 +60,12 @@ test('retains publication keys, authors, chronology, citations, and PDF files', '', ); const entries = bibtex.toJSON(source).filter((entry) => entry.citationKey); + const arxivIds = entries.map((entry) => entry.entryTags.arxiv).filter(Boolean); + assert.equal( + new Set(arxivIds).size, + arxivIds.length, + 'Different titles must not duplicate the same arXiv work', + ); const $ = load(await readFile(join(dist, 'publications/index.html'), 'utf8')); assert.equal($('.publication').length, entries.length); for (const entry of entries) {