acceptodds
Under review as a conference paper at ICLR 2027

FlowGuard: Towards Lightweight In-Generation Safety Detection for Diffusion Models via Linear Latent Decoding

Abstract

Diffusion-based image generation models have advanced rapidly but pose a safety risk due to their potential to generate Not-Safe-For-Work (NSFW) content. Existing NSFW detection methods mainly operate either before or after image generation. Pre-generation methods rely on text prompts and struggle with the gap between prompt safety and image safety. Post-generation methods apply classifiers to final outputs, but they are poorly suited to intermediate noisy images. To address this, we introduce FlowGuard, a cross-model in-generation detection framework that inspects intermediate denoising steps. This is particularly challenging in latent diffusion, where early-stage noise obscures visual signals. FlowGuard employs a novel linear approximation for latent decoding and leverages a curriculum learning approach to stabilize training. By detecting unsafe content early, FlowGuard reduces unnecessary diffusion steps to cut computational costs. Our cross-model benchmark spanning nine diffusion-based backbones shows the effectiveness of FlowGuard for in-generation NSFW detection in both in-distribution and out-of-distribution settings, outperforming existing methods by over 30% in F1 score while delivering transformative efficiency gains, including slashing peak GPU memory demand by over 97% and projection time from 8.1 seconds to 0.2 seconds compared to standard VAE decoding.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Diffusion Models, Content Safety Detection

Reviews

Among:
Shape:
1234this paper, Bottom 25%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.75 over 4 reviews, above 25% of the others.
Reviewer_Bk7NOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper targtes at the question of NSFW classifier in Latent Diffusion Models. Traditional Pre-generation methods struggles with the gap between the textual propmt safety and visual image safety, post-generation methods have to wait for the full image finish being denoised which leads to inefficiency. The authors propose FlowGuard, a novel cross-model in-generation frameworks that allows detection within the denoising process. By leveraging linear approximation for latent decoding, curriculum learning and constructing a dataset containing images from different intermediate steps and different underlying model types, FlowGuard achieves the highest ID and OOD performance while reduces the time latency and peak GPU memory.

Critical strengths
  1. Practical problem targeting: The paper targets cross-model in-generation detection, a setting where existing in-generation detectors (Wukong, IGD) requires a separately trained detector for each backbone. The decomposition proposed in this paper makes adding new backbone to the system inexpensive. On four held-out backbones, the detector is kept frozen and only the linear decoder is fitted, without any safety labels.
  2. Higher performance with lower inspection overhead: Replacing VAE decoding with the linear projection reduce per-step decoding time from 8.1 s to 0.2 s and peak GPU memory by over 97% at batch size 50, which makes inspecting intermediate states actually affordable.
Critical weaknesses
  1. Detection is performed only at step 20. At inference, FlowGuard inspects a single fixed step (step 20 of 50) for all backbones and all samples, which is not adaptive. From Fig. 3 it seems detection at earlier steps may already be enough for some backbones, in that case unsafe generations could be terminated earlier and more computation could be saved.
  2. Baselines in Table 2 are not retrained on the constructed dataset. The post-generation baselines are applied directly to step-20 reconstructions, while FlowGuard is trained on reconstructions from the same dataset. Several baselines label every sample as unsafe (recall 1.000), which indicate that they are evaluated on inputs they were not designed for. So the comparison may be unfair, and it’s still unclear how much of the improvement come from the proposed method itself rather than from training on in-domain data.
Questions for authors
  1. How was step 20 chosen as the detection step? Is there any possible addaptive mechanism that we could design so that under different conditions and underlying models, we could decide at which specific steps we need to call the detector for a detection. For example, some images may already could be detected at early steps, while some other tricky situations we may need to wait until the later steps
  2. How would the post-generation baselines in Table 2 perform if they were retrained or fine-tuned on the same step-20 reconstructions used to train FlowGuard?
  3. Could you add a control trained on the same multi-step data without curriculum ordering, so that the gain of curriculum learning can be separated from the effect of more training data and broader noise-level coverage?
  4. Appendix C states that FlowGuard is 0.047 below Wukong, while Table 3 reports 0.880 vs. 0.833; which one is correct?
