acceptodds
Under review as a conference paper at ICLR 2027

Obscrowd: Joint Face-Localized Identity Protection for Multi-Portrait Images under Generative Editing

Abstract

Generative image editors can modify group photographs while preserving biometric cues that allow face-recognition systems to identify the depicted individuals. We present Obscrowd, a method that jointly optimizes a single perturbation localized to all detected faces through soft masks. A diffusion teacher-student pipeline with inference-time refinement optimizes identity disruption across simulated edits using an ensemble of face recognizers. We evaluate Obscrowd on group photographs and single portraits, comparing protected faces with matched unprotected controls to distinguish protection from identity loss caused by editing itself. Evaluation examines both crop-edit orderings, transfer to a held-out recognizer, and the effects of perturbation budget and perceptual cost. Across the evaluated editing and processing conditions, Obscrowd reduces biometric similarity significantly relative to matched unprotected controls. Under crop-then-edit evaluation with an instruction-based editor, mean cosine similarity on group photographs falls from 0.662 to 0.287. Joint optimization also achieves protection comparable to independent per-face optimization using approximately one-quarter of the compute. Alongside these gains, protection is limited to detected faces and weakens as wider crops reduce the protected face’s share of the recognizer input. These findings support joint optimization as a computationally efficient approach to protecting multiple faces under generative editing, while identifying cropping and adaptive attacks as priorities for further investigation.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Multi-face privacy protection, generative image editing, face recognition, adversarial perturbations, biometric privacy, teacher–student distillation

Reviews

Among:
Shape:
1234this paper, Top 32%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.50 over 2 reviews, above 68% of the others.
Reviewer_nUSyOpenReview ↗
Rating
2
Confidence
2
Informativeness
1
Presentation
2
Soundness
3
Read review
Paper summary

This paper presents Obscrowd, a protection method against generative image editing by injecting a carefully crafted perturbation into group photographs and single portraits we want to protect. To craft such a perturbation, Obscrowd follows a teacher-student-based framework where the student learns to craft perturbation that reduces the cosine similarity value below a margin mm when added to the target image (implicitly guided by the teacher), even when a fixed family of transformations is applied (directly guided by the student loss). The output perturbation from the student model then serves as the starting point of the subsequent PGD-based refinement. The authors compare Obscrowd with existing anti-editing (PhotoGuard, EditShield) and identity-disrupting protection (FaceLock) works, showing that Obscrowd outperforms these works in terms of the protection gap, i.e., the gap on the cosine similarities from editing before and after protection.

Critical strengths
  • The proposed Obscrowd looks lightweight enough for practical distribution settings, though computation would be a bottleneck.
Critical weaknesses
  • I'm not fully convinced why we need to care about cosine similarity scores. In my opinion, just making the edited face easily detectable looks enough. As shown in Figs 4-6, the baseline protection methods already produce human-visible artifacts after editing, and when such edited images are misused by the adversary, one can easily detect such attempts through these visual artifacts. Of course, the adversary may try to remove such artifacts through image-level refinement after editing, but the authors did not consider such a case. As a result, this makes your method equivalent to just crafting adversarial examples that are robust to diffusion-based editing. I feel that the problem setting must be more clearly stated and well-justified but the current manuscript does not.
