{"id":"eefee3fa-24ea-4296-9c93-15544cc1cda7","arxiv_id":"2505.03012","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":6,"one_line_summary":"GIF trains face recognition by predicting structured integer codes per identity, cutting classifier cost from linear to logarithmic in the number of identities while improving IJB-B/IJB-C accuracy over efficient-training competitors.","lead":"GIF replaces per-identity scalar labels in face recognition training with structured integer codes, making the classifier's cost grow logarithmically instead of linearly with the number of identities. On IJB-B and IJB-C the method reports gains over efficient-training baselines while using far less GPU memory and faster training.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The uniformity step in §3.4.1 may destroy the CLIP-derived semantic structure that the 'structured identity code' claim depends on; the paper never verifies that optimized code vectors preserve neighborhoods, and the random-initialization control is missing.","rationale":"The reader's weakest_assumption identified the same unverified link between CLIP initialization plus uniformity optimization and semantically meaningful identity codes. I agree that this is a load-bearing gap in the argument, because the paper's distinction between structured and atomic codes is what explains why the method trains successfully and why it outperforms scalar-label softmax. The concrete random-initialization control is the natural experiment to settle whether the semantic component actually survives the uniformity step. I would not raise the verdict to REJECT: the method is well specified enough that the missing control is a verification gap rather than evidence of failure, and the computational claim about the per-batch classifier cost being O(l v) with v bounded is internally consistent. I also note the reader's other concerns, including the ViT AgeDB inconsistency and unreported hyperparameters such as the logit scale in Eq. 7 and the Gaussian potential width t; those are real reproducibility issues but they are secondary to the semantic-preservation question. The verdict should remain CONDITIONAL, which is the same as the reader's verdict; no adjustment is needed.","tokens_in":18502,"tokens_out":6736,"duration_ms":84265,"concrete_test":"Run GIF with identical settings (WebFace4M, ResNet-100, same l/v schedule and Eq. 10 with gamma=1) but initialize H from random points on S^{d-1} instead of CLIP identity means, then apply the same uniformity optimization and hierarchical k-means. Report IJB-B and IJB-C TAR@FAR=1e-4. If random-initialized H performs within roughly 1% of CLIP-initialized H, the semantic prior is not necessary and the structured-code claim is weakened; if it collapses, that would support preservation of semantics, and a follow-up rank-correlation check between CLIP pairwise similarities and optimized-H pairwise similarities would directly quantify the preservation.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The paper's central novelty is that scalar labels are replaced by structured identity codes whose shared tokens encode inter-identity semantics. This claim rests on the premise that the Gaussian-potential uniformity optimization in Eq. 6 preserves the semantic ordering of the CLIP-initialized code vectors H. That premise is never checked. Table 3 shows CLIP-initialized means without uniformity collapse to 24.30% TAR@FAR=1e-4 on IJB-B, and Figure 5d shows atomic codes fail, so both components are claimed necessary. But if the repulsive Gaussian potential reorders the identity vectors globally, then the hierarchical k-means codes no longer reflect CLIP semantics; the method reduces to a well-separated but arbitrary label decomposition, and the 'structured' part of the claim is unsupported. The paper also asserts without evidence that random initialization of H is equivalent to atomic codes; it does not run the control of random H followed by the same uniformity optimization and k-means. If that control succeeds, then the semantic code structure is not load-bearing for the accuracy gain; if it fails, the survival of CLIP neighborhoods after uniformization still needs direct verification. This is the weakest point in the chain from identity tokenization to the central claim that structured codes yield logarithmic cost plus improved accuracy.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes GIF, a face-recognition training scheme that replaces scalar identity labels with structured integer codes. Code vectors are initialized from per-identity CLIP embeddings, optimized for hyperspherical uniformity via a Gaussian-potential loss, and then converted to identity codes by hierarchical k-means. Training predicts the l tokens of each identity code through l parallel v-way classifiers, augmented by an angular-regression loss to the assigned code vector, yielding a claimed O(log m) training cost instead of the O(m) cost of a conventional softmax classifier. Experiments on MS1MV2, WebFace4M, WebFace12M, and WebFace42M with ResNet-100 and ViT-B backbones report improvements over prior efficient-training methods on IJB-B and IJB-C, along with memory and speed advantages.","tokens_in":18719,"tokens_out":4245,"duration_ms":46698,"significance":"If the empirical claims hold, GIF is a useful contribution to large-scale face recognition: it changes the scaling of classifier cost and memory from linear to logarithmic in the number of identities, while reporting consistent gains on IJB-B and IJB-C across multiple training-set scales. The paper also provides a constructive ablation structure—loss components, structured versus atomic codes, code length, token range, and CLIP-versus-DINO initialization—and promises public code. The main open question is whether the learned codes are genuinely structured in the semantic sense claimed, and whether that structure is responsible for the accuracy gains, rather than the uniformity-regularized prototype regression alone.","major_comments":[{"comment":"The statement that 'initializing code vectors from a random distribution instead of using the CLIP visual encoder is the same as having atomic codes' is asserted but not tested. A random-initialization control with the same Gaussian-potential optimization and hierarchical k-means is missing. If that control retains the reported accuracy, the semantic structure of the codes is not load-bearing for the gains; if it fails, the paper still needs to demonstrate directly that the optimized code vectors preserve CLIP-derived semantic neighborhoods. This experiment is necessary to support the central contribution claim of structured identity codes.","section":"§4.5.2"},{"comment":"Table 3 shows that CLIP initialization without the uniformity optimization collapses to 24.30% TAR@FAR=1e-4 on IJB-B, and Figure 5d shows that atomic codes fail, so each component is claimed necessary. However, the paper does not verify that the Gaussian-potential optimization preserves the semantic ordering of the CLIP-initialized code vectors. If the repulsive optimization substantially reorders the vectors, the hierarchical k-means codes no longer reflect the 'similar generic information' that the structured-code claim relies on. I request a quantitative check, such as k-nearest-neighbor overlap or normalized mutual information between the initial and optimized code vectors, or an evaluation with a randomly permuted initial H followed by the same optimization pipeline.","section":"§3.4.1 / Table 3"},{"comment":"The WebFace42M/ViT row reports AgeDB=96.16 for GIF versus 98.53 for PFC, a drop of 2.37 percentage points, which contradicts the text in §4.4 that 'GIF enhances all previous ET methods across LFW, CFP-FP and AgeDB.' This inconsistency must be resolved: either the table entry is incorrect, or the claim needs to be qualified. Because the abstract and conclusion emphasize universal improvement, this discrepancy is material to the paper's main empirical claim.","section":"Table 1"},{"comment":"Several hyperparameters that directly control the method are not reported. The logit scale gamma in Eq. (7) is introduced in Algorithm 1 but its value is never given; the Gaussian-potential width t in Eq. (4) is not specified; and the exact code length l and token range v per dataset are only described by the range 5 <= v <= 20. Since the O(log m) cost claim depends on the actual l and v choices, and since the empirical results cannot be reproduced without these values, the experimental section needs a full hyperparameter table, including per-dataset settings.","section":"§4.2 / Eq. (7)"}],"minor_comments":[{"comment":"The phrase 'tow steps tokenization scheme' appears to be a typo for 'two-step tokenization scheme.'","section":"§3.4.1"},{"comment":"The caption contains 'Abblation,' which should read 'Ablation.'","section":"Table 3 caption"},{"comment":"The notation gi,j is used without defining the matrix G; please clarify that gi,j = G_t(h_i, h_j) with G_t as in Eq. (4).","section":"Eq. (6)"},{"comment":"The description of assigning 'an arbitrary number from [0,v-1]' to the l-th token should clarify whether this assignment is fixed before training and whether the resulting leaf codes are unique.","section":"§3.4.2"},{"comment":"The caption states that the average performance across five benchmarks is reported, but the figure does not show individual benchmark values or error bars; please make the aggregation and the axis ranges explicit.","section":"Figure 5e/f"},{"comment":"Line 25 writes 'cyi = [H_phi_1(z),...,H_phi_l(z)]', but H_phi_j are projection heads, not identity codes; the returned values should be described as predicted token logits or probabilities, not codes.","section":"Algorithm 1"}],"recommendation":"major_revision","confidential_remarks":"The paper's central novelty is interesting and the reported efficiency gains are potentially valuable, but the referee panel should require the random-initialization control and the semantic-preservation analysis before acceptance. The exact hyperparameter table is also needed for reproducibility. The missing ViT AgeDB discrepancy in Table 1 should be resolved by the authors; if it is an error, a corrected table is required."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Here's my take on the GIF paper. The core move — replacing the scalar identity label with a short integer code and training l parallel v-way classifiers instead of one m-way classifier — is real, and it delivers on cost: the memory and speed numbers in Figure 5 are convincing, and the accuracy gains on IJB-B/IJB-C are mostly consistent across training sets and backbones. The tokenization scheme (CLIP means → Gaussian-potential uniformity → hierarchical k-means) is a sensible way to build codes without privileged text. Credit where due: the paper is honest enough to show that raw CLIP means collapse (Table 3) and that atomic codes fail (Figure 5d), and the DINO/CLIP comparison in the supplement is a useful robustness check.\n\nThe soft spots are real but not fatal. First, the paper's own numbers contradict its claims. In Table 1, the WebFace42M ViT row drops 2.4 points on AgeDB relative to PFC (96.16 vs 98.53), yet the text says GIF outperforms PFC across both backbones. Either that needs an explanation or the claim needs to be tempered.\n\nSecond, the load-bearing part of the story — that the codes are structured, i.e., shared tokens carry inter-identity semantics — is never actually verified. CLIP neighborhoods are computed, then the uniformity optimization moves the vectors, then k-means chops them up. Nothing checks that the resulting codes preserve the semantics, or that those semantics drive the gain. The paper asserts that random initialization is equivalent to atomic codes without running that control. A random-but-uniform H through the same pipeline would settle it: if it works, the semantic story is decoration; if it fails, you still haven't shown the surviving structure is load-bearing. This is the weakest link and it's fixable.\n\nThird, reproducibility: the logit scale in Eq 7 and the Gaussian width t are unreported; λ is 'one' in the main text and '1/l' in the supplement; exact l per dataset is given only as a range. The O(log m) claim is defensible, but the schedule that realizes it from m = 2M to 64M should be explicit.\n\nNone of this makes the method look unstable — the efficiency result is solid and the gains are mostly consistent — but the claims as written are tighter than the evidence. Who it's for: people working on efficient FR training or massive-label classification. I'd send it to a serious referee and let the reviews push for the missing controls and the ViT explanation. My own bottom line: conditional accept, largely because the semantic-structure claim is currently unexamined rather than because the method looks shaky.","headline":"The tokenized-label trick genuinely makes classifier cost logarithmic and mostly improves accuracy, but the paper overclaims on its own ViT numbers and never verifies that the CLIP-derived 'structure' in the codes is what drives the gains.","tokens_in":19314,"tokens_out":6101,"would_cite":true,"duration_ms":60011,"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":"Replacing scalar labels with structured integer codes makes face-recognition training cost logarithmic in the number of identities and improves accuracy on IJB-B and IJB-C.","keywords":["face recognition","structured identity codes","efficient training","logarithmic scaling","hierarchical k-means","hyperspherical uniformity","minority collapse","generative retrieval"],"falsifier":"A concrete check is to measure whether the uniformity optimization preserves semantic structure: compare the average semantic-embedding similarity of identity pairs that share a first code token against pairs that do not, using the optimized code tree. If the first-token groups are no more similar than random groups, the structured part of the code is not carrying face semantics. A second check is to keep the same tree shape but randomly permute which identity lands in which leaf; the paper's atomic-code ablation predicts this collapse, so it would isolate hierarchy from uniformity.","tokens_in":18244,"feed_emoji":"👤","tokens_out":10484,"duration_ms":95729,"temperature":0.7,"pith_summary":"The paper sets out to remove the main scaling bottleneck in large-scale face-recognition training: the softmax classifier, whose cost grows linearly with the number of identities. It claims that atomic scalar labels can be replaced by structured identity codes, short sequences of integer tokens, and that a face encoder trained to predict the tokens instead of a class label reduces label-matching cost to $O(\\log m)$ while actually improving verification accuracy. The identity codes are built by starting from per-identity semantic visual embeddings, spreading those embedding points uniformly over the unit hypersphere, and then applying hierarchical $k$-means to route every identity to a code path. On the IJB-B and IJB-C benchmarks the method reports gains over prior efficient-training and standard training baselines at TAR@FAR=$10^{-4}$, with larger gains on the more imbalanced datasets. If the claim holds, million-identity face training becomes feasible on much smaller GPU budgets.","feed_headline":"Face training cost becomes logarithmic in identity count","feed_subtitle":"Structured integer codes replace scalar labels, beating prior face methods on IJB-B and IJB-C with less memory.","key_machinery":"The load-bearing object is the identity-code tree. A structured identity code is a sequence of integers that names a path through a tree: the root branches into $v$ clusters, each cluster branches again, and the leaf path is the code. To build that tree the paper maps every identity to a point on the unit hypersphere, using the mean of semantic visual embeddings, then applies a Gaussian-potential uniformity loss to spread the $m$ points as evenly as possible, and finally runs hierarchical $k$-means on the spread points. During training, $l$ small classifiers each predict one token of the code, with each token normalized over only $v$ possibilities, plus a regression loss that pulls the face embedding toward its assigned point. The mechanism is what converts the $O(m)$ normalization of angular-margin softmax into $l$ normalizations of size $v$. The code structure carries the semantics: identities that share a token are intended to be generically similar.","core_discovery":"The paper's central claim is that face-recognition training need not match a feature vector against one centroid per identity. Each identity is assigned a structured code $c_{y}=(c_{y}^{1},\\dots,c_{y}^{l})$ with every token in $[0,v-1]$, and training solves $l$ parallel $v$-way classification problems instead of one $m$-way problem; since $v^{l}\\ge m$, the classifier cost scales as $O(\\log m)$. The code is not arbitrary: per-identity reference points are initialized from semantic visual embeddings, optimized to be uniformly spread on the unit hypersphere with a Gaussian-potential uniformity loss, and then partitioned by hierarchical $k$-means so that similar identities share token prefixes. A regression term pulls the embedding toward its assigned reference point, and the combined objective is claimed to avoid 'minority collapse' because the reference-point layout is independent of how many images each identity has. The paper reports that this scheme outperforms prior efficient-training methods, with gains such as 1.52% and 0.6% at TAR@FAR=$10^{-4}$ on IJB-B and IJB-C, while also beating standard distributed-training baselines.","pith_inferences":["Editorial inference: the claimed $O(\\log m)$ saving is a per-training-iteration statement about the classifier head; the one-time tokenization still processes all $m$ identities, so total pipeline cost remains at least linear in $m$ for a fixed dataset.","Editorial inference: if the hierarchical code tree genuinely preserves semantic neighborhoods after the uniformity step, the tree itself could be reused for coarse-to-fine retrieval or for organizing synthetic identities, applications the paper does not explore.","Editorial inference: the dependence on a pretrained semantic encoder means the method's transfer to other recognition domains, such as vehicle or product recognition, is a testable extension; the paper only demonstrates faces.","Editorial inference: the reported memory plateau suggests that at very large identity counts the dominant cost may shift from the classifier to the backbone and feature pipeline, so the practical ceiling is no longer the label space."],"forward_implications":["With the classifier head no longer proportional to identity count, training on datasets with tens of millions of identities fits on far fewer GPUs.","The reported gains on IJB-B and IJB-C, particularly on imbalanced WebFace subsets, indicate that dropping the global softmax normalization does not cost accuracy and can improve it.","Because the reference-point layout is fixed before training and does not depend on per-identity sample counts, the minority-collapse failure mode of angular-margin softmax is removed by construction.","The embedding produced by the backbone remains the deployment representation, so the method changes training cost without changing verification or identification protocols.","Structured codes are necessary: the paper's ablations show replacing them with random atomic codes drops performance to near chance."],"supporting_citations":[{"why":"Supplies the semantic visual features used to initialize the per-identity code vectors before uniformity optimization.","marker":"[47]"},{"why":"Provides the alignment-and-uniformity principle and the Gaussian-potential uniformity loss used to spread code vectors on the hypersphere.","marker":"[64]"},{"why":"Motivates hyperspherical prototype organization as a way to impose structure on identity codes without privileged text information.","marker":"[40]"},{"why":"Inspires the generative formulation in which entity labels are replaced by predicted integer codes and unstructured atomic codes fail at scale.","marker":"[8]"},{"why":"Baseline efficient-training method whose linear-cost approximation GIF compares against and outperforms.","marker":"[2]"},{"why":"Standard angular-margin softmax baseline whose O(m) normalization GIF replaces and whose performance is a reference in the comparison tables.","marker":"[11]"},{"why":"Efficient-training baseline that GIF compares against and whose linear-cost scaling it seeks to surpass.","marker":"[32]"},{"why":"Supplies the minority-collapse and neural-collapse analysis used to argue that fixed, sample-count-independent code vectors avoid collapsed centroids.","marker":"[68]"}],"fun_headline_variants":["Face recognition training cost now logarithmic in identities","Structured codes slash face training cost to log scale","Logarithmic face training: replace labels with token codes","GIF method cuts face recognition cost to logarithmic scaling","Face ID training: structured codes make cost log-scale"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The whole scheme rests on the assumption that spreading the reference points uniformly over the sphere preserves enough of their original semantic ordering for the hierarchical codes to group genuinely similar faces; if that ordering is destroyed, shared code tokens become meaningless and the method reduces to atomic codes, which the paper's own ablation shows fail.","fun_headline_variants_meta":{"raw":{"variants":["Face recognition training cost now logarithmic in identities","Structured codes slash face training cost to log scale","Logarithmic face training: replace labels with token codes","GIF method cuts face recognition cost to logarithmic scaling","Face ID training: structured codes make cost log-scale"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000657,"raw_usage":{"total_tokens":3052,"prompt_tokens":1036,"completion_tokens":2016,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":652,"completion_tokens_details":{"reasoning_tokens":1941}},"tokens_in":652,"tokens_out":2016,"duration_ms":11539,"temperature":1.0,"reasoning_tokens":1941,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-16T00:02:25.221853+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"A concrete check is to measure whether the uniformity optimization preserves semantic structure: compare the average semantic-embedding similarity of identity pairs that share a first code token against pairs that do not, using the optimized code tree. If the first-token groups are no more similar than random groups, the structured part of the code is not carrying face semantics. A second check is to keep the same tree shape but randomly permute which identity lands in which leaf; the paper's atomic-code ablation predicts this collapse, so it would isolate hierarchy from uniformity.","supporting_citations":[{"cited_title":"Learn- ing transferable visual models from natural language super- vision","cited_arxiv_id":null,"evidence_quote":"Supplies the semantic visual features used to initialize the per-identity code vectors before uniformity optimization."},{"cited_title":"Understanding contrastive representation learning through alignment and uniformity on the hypersphere","cited_arxiv_id":null,"evidence_quote":"Provides the alignment-and-uniformity principle and the Gaussian-potential uniformity loss used to spread code vectors on the hypersphere."},{"cited_title":"Hyper- spherical prototype networks","cited_arxiv_id":null,"evidence_quote":"Motivates hyperspherical prototype organization as a way to impose structure on identity codes without privileged text information."},{"cited_title":"A generative approach for wikipedia-scale visual entity recognition","cited_arxiv_id":null,"evidence_quote":"Inspires the generative formulation in which entity labels are replaced by predicted integer codes and unstructured atomic codes fail at scale."},{"cited_title":"Killing two birds with one stone: Efficient and robust training of face recognition cnns by partial fc","cited_arxiv_id":null,"evidence_quote":"Baseline efficient-training method whose linear-cost approximation GIF compares against and outperforms."},{"cited_title":"Arcface: Additive angular margin loss for deep face recognition","cited_arxiv_id":null,"evidence_quote":"Standard angular-margin softmax baseline whose O(m) normalization GIF replaces and whose performance is a reference in the comparison tables."},{"cited_title":"Dynamic class queue for large scale face recognition in the wild","cited_arxiv_id":null,"evidence_quote":"Efficient-training baseline that GIF compares against and whose linear-cost scaling it seeks to surpass."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Supplies the minority-collapse and neural-collapse analysis used to argue that fixed, sample-count-independent code vectors avoid collapsed centroids."}],"review_version":1}