Reviewer_3WUWOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes a safety detection method, namely Flowguard, for text-to-image generation. This method’s novelty is to enable in-generation detection instead of post-generation and cross pretrained models.

Specifically, this method first uses a linear Network to approximately decode latent in generation into an image, then uses a ViT-based detector to classify whether the generation is safe. This paper trains a per-model linear Neural Network to project latent back to image space by aligning the decoding result with the corresponding VAE decoding result. It then trains the safety predictor based on ViT-16 on 224-resolution approximately decoded images. Its training data is annotated by LLMs, while its test set is manually annotated, which ensures the ground truth of test images for fair comparison.

Critical strengths
  1. This paper enables in-generation and on-the-fly safety detection for text-to-image generation, which may stop unsafe generation earlier; this novel and practical problem setting could be of interest to the community.
  2. This method might enable other kinds of detections during generation, which enable finer control over the generation process.
  3. This method also helps to slightly improve the detection performance over some baselines.
Critical weaknesses
  1. There are no experiments in indicating whether the linear decoded image approximates well to VAE decoded images to make it suffice for semantic discrimination. Also, original latents, if normalized and visualized, are semantically discriminative enough.
  2. This paper introduces the use of intermediate latent to allow early stopping; however, it is also possible to do 1-step generation (eg., by DDIM or Euler Discretization) from the current intermediate noisy latent and timestep towards the end, which allows even cleaner latent and makes LPF useless without introducing any additional Neural Function Evaluation.
  3. This paper’s method, especially the linear approximated decoding, might be restricted by training resolution of each model, since different resolutions will change the dimensionality while the trained linear NN has fixed dimensionality; if the linear transformation acts per-pixel, which resolves this problem, the interaction between different "pixels" of latent won't be captured.
  4. The proposed method is only evaluated on 50 denoising steps, so does its save in computation; however, current models (eg. FLUX) only need 30 steps to achieve full performance.
Questions for authors
  1. Could authors clarify why current more complicated pipeline over simply detect safety directly on latent since latent after normalization shows semantic content by visualization, it is also possible to perform rescale in latent space to uniform the resolution to also bypass per-model latent projection, and the detection time can be further saved since no additional decoding or projection Network is needed. In short, combined with the raised points in weakness, can the authors clarify the current pipeline over the following pipeline: 1-step generation to final clean latent -> normalize and rescale the latent -> detection Network to predict whether safe on each or selective channels of latents. Are there any empirical or theoretical insights for the current pipeline? (This is the major concern; if this can be at least partly resolved, I will raise my rating.)
  2. Why not perform some experiments on different numbers of generation steps, especially 20-30 which is the effective range of number of generation steps for models evaluated in this paper.
Reviewer_4Do2OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper focuses on detecting unsafe content during image generation across different diffusion models. To improve efficiency, it uses a small linear decoder for each generator to turn intermediate latents into rough image previews, which are checked by a shared safety classifier so unsafe generations can be stopped early. The paper reports better detection performance than previous method on both in-distribution and out-of-distribution models.

Critical strengths
  • Detecting unsafe content before generation finishes is an important efficiency problem
  • The design is simple and effective. Each generator gets a small decoder, while all generators share one safety classifier. Adding a new generator does not require new safety labels.
  • Various generation models are evaluated, including OOD models.
Critical weaknesses
  • An important ablation is missing. What happens if we use the original VAE decoder with the same classifier and training data? This would help show what the linear decoder adds.
  • FlowGuard is trained on noisy intermediate images, but the main baselines are not. The comparison is not fair enough.
  • It is unclear whether 100 training pairs are enough. The authors should try different amounts of data and also different sample distributions.
Questions for authors

see weakness

Reviewer_mVuzOpenReview ↗
Rating
1
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary
  • Detects NSFW content during generation for diffusion/flow backbone. Each backbone gets its own affine latent2RGB decoder. The decoded image is low-pass filtered with an FFT, then passed to a shared ViT-B/16 trained with a step-wise curriculum and a temporal-consistency loss
  • Builds a trajectory dataset: about 4k T2ISafety toxicity prompts × 9 backbones; 5 backbones are ID and 4 are held out as OOD
  • Headline result at step 20/50: mean F1 rises from 0.69 to 0.85 over zero-shot post-hoc classifiers. Decoding costs >97% less memory and runs >2 orders of magnitude faster than the VAE