Questions for authors
  • Many recent commercial LLM services also support image editing (such as GPT-Image, Grok Imagine, Nano Banana by Gemini) and the attacker can use them without any significant effort. Though I appreciate the authors' effort on testing their method against open-source image editing methods, I think considering such a type of attackers is worth investigating as one of the possible realistic threats. Can Obscrowd also defend against such an attacker who exploits off-the-shelf commercial services?

  • I feel that the threshold choice at a specific FAR=0.01% is somewhat arbitrary. From my understanding, the decision of the FR model serves as the extent to which the protection is strong (lower FAR makes protection easier), and the desired protection level depends on the target scenario. For example, if the defender wishes to prevent the edited face from being misused at high-security thresholds, e.g., banking applications, it suffices to select lower FARs, e.g., FAR=0.001% or 0.0001%. On the other hand, if the defender wants to make the edited image get caught by FR similarity-based crawling, then FAR should be set higher, e.g., 1% or 0.1%. It would be nice if you could clearly justify your choice FAR=0.01%, and provide results on other FAR levels, e.g., 1%, 0.1%, 0.001%, and 0.0001%.

  • I don't think the per-face PGD is a genuine "control". You said per-face PGD excludes the "simulator", A\mathcal{A} drawn from one of nine predefined transformation families (if I correctly understand). However, taking an expectation over such transformations is a well-established standard technique, EOT [AEIK18], in adversarial attacks, and it is quite straightforward for me to add such a technique in your setting. Thus, the baseline should be the PGD attack in accordance with Eq. (5), with zero/randomly initialized δt\delta_{t} instead of one from the student model, the same setting mentioned in the second paragraph of Section 5.6 (Ablations & Robustness). At the end, it seems that the gain from employing the student looks relatively marginal compared to adopting the "simulator". Could you comment on this situation, and clarify how novel your "simulator" is compared to existing EOT-based approaches?

[AEIK18] Athalye, A., Engstrom, L., Ilyas, A., & Kwok, K. (2018, July). Synthesizing robust adversarial examples. ICML 2018.

  • How robust Obscrowd is against FR models with adversarial training?
5 comments
AuthorsOpenReview ↗

Response to Reviewer nUSy (1/3)

Weakness

Thank you for the review. One notable point is that our operating points are FAR = 0.01 and 0.001, i.e. 1% and 0.1%, not 0.01%. The paper writes FAR as a fraction; If needed the revision can use percentages.

Why cosine similarity rather than visible artifacts

We are targeting automatic re-identification systems. A face search engine or crawler ingests the face and relinks back to the original person, where no human looks at the image, so visible artifacts doesn’t stop the link.Cosine similarity is the quantity those systems threshold.

Our data show that visible damage and recognizability are largely independent:

  • PhotoGuard causes the most visible damage among the baselines (face LPIPS 0.156 single / 0.412 group, Table 20). After InstructPix2Pix, the calibrated 2-of-3 majority still rejects only 1% of its single-portrait faces at FAR 1%, against 2% with no protection.

  • FaceLock and EditShield are close to invisible (face LPIPS 0.033–0.060), and their edited outputs stay close to unprotected edits (edit-LPIPS 0.090–0.128). There is no artifact to detect. When the edit succeeds, only 4–19% of Obscrowd faces remain verifiable, against 84–100% for FaceLock and per-face PGD (Table 3).

  • Obscrowd removes identity because it optimizes the quantity recognizers use: it minimizes recognizer similarity directly, through simulated edits, on the face pixels. At similar or lower face LPIPS than PhotoGuard (0.144 vs 0.156 single, 0.216 vs 0.412 group), the same calibrated majority rejects 16% of Obscrowd's single-portrait faces after InstructPix2Pix (44% at FAR 0.1%), against PhotoGuard's 1%.

A detector that flags an image as edited also does not stop a search index from linking the face to the person.

Artifact removal after editing

We ran tests where the adversary edits the protected group photo with InstructPix2Pix, then cleans the edited output with JPEG 75, a Gaussian denoiser or DiffPure. The unprotected control goes through the same process, on 638 faces, with a 1% FAR threshold and 2 of 3 majority recognizer voting.

chainprotected similaritynot verifiedcontrol
IP2P0.28528%5%
IP2P → JPEG 750.28227%6%
IP2P → denoise0.28828%5%
IP2P → DiffPure0.21454%11%

Cleaning the edited image restores no identity. DiffPure damages both images and drops the control from 0.651 to 0.434. Here an attacker is only damaging the very thing they’re trying to recover. We have not tested purifiers designed against our perturbation, and Our Section 6 (Limitations) will state this in the revision.

"Equivalent to adversarial examples robust to diffusion editing"

Obscrowd is an adversarial perturbation against recognizers, as are FaceLock and per-face PGD, and we do not claim a new class of attack. Our contribution is the multi-face setting and how we solve it.

