{"id":"261ee67b-c560-4ffb-9936-8ea1ec1c1e2a","arxiv_id":"2505.06948","paper_version":1,"verdict":"CONDITIONAL","confidence":"HIGH","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":6,"one_line_summary":"UCDM builds positive and negative image pairs with a text-to-image diffusion model and trains an open-set classifier with no instance labels, outperforming semi-supervised baselines on three benchmarks.","lead":"UCDM trains an open-set classifier without labeled images by using a diffusion model to add or erase object classes in photos, creating positive and negative training pairs. The approach targets class distribution mismatch, where training data contains classes the task must later distinguish; it removes the need for human labels.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Diffusion add/erase reliability is unverified per class; if Stable Diffusion fails on fine-grained known classes, generated pairs are systematically mislabeled and the reported gains rest on noisy training data.","rationale":"The reader's CONDITIONAL verdict is appropriate, but the specific evidence cited ('papillon' failure) is partially misread: Fig. 12 shows UCDM preserving the dog while random generation produces a butterfly, so it is a success for the positive pipeline, not a failure of UCDM. The broader concern stands: the paper never quantifies per-class add/erase reliability, and the erase direction is exactly where ambiguity could hurt. This is load-bearing because the method's training signal is entirely produced by the generator; no real labels exist to correct systematic errors. The paper deserves credit for releasing code, for ablating the loss components and the generation pipeline, and for showing that real-image pseudo-labeling helps (Fig. 4a, Fig. 11). The abstract's numbers (35.1/63.7/72.5 on Tiny-ImageNet) actually match CIFAR-100 at 60% mismatch (Table 3), a separate reporting error that should be fixed alongside the proof issues flagged by the reader. My proposed audit is a single check that would determine whether the load-bearing assumption holds; if it passes for all 20 classes, the concern is resolved and the paper can be accepted after minor corrections.","tokens_in":29355,"tokens_out":10612,"duration_ms":106778,"concrete_test":"Run a per-class generation audit on Tiny-ImageNet: for each of the 20 known classes, generate 50 positives (prompt 'A photo of [class]', seed images from other classes) and 50 negatives (erase prompt, seed images of that class). Label each generated image with a strong pretrained classifier (e.g., CLIP ViT-L/14 or an ImageNet-1k model). Compute (a) the fraction of positives whose top prediction is the target class and (b) the fraction of negatives whose top prediction is no longer the target class. If any class has either fraction below 0.9, retrain UCDM without that class and compare known/unknown/new accuracies; if performance changes substantially, the advertised result depends on unreliable per-class generation.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim requires that the pretrained Stable Diffusion model can, for every known class, (i) render the class into an arbitrary seed image (positive pipeline, Sec. 3.3) and (ii) erase the class from a seed image while preserving other visual content (negative pipeline, Sec. 3.4). This is the load-bearing condition: if either operation fails for some classes, the generated pairs are mislabeled and the training loss in Eq. (13) fits those wrong labels. The paper does not audit this per class. Its support is a few cherry-picked visualizations (Figs. 12-20) and a CIFAR-10 ablation (Table 5); Tiny-ImageNet's 20 known classes include fine-grained or uncommon species ('tailed frog', 'southern black widow', 'brain coral', 'spiny lobster') where text-to-image rendering is known to be unreliable. Figure 12's 'papillon' example illustrates the underlying polysemy problem for random text-to-image generation; the erase direction is not shown for such ambiguous names. The theorems (Sec. 3.4, Appendix A.5-A.7) do not close this gap: their derivations contain algebraic slips (Eq. 17 to 18, Eq. 27), and they only establish a gradient-direction argument, not per-class semantic correctness of the final image. If even a minority of classes fail add/erase, the reported Tiny-ImageNet known accuracy (15.8% at 60% mismatch) may be bounded by label noise from the generator rather than by the classifier.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes UCDM, an unsupervised method for class distribution mismatch (CDM) in which no ground-truth labels are used during training and only the names of the known classes are provided. UCDM samples seed images from the unlabeled training set and uses a pretrained Stable Diffusion model to generate positive instances (by adding the semantic class specified by a known-class prompt) and negative instances (by erasing the semantic class via conditional DDIM inversion followed by unconditional DDIM reverse). A confidence-based pseudo-labeling mechanism selects real images with high prediction confidence and incorporates them into training. The classifier is trained with a combination of open-set multi-binary losses and a closed-set loss. Experiments are reported on CIFAR-10, CIFAR-100, and Tiny-ImageNet across mismatch proportions of 20% to 75%, comparing against SCDMCT and SCDM baselines, with the claim that UCDM outperforms semi-supervised methods without using labels. Two theorems are provided to theoretically support the negative-instance generation pipeline.","tokens_in":29671,"tokens_out":10859,"duration_ms":94254,"significance":"If the empirical claims are correct, this would be a meaningful contribution: it removes the labeled-data requirement for CDM and shows that a frozen text-to-image diffusion model can generate effective training pairs for both closed-set and open-set classification. The study is broad (three datasets, four mismatch proportions, seven baselines), includes a held-out evaluation, provides a code link, and contains an ablation study of the loss components and generation pipelines. However, the central assumption that the pretrained diffusion model can reliably add and erase the semantic class of every known class from arbitrary seed images is not audited, the theoretical proofs contain algebraic inconsistencies, and several reported numbers and dataset configurations are internally inconsistent. These issues do not necessarily invalidate the framework, but they prevent the current version from being fully convincing.","major_comments":[{"comment":"The method's core assumption is that the pretrained Stable Diffusion model can, for every known class, (i) render that class into an arbitrary seed image and (ii) erase the class from a seed image while preserving other visual content. The paper provides only a handful of visualizations (Figures 12-20) and a CIFAR-10 ablation (Table 5) as evidence; it does not audit per-class success on the 20 known classes of Tiny-ImageNet, which include fine-grained or ambiguous names such as 'tailed frog', 'brain coral', 'southern black widow', and 'spiny lobster'. Figure 12 itself documents a polysemy failure ('papillon' being rendered as a butterfly when sampling from noise), and although the authors argue that starting from the seed image's latent avoids this, no systematic evaluation is presented. Since Eq. (13) optimizes against the labels y assigned to generated positives and negatives, any class for which generation fails introduces systematic label noise into the training data. The authors should provide a per-class audit for all known classes in every dataset, for example by measuring oracle classification accuracy of generated positives, human evaluation of erase fidelity, or an image-text consistency metric.","section":"Appendix A.5, Eqs. (17)-(18), and Appendix A.7, Eq. (27)"},{"comment":"The theoretical derivations contain algebraic slips that, as written, break the proofs of Theorems 3.1 and 3.2. In Eq. (17), the coefficient of delta_{i+1} is sqrt(alpha_t) * (sqrt(1/alpha_{i+1}-1) - sqrt(1/alpha_i-1)); after defining s_i with the factor sqrt(alpha_t (1 - alpha_bar_{i+1})), this coefficient becomes s_i / sqrt(1 - alpha_bar_{i+1}), but Eq. (18) writes s_i / (1 - sqrt(alpha_bar_{i+1})). The same incorrect denominator is carried into Eq. (20). In Appendix A.7, Eq. (27), the double-sum coefficient s_i / sqrt(alpha_t (1 - alpha_bar_{j+1})) differs from what follows from Eq. (24) by a misplaced or missing 1/sqrt(alpha_t) factor. Because these theorems are invoked in Section 3.4 as theoretical support for the negative-instance pipeline, the authors should either correct the derivations or restate the theorems with valid hypotheses.","section":"Abstract and Table 4"},{"comment":"The abstract states that on Tiny-ImageNet with a 60% mismatch proportion, UCDM surpasses OpenMatch by 35.1%, 63.7%, and 72.5% in classifying known, unknown, and new classes. Table 4 reports absolute differences of 5.0, 91.4, and 89.5 percentage points for these three metrics at 60% mismatch; the values 35.1, 63.7, and 72.5 instead match CIFAR-100 at 60% mismatch in Table 3. The abstract thus misstates the main result, and the introduction's own numbers (5.0%, 91.4%, 89.5%) are inconsistent with the abstract. The abstract should be corrected to match the tables.","section":"Section 4.2 and Appendix C.1, Tables 11, 14, 15"},{"comment":"The dataset configurations are internally inconsistent. Section 4.2 states that CIFAR-10 includes 2 known, 6 unknown, and 2 new classes, but Table 11 lists 2 known, 5 unknown, and 3 new classes. The training-set counts in Table 14 (30,000 unknown images at 75% mismatch) are consistent with 6 unknown classes, not 5. Additionally, Table 15 reports 2,000 test images for each of the known, unknown, and new categories, which is impossible for CIFAR-10 with the stated class splits (2,000/5,000/3,000 test images for 2/5/3 classes) and its 10,000-image test set. These inconsistencies undermine the reproducibility of the experimental setup and should be corrected.","section":"Tables 3 and 4"},{"comment":"The baseline behavior in several reported settings appears degenerate and is not discussed. On CIFAR-100 and Tiny-ImageNet, IOMatch reports identical known/unknown/new accuracies of 0.0/100.0/100.0 across all mismatch proportions (Tables 3 and 4), which indicates the evaluated IOMatch collapses to predicting only the 'other' class. This makes IOMatch a vacuous comparator in those settings. The authors should clarify whether this behavior is expected under their evaluation protocol or whether the baseline implementation is problematic, and should discuss how it affects the comparison.","section":"Tables 3 and 4"}],"minor_comments":[{"comment":"The baseline is referred to as 'MTCF' in Section 2.1 but as 'MCTF' in Tables 1-4; the spelling should be made consistent.","section":"Section 2.1 and Table 1"},{"comment":"The entry '3,0000' for the 75% unknown-class count in CIFAR-10 should be '30,000', and the table header has duplicate 'kno. unkno.' labels that should be cleaned up.","section":"Table 14"},{"comment":"The pseudo-code condition 'if epoch = ec then' does not match the text in Section 4.3, which describes an interval of 40 epochs and 10 labeling rounds; the algorithm should state the actual triggering condition, such as 'if epoch mod 40 == 0'.","section":"Appendix A.3, Algorithm 2"},{"comment":"The caption reads 'original UCDM random', but each row contains six images; the caption should explain the layout, for example by labeling which columns correspond to 'original', 'UCDM', and 'random'.","section":"Appendix B.8, Figure 12 caption"},{"comment":"The acronym 'UCMD' appears instead of 'UCDM' in the first sentence of Section B.7; this typo should be fixed.","section":"Appendix B.7"}],"recommendation":"major_revision","confidential_remarks":"The manuscript has several internal inconsistencies in reported numbers and experimental configurations, particularly in the abstract versus Table 4 and in the CIFAR-10 class counts. The strongest concern is the unverified per-class reliability of the diffusion-based add/erase procedure, which is load-bearing for the method's central claim. The algebraic slips in the appendix are correctable, but the authors should be asked to provide a per-class audit or a quantitative oracle evaluation of generated pairs before the results can be fully trusted. The degenerate IOMatch baseline results in Tables 3 and 4 also deserve scrutiny, as they may indicate a baseline implementation issue that affects the comparison."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Colleague,\n\nUCDM is a genuinely new recipe for unsupervised class distribution mismatch: use a pretrained diffusion model to turn unlabeled seeds into positive-negative training pairs by conditioning on a class name to add the class, and using conditional DDIM inversion to erase it, then reversing unconditionally to keep the visual content. That combination, as far as I know, is not in the CDM literature, and it separates the paper from DPT and DWD, which assume matched distributions or retrain the diffusion model. The empirical work is broad: three datasets, four mismatch levels, seven baselines. On the open-set metrics, UCDM dominates: on Tiny-ImageNet at 60% mismatch, unknown and new accuracies are in the 90s while OpenMatch sits in single digits. The held-out evaluation means the headline result is not circular.\n\nThe paper also does some things right that are easy to miss. The ablation in Table 5 shows the generation pipeline matters: swapping in random noise drops the balance score from 94.6 to the low 70s. The confidence-based labeling has a useful dual-confidence check, and Appendix B.7 reports pseudo-label accuracy per round, which is the right kind of evidence. The code is provided.\n\nThe soft spots are real but uneven. First, the abstract's numbers do not match Table 4: it claims gains of 35.1/63.7/72.5 over OpenMatch, but the table shows 5.0/91.4/89.5. That needs an immediate fix. Second, the theorem proofs in Appendix A.5 and A.7 contain algebraic slips: the coefficient of delta_{i+1} changes between Eqs. (17) and (18), and Eq. (27) drops a 1/sqrt(alpha_t) factor and moves the (1 - alpha-bar) term from denominator to numerator. As written, the theorems do not establish what the paper claims. The authors should either correct the derivations or explicitly call this a heuristic justification. Third, the load-bearing assumption is that Stable Diffusion can add and erase each known class from arbitrary seeds. The paper shows only a handful of visualizations, mostly common classes, and no per-class audit for the 20 Tiny-ImageNet known classes -- many are fine-grained species like tailed frog or spiny lobster. Figure 12 shows the polysemy problem (\"papillon\") in random generation, and the paper argues that conditioning on the seed latent resolves it; that is plausible, but the erase direction is not shown for ambiguous names. The modest known-class accuracy on Tiny-ImageNet (15.8%) could well be bounded by the generator's reliability rather than the classifier.\n\nWho is this for? Anyone working on open-set SSL, unsupervised CDM, or diffusion-based augmentation. The empirical recipe is worth a serious look, and the method deserves a real referee. I would not desk-reject it. Send it out with the expectation of major revision: fix the abstract, repair or downgrade the proofs, and add a per-class audit of generation reliability.","headline":"A genuinely new unsupervised CDM recipe with strong open-set gains, but the proofs have algebraic slips and the diffusion add/erase reliability is unaudited.","tokens_in":30242,"tokens_out":6076,"would_cite":true,"duration_ms":52728,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"A pretrained diffusion model can generate the positive and negative training pairs needed to solve class distribution mismatch without any labeled data.","keywords":["class distribution mismatch","unsupervised learning","diffusion models","open-set classification","positive-negative pair generation","pseudo-labeling","DDIM inversion","Tiny-ImageNet"],"falsifier":"Take one known class at a time from Tiny-ImageNet, run the positive and negative generation pipelines on held-out images of that class, and measure with a human or a robust semantic-scoring model how often positives still lack the class or negatives still show it; if mislabeled pairs occur at a substantial rate for any class, the classifier is being trained on wrong labels even when aggregate accuracy looks high.","tokens_in":1909,"feed_emoji":"🖼️","tokens_out":3736,"duration_ms":89581,"temperature":0.7,"pith_summary":"This paper takes on class distribution mismatch, the situation where training data contain classes the target task does not ask for, and the target task contains classes absent from training. Previous approaches to this problem are semi-supervised and need labeled examples of known classes. The paper claims that labeled data are unnecessary: a pretrained diffusion model can generate the needed training signal by adding a known class to a seed image (positive instance) or erasing it (negative instance), producing contrastive pairs from unlabeled data alone. With those pairs, a one-vs-all open-set classifier plus a closed-set classifier can be trained end to end, and a confidence-based labeling step pulls high-confidence real images into training with pseudo-labels. If this stands, class distribution mismatch can be handled without annotation; on Tiny-ImageNet at 60% mismatch, the reported known, unknown, and new class accuracies are 15.8%, 94.9%, and 95.4%, versus 10.8%, 3.5%, and 5.9% for OpenMatch with 40 labels per class.","feed_headline":"Zero labels, one diffusion model: UCDM solves class mismatch","feed_subtitle":"Adding or erasing classes in unlabeled images yields training pairs that beat label-dependent baselines.","key_machinery":"The central machinery is the diffusion-driven pair generator. It uses the score-based view of diffusion models, in which the conditional noise estimator points along the gradient of the conditional log-likelihood, so conditioning on class y creates the class and replacing the conditional estimator with the unconditional one erases it. Negative instances are produced by conditional DDIM inversion, which walks the noise vector in the direction that reduces the class likelihood, followed by unconditional DDIM reverse to recover the original image minus that class; positive instances are produced by adding noise to a seed and conditionally reversing with random noise strength \\sigma_t = 1 for diversity. The second machinery is the confidence-based labeling rule: two (K+1)-way distributions, q and \\tilde{q}, are formed by combining the binary open-set probabilities with the closed-set probabilities, and a real image receives a pseudo-label only when both distributions agree on the top class above a high threshold (\\delta = 0.98). These labeled real images are then paired with generated negatives for known classes or generated positives for the 'other' class, converting an unlabeled dataset into a training signal without human annotation.","core_discovery":"The central claim is that semantic add-and-erase operations by a diffusion model provide enough weak supervision to train the whole class-distribution-mismatch pipeline, so the classifier can be learned from unlabeled images plus a list of known class names. Given a seed image, the pipeline constructs positives by noising the image and conditionally reversing toward a prompt such as 'A photo of a [CLASS].' It constructs negatives by conditional DDIM inversion to erase the class, followed by unconditional DDIM reverse to restore visual structure. The paper proves two supporting theorems: conditional inversion moves the noise vector along the negative gradient of the class-conditional log-likelihood, and unconditional reverse approximately removes only the class-specific semantic term while preserving the original image's visual characteristics. Each binary known-class classifier is trained to accept positives and reject negatives, the closed-set head is trained on positives, and iterative confidence-based labeling assigns pseudo-labels to real images whose two complementary open-set probability estimates agree at high confidence. On CIFAR-10, CIFAR-100, and Tiny-ImageNet, the method reports the highest balance scores across the mismatch proportions tested, including settings where several baselines collapse to near-zero unknown and new class accuracy.","pith_inferences":["A natural extension the paper does not test is to use multiple or per-instance prompts, or an LLM to expand the prompt set, to handle polysemous class names like 'papillon'; the paper's own Figure 12 shows exactly the failure mode this would address.","If diffusion erasure is reliable, the same positive-negative construction could supply open-set training signal to neighbouring tasks where labels are the bottleneck but class names are known, such as out-of-distribution detection, active learning, or domain adaptation.","The reported trade suggests the main cost shifts from human annotation to compute, since each seed image requires one diffusion forward pass per known class; whether that trade is worthwhile depends on how diffusion costs compare with a few manual labels per class.","A direct stress test implied by the method is to swap the pretrained text-to-image model for a different one and check whether the gains survive, since the paper's claim is about diffusion-based semantic add and erase in general, not about a single checkpoint."],"forward_implications":["At 60% mismatch on Tiny-ImageNet, UCDM reports known, unknown, and new class accuracies of 15.8%, 94.9%, and 95.4%, against OpenMatch's 10.8%, 3.5%, and 5.9% with 40 labels per class.","UCDM's closed-set accuracy improves or stays stable as the mismatch proportion increases, for example from 95.2% at 20% to 96.7% at 75% on CIFAR-10, suggesting negative instances become more useful as the unlabeled pool gets noisier.","The same framework works at 0% mismatch, reporting high known-class accuracy and high rejection of unseen categories on CIFAR-10, so the negative-generation signal is not specific to heavily mismatched training sets.","The confidence-based labeling step materially improves known-class accuracy: the ablation shows that adding real images paired with generated negatives or positives outperforms training on generated pairs alone.","Raising the pseudo-label confidence threshold above 0.95 stabilizes open-set performance, which the paper attributes to fewer incorrect pseudo-labels entering training."],"supporting_citations":[{"why":"Supplies the pretrained Stable Diffusion 2.0 model used as the fixed generator for positive and negative instances.","marker":"Rombach et al., 2022"},{"why":"Provides DDIM inversion and reverse, the procedure the two theorems build on for erasing and preserving image content.","marker":"Song et al., 2020a"},{"why":"Provides classifier-free guidance, used in the conditional reverse and conditional inversion processes.","marker":"Ho & Salimans, 2022"},{"why":"Provides the diffusion forward and reverse formulation, the noise schedule, and the noise estimator the generation pipelines call.","marker":"Ho et al., 2020"},{"why":"Establishes the score-based view connecting noise estimates to log-likelihood gradients, the basis of the two theorem proofs.","marker":"Song et al., 2020b"},{"why":"OpenMatch, the main open-set SCDM baseline that UCDM is compared against on the open-set task.","marker":"Saito et al., 2021"},{"why":"UASD, the SCDMCT baseline used for comparison on the closed-set task.","marker":"Chen et al., 2020"},{"why":"IOMatch, the source of the known-probability-driven confidence estimate used to build the second distribution.","marker":"Li et al., 2023"},{"why":"Cited to motivate needing effective contrast in positive-negative pairs for distinguishing known from unknown classes.","marker":"Tack et al., 2020"}],"fun_headline_variants":["UCDM: Diffusion add-and-erase trains classifiers with zero labels","Zero-label CDM via diffusion-built positive-negative pairs","Diffusion-pair training beats labeled baselines on class mismatch","Add or erase classes with diffusion to learn CDM without labels","Unlabeled images plus diffusion pairs fix class distribution mismatch"],"cache_read_input_tokens":32256,"weakest_assumption_plain":"The whole pair-construction pipeline assumes that the pretrained Stable Diffusion model, prompted with 'A photo of [CLASS],' can reliably add or erase the semantic class of every known class on arbitrary seed images; the paper's own Figure 12 shows a failure case where the prompt 'papillon' turns a dog into a butterfly.","fun_headline_variants_meta":{"raw":{"variants":["UCDM: Diffusion add-and-erase trains classifiers with zero labels","Zero-label CDM via diffusion-built positive-negative pairs","Diffusion-pair training beats labeled baselines on class mismatch","Add or erase classes with diffusion to learn CDM without labels","Unlabeled images plus diffusion pairs fix class distribution mismatch"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000365,"raw_usage":{"total_tokens":1987,"prompt_tokens":991,"completion_tokens":996,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":607,"completion_tokens_details":{"reasoning_tokens":912}},"tokens_in":607,"tokens_out":996,"duration_ms":10205,"temperature":1.0,"reasoning_tokens":912,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-15T22:29:04.406375+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Take one known class at a time from Tiny-ImageNet, run the positive and negative generation pipelines on held-out images of that class, and measure with a human or a robust semantic-scoring model how often positives still lack the class or negatives still show it; if mislabeled pairs occur at a substantial rate for any class, the classifier is being trained on wrong labels even when aggregate accuracy looks high.","supporting_citations":[],"review_version":1}