Critical strengths
  • The problem is practically relevant: one detector for a heterogeneous, fast-changing fleet of image generation models
  • The recipe is simple and cheap. A per-backbone decoder needs no safety labels, and the detector stays frozen on OOD backbones.
  • Useful artifact: full denoising trajectories across 9 backbones would be great for community, if the dataset is released.
  • The paper reports honestly where baselines degenerate (Tab. 2 recall = 1.0).
Critical weaknesses

Novelty and positioning

  • It is unclear what goes beyond SLD [1] and UCE [2]. Both already exploit the early emergence of unsafe semantics or linear structure in the generation process. The paper cites [1] only as concept erasure, discusses neither as a conceptual precursor, and does not cite [2] at all.
  • Universal Guidance [3], which applies off-the-shelf clean-image classifiers to x̂₀ predicted from a noisy x_t, is missing. ẑ₀ is mentioned only in passing and is never used as an input or baseline.
  • The linear latent2RGB preview is common community practice (latent-preview factors, TAESD [4]), so calling it "a novel linear approximation" (abstract) is overstated.
  • The claim that cross-model in-generation detection "remains underexplored" is contradicted by prior work:
    • [5] does cross-architecture in-generation filtering via x-pred on Z-Image and Qwen-Image, two of the four OOD backbones here.
    • [6] does early, one-step NSFW detection.
    • [7] applies lightweight latent probes during generation.

Missing baselines (latent / interpretability side)

  • There are no latent-space intervention or classification baselines: linear probes on raw z_t [8], activation or concept directions [9], SAE features [10]. The pipeline (affine map to LPF) is linear up to the ViT, so a probe directly on z_t is the obvious control.
  • It is neat that a classifier works on decoded latents, but without these baselines the necessity of the decode to ViT design is not established.
  • The post-hoc baselines are weak. They are fed noisy step-20 reconstructions zero-shot and are not retrained. Falconsai predicts everything as unsafe on all 9 backbones, and LlavaGuard gets P = R = 0 on PixArt and Flux2 (Tab. 2).
  • Missing fair controls:
    • the same ViT + LPF + curriculum trained on full VAE decodes of z_t (instead of linear reconstructions), to quantify the detection-accuracy cost of the linear approximation; Fig. 5 reports only its speed benefit. It is also unclear whether the Tab. 2 baselines receive linear reconstructions or VAE decodes;
    • an off-the-shelf classifier on decoded x̂₀ [3, 5];
    • Falconsai fine-tuned on the same data;
    • a timestep-conditioned noisy classifier [11].
  • The post-hoc baselines are thin. Standard image-safety classifiers and benchmarks are missing: the SD safety checker, Q16, ShieldGemma 2, UnsafeBench [12–15].
  • The in-generation baselines are compared on SDv1.5 only, with a single reproduction.

Timestep conventions / schedule comparability

  • The indexing is unusual and confusing. "Step 49 is nearly clean", whereas the standard convention is t = 0 clean with t ∈ [0,1] (continuous / flow matching) or t ∈ [0,1000] (DDPM). The appendix then introduces a second, reversed index s.
  • The sampling setup is never specified. Only T = 50 is given; scheduler/sampler, shift, guidance scale, resolution and seeds are missing, as is which Z-Image variant was used (base or the 8-step distilled Turbo). Since detection is defined by step index, this is critical:
    • The default schedulers differ by more than shift (HF scheduler_config.json): PNDM (SDv1.5), Euler-discrete ε-pred (SDXL), DPM-Solver++ with linear β (PixArt-Σ), and flow-matching Euler with shift 3 (SD3/3.5), resolution-dependent dynamic shift (Flux1/2, Qwen-Image) or shift 6 (Z-Image base).
    • Under these defaults, "step 20 of 50" is roughly SNR 0.19 for SDv1.5/SDXL, 0.07 for Qwen-Image, 0.03–0.05 for PixArt-Σ, SD3 and Flux, and 0.01 for Z-Image base, a spread of about 15×. Shared step indices in the curriculum and evaluation therefore mean different noise levels per backbone.
    • The background section describes only DDPM ε-prediction, whereas 6 of the 9 backbones (SD3/3.5, Flux1/2, Qwen-Image, Z-Image) are flow-matching / velocity models.
    • The paper argues that a deployed detector must stay reliable "when a backbone changes its noise schedule or its number of sampling steps", but never tests a change of scheduler or step count.
    • Detection should be reported against σ/SNR, not step index (Tab. 2, Fig. 3).