Shared photos often show several people. FaceLock's own paper names multi-person images as an open challenge, IDProtector protects a single face by design, and a whole-image perturbation spends about 91% of its budget off the faces in a typical group photo. Obscrowd places one bounded perturbation on all detected faces with soft masks and optimizes them jointly, with no cap on face count. This costs 4.2× less compute than protecting each face separately, at no measurable loss (paired −0.0009 [−0.005, +0.004], 149 photos).

On group photos (1,373 faces), Obscrowd has the largest gap of all compared methods under VAE, JPEG and InstructPix2Pix (IP2P: +0.375, vs PhotoGuard +0.232, per-face PGD +0.190, EditShield +0.029, FaceLock +0.008)

AuthorsOpenReview ↗

Response to Reviewer nUSy (2/3)

Q1. Commercial editors

Commercial services add server-side moderation, account-level accountability and logging. These do not prevent every misuse, but they raise the cost of abuse in a way that local models do not. They do no content moderation, no usage logging, no rate limits and no terms of service, and they can be fine-tuned or scripted to process images at scale. Therefore We evaluated open-weight editors run locally (SD, SDXL, FLUX), On two editors absent from training and from the simulator, SDXL Img2Img and FLUX.1-schnell, the gap is +0.190 / +0.238 and +0.337 / +0.430 (single / group, Table 26). A service that regenerates the face may also erase identity from the unprotected image, which is why we always report the matched control.

Q2. FAR choice and other levels

We headline FAR 1% for three reasons:

  • It fits the threat. Crawlers and face search favor recall, the setting you place at 1% or 0.1%.
  • It is the hardest point for a defense: As you note, a lower FAR makes protection easier. Every Obscrowd rate rises from 1% to 0.1%.Even Headlining 0.1% would have flattered our scores.
  • The thresholds do not depend on our method: We set them once from 44,850 impostor pairs among unprotected faces. The same thresholds score every method and the control.

Obscrowd, % (FaceNet / AdaFace-1 / AdaFace-2 / majority), unprotected control in brackets:

set, attackFAR 1%FAR 0.1%
single, IP2P80 / 14 / 10 / 16 (9 / 2 / 2 / 2)97 / 42 / 27 / 44 (20 / 3 / 3 / 3)
group, IP2P86 / 23 / 19 / 26 (23 / 5 / 5 / 6)98 / 52 / 38 / 57 (36 / 10 / 8 / 10)

We cannot estimate FAR 0.001% or 0.0001% from 44,850 pairs: about 0.45 impostor pairs would fall above a 10⁻⁵ threshold. Thresholds only rise as FAR falls, so the non-match rates at any lower FAR are at least the 0.1% values.

Q3. Per-face PGD, the student, and the simulator vs EOT

Per-face PGD

We clarify that per-face PGD was included as a negative control to represent conventional adversarial attacks on face recognition (optimizing directly on clean faces without modeling the downstream generative editing pipeline). Its large deficit (+0.225 behind Obscrowd on multi; +0.242 on solo) proves that standard adversarial face perturbations are thoroughly erased by generative editors.

The student

While it is not the main source of strength, the student initialization contributes to an additional consistent gain. For group photographs, under the same simulator at K = 30, the student achieves +0.391, compared with +0.318 for zero initialization and +0.310 for random initialization. At K = 50, the student retains an advantage (+0.370 vs. +0.293 and +0.302, respectively). We therefore do not attribute the entire improvement to the student; rather, the simulator and learned initialization serve complementary roles, with the latter providing a measurable benefit even when the optimizer has access to the same simulator.

The simulator vs EOT

We follow EOT's sampling rule (Athalye et al., 2018): draw one transformation per step and compute the gradient through it. We make no novelty claim for this rule. But our contribution lies in how it is applied:

EOT (Athalye et al., 2018)Obscrowd
Sampling ruleone draw per stepsame
Distributionrotation, rescaling, translation, lighting, noise; 3D renderingstochastic diffusion edits: SDEdit at t = 200/400/600 with fresh noise per draw, text-conditioned SDEdit, VAE round-trip; plus pixel noise
Objectivetargeted misclassification of an ImageNet classifierhinge on identity similarity for every face, three recognizers
Scopeone objectthe whole photo: each draw edits all faces together, one soft-masked δ covers them all (masks overlap on 108 of 149 group photos)
Backward passthrough the transformationSDEdit U-Net noise estimate held fixed (BPDA, Athalye, Carlini & Wagner, 2018)

