AI Tech Inspire

ECCV 2026 U&ME: Call for Papers on Unlearning and Model Editing

If you’ve ever wished you could make a model forget a harmful pattern, surgically add a new skill without a full retrain, or keep systems compliant as data policies evolve, this one’s for you. At AI Tech Inspire, we spotted a timely call for papers that aims squarely at these problems — and it actively welcomes scrappy, evolving ideas that don’t neatly fit the typical conference mold.

Quick facts at a glance

  • The U&ME workshop at ECCV 2026 announced a call for papers focused on unlearning, model editing, controllability, and safety.
  • Organizers encourage submissions from the broader community — especially students and researchers — including unfinished or exploratory work.
  • Welcomed topics include: Unlearning; Model Stitching and Editing; Model Merging and “MoErging” (Mixture of Experts Merging); Model Compression; Efficient Domain Adaptation; Multi-/Cross-Domain U&ME; Online/Lifelong Learning, Unlearning, and Model Editing; Responsible U&ME (robustness, ethics, fairness, resource efficiency, privacy, regulatory compliance); and Applications in computer vision.
  • The goal is to convene researchers and practitioners deeply interested in these questions at ECCV 2026.

Why this matters now

Unlearning and model editing are moving from niche research corners into everyday engineering concerns. Regulations evolve; data can become off-limits; product behavior needs to change without catastrophic side effects. Retraining from scratch is often impractical — think weeks of GPU time, massive datasets, and operational complexity. Practical, verifiable ways to update models in place are a big deal for anyone running production AI.

For computer vision specifically, consider how quickly visual domains shift: new logos, fashion cycles, camera pipelines, cultural norms. A robust unlearning or editing toolkit lets teams react fast — whether removing a class that should not be recognized, correcting a misbehavior in a detection model, or adding a carefully scoped capability to a generative system.

Key takeaway: Reliable unlearning and precise model editing are becoming essential DevOps for AI—change management for parameters.

Unlearning, model editing, and controllability — in plain terms

Think of unlearning as targeted forgetting: making a model behave as if certain data, attributes, or behaviors never influenced its parameters. Model editing is surgical change: injecting or removing knowledge in a small region of a model’s behavior without cascading regressions elsewhere. Controllability is the reliability umbrella: can you predictably steer outcomes with bounded side effects, and can you verify that control?

Across modalities, these ideas are familiar. Developers have long nudged and patched systems built on PyTorch or TensorFlow. Large-scale adaptation shows up in GPT-style language models, diffusion-based image generators such as Stable Diffusion, and multi-expert architectures. What’s new is the push for principled, auditable, and efficient methods that are safe to deploy.

Deep dive on the workshop themes (with practical angles)

  • Unlearning: How to forget a class, a subset of users’ data, or a harmful attribute while retaining overall accuracy? Expect techniques that adjust gradients selectively, distill to new checkpoints, or certify removal via behavioral and representational tests. For vision, imagine removing a sensitive object category from a detector without wrecking performance on visually similar objects.
  • Model Stitching and Editing: Stitching can mean plugging a small adapter or layer into an existing backbone to alter behavior. Editing is more precise: changing how a concept is represented at specific layers. Picture adding a lightweight OCR head to a vision transformer or adjusting a generative model’s concept embedding to reduce unsafe content generation.
  • Model Merging and “MoErging”: Weight merging blends specialized checkpoints; MoErging manages multiple experts and combines their strengths. Practical questions abound: how to align representations before merging (e.g., via CKA-like similarity), how to avoid destructive interference, and whether gating policies recover specialist quality without heavy finetuning.
  • Model Compression: Pruning, quantization, and distillation are back in focus — now with constraints around forgetting or editing. Can a compressed model both meet on-device limits and honor a data-deletion request?
  • Efficient Domain Adaptation: Engineers want quick pivots between domains. Parameter-efficient techniques (e.g., LoRA-style adapters) can double as editing hooks: pivot behavior on a budget while preserving a clean rollback path with Ctrl+Z-like reversibility.
  • Multi-/Cross-Domain U&ME: How do unlearning and editing transfer across related tasks or domains? In vision, this might mean forgetting a class in detection while maintaining alignment for segmentation or retrieval.
  • Online/Lifelong Learning and Unlearning: Continuous updates are risky when they accumulate drift. What unit tests can catch regressions in near-real time? Techniques that balance plasticity with stability are fair game.
  • Responsible U&ME: Robustness, fairness, privacy, resource efficiency, and compliance (e.g., data deletion requests) are front and center. Expect proposals that measure trade-offs transparently and detail audit trails for safety reviews.
  • Computer Vision Applications: From content moderation in generative imaging to sensitive-attribute removal in recognition, the space spans classic and modern tasks. Edge deployment brings additional constraints like CUDA memory ceilings and latency budgets.