Deployment realism: timestep distillation missing

  • The paper's motivation is deployment, yet every trajectory uses T = 50. Production models are timestep-distilled (about 1–8 NFEs, e.g. Flux-schnell, Z-Image-Turbo, SDXL-Turbo / LCM [16, 17]).
  • At 4–8 steps the trade-offs change completely. There are only 1–3 intermediate states to inspect, the savings from early exit are marginal, and the latent-preview quality is very different. There is no analysis or ablation of this.

Efficiency claims (Fig. 5)

  • Fig. 5 is hard to interpret. Decoding with the SDv1.5 VAE at about 8.1 s for batch size 1 is implausible on an H100, where tens of ms is typical.
  • It is also unclear how 20 measured instances relate to batch size 50.
  • The cost of the classifier itself (ViT-B/16 at 224px, plus the FFT LPF) is not included. Only decoder cost is compared.
  • The comparison is unfair: a 128px linear output against a 1024px VAE decode. Fair comparisons would be a low-res or tiled VAE decode, TAESD [4], or a probe directly on z_t.
  • No end-to-end saving is reported, i.e. how many denoising steps or GPU-seconds early exit saves in practice. The cost of false positives, where safe generations are killed, is also not quantified.

Internal inconsistencies in reported numbers

  • Tab. 2, Falconsai: recall = 1.0 implies precision = the unsafe fraction of the test set. That conflicts with Tab. 1. Qwen-Image should give 496/696 = 0.71 (reported 0.501); SD3.5 should give 0.46 (reported 0.576); SDXL should give 0.50 (reported 0.452).
  • Tab. 2, Qwen3-VL: these values are infeasible given the split sizes in Tab. 1.
    • SD3: P = 0.020 with R = 1.0. With 200 unsafe samples this needs about 9,800 false positives, but there are only 200 safe samples.
    • SD3.5: P = 0.004 with R = 1.0 is infeasible for the same reason.
    • Qwen-Image: P = 0.288 with R = 0.859 needs about 1,050 false positives against 200 safe samples.
  • The appendix claims FlowGuard's F1 of 0.880 is "0.047 below Wukong" and that "Wukong ... obtains the best F1". Tab. 3 shows Wukong at 0.833, which is lower.
  • The ablation reports F1 of about 0.94–0.95 (Fig. 4), while the main results show about 0.85–0.90 (Tab. 2). The split and step behind Fig. 4 are not stated.
  • "The linear decoder owns between 12 and 0.31 M parameters" is garbled. The 128×128 output equals the latent grid of an 8× VAE at 1024², and 12 = 4×3 matches a per-pixel channel map for 4-ch latents. This suggests D_lin is a 1×1 C→3 projection (i.e. the standard latent-preview factors), not a learned decoder. The 0.31 M upper bound, and how 64×64 latents (SDv1.5 at 512², Flux2) reach 128×128, are unexplained.