The EOT based protection methods we compare against also differ from Obscrowd. In their released code, EditShield applies EOT over crop, blur, and resize to shift the editor's image embedding, without an identity objective. FaceLock targets identity using a single fixed VAE encode–decode pass on one face, without transformation sampling.

The choice of transformations matters far more than the sampling. Averaging three draws per step adds +0.012 at matched perturbation density (p = 0.081). Adding the editing surrogates to a transformation-free optimizer adds +0.18 to +0.20, measured with a simulator that held only the diffusion surrogates and pixel noise. Against FaceLock rerun at our L∞ over the whole image, Obscrowd leads by +0.183 [+0.174, +0.192] on 484 of 500 portraits, scored by a recognizer neither method optimized against (Table 21).

AuthorsOpenReview ↗

Response to Reviewer nUSy (3/3)

Q4. Robustness against FR models with adversarial techniques

We evaluated three IR50-ArcFace recognizers from RobFR, sharing the same backbone and training data: a standard model, a PGD adversarially trained model, and a TRADES model. None was used during Obscrowd's optimization. At FAR 1% with K=10:

Obscrowd successfully protects faces against normal recognition models, even ones it has never seen during optimization. However, adversarially trained models can largely overcome this protection. We acknowledge this limitation. But these robust models also perform much worse at recognizing genuine faces, making them less practical in the tested setting.

standardPGD-ATTRADES
group, VAE+0.661 · 88 / 0+0.046 · 0 / 0+0.022 · 1 / 0
group, IP2P+0.380 · 94 / 23+0.018 · 3 / 4+0.009 · 10 / 8
single, IP2P+0.417 · 89 / 6+0.041 · 3 / 1+0.024 · 19 / 5
  • Against the standard recognizer, Obscrowd prevents recognition for 64–94% of protected faces,
  • Against PGD adversarial training, protection drops substantially, with only 0–3% of protected faces becoming unrecognized.
  • Against TRADES, protection is also reduced, with 0–19% of protected faces becoming unrecognized.

This demonstrates that adversarial training can substantially weaken Obscrowd's protection. However, there is an important trade-off: at the same operating point, the PGD-AT and TRADES recognizers correctly recognize only 26% and 72% of genuine LFW pairs from different photographs, respectively, compared with 98-99.5% for the recognizers in our evaluation.

Thus, adversarially trained recognizers can defeat much of Obscrowd's protection, but they also sacrifice considerable genuine-pair recognition performance.

Important to note that, None of the methods we compare against reports this test. FaceLock optimizes and evaluates with the same single recognizer, and PhotoGuard and EditShield use no recognizer. The limitation is shared by the class: Fawkes reports 64% protection against a strongly robust tracker (Shan et al., 2020), and Radiya-Dixit et al. (2022) show that a trainer who fine-tunes on the perturbations breaks Fawkes and LowKey.

Reviewer_4iEFOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper studies proactive protection against face recognition after generative editing. The paper uses soft face masks to localize a jointly optimized perturbation, an offline diffusion teacher to produce training targets, a student network to predict perturbations. It also documents important limitations of existing methods, including visible perturbations, verification outcomes, and weakened protection under wider crops.

Critical strengths

1.The evaluation addresses several consequential confounds in measuring identity protection. In particular, it shows how favorable conclusions weaken under alternative evaluation. 2.The joint multi face formulation offers a efficiency benefit. This supports comparable measured protection at lower cost within the evaluated setting.

Critical weaknesses

