{"id":"a0fb4d25-33a4-4dad-aafd-6ea006a968fc","arxiv_id":"2412.16942","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":4.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":5,"one_line_summary":"BloomCoreset uses Bloom filters on binarized OpenCLIP features to sample image coresets from large open-set pools, cutting sampling time by 98.5% with an average 0.83% accuracy trade-off.","lead":"BloomCoreset is a new sampling method that picks a small, useful subset of unlabeled images for fine-grained self-supervised learning. It uses a Bloom filter and pretrained OpenCLIP features to cut sampling time by about 98.5% compared to the SimCore baseline, at a small average accuracy cost.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Bloom filter membership in Algorithm 1 tests exact 512-bit sign patterns, so true matches are essentially zero and the ~74% pass rate is false positives; the filter cannot be performing the claimed semantic similarity selection.","rationale":"The reader's CONDITIONAL verdict focused on the untested assumption that frozen, binarized OpenCLIP features preserve fine-grained similarity. My concern is more basic: under the pseudocode, the Bloom filter cannot implement that assumption at all. Exact sign-pattern membership has essentially zero true positives for distinct images, and the reported parameters force a ~74% false-positive rate, so the 'membership test' is equivalent to dropping ~26% of the open-set at random. That means the quality of the coreset, if Table II is reproducible, comes from the top-k cosine step over a random subset, not from Bloom-filter hashing. This would make the paper's stated contribution—using Bloom filters as a space-efficient similarity-retrieval mechanism—vacuous, while the speed gain could be obtained by simple random subsampling before top-k. I therefore recommend REJECT as written, with the concrete random-gate experiment as the decisive check. I give partial agreement to the reader: the transfer-quality assumption is real, but it is downstream of the more fundamental mismatch between the described algorithm and the claimed mechanism. I also note the manuscript's own weaknesses (no code link, no error bars, Table II discrepancy), but the algorithmic incoherence is the load-bearing issue.","tokens_in":8933,"tokens_out":8346,"duration_ms":74722,"concrete_test":"Obtain the implementation (or reimplement Algorithm 1 exactly). Replace only the membership test cbloom.check(binz) with a Bernoulli gate that keeps each open-set image with probability equal to the empirically measured pass rate of the Bloom filter for that target dataset (expected ≈0.74), keeping the top-k cosine filtering and all training/evaluation identical. Train SimCLR on the resulting coreset and compare the 11 downstream accuracies with Table II. If accuracy changes by less than the run-to-run variation, the Bloom filter is contributing no semantic selection and the central methodological claim fails; if accuracy drops substantially, the filter is doing real work and the concern is resolved. A secondary check: run top-k over the full open-set without any prefilter to quantify what the random prefilter costs.","verdict_should_be":"REJECT","load_bearing_attack":"In Algorithm 1 (Section II-B), each OpenCLIP embedding z ∈ R^512 is binarized as binz = where(z<0,0,1), and cbloom.update(binz) inserts that exact 512-bit pattern; cbloom.check(binz) then asks whether the same exact pattern was inserted. For a non-duplicate open-set image the probability of an exact match with any of the NX downstream patterns is about NX/2^512, i.e. astronomically small. Consequently, almost all open-set images that pass the check do so through Bloom-filter false positives. Using the paper's own sizes (k=10 hash functions, m = 10000·NX/3500 bits), the false-positive rate is (1 − e^{−kNX/m})^k ≈ (1 − e^{−3.5})^10 ≈ 0.74, independent of semantic similarity. The membership stage is therefore a random subsampler, not a content-based filter. The actual selection is done by the later top-k cosine-similarity step over this random ~74% subset. The paper gives no evidence that this random prefiltering, rather than the claimed similarity hashing, produces the reported accuracy. If the released code (not linked in the manuscript) uses a different update/check semantics, that needs to be stated; as written, the core mechanism of BloomCoreset is not what Algorithm 1 implements.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper addresses coreset sampling for fine-grained self-supervised learning from an unlabeled open set. The authors propose BloomCoreset, which uses a pretrained OpenCLIP image encoder to extract 512-d features for the downstream dataset and the open set, binarizes those features by sign, inserts the downstream binary patterns into a Counting Bloom Filter, and then checks open-set patterns for membership. A top-k cosine-similarity filter over the real-valued features selects the final 1% coreset, which is used together with the downstream data to train SimCLR. The paper reports a 98.5% reduction in sampling time (from about 23 hours to about 20 minutes on two RTX 3090 GPUs) with a 0.83% average accuracy trade-off across 11 downstream datasets relative to SimCore.","tokens_in":9242,"tokens_out":9232,"duration_ms":82375,"significance":"The potential significance is high: coreset sampling from large unlabeled pools is a practical bottleneck, and a near-order-of-magnitude speedup with roughly 1% accuracy cost would make open-set SSL substantially more scalable. The paper evaluates across 11 downstream datasets and 3 open-sets, compares against the SimCore baseline, and includes a random-Bloom control in Table III, which is a useful breadth of experiments. However, the significance presently rests on the claim that the Bloom filter performs semantic similarity hashing. If, as Algorithm 1 indicates, the membership stage is a fixed-rate random prefilter, the contribution reduces to random subsampling plus cosine top-k, and the novelty claim is substantially weakened. The empirical results may still be valid for that variant, but the manuscript does not currently provide the evidence needed to separate these cases. The abstract's claim that the code is publicly available is also not backed by any repository link in the manuscript.","major_comments":[{"comment":"In Algorithm 1, `cbloom.update(binz)` inserts the exact 512-bit sign pattern of each downstream image, and `cbloom.check(binz)` tests whether the same exact pattern was inserted. For any open-set image that is not a near-duplicate of a downstream image, the chance of exact match is at most NX/2^512, i.e., negligible. With k=10 hash functions and m=10000*NX/3500 bits, the false-positive rate is (1 - exp(-k*NX/m))^k = (1 - exp(-3.5))^10 ≈ 0.74, independent of image content. Therefore the ~74% pass rate implied by the setup consists almost entirely of false positives, and the Bloom stage is a content-independent Bernoulli(0.74) prefilter. The actual selection is done by the subsequent cosine top-k filter over the randomly retained 74%. This contradicts the paper's narrative in Section II and Fig. 2 that Bloom filters store both low- and high-level features and perform similarity-based membership. The authors must either specify a different update/check semantics that makes the membership test similarity-aware (e.g., hashing overlapping feature blocks or using multi-probe LSH), or explicitly state that the contribution is randomized prefiltering plus top-k selection and remove the Bloom-based semantic-retrieval claims. This issue is load-bearing for the central claim of the paper.","section":"II-B, Algorithm 1"},{"comment":"Table II reports the Cars accuracy trade-off as -5.1%, but the table values are 52.08 (ours) minus 57.90 (SimCore), which is -5.82%. The abstract's average trade-off of -0.83% is consistent with the -5.82% value and not with the tabulated -5.1%. This numerical inconsistency must be corrected; it directly affects the headline quantitative claim.","section":"Table II"},{"comment":"No error bars or multiple seeds are reported for any accuracy number. The differences that support the trade-off claim are often small (e.g., Pet -0.7%, Food +0.42%, Faces -3.13%), and single-run fine-grained accuracy can easily shift by more than one percentage point across training seeds. The authors should report mean and standard deviation over at least 3 seeds for the 1% coreset experiments for both SimCore and BloomCoreset, or otherwise show that the reported trade-off is not within training noise.","section":"III-A and III-B, Tables II-III"},{"comment":"The implementation is under-specified and the promised code is absent. The abstract states 'We have made the code publicly available,' but no repository link is provided in the manuscript. Algorithm 1 does not define the `CBloomFilter` operations (how murmurhash3 is used to derive the 10 hash functions, what `csize=32` controls, how the counting mechanism is used), nor the exact top-k rule of the `Filter` function beyond the budget B. The timing protocol for Table I is also incomplete: it does not state which OpenCLIP model was used, how many open-set images were processed, whether OpenCLIP feature-extraction time is included in the 20 minutes, or how the 23-hour SimCore number was obtained. Without these details the 98.5% speedup cannot be reproduced or audited.","section":"Section II-B and abstract"}],"minor_comments":[{"comment":"The method is called 'BloomSSL' in Section III and 'BloomCoreset' elsewhere, and the conclusion misspells it as 'BloomCorest'; the naming should be unified throughout.","section":"Sections III and V"},{"comment":"The caption and legend of Figure 3 do not define the 'Ours' bar clearly; the caption should specify that 'Ours' is BloomCoreset applied to the corresponding open-set, and the axes should be labeled consistently.","section":"Figure 3"},{"comment":"The density maps in Figure 4 have no axis labels, color scale, or explanation of how 'Clip Downstream', 'Clip Coreset', 'Pre-trained Downstream', and 'Pre-trained Coreset' were generated; this makes the figure difficult to interpret.","section":"Figure 4"}],"recommendation":"major_revision","confidential_remarks":"To the editor: the Algorithm 1 issue is severe enough that I would like to see, at revision, either a corrected algorithm with similarity-aware membership or an explicit reframing as random prefiltering plus top-k selection. I also recommend requiring the actual sampling code and a reproducibility statement before acceptance, given the missing code link and the Table II numerical inconsistency."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Short version: this paper has a useful practical observation and a broad empirical study, but the central mechanism as written does not work the way the paper says. In Algorithm 1, the Bloom filter stores the exact 512-bit sign pattern of each downstream OpenCLIP feature. A membership check on an open-set image asks whether that exact pattern was seen before. For non-duplicate images, the probability of a true match is essentially zero; the ~74% pass rate is the false positive rate of the filter (with k=10, m=10000*NX/3500). So the membership stage is a random subsampler, not a semantic similarity filter. The actual selection is done by the top-k cosine similarity step on that random subset. The paper gives no evidence that random prefiltering plus top-k produces the reported accuracy; if the released code (which is not linked) uses different update/check semantics, the authors need to say so. As written, the core contribution is not 'Bloom hashing for semantic retrieval' but '74% random subsample then cosine top-k' — which is a much thinner contribution.\n\nWhat the paper does well: the speed comparison is honest and the scale is impressive (23h → 20min). The experimental coverage is broad (11 datasets, 3 open-sets). Table III is a nice check that top-k refinement matters. The 0.83% average trade-off is consistent with Table II's numbers once you fix the Cars row (the listed -5.1% should be -5.82%; the average actually works out with the correct value).\n\nSoft spots: no code released despite the claim, no error bars, no sensitivity analysis for filter size, counter bits, hash count, or binarization threshold. The OpenCLIP transfer assumption is untested. But the Bloom-filter-mechanism issue is the load-bearing one.\n\nThis paper deserves a serious referee, not because the current form is acceptable, but because the idea of replacing expensive fine-tuning-based sampling with a cheap prefilter is worth exploring. The referee should ask for code and a corrected algorithm description. If the authors can show that the top-k step alone (without any prefilter) gives the same speed/accuracy trade-off, the contribution shrinks considerably.","headline":"The speedup is real, but the Bloom filter as described is a random prefilter; the actual work is top-k on OpenCLIP features.","tokens_in":9768,"tokens_out":3997,"would_cite":false,"duration_ms":34528,"reading_group":"maybe","serious_thinker":"no","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"BloomCoreset claims that a Bloom filter built from binarized OpenCLIP features can replace the expensive train-then-sample coreset selection of SimCore, cutting sampling time by 98.5% while keeping average downstream accuracy within 0.83%.","keywords":["coreset sampling","self-supervised learning","Bloom filter","counting Bloom filter","fine-grained classification","open-set learning","OpenCLIP","contrastive learning"],"falsifier":"Run BloomCoreset on a downstream fine-grained dataset whose classes are known to be hard for OpenCLIP's zero-shot features, such as car models or dog breeds, and compare the accuracy trade-off against SimCore; if the trade-off is substantially larger than 0.83%, or if the selected coreset has no higher cosine similarity to the downstream data than a random sample, the binarized-feature proxy is the weak point.","tokens_in":8756,"feed_emoji":"⚡","tokens_out":4737,"duration_ms":43327,"temperature":0.7,"pith_summary":"This paper tries to establish that coreset sampling for fine-grained self-supervised learning can be made dramatically faster without much loss in quality by using a probabilistic hashing structure instead of training a model on the downstream data first. The proposed method, BloomCoreset, builds a Counting Bloom Filter from binarized OpenCLIP features of the downstream dataset, uses it to quickly filter candidate images from a large unlabeled open-set, then applies a cosine-similarity top-k refinement. Integrated into the SimCore framework, it selects a 1% coreset from ImageNet-1k in about 20 minutes rather than about 23 hours, with an average accuracy trade-off of 0.83% across 11 fine-grained downstream datasets, and it beats SimCore on four of them. This matters because the sampling stage is what makes open-set self-supervised learning impractical as an off-the-shelf tool, and the paper argues the speedup comes with only a small quality penalty.","feed_headline":"Bloom filters cut coreset sampling time by 98.5%","feed_subtitle":"A 20-minute sampler matches a 23-hour baseline within 0.83% average accuracy across 11 datasets.","key_machinery":"The central object is a Counting Bloom Filter (CBF) over binarized OpenCLIP image features. Each downstream image's 512-dimensional feature vector is converted to a binary code by thresholding at zero, and ten murmurhash3 variants set counters in the CBF; open-set images whose binary codes pass the membership test become candidates. Since Bloom filters have false positives but no false negatives, the candidate set is then refined by computing cosine similarity between downstream features and candidates and keeping the top-k, so the exponential speedup of hashing is combined with a cheap exact similarity step on the surviving candidates.","core_discovery":"The central claim is that SimCore's expensive first stage—training a self-supervised encoder on the downstream data to find the closest open-set images—can be replaced by a membership test in a Counting Bloom Filter populated with binarized features from a frozen OpenCLIP encoder, followed by a cosine-similarity top-k filter. With this two-stage pipeline, the paper reports a 98.5% reduction in sampling time and an average accuracy trade-off of 0.83% against SimCore across 11 downstream datasets, with per-dataset trade-offs ranging from −5.4% to +4.48%. The paper also claims the method generalizes across different open-sets (ImageNet-1k, MS COCO, iNaturalist) and that the top-k refinement is necessary because raw Bloom-filter membership alone produces a coreset that does not improve representation learning.","pith_inferences":["The method's success likely depends on how well OpenCLIP's frozen features separate fine-grained classes; on datasets where those features are weak, the binarized Bloom proxy would select irrelevant images and the accuracy trade-off would grow beyond 0.83%.","A testable extension is to replace the global zero-threshold binarization with learned per-dimension thresholds or multi-bit quantization, which could reduce false positives while keeping the fast hashing.","The same pattern—Bloom membership test followed by a small exact similarity search—could accelerate other large-scale subset-selection problems wherever a good pretrained feature encoder exists.","Because the paper does not analyze which downstream datasets lose the most accuracy, an important next step is to characterize the failure cases, e.g., whether losses concentrate on datasets with many visually similar classes."],"forward_implications":["Coreset sampling for fine-grained SSL can be cut from hours to minutes: on two RTX 3090 GPUs, sampling a 1% ImageNet-1k coreset drops from roughly 23 hours to roughly 20 minutes.","A practitioner can swap BloomCoreset into SimCore in place of its sampling stage and expect an average accuracy loss of only 0.83% across 11 datasets, with gains on Action, Indoor, Textures, and Food.","The top-k filtering step is load-bearing: without it, Bloom-filter membership alone yields a coreset whose downstream accuracy is much closer to training on the downstream data alone.","The speedup transfers to other open-sets, with competitive or better accuracy than SimCore on several downstream targets when MS COCO or iNaturalist is used as the open-set.","Because OpenCLIP is frozen and no downstream training is needed for sampling, the bottleneck shifts to feature extraction throughput rather than optimization, so the method scales better as open-sets grow.","The 0.83% average trade-off is an average over datasets; the per-dataset range runs from a 5.4% loss on Dogs to a 4.48% gain on Indoor, so the worst-case loss is larger than the headline number."],"supporting_citations":[{"why":"Defines the SimCore baseline whose sampling strategy and accuracy results BloomCoreset replaces and compares against.","marker":"[1]"},{"why":"Supplies the frozen OpenCLIP encoder used to extract image features and hash codes for both downstream and open-set data.","marker":"[25]"},{"why":"Defines the Bloom filter probabilistic membership structure that provides the speedup.","marker":"[24]"},{"why":"Provides the counting Bloom filter variant used to track hash-access frequencies.","marker":"[42]"},{"why":"Supplies the murmurhash3 hash family used to populate the Bloom filter.","marker":"[28]"},{"why":"Describes SimCLR, the contrastive self-supervised method used to train on the coreset plus downstream data and evaluate representation quality.","marker":"[17]"},{"why":"Provides ImageNet-1k, the primary open-set used for the sampling-time and accuracy comparisons.","marker":"[12]"}],"fun_headline_variants":["Bloom filters slash SSL coreset sampling time by 98.5%","BloomCoreset: 98.5% faster sampling with 0.83% accuracy trade-off","Coreset sampling 98.5% faster via Bloom filters, accuracy nearly intact","Bloom filters enable 98.5% faster coreset built, 0.83% average accuracy cost","Fast fine-grained SSL coreset: Bloom filters cut time 98.5%, keep accuracy"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that binarized features from a frozen OpenCLIP encoder preserve enough fine-grained semantic similarity that cosine nearest neighbors in this space are a good proxy for the target-specific neighbors SimCore finds by training on the downstream data.","fun_headline_variants_meta":{"raw":{"variants":["Bloom filters slash SSL coreset sampling time by 98.5%","BloomCoreset: 98.5% faster sampling with 0.83% accuracy trade-off","Coreset sampling 98.5% faster via Bloom filters, accuracy nearly intact","Bloom filters enable 98.5% faster coreset built, 0.83% average accuracy cost","Fast fine-grained SSL coreset: Bloom filters cut time 98.5%, keep accuracy"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000233,"raw_usage":{"total_tokens":1491,"prompt_tokens":943,"completion_tokens":548,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":559,"completion_tokens_details":{"reasoning_tokens":431}},"tokens_in":559,"tokens_out":548,"duration_ms":4888,"temperature":1.0,"reasoning_tokens":431,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-11T05:57:17.273818+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run BloomCoreset on a downstream fine-grained dataset whose classes are known to be hard for OpenCLIP's zero-shot features, such as car models or dog breeds, and compare the accuracy trade-off against SimCore; if the trade-off is substantially larger than 0.83%, or if the selected coreset has no higher cosine similarity to the downstream data than a random sample, the binarized-feature proxy is the weak point.","supporting_citations":[{"cited_title":"Coreset sampling from open-set for fine-grained self-supervised learning,","cited_arxiv_id":null,"evidence_quote":"Defines the SimCore baseline whose sampling strategy and accuracy results BloomCoreset replaces and compares against."},{"cited_title":"Reproducible scaling laws for contrastive language-image learning,","cited_arxiv_id":null,"evidence_quote":"Supplies the frozen OpenCLIP encoder used to extract image features and hash codes for both downstream and open-set data."},{"cited_title":"Space/time trade-offs in hash coding with allowable errors,","cited_arxiv_id":null,"evidence_quote":"Defines the Bloom filter probabilistic membership structure that provides the speedup."},{"cited_title":"Murmurhash3,","cited_arxiv_id":null,"evidence_quote":"Supplies the murmurhash3 hash family used to populate the Bloom filter."},{"cited_title":"Imagenet: A large-scale hierarchical image database,","cited_arxiv_id":null,"evidence_quote":"Provides ImageNet-1k, the primary open-set used for the sampling-time and accuracy comparisons."}],"review_version":1}