Method / evidence

  • The theoretical justification is hand-wavy. Trajectory latents are not a small neighbourhood in which a first-order Taylor expansion holds, no error bound is given, and the Lipschitz constant of a ViT is not controlled.
  • The OOD claim is weaker than stated. Three of the four "OOD" backbones reuse the VAE / latent space of an ID backbone (Tab. 1, per the HF vae/ configs and weights):
    • Z-Image (OOD) uses the FLUX.1 VAE (ID): the weight file is byte-identical (same SHA-256), and the config names flux-dev as its source.
    • SDXL (OOD) and PixArt-Σ (ID) share a latent space. PixArt-Σ ships sdxl-vae-fp16-fix (SHA-256 identical), an fp16 fine-tune of the SDXL VAE with the same 4-ch architecture and scaling_factor 0.13025.
    • SD3.5 (OOD) uses the SD3 VAE (ID): same 16-ch architecture and scale/shift (1.5305 / 0.0609), and all 244 tensors equal up to fp16 vs. bf16 rounding.
    • Only Qwen-Image has a genuinely different VAE (Wan-style, AutoencoderKLQwenImage). The ID set also covers all three latent families: 4-ch SD/SDXL, 16-ch Flux/SD3, and 32-ch Flux2.
    • So "OOD" mostly tests a new denoiser on a known latent space, not a new latent space. The per-backbone linear decoder is near-identical to an ID one.
    • The two weakest OOD results (SDXL 0.735, SD3.5 0.739 F1, Tab. 2) come from backbones whose VAEs are shared with ID backbones. Whatever limits transfer is therefore not the latent space, which the paper doesn't analyse.
  • Possible prompt leakage: the same ~4k prompts are rendered by all 9 backbones. If test prompts also appear in training on other backbones, OOD measures generalisation to a new backbone on seen prompts, not to new content (the paper says "samples", not prompts).
  • The curriculum ablation is confounded. "w/o CL" trains at a single static noise level, whereas the full model sees many steps. A baseline trained on all steps without a curriculum is needed. The consistency loss is not ablated at all.
  • Labels:
    • Each trajectory has one label taken from the final image, even when unsafe content appears only late.
    • Training labels come from Qwen3-VL-32B with "UNSAFE if any reasonable doubt", and a model from the same family serves as a baseline.
    • Annotator count, agreement and guidelines for the human-labelled test set are not reported.
  • The NSFW definition is broad (horror, "disturbing", hate). This mismatches nudity-only classifiers such as Falconsai, which partly explains their poor scores.
  • Statistical rigour: there are no seeds, variances or CIs. Main results use a single detection step (20) and a fixed threshold of 0.5.
  • Adversarial robustness is not evaluated, even though jailbreaks motivate the paper. Attack benchmarks such as [18, 19] are not used. The detector is a fully differentiable linear decoder plus ViT, so white-box evasion through guidance is easy.

References

  • [1] Schramowski et al., Safe Latent Diffusion, CVPR 2023 (cited only as concept erasure)
  • [2] Gandikota et al., Unified Concept Editing in Diffusion Models (UCE), WACV 2024
  • [3] Bansal et al., Universal Guidance for Diffusion Models, CVPRW 2023
  • [4] Boer Bohan, TAESD: Tiny AutoEncoder for Stable Diffusion (GitHub, 2023); also per-model latent_rgb_factors in ComfyUI / A1111
  • [5] Taniguchi et al., EDGE-Shield: Efficient Denoising-staGE Shield for Violative Content Filtering, arXiv 2604.06063, 2026 (effectively concurrent)
  • [6] Park et al., Training-Free Framework for Defending Unsafe Image Synthesis Attack (SC-Pro), ICASSP 2026 (arXiv 2501.05359, Jan 2025)
  • [7] Khatri & Prabhu, Latent Space Probing for Adult Content Detection in Video Generative Models, DSN-W 2026
  • [8] Chen et al., Beyond Surface Statistics: Scene Representations in a Latent Diffusion Model, arXiv 2023
  • [9] Li et al., Self-Discovering Interpretable Diffusion Latent Directions for Responsible T2I Generation, CVPR 2024
  • [10] Cywiński & Deja, SAeUron: Interpretable Concept Unlearning in Diffusion Models with Sparse Autoencoders, ICML 2025
  • [11] Dhariwal & Nichol, Diffusion Models Beat GANs on Image Synthesis, NeurIPS 2021
  • [12] Rando et al., Red-Teaming the Stable Diffusion Safety Filter, arXiv 2022
  • [13] Schramowski et al., Q16: Can Machines Help Us Answering Question 16 in Datasheets…, FAccT 2022
  • [14] Zeng et al., ShieldGemma 2: Robust and Tractable Image Content Moderation, arXiv 2025
  • [15] Qu et al., UnsafeBench: Benchmarking Image Safety Classifiers on Real-World and AI-Generated Images, CCS 2024
  • [16] Sauer et al., Adversarial Diffusion Distillation (SDXL-Turbo), ECCV 2024
  • [17] Luo et al., Latent Consistency Models: Synthesizing High-Resolution Images with Few-Step Inference, arXiv 2023
  • [18] Yang et al., MMA-Diffusion: MultiModal Attack on Diffusion Models, CVPR 2024
  • [19] Tsai et al., Ring-A-Bell! How Reliable are Concept Removal Methods for Diffusion Models?, ICLR 2024
  • [20] Chen et al., Deep Compression Autoencoder for Efficient High-Resolution Diffusion Models (DC-AE), ICLR 2025