1.The reduction in cosine similarity translates into limited protection at calibrated verification thresholds, particularly beyond FaceNet. In Table 14, under VAE reconstruction on group photographs, only 9% and 6% of protected faces become non-matching for the two AdaFace backbones. In Table 15, the corresponding single-portrait non-match rates under InstructPix2Pix are 14% and 10%, versus 2% for the unprotected controls. These are recognizers used during optimization, so the low success rates cannot be attributed solely to unseen-model transfer. Moreover, widening the group-photo crop raises protected similarity to 0.865 against an unprotected value of 0.973 (Table 23). 2.The incremental value of the teacher–student pipeline is not established at matched total inference cost, and the strongest controlled comparisons remain incomplete for the central group-photo setting. The main PGD baseline omits both learned initialization and the attack simulator, so its substantial deficit does not isolate the benefit of learning. The same-K initialization ablation is useful, but the student rollout costs 9.8 seconds out of a 21.2-second deployment, and its reported gain on group photographs is only +0.0250. A joint zero-initialized optimizer using the same simulator could spend that additional runtime on optimization; this comparison is not reported. These results do not invalidate its effectiveness.

Questions for authors

See weaknesses.

3 comments
AuthorsOpenReview ↗

Response to Reviewer 4iEF

Weakness 1

Protection at calibrated thresholds beyond FaceNet

We acknowledge that protection rates against AdaFace at the deployed configuration are modest.

We examined the results relative to existing protection methods under the same evaluation protocol. No comparable method does better on these recognizers. Under crop-then-edit on 515 single portrait faces, InstructPix2Pix, the 2-of-3 majority non-match rates for per-face PGD, FaceLock, PhotoGuard, and EditShield are 1–3%, compared with a 2% unprotected control; Obscrowd achieves 16%

The cause for it’s our hinge margin. Our identity term is a hinge with m = 0.3: once a face falls below 0.3 the gradient is zero, so protected group faces settle at 0.328. FaceNet’s FAR 1% threshold is 0.4590, above that band, and 83% of faces no longer verify. The two AdaFace thresholds are 0.2209 and 0.1614, below it, so the loss never drives faces past them. This is the whole asymmetry you observe, and it is a hyperparameter rather than a property of the method; the revision could report a margin sweep.

Crop widening

We agree this is the main limit of face-localized protection, and our limitations section says so. The cause is face coverage. A CelebA-HQ portrait's face already fills the frame, so a wider crop adds background rather than more of the person: from a 1.3× to a 3.5× margin our single-portrait gap keeps 89% of its value (+0.550 → +0.490, Table 24). A WIDER face covers about 9% of its frame, so a wider crop pulls in hair, shoulders and upper body that the face mask leaves unperturbed, and the group-photo gap keeps 16% (+0.665 → +0.108). Per-face PGD dilutes faster on the same photos (5% retained), so this affects face-localized protection in general. Face size points the same way: the gap is +0.403 for faces under 32 px and +0.499 for faces of 128 px or more (Table 25), although these bins alone do not prove the mechanism. We will move the sweep into the main text and state the operating range.

Weakness 2

Student matched Inference cost

We also conducted the requested computer-matched comparison, evaluating zero-initialized PGD with the same attack simulator at K = 50 steps (≈19.0 s), compared with the deployed teacher–student pipeline at 21.2 s per image.

Group Photographs Step Sweep:

InitializationK = 0K = 10K = 20K = 30 (Deployed)K = 50 (Matched Cost)
Student (Obscrowd)+0.243+0.410+0.393+0.391+0.370
Zero Init—+0.349+0.342+0.318+0.293
Random Init—+0.327+0.327+0.310+0.302

Single Portraits Step Sweep:

InitializationK = 0K = 10K = 20K = 30 (Deployed)K = 50 (Matched Cost)
Student (Obscrowd)+0.111+0.481+0.433+0.412+0.390
Zero Init—+0.451+0.394+0.367+0.343
Random Init—+0.431+0.385+0.363+0.351

The student retains a clear advantage over zero initialization at matched inference cost, including on the central group-photo setting (+0.370 vs. +0.293). Additional optimization steps therefore do not close the gap, supporting the incremental value of the learned initialization beyond simply providing more inference time.

Dear Reviewer,

We sincerely thank you for your time and thoughtful feedback on our work. We have tried our best to carefully address your concerns and questions in our rebuttal.

We would be truly grateful if you could kindly take a moment to review our responses whenever your time permits. We would also be more than happy to provide any further clarification if needed.

Thank you for your reply. I will change the score.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.