Back to paper library
CVPR 2024Face anti-spoofingPaper notes

HPDR

The Hyperbolic World Tree

Original paper

Rethinking Generalizable Face Anti-spoofing via Hierarchical Prototype-guided Distribution Refinement in Hyperbolic Space

Paper authors

Chengyang Hu · Ke-Yue Zhang · Taiping Yao · Shouhong Ding · Lizhuang Ma

Publication
CVPR 2024Conference
Cite this paper · BibTeX

The citation identifies the linked source version. It cites the original paper and its authors.

@inproceedings{faceantispoofinghpdr2024,
  title = {{Rethinking Generalizable Face Anti-spoofing via Hierarchical Prototype-guided Distribution Refinement in Hyperbolic Space}},
  author = {Chengyang Hu and Ke-Yue Zhang and Taiping Yao and Shouhong Ding and Lizhuang Ma},
  year = {2024},
  booktitle = {CVPR},
  url = {https://openaccess.thecvf.com/content/CVPR2024/html/Hu_Rethinking_Generalizable_Face_Anti-spoofing_via_Hierarchical_Prototype-guided_Distribution_Refinement_in_CVPR_2024_paper.html}
}
On this page

Let's look at a CVPR paper.

The authors attempt to approach the FAS problem from a different perspective, presenting a very novel concept.

Defining the Problem

The safeguard for face recognition systems is built upon Face Anti-Spoofing (FAS).

With the maturity of deep learning, research progress has been remarkable: from early handcrafted features, to deep binary classification architectures, and more recently, cross-domain learning techniques. FAS has gradually learned how to recognize risks amidst chaos.

However, once the dataset changes or the scenario shifts, the model’s performance drastically deteriorates, repeatedly confirmed.

Later, researchers tried to teach models to "learn generalization" by introducing adversarial, disentanglement, contrastive, meta-learning, and other training strategies, aiming to make features consistent across different scenarios.

But in this process, one thing is unknowingly sacrificed: the semantic structure.

By semantic structure, it is not the network architecture itself, but the "semantic distance" and "hierarchical context" between samples:

  • A photo printed by a color printer and a video replayed on a mobile phone may be close in pixel distribution, but the types of attacks and underlying mechanisms they represent are vastly different.
  • The generation conditions of an attack, including lighting, background, or material, essentially segment the semantic attributes of samples rather than noise.

Yet existing methods mostly force all samples into a single "Euclidean" feature space, prioritizing minimizing the domain gap, which leads to over-alignment.

We cram features that should be separate together, compressing the structure the model might have understood into a flat space without hierarchy.

Isn't that strange?

Therefore, the authors of this paper believe:

Since the difficulty of generalization stems from semantic imbalance, can we change the space to let hierarchy speak for itself?


Solving the Problem

To repair the semantic structural fractures caused by compression, this paper proposes a novel methodology:

  • Hierarchical Prototype-guided Distribution Refinement (HPDR).

Overall, HPDR is built upon three core components:

  1. Embedding features in hyperbolic space to capture their intrinsic hierarchical structure;
  2. Using prototype learning as a semantic coordinate system, associating samples with semantic cluster centers;
  3. Employing multi-level alignment and optimization strategies to gradually approach a generalizable semantic distribution.

First, let’s start by examining this space itself.


Hyperbolic Space

If semantics have a tree-like structure, then hyperbolic space is the precise geometric choice.

We can imagine a semantic tree, branching from the main trunk of “attack” and “real,” continuously subdividing according to material, presentation method, and source device. If we forcibly compress this tree into a flat Euclidean map, its branches become distorted, overlapped, and unable to spread out; but in hyperbolic space, it naturally extends, avoids overlap, and can infinitely proliferate near the boundary.

HPDR adopts exactly such a spatial model: the Poincaré Ball Model.

The Poincaré Ball can be represented as:

Dcn={x∈Rn∣c∥x∥2<1}\mathbb{D}_c^n = \left\{ \mathbf{x} \in \mathbb{R}^n \mid c\|\mathbf{x}\|^2 < 1 \right\}

For curvature parameter cc, all points lie in an open ball of radius 1/c1/\sqrt{c}; the radius is 1 only when c=1c=1.

At first glance, it looks like a closed boundary, but this sphere’s edge is not a limit — it is infinitely far away.

This means we can approach the boundary arbitrarily close, but never actually reach it.

This design has a key property: the closer points are to the boundary, the distances between them nonlinearly expand. In other words, distance itself carries semantic hierarchical tension.

To make this space computationally viable, we cannot use the traditional Euclidean metric; instead, we introduce a curvature-controlled Riemannian metric tensor:

gD=λc2⋅gE,λc=21−c∥x∥2g_{\mathbb{D}} = \lambda_c^2 \cdot g_E, \quad \lambda_c = \frac{2}{1 - c\|\mathbf{x}\|^2}
  • gEg_E: the familiar Euclidean metric;
  • λc\lambda_c: a location-dependent scaling factor (conformal factor).

Near the center, λc\lambda_c approaches a constant and the geometry behaves almost flat. Near the boundary, as c∥x∥2→1c\|\mathbf{x}\|^2 \to 1, λc\lambda_c diverges and small coordinate shifts are greatly amplified in distance.

This is the essence of hyperbolic space: allowing hierarchical expansion to unfold naturally.

To describe displacements in this geometry, we use Möbius addition:

u⊕cv=(1+2c⟨u,v⟩+c∥v∥2)u+(1−c∥u∥2)v1+2c⟨u,v⟩+c2∥u∥2∥v∥2\mathbf{u} \oplus_c \mathbf{v} = \frac{(1 + 2c\langle \mathbf{u}, \mathbf{v} \rangle + c\|\mathbf{v}\|^2)\mathbf{u} + (1 - c\|\mathbf{u}\|^2)\mathbf{v}}{1 + 2c\langle \mathbf{u}, \mathbf{v} \rangle + c^2\|\mathbf{u}\|^2\|\mathbf{v}\|^2}

This is not familiar vector addition but a way to combine displacements in the hyperbolic ball; the result depends on the current position and the curvature parameter.

The distance between two points is given by the hyperbolic distance:

dH(u,v)=2c⋅arctanh(c⋅∥−u⊕cv∥)d_H(\mathbf{u}, \mathbf{v}) = \frac{2}{\sqrt{c}} \cdot \mathrm{arctanh}\left( \sqrt{c} \cdot \| -\mathbf{u} \oplus_c \mathbf{v} \| \right)

This distance formula geometrically interprets “semantic divergence,” measuring how much vectors bend or split, rather than their traditional “distance apart.”

Having hyperbolic space ready, the next question is:

  • How do we map neural network outputs into it?

Since neural network outputs are still Euclidean vectors, we must find a proper way to map them into hyperbolic space.

This is done by the exponential map:

exp⁡0c(v)=tanh⁡(c∥v∥)⋅vc∥v∥\exp_0^c(\mathbf{v}) = \tanh\left(\sqrt{c}\|\mathbf{v}\|\right) \cdot \frac{\mathbf{v}}{\sqrt{c}\|\mathbf{v}\|}

This operation has two effects:

  • Short vectors map near the ball center;
  • Long vectors map closer to its boundary.

Whether those positions correspond to a semantic hierarchy depends on the subsequent prototypes and losses; the map alone does not assign meaning.

Semantic Anchors

With hyperbolic space prepared, where do semantics grow?

In HPDR, the authors do not classify from the feature vector alone. Before the final decision, they add learnable relationships to reference points called prototypes; the system is still trained end to end.

Prototypes are not mere points but semantic aggregation units.

  • Their coordinates determine how samples are categorized;
  • The distances between prototypes shape the distribution of the entire semantic space.

First, define a basic set of prototypes called Leaf Prototypes, which correspond directly to semantic cluster centers of samples, with explicit label information.

Mathematically defined as:

Pleaf={pij∣i∈{0,1},j∈{0,…,K−1}}\mathcal{P}_{\text{leaf}} = \{ p_{ij} \mid i \in \{0,1\}, j \in \{0, \dots, K-1\} \}
  • ii: binary class index distinguishing fake from live;
  • jj: the jjth prototype within class ii, total KK;
  • Thus, there are 2K2K leaf prototypes corresponding to semantic subgroups of the two classes.

This design assumes that samples in one class may form multiple feature subgroups, each represented by a different leaf prototype; the paper does not provide separate subgroup labels.

In theory, these prototypes should be initialized directly in hyperbolic space, but practically initializing in Dn\mathbb{D}^n often causes gradient explosion or unstable optimization. Therefore, the authors' practical approach is:

  1. Randomly initialize prototype vectors pEuc\mathbf{p}_{\text{Euc}} in Euclidean space Rn\mathbb{R}^n;
  2. Map them into hyperbolic space via the exponential map:
p=exp⁡0c(pEuc),pEuc∈Rn\mathbf{p} = \exp_0^c(\mathbf{p}_{\text{Euc}}), \quad \mathbf{p}_{\text{Euc}} \in \mathbb{R}^n

This avoids the optimization difficulty of initializing directly in hyperbolic space.

The most interesting part of the overall structure design follows: None-leaf Prototypes.

These prototypes do not correspond to any single sample but serve as candidate common ancestors and connecting nodes for leaf prototypes.

Defined as:

Pnone-leaf={pk∣k∈{0,…,K′−1}}\mathcal{P}_{\text{none-leaf}} = \{ p_k \mid k \in \{0, \dots, K'-1\} \}
  • These are also embedded in Dn\mathbb{D}^n but carry no label information;
  • They exist to build internal nodes of the semantic tree, simulating transitions and convergences between semantic hierarchy levels.

In other words:

  • Leaf Prototypes aggregate samples → establish semantic correspondence;
  • None-leaf Prototypes aggregate prototypes → establish hierarchical structure.

The beauty of this design is that it learns prototype relations without extra hierarchy labels inside a classifier that does use known real/fake labels.

We do not explicitly label which subgroup belongs to whom; the model discovers by itself which prototypes are close, which share common ancestors, which ancestors should be near the boundary, and which remain near the center.

Semantic Three-Level Alignment

With hyperbolic space and prototypes established, the next step is to build a learnable system.

This design is called Hyperbolic Prototype Learning (HPL), a learning framework crafted around three semantic-level relationships:

  • Prototype ↔ Instance: point-to-point semantic alignment
  • Instance ↔ Instance: internal consistency among samples
  • Prototype ↔ Prototype: hierarchical construction of semantic structure

Let’s examine each in turn:

  1. Prototype-based Feature Alignment

    Starting with the basic step: letting each sample find its semantic anchor.

    For each sample feature vector z\mathbf{z}, according to its label yy, find the closest leaf prototype in that class:

    p(z)=arg⁡min⁡pyj∈PleafdH(z,pyj)p(\mathbf{z}) = \arg\min_{p_{yj} \in \mathcal{P}_{\text{leaf}}} d_H(\mathbf{z}, p_{yj})

    This establishes a "correct prototype" for each sample.

    Next, the model is encouraged to learn features that move closer to these prototypes while distancing from others, applying contrastive learning in hyperbolic space:

    LPI=−∑n=1Nlog⁡e−dH(zn,pck)∑i,je−dH(zn,pij)\mathcal{L}_{PI} = -\sum_{n=1}^N \log \frac{e^{-d_H(\mathbf{z}_n, p_{c_k})}}{\sum_{i,j} e^{-d_H(\mathbf{z}_n, p_{ij})}}

    This loss lets the model autonomously judge which samples should be close or far apart in semantic space.

    To avoid collapse where all samples map to one prototype, the paper proposes balanced assignments within each mini-batch. Yet the paper's stated 20 leaf prototypes per class mean 40 leaves for a batch of 30 samples. The released code instead uses 20 leaves in total; these settings must not be conflated when reproducing the result.


  1. Instance-based Consistency

    Real-world samples are not static; they undergo perturbations from lighting, angle, occlusion, etc. The goal is for the model to learn signals truly related to semantics.

    HPL introduces sample consistency learning:

    Given a sample and its augmentation (x,xaug)(x, x_{\text{aug}}), extract features z,zaug\mathbf{z}, \mathbf{z}_{\text{aug}}, and encourage consistency by minimizing their distance in semantic space:

    LII-feat=dH(detach(z),zaug)\mathcal{L}_{II\text{-feat}} = d_H(\mathrm{detach}(\mathbf{z}), \mathbf{z}_{\text{aug}})

    where detach(⋅)\mathrm{detach}(\cdot) blocks gradients to only update zaug\mathbf{z}_{\text{aug}}, stabilizing the anchor feature.

    At the semantic distribution level, their distance profiles to all prototypes should be consistent:

    LII-dist=∥dH(detach(z),Pleaf)−dH(zaug,Pleaf)∥2\mathcal{L}_{II\text{-dist}} = \left\| d_H(\mathrm{detach}(\mathbf{z}), \mathcal{P}_{\text{leaf}}) - d_H(\mathbf{z}_{\text{aug}}, \mathcal{P}_{\text{leaf}}) \right\|_2

    The total loss is:

    LII=LII-feat+LII-dist\mathcal{L}_{II} = \mathcal{L}_{II\text{-feat}} + \mathcal{L}_{II\text{-dist}}

    This design encourages the feature's position in the semantic structure to stay stable as the sample's appearance changes.


  1. Hierarchical Structure Modeling

    The relationships among prototypes cannot be “evenly spread.” They should have proximity, hierarchy, and ancestor-descendant relations.

    This is the most symbolic step in HPDR: the semantic tree self-growth.

    To learn this structure, the authors borrow the Dasgupta cost concept from hierarchical clustering:

    C=∑i,jwij⋅∣leaves(pi∨pj)∣\mathcal{C} = \sum_{i,j} w_{ij} \cdot |\mathrm{leaves}(p_i \vee p_j)|

    where pi∨pjp_i \vee p_j denotes the lowest common ancestor (LCA) of pip_i and pjp_j, and ∣leaves(⋅)∣|\mathrm{leaves}(\cdot)| is the number of leaf nodes under that subtree. Essentially, this cost asks: Can semantically close prototypes merge at a lower level?

    Because Dasgupta cost has a discrete form and there are no ground-truth similarity weights for these nodes, the authors use a triplet-based optimization strategy:

    1. Positive pair: pi,pjp_i, p_j are mutual K-nearest neighbors;
    2. Negative prototype: pkp_k does not satisfy the above mutual-neighbor condition with pip_i.

    Then, for each (pi,pj,pk)(p_i, p_j, p_k), select ρij\rho_{ij} from the none-leaf prototypes as a candidate LCA of pip_i and pjp_j:

    πij(ρ)=exp⁡(−max⁡(dH(pi,ρ),dH(pj,ρ)))\pi_{ij}(\rho) = \exp\left( - \max(d_H(p_i, \rho), d_H(p_j, \rho)) \right) ρij=arg⁡max⁡ρ(πij(ρ)+gij)\rho_{ij} = \arg\max_{\rho} \left( \pi_{ij}(\rho) + g_{ij} \right)

    Here gijg_{ij} is Gumbel noise used to perturb the candidate ancestor selection; argmax alone is not differentiable.

    Then define ρijk\rho_{ijk} as the common ancestor of ρij\rho_{ij} and pkp_k, and formulate the triplet loss:

    LPP-LCA=[dH(pi,ρij)−dH(pi,ρijk)+δ]+[dH(pj,ρij)−dH(pj,ρijk)+δ]+[dH(pk,ρijk)−dH(pk,ρij)+δ]\begin{aligned} \mathcal{L}_{PP\text{-LCA}} = &\left[d_H(p_i, \rho_{ij}) - d_H(p_i, \rho_{ijk}) + \delta\right] \\ + &\left[d_H(p_j, \rho_{ij}) - d_H(p_j, \rho_{ijk}) + \delta\right] \\ + &\left[d_H(p_k, \rho_{ijk}) - d_H(p_k, \rho_{ij}) + \delta\right] \end{aligned}

    Additionally, two structural constraints on leaf prototypes’ distribution are imposed:

    • Encourage prototypes to stay away from the origin (to prevent collapse):
    LP-Origin=−log⁡11+∑pi∈Pleafexp⁡(−dH(pi,O))\mathcal{L}_{P\text{-Origin}} = -\log \frac{1}{1 + \sum_{p_i \in \mathcal{P}_{\text{leaf}}} \exp(-d_H(p_i, \mathbf{O}))}
    • Encourage prototypes to disperse from each other:
    LPP-leaf=−log⁡11+∑pi,pj∈Pleafexp⁡(−dH(pi,pj))\mathcal{L}_{PP\text{-leaf}} = -\log \frac{1}{1 + \sum_{p_i, p_j \in \mathcal{P}_{\text{leaf}}} \exp(-d_H(p_i, p_j))}

    The total semantic structure modeling loss is:

    LPP=LPP-LCA+LP-Origin+LPP-leaf\mathcal{L}_{PP} = \mathcal{L}_{PP\text{-LCA}} + \mathcal{L}_{P\text{-Origin}} + \mathcal{L}_{PP\text{-leaf}}

The real challenge of semantic alignment lies in letting relationships among points grow into a tree structure.

HPDR’s Hyperbolic Prototype Learning turns classification into a syntactic parsing process within a nonlinear space, rather than merely assigning labels.

In the figure, the Prototype-oriented Classifier uses each sample's hyperbolic distances to the leaf prototypes to predict live or fake. Thus the final decision uses prototype information, not only the feature vector. The paper's Equation (19) writes this with a sigmoid; the released code instead uses a linear layer to produce two class logits and trains it with cross-entropy.

Training Procedure

The training process is divided into three steps:

  • Step 1: Prototype Initialization

    First, initialize randomly in Euclidean space, then map into hyperbolic space:

    • All Leaf Prototypes (used to align samples)
    • All None-leaf Prototypes (used to build hierarchy)

    At this stage, prototypes are scattered without structure and have no explicit correspondence with samples. They quietly exist, awaiting to be claimed by samples and to grow semantics from distances.


  • Step 2: Prototype Assignment

    Samples are mapped into hyperbolic space and begin searching for their semantic anchors.

    The authors assign each sample feature z\mathbf{z} to the closest leaf prototype within the same class according to its label yy.


  • Step 3: Prototype Optimization

    Once the relationships between samples and prototypes are established, the system jointly adjusts and aligns semantics.

    The entire system is optimized via the combined loss:

    Lall=Lpred+LPI+LII+LPP\mathcal{L}_{\text{all}} = \mathcal{L}_{\text{pred}} + \mathcal{L}_{PI} + \mathcal{L}_{II} + \mathcal{L}_{PP}

    These four losses correspond respectively to:

    • Stability of semantic decision-making (Lpred\mathcal{L}_{\text{pred}})
    • Alignment degree between samples and prototypes (LPI\mathcal{L}_{PI})
    • Consistency of samples under augmentation (LII\mathcal{L}_{II})
    • Hierarchical and structural relations among prototypes (LPP\mathcal{L}_{PP})

    After this optimization round, both samples and prototypes in the space update: prototypes are fine-tuned, sample embeddings converge, and semantic tension redistributes.

    The process then returns to Step 2, repeating assignment and entering the next convergence cycle.

Experimental Setup

To validate HPDR's generalization capability, the authors used the commonly adopted OCIM benchmark.

To ensure learnability and reproducibility of the overall architecture, key model implementation settings are as follows:

  • Input image size: 256×256 (cropped color face region)
  • Leaf prototype count: the paper's prose says K=20K=20 per class, while Table 5 labels a total ∣Pleaf∣=20|\mathcal{P}_{\text{leaf}}|=20; the released code also uses 20 total, or 10 per class
  • Number of none-leaf prototypes K′=256K' = 256: backbone nodes for building semantic hierarchy
  • Feature dimension: 256-dimensional hyperbolic feature space
  • Curvature parameter c=0.01c = 0.01: controls the degree of hyperbolic curvature
  • Sample configuration: 5 samples per class per domain, total batch size of 30
  • Positive prototype pairs in triplets: top 3 KNN selected as positives
  • Structural margin δ\delta in loss function: 0.1

Training was implemented with PyTorch framework using DepthNet as backbone, performed on NVIDIA 4090 GPU, with Adam optimizer and a learning rate of 0.001.

Discussion

OCIM Benchmark

This benchmark has become a standard in recent years, where three datasets are chosen as training sources and one unseen domain is left as the test set.

The experimental goal is to simulate real-world challenges of “new devices, new lighting, new environments.”

Results shown in the table:

  • DG methods generally perform better than traditional methods, but not every DG method beats every traditional one in each test;
  • HPDR has the lowest HTER in all four settings. Its AUC is highest in the C and O targets, but not in the I and M targets.

Notably, HPDR's HTER and AUC also beat the listed prototype and hyperbolic-embedding methods in these four tests. The authors suggest this may be because HPDR does more than align samples: it also builds a hierarchical semantic tree.

The advantage comes from the model’s built-in syntactic structure. Other methods align point-to-point relations, whereas HPDR aligns positions and hierarchies between semantic concepts.


Limited Source Domain

In this test, the authors use only two datasets—MSU and Idiap Replay-Attack—as training sources, then test on OULU and CASIA. This examines generalization with a limited number of source domains.

Compared with AMEL, HPDR improves AUC by 3.42 percentage points and reduces HTER by 2.30 percentage points under M&I→C. Under M&I→O, HPDR has the higher AUC, but its 21.07% HTER remains above AMEL's 19.68%. It leads the listed hyperbolic and prototype methods in both settings.

This shows that in these two limited-source tests, HPDR can still achieve comparatively low error rates on unseen datasets.

HPDR here acts like a map reader with clear vision, relying on built-in terrain knowledge rather than the immediate route.


Cross-Attack

Finally, the authors conduct cross-attack testing on the HQ-WMCA dataset.

The challenge is: exclude a certain attack type during training and test exclusively on that type, testing the robustness of semantic transfer.

HPDR has the lowest ACER for four of the eight attacks, and its overall mean and standard deviation, 14.6±8.5%, are the lowest in the table. Yet its Replay ACER of 19.0% is higher than every compared method. It helps on some unseen attacks, with a clear exception.

In other words, the model tries to use prototype relationships to judge whether “the overall semantics of this face fit within a known semantic structure.”.


What Is Key in Semantic Space?

From experiments, several observations arise:

  • Without the three HPL losses, the model still has classification loss Lpred\mathcal{L}_{\text{pred}}, but performs worst (HTER 17.78%). Merely entering hyperbolic space is insufficient; it needs structured supervisory signals.
  • Adding only LPI\mathcal{L}_{PI} (prototype-instance alignment) significantly improves performance, showing that correspondence between samples and semantic prototypes is the primary factor for stable embeddings.
  • Adding LPP\mathcal{L}_{PP} on top of LPI\mathcal{L}_{PI} lowers HTER from 15.56% to 12.78%, supporting the value of prototype-structure constraints in this test.
  • Using the full loss yields the best results, confirming HPDR’s design logic is synergistic, not a linear stack, but a three-dimensional semantic syntax puzzle.

In this ablation, alignment, consistency, and hierarchy perform best together.


How Many Branches Should the Semantic Tree Have?

The authors tested different numbers of leaf prototypes. As the count rose from 4 to 20, HTER declined, although AUC did not rise monotonically. Beyond 20, both HTER and AUC worsened in this test.

The authors suggest that too many prototypes may make mini-batch assignments uneven. Under this test setting, Table 5 labels 20 total leaf prototypes as the best result, inconsistent with the paper's statement of 20 per class.


How Curved Should the Semantic Space Be?

From the results:

  • Euclidean space (c=0c=0) performs worst, since semantic hierarchies cannot unfold;
  • Performance improves as curvature increases up to 0.01, indicating clearer semantic hierarchies;
  • As cc increases further, performance worsens; the authors conjecture that this relates to the exponential-map approximation with x=0x=0 as its base point.

Hence, hyperbolic space should be “just right” — curved enough to let semantic branches grow freely but not so much as to lose direction.


Visualization Results

Finally, the authors visualize the feature distributions learned by HPDR on Leave-One-Out and Cross-Attack tasks.

In the figures:

  • Sample colors distinguish both live/spoof class and source/target domain;
  • Positions correspond to hyperbolic embeddings;
  • Leaf and none-leaf prototypes are marked as specific points or hierarchical nodes.

Key observations:

  1. In panels (a) and (c)–(h), live and spoof samples are broadly separated in the selected cross-dataset and cross-attack settings, forming branches with the prototypes;
  2. None-leaf prototypes connect several leaf prototypes in these panels, showing the hierarchy the authors designed;
  3. These visualizations offer distribution clues.

In figure (b), samples corresponding to each leaf prototype are visualized in groups, revealing:

  • In the selected examples, samples under the same prototype share some visible similarities;
  • Prototypes sharing lower-level LCAs exhibit higher semantic consistency among their samples, confirming hierarchy geometrically reflects semantic consistency rather than just classification.

The visualization shows prototype relationships learned without extra hierarchy labels; live/spoof labels and hierarchical losses still participate in training.

Conclusion

The core idea of this study is not to memorize more samples, but to build a spatial logic that accommodates semantic hierarchies.

The authors examine HPDR through experiments and visualization. Across unseen datasets, limited source domains, and new attack types, it improves several tested results, with the exceptions noted above. These findings support the value of structural modeling for cross-domain recognition in the tested settings.

With recent trends integrating natural language capabilities into FAS, combining the semantic tree concept with language models may reveal a fundamentally different kind of semantic tree in the future.