What makes this call distinctive

Unlike typical venues that prioritize “polished” stories, the U&ME call explicitly invites unfinished ideas, strange observations, negative results, and projects that don’t fit a standard template. That’s refreshing. Many teams discover the most valuable insights when something fails in a specific, reproducible way.

For developers: this could be the place to share a carefully documented “it didn’t work” that still saves others months of experimentation. A high-quality ablation chart or a sharp failure analysis can be as influential as a new benchmark high score.

Practical starter ideas (that could mature into submissions)

  • Forgetting a fine-grained class: Take a classifier, remove a handful of closely related classes (e.g., bird species), and quantify how well the model preserves accuracy on visually similar neighbors. Report boundary cases and retraining cost vs. editing cost.
  • Editing a concept in a generator: Modify a single concept token in a diffusion model and evaluate drift elsewhere. Include visual side-by-sides, safety checks, and a rollback path using adapters stored in Hugging Face repos.
  • Merging specialists: Merge two vision specialists (e.g., food vs. vehicles) and probe transfer vs. interference. Compare naive averaging, representation alignment, and MoE gating on held-out scenes.
  • Compression under deletion constraints: Quantize a model while honoring a simulated deletion request. Show trade-offs between compression ratio, forgetting effectiveness, and latency on mobile hardware.
  • Online updates with unit tests: Build a small “behavioral unit test” harness that runs after each streaming update to catch regressions in a target behavior or fairness metric.

What reviewers will likely appreciate

  • Clear problem statements: Define what’s being forgotten or edited, how it’s measured, and what counts as success.
  • Auditable evaluation: Include before/after metrics, visualizations, and probe tests for side effects.
  • Baselines and ablations: Compare against simple retraining, naive finetuning, or “do nothing” controls.
  • Compute realism: Report hardware and time. Many readers operate under strict budgets.
  • Reproducibility: Minimal scripts in PyTorch or TensorFlow, environment notes, and one-click runs help others validate claims.

Engineering tips to reduce risk

Consider staging edits as removable modules (adapters, LoRA, or lightweight heads) so you can roll back changes quickly. Maintain a small suite of targeted scenario tests — think of them as unit tests for behaviors. Keep a ledger of edits with dataset hashes to track provenance and support internal audits. Where possible, keep separate checkpoints for “clean” base models and “edited” overlays.

The bigger picture

We’ve seen an industry shift toward modular, inspectable stacks powered by tools like Hugging Face and accelerated by CUDA-class hardware. The next wave demands trustworthy change management: not just making models better, but making them correctable on demand. Vision has unique challenges — distribution shifts, sensitive attributes, and aesthetics — that make the ECCV setting particularly apt.

For many teams, the question is no longer “Can we train a strong model?” but “Can we safely update it, prove what changed, and ensure nothing else broke?” The U&ME workshop is aiming to collect concrete answers, sharp counterexamples, and practical toolkits.

Bottom line: if you’re experimenting with unlearning, stitching, merging, editing, or responsible deployment in vision — even if your idea is still rough — this call is worth a look. The organizers are explicitly inviting the kinds of results that real engineers produce every day: partial wins, odd failures, and carefully scoped fixes.

AI Tech Inspire will be following the workshop closely and highlighting standout ideas that push unlearning and editing from theory to practice. If your work makes developers think “I can apply this on Monday,” you’re exactly the audience this call hopes to reach.

Recommended Resources

As an Amazon Associate, I earn from qualifying purchases.