Additional related work from automated literature review

  • Other missing related work:
    • Fast decoding of noisy latents: PiD (arXiv 2605.23902).
    • Safety classifiers: Unsafe Diffusion (Qu et al., CCS 2023), Llama Guard 3 Vision (Chi et al., 2024), SafeVision, VModA.
    • Attacks: UnlearnDiffAtk (ECCV 2024), JailbreakDiffBench.
    • In-generation safety: SafeGen (CCS 2024), SafeCtrl, Disciplined Diffusion, SafeDIG, TrajShield.
    • Pre-generation guards: GuardT2I (NeurIPS 2024), PromptGuard, SafeGuider, PurifyGen.
    • Semantic latent space and erasure: h-space (Kwon et al., ICLR 2023), MACE (Lu et al., CVPR 2024).
  • Citation errors in the existing reference list:
    • Falconsai is attributed to Xue et al. 2025 (Falcon dataset), which appears unrelated to the HF model Falconsai/nsfw_image_detection.
    • Rombach et al. 2022 is listed twice (2022a/b).
    • Chin et al. (P4D) is dated 2026; it is ICML 2024 / arXiv 2023.
    • "Diederik & Max (2019)" has first and last names swapped.
    • FLUX.1 Kontext (an editing model) is cited for FLUX.1-dev (T2I).
    • ToxiGen (a text hate-speech dataset) is cited as a T2I pre-generation filter.
    • SAFREE is cited as an in-generation detector, but it is a steering method.
Questions for authors
  1. How does FlowGuard differ conceptually from SLD/UCE-style in-generation use of early semantics [1, 2], and from classifier-on-x̂₀ approaches [3, 5]? Why not classify the Tweedie / x-pred ẑ₀ instead of z_t?
  2. What do you get with a linear probe, activation direction or SAE-feature classifier directly on z_t or the denoiser's activations, per backbone and shared [7–10]?
  3. How does performance and savings change on timestep-distilled models (Flux-schnell, Z-Image-Turbo, SDXL-Turbo [16]) with 1–8 steps?
  4. Which scheduler/sampler, shift, guidance scale, resolution and Z-Image variant were used per backbone? Can you report detection versus σ/SNR rather than step index, and evaluate robustness to a change of scheduler or step count?
  5. Fig. 5: what hardware, precision, resolution and batching gave 8.1 s for one SDv1.5 VAE decode? What is the total overhead including the ViT and the FFT, compared with TAESD [4]? What is the end-to-end saving in denoising steps or GPU-seconds after accounting for false-positive aborts?
  6. Please reconcile Tab. 2 with Tab. 1: the Falconsai precision versus class balance, and the infeasible Qwen3-VL precision/recall pairs on SD3, SD3.5 and Qwen-Image. Also reconcile the Wukong vs. FlowGuard statement in the appendix with Tab. 3.
  7. Is D_lin a per-pixel 1×1 C→3 projection? What are the per-backbone latent and output resolutions, the parameter counts (which backbone needs 0.31 M?), and how are 64×64 latents mapped to 128×128?
  8. Given that Z-Image, SD3.5 and SDXL reuse ID VAEs, what happens on a backbone with a truly novel latent space, e.g. a DC-AE [20] or pixel-space model?
  9. Are test prompts disjoint from training prompts across all backbones?
  10. What do you get from a no-curriculum, all-steps baseline, and from an ablation of λ for L_consis?
  11. How many human annotators were there, how were they recruited, what are their demographics, and how were they compensated? Was IRB/ERB approval and informed consent obtained, and which wellbeing safeguards (content warnings, opt-out, exposure limits) were in place? What guidelines did they follow, did they see the VLM labels, and what were inter-annotator and VLM–human agreement on the test split?
  12. How robust is the detector to adversarial prompts [18, 19] and to white-box evasion against the differentiable detector?
  13. Will the dataset, including trajectories, and the code be released?

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.