Paper · 2022-11-07 · cs.CV
Body Part-Based Representation Learning for Occluded Person Re-Identification
BPBreID learns a pixel-wise body-part classifier, supervised by coarse parsing masks from PifPaf poses, and pools one feature per part. GiLt applies the identity loss to holistic features only and a part-averaged triplet loss to part features only. Inference compares mutually visible parts only. Author-reported Occluded-Duke: 66.7 rank-1 / 54.1 mAP with ResNet-50, 75.1 / 62.5 with HRNet-W32.
Part-based featuresMetric learningLabel smoothingperson-re-identificationocclusionbody-partsmetric-learning
arXivPDFCodeMarkdown15 min read
AI-compiled by claude-haiku-5-5 on 2026-11-12, not yet reviewed by a human. Every claim cites its source; check it when a detail matters.
In plain words
Re-identification means recognising the same person across camera images. It gets hard when other people or objects hide part of the person. This paper's model splits the person into body parts, such as head, torso, legs and feet, and learns a map that says which pixels belong to which part. It turns each part into its own feature vector. Two people are then compared only on the parts that both images can see.
Training is the tricky part. One body part is often not distinctive enough to tell two people apart, so the usual identity objective does not fit part features. The paper's fix is to apply the identity loss to whole-person features and a triplet loss to the part features only. The authors report gains on both occluded and ordinary person re-identification benchmarks.
TL;DR
BPBreID is a person re-identification model that learns K body-part attention maps from coarse parsing masks and pools one feature per part §3.1 §3.2. GiLt gives the identity classification objective to whole-person embeddings and a part-averaged metric objective to the part embeddings alone §3.3. At inference it compares a pair only over mutually visible parts §3.4. Author-reported, the HRNet-W32 model beats every listed method on Occluded-Duke at rank-1 and mAP; the ResNet-50 model does not beat PFD there tab. 1.
Problem
Global re-identification features are built from the whole image, so they pick up occluders and other pedestrians, and they cannot align body parts between two partly hidden images §1. Part-based methods fix alignment, but two things go wrong when training them with identity labels: single parts are often not discriminative, and standard identity and triplet losses assume that global appearance separates identities §1. Also, re-identification datasets have no body-part annotation, and off-the-shelf pose or parsing tools transfer poorly to them §1.
Method
The model has two modules and one training objective §3. The body part attention module §3.1 applies a 1×1 convolution and a softmax over K+1 classes, background plus K parts, to the backbone feature map G eq. 1. It is trained with a label-smoothed cross-entropy against coarse parsing labels §3.1.3 eq. 2. Those labels come from PifPaf pose outputs that are merged into K regions §3.1.2 § Supplementary materials (Human Parsing Labels Generation with PifPaf). The global-local module §3.2 then pools G with the part maps eq. 3. It produces a foreground embedding (the maximum of the part maps), K part embeddings, a global average embedding and a concatenation of the part embeddings §3.2.1. It also gives each part a binary visibility score, which the paper computes as 1 when the part map exceeds a threshold of 0.4 §3.2.2 eq. 4. The paper sets the visibility of the holistic embeddings to 1 §3.2.2.
Training minimises a weighted sum of the part attention loss and GiLt eq. 5. GiLt applies the identity loss to the global, foreground and concatenated embeddings and a part-averaged triplet loss to the K part embeddings only §3.3.1 eq. 6. The identity loss uses label smoothing and the BNNeck trick §3.3.1. The part-averaged triplet loss averages the Euclidean distance over the K part pairs of two samples eq. 7 and then applies the batch-hard triplet with a margin §3.3.2 eq. 8. Visibility is not used in training §3.2.2.
At inference the query-gallery distance uses only the foreground embedding and the K part embeddings §3.4. Each pair is weighted by the product of the two visibility scores, and pairs with no mutually visible embedding get an infinite distance §3.4 eq. 9. The global and concatenated embeddings are not used at inference §3.4. The paper illustrates the model with K=4 for head, torso, legs and feet fig. 2.
The training loop below follows the paper's equations. Values not stated in the paper are marked in the Paper vs code section.
# Training step of BPBreID [§3.3] [eq. 5]
# Input: images (N, 3, 384, 128); part_masks (N, K+1, H, W); pids (N,)
# Output: scalar loss
def training_step(images, part_masks, pids):
# Backbone feature map G with C channels [§3.2]
feature_map = backbone(images) # (N, C, Hf, Wf)
# Per-pixel scores over K+1 classes, class 0 is background [§3.1.1] [eq. 1]
pixel_scores = pixel_classifier(feature_map) # (N, K+1, Hf, Wf)
part_maps = softmax(pixel_scores, dim=1) # (N, K+1, Hf, Wf)
# Part attention loss against the coarse parsing labels [§3.1.3] [eq. 2]
target = resize_and_argmax(part_masks, feature_map.shape)
loss_pa = attention_loss(pixel_scores, target)
# Foreground map: pixelwise max over the K part maps [§3.2.1]
foreground_map = max(part_maps[:, 1:], dim=1)
# Weighted pooling of G per part and for the foreground [§3.2.1] [eq. 3]
part_feats = weighted_pool(feature_map, part_maps[:, 1:]) # (N, K, C)
foreground_feat = weighted_pool(feature_map, foreground_map) # (N, C)
# Global average pooling and concatenation of the part features [§3.2.1]
global_feat = average_pool(feature_map) # (N, C)
concat_feat = flatten(part_feats) # (N, K*C)
# Identity loss on the three holistic embeddings, with BNNeck and label
# smoothing [§3.3.1] [eq. 6]
loss_id = sum(
id_loss(f, pids)
for f in [global_feat, foreground_feat, concat_feat]
)
# Part-averaged triplet loss on the K part embeddings only, margin 0.3
# [§3.3.2] [eq. 7] [eq. 8] [§4.2]
loss_tri = part_averaged_triplet(part_feats, pids, margin=0.3)
# Overall objective with lambda_pa = 0.35 [§3.3] [eq. 5]
return 0.35 * loss_pa + loss_id + loss_tri# Part-averaged triplet loss [§3.3.2] [eq. 7] [eq. 8]
# Input: parts (N, K, D); pids (N,); margin alpha
# Output: scalar loss
def part_averaged_triplet(parts, pids, margin):
# Distance between samples i and j: mean of the K part distances [eq. 7]
dist = mean_over_parts(euclidean(parts[:, None], parts[None, :]))
# Hardest positive and hardest negative for each anchor [§3.3.2]
d_pos = max(dist where pids match and i != j)
d_neg = min(dist where pids differ)
# Hinge with margin alpha [eq. 8]
return mean(relu(d_pos - d_neg + margin))# Query-gallery distance with mutual visibility [§3.4] [eq. 9]
# Used embeddings: foreground and the K part embeddings only [§3.4]
# Visibility per part: v_i = 1 if max over pixels of M_i > 0.4 [§3.2.2] [eq. 4]
def pair_distance(query, gallery):
# Weight v_q * v_g per used embedding [§3.4] [eq. 9]
weight = query.visible * gallery.visible
# Euclidean distance per used embedding [§3.4] [eq. 7]
dist = euclidean(query.embeddings, gallery.embeddings)
# No mutually visible embedding means an infinite distance [§3.4]
if sum(weight) == 0:
return infinity
# Visibility-weighted mean over the used embeddings [eq. 9]
return sum(weight * dist) / sum(weight)Key equations, as printed in the paper:
S = \text{softmax}(G P^{T}), \quad P \in R^{(K+1) \times C} eq. 1
L_{pa} = -\sum_{k=0}^{K}\sum_{h=0}^{H-1}\sum_{w=0}^{W-1} q_{k}\,\log S_{k}(h,w), \quad q_k = \begin{cases} 1-\frac{N-1}{N}\varepsilon & Y(h,w)=k \\ \frac{\varepsilon}{N} & \text{otherwise} \end{cases} eq. 2
f_i = \frac{\sum_{h,w} G(h,w)\, M_i(h,w)}{\sum_{h,w} M_i(h,w)}, \quad i \in \{\text{f},1,\dots,K\} eq. 3
v_i = \begin{cases} 1 & \max_{h,w} M_i(h,w) > \lambda_v \\ 0 & \text{otherwise} \end{cases} eq. 4
L = \lambda_{pa} L_{pa} + L_{GiLt} eq. 5
L_{GiLt} = L_{id} + L_{tri} = \sum_{i \in \{g,f,c\}} L_{CE}(f_i) + L_{tri}^{parts}(f_1,\dots,f_K) eq. 6
d_{parts}^{ij} = \frac{1}{K}\sum_{k=1}^{K} dist_{eucl}(f_k^i, f_k^j) eq. 7
L_{tri}^{parts} = \left[ d_{parts}^{ap} - d_{parts}^{an} + \alpha \right]_{+} eq. 8
dist_{total}^{qg} = \frac{\sum_{i \in \{f,1,\dots,K\}} v_i^{q} v_i^{g}\, dist_{eucl}(f_i^{q}, f_i^{g})}{\sum_{i \in \{f,1,\dots,K\}} v_i^{q} v_i^{g}} eq. 9
Symbols follow the paper: G is the backbone map, M_i the attention map of part i, N the batch size in eq. 2 as printed (see Pitfalls), lambda_v = 0.4 and lambda_pa = 0.35.
Hyperparameters
| Name | Value | Where | Notes |
|---|---|---|---|
| Backbone | ResNet-50 (RN) with last stride 1; HRNet-W32 (HR) and ResNet-50-ibn (RI) also used | §4.2 | ImageNet pre-training §4.2; code default last stride 1 default_config.py |
| Input size | 256×128 for RN; 384×128 for HR and RI | §4.2 | Occluded-Duke train config uses 384×128 bpbreid_occ_duke_train.yaml |
| K (body parts) | 5 for holistic datasets; 8 for occluded datasets | §4.2 | K=8 grouping: head, torso, arms, legs, feet § Supplementary materials (Study on K, the number of body parts) |
| Augmentation | Random crop with 10 px padding; random erasing with probability 0.5 | §4.2 | Random flip is not used in the paper text |
| Batch | 64 samples: 16 identities × 4 images | §4.2 | Code sampler uses 4 instances per identity default_config.py |
| Epochs | 120 | §4.2 | Code default default_config.py |
| Optimizer | Adam | §4.2 | Code default default_config.py |
| Learning rate | Linear warm-up from 3.5e-5 to 3.5e-4 over 10 epochs; multiplied by 0.1 at epochs 40 and 70 | §4.2 | Code peak 3.5e-4 default_config.py; warm-up start differs, see Paper vs code |
| Weight decay | not stated | §4.2 | Code default 5e-4 default_config.py |
| Label smoothing epsilon | 0.1 | §4.2 | Also the default of the code's cross-entropy cross_entropy_loss.py |
| Triplet margin alpha | 0.3 | §4.2 | Code default GiLt_loss.py |
| lambda_pa (part attention weight) | 0.35 | §3.3 | Code value bpbreid_occ_duke_train.yaml |
| lambda_v (visibility threshold) | 0.4 | §3.2.2 | Code uses a different rule, see Paper vs code |
| lambda_t (label threshold) | 0.5 | § Supplementary materials (Human Parsing Labels Generation with PifPaf) | Code background threshold 0.5 default_config.py |
| Visibility during training | not used | §3.2.2 | Code default off default_config.py |
| Test embeddings | Foreground and K part embeddings; no global or concatenated | §3.4 | Code: test_embeddings bn_foreg and parts bpbreid_occ_duke_test.yaml |
| Hardware | One NVIDIA Quadro RTX8000 GPU | §4.2 | Not stated for the other settings |
| Evaluation | Single query, no re-ranking; CMC rank-1 and mAP | §4.1 | Occluded-ReID has no train set, so Market-1501 is used for training §4.1 |
Results
Author-reported. The setup is the single-query protocol without re-ranking §4.1. Baseline is the BoT training scheme with a ResNet-50 backbone §4.4.1. The table below lists the paper's main comparison for the three BPBreID variants against BoT tab. 1. The full table, with all baselines, is at the end of this section.
| Dataset | Metric | BoT, RN-50 | BPBreID, RN-50 | BPBreID, HRNet-W32 | Source |
|---|---|---|---|---|---|
| Occluded-Duke | rank-1 | 51.4 | 66.7 | 75.1 | tab. 1 |
| Occluded-Duke | mAP | 44.7 | 54.1 | 62.5 | tab. 1 |
| Market-1501 | rank-1 | 94.5 | 95.1 | 95.7 | tab. 1 |
| Market-1501 | mAP | 85.9 | 87.0 | 89.4 | tab. 1 |
| DukeMTMC-reID | rank-1 | 86.4 | 89.6 | 92.4 | tab. 1 |
| DukeMTMC-reID | mAP | 76.4 | 78.3 | 84.2 | tab. 1 |
| Occluded-ReID | rank-1 | 58.4 | 76.9 | 82.9 | tab. 1 |
| Occluded-ReID | mAP | 52.3 | 68.6 | 75.2 | tab. 1 |
| P-DukeMTMC | rank-1 | 87.0 | 91.0 | 93.0 | tab. 1 |
| P-DukeMTMC | mAP | 74.9 | 77.8 | 83.2 | tab. 1 |
The abstract's margins of 0.7 mAP and 5.6 rank-1 on Occluded-Duke §1 equal the HRNet-W32 row minus the PFD row of the comparison table (62.5 − 61.8 and 75.1 − 69.5). This is our arithmetic on the table, and the HRNet-W32 model is the one that gives those margins. The ResNet-50 model is below PFD on that dataset tab. 1.
Ablations on Occluded-Duke with ResNet-50 §4.4.1 tab. 2:
| Variant | rank-1 | mAP |
|---|---|---|
| BoT baseline | 51.4 | 44.7 |
| BPBreID | 66.7 | 54.1 |
| w/o learnable attention (fixed PifPaf weights) | 51.6 | 39.2 |
| w/o visibility scores | 52.6 | 45.3 |
| w/o part-averaged triplet loss (one triplet per part) | 64.8 | 51.7 |
Embeddings on Occluded-Duke with ResNet-50, with the paper's text giving K=6 for this study §4.4.3 tab. 3:
| Embedding | rank-1 | mAP |
|---|---|---|
| Global f_g | 60.2 | 47.5 |
| Foreground f_f | 64.1 | 49.7 |
| Concatenated f_c | 64.4 | 50.3 |
| Part 1, head | 47.1 | 24.7 |
| Part 2, torso | 52.0 | 31.7 |
| Part 3, left arm | 55.7 | 34.4 |
| Part 4, right arm | 56.7 | 34.1 |
| Part 5, legs | 22.3 | 13.3 |
| Part 6, feet | 16.1 | 9.0 |
| All parts f_1..f_6 | 65.9 | 52.2 |
| Foreground and all parts | 66.1 | 52.5 |
Loss combinations on Occluded-Duke with ResNet-50 §4.4.2 tab. 4. The Identity loss and Triplet loss columns list the embeddings each loss is applied to: g, f and c are the holistic embeddings, p the part embeddings. "Triplet on p" is the part-averaged triplet loss. The last two columns are the PCB architecture under the same loss placement:
| Row | Identity loss on | Triplet loss on | BPBreID rank-1 | BPBreID mAP | PCB column rank-1 | PCB column mAP |
|---|---|---|---|---|---|---|
| GiLt (ours) | g, f, c | p (part-averaged) | 66.7 | 54.1 | 54.6 | 46.3 |
| PCB | p | none | 57.2 | 43.2 | 51.2 | 40.8 |
| 1 | p | g, f, c | 52.9 | 43.2 | 50.2 | 40.9 |
| 2 | g, f, c, p | g, f, c, p | 59.5 | 48.2 | 51.1 | 42.8 |
| 3 | g, f, c, p | none | 61.5 | 49.5 | 52.1 | 44.8 |
| 4 | none | g, f, c, p | 53.9 | 41.9 | 45.5 | 37.6 |
| 5 | g, f, c, p | p | 61.8 | 49.4 | 51.0 | 43.5 |
| 6 | g, f | p | 65.5 | 51.4 | 52.9 | 43.5 |
| 7 | g, c | p | 56.5 | 41.9 | not reported | not reported |
| 8 | f, c | p | 64.0 | 52.9 | 56.2 | 46.2 |
| 9 | g, f, c | c, p | 66.2 | 53.3 | 55.9 | 46.1 |
| 10 | g, f, c | f, p | 63.6 | 52.2 | not reported | not reported |
| 11 | g, f, c | g, p | 64.0 | 52.4 | 54.8 | 45.9 |
| 12 | g, f, c | c | 65.3 | 52.9 | 54.4 | 45.7 |
Number of parts K on Occluded-Duke with ResNet-50 § Supplementary materials (Study on K, the number of body parts):
| K | rank-1 | mAP | Grouping for the parsing labels |
|---|---|---|---|
| 2 | 58.3 | 49.0 | top region (head, trunk, arms); bottom region (legs, feet) |
| 3 | 63.0 | 52.0 | head; central region (trunk, arms); bottom region (legs, feet) |
| 4 | 64.3 | 52.9 | head; trunk; arms; bottom region (legs, feet) |
| 5 | 65.0 | 53.3 | head; trunk; arms; legs; feet |
| 6 | 66.1 | 52.5 | head; trunk; right arm and left arm as two parts; legs; feet |
| 8 | 66.7 | 54.1 | head; trunk; each arm; each leg; each foot |
| 11 | 66.5 | 52.9 | head; upper and lower trunk; upper and lower arm on each side; each leg; each foot |
Full comparison tab. 1. Symbols: dagger for global methods, double dagger for part-based methods. The paper's bold and rank marks are omitted. The three BPBreID rows are the paper's own models; the baselines are the paper's reported numbers:
| Method | Market R-1 | Market mAP | Duke R-1 | Duke mAP | Occ-Duke R-1 | Occ-Duke mAP | Occ-ReID R-1 | Occ-ReID mAP | P-Duke R-1 | P-Duke mAP |
|---|---|---|---|---|---|---|---|---|---|---|
| BoT (dagger) | 94.5 | 85.9 | 86.4 | 76.4 | 51.4 | 44.7 | 58.4 | 52.3 | 87.0 | 74.9 |
| SGAM (double dagger) | 91.4 | 67.3 | 83.5 | 67.3 | 55.1 | 35.3 | - | - | - | - |
| PGFA (double dagger) | 91.2 | 76.8 | 82.6 | 65.5 | 51.4 | 37.3 | - | - | 44.2 | 23.1 |
| MHSA (double dagger) | 94.6 | 84.0 | 87.3 | 73.1 | 59.7 | 44.8 | - | - | 70.7 | 41.1 |
| VGTri (double dagger) | - | - | - | - | 62.2 | 46.3 | 81.0 | 71.0 | - | - |
| OAMN (dagger) | 93.2 | 79.8 | 86.3 | 72.6 | 62.6 | 46.1 | - | - | - | - |
| HG (dagger) | 95.6 | 86.1 | 87.1 | 77.5 | 61.4 | 50.5 | - | - | - | - |
| BPBreID RN-50 (double dagger) | 95.1 | 87.0 | 89.6 | 78.3 | 66.7 | 54.1 | 76.9 | 68.6 | 91.0 | 77.8 |
| PVPM (double dagger) | - | - | - | - | - | - | 66.8 | 59.5 | 85.1 | 69.9 |
| HOReID (double dagger) | 94.2 | 84.9 | 86.9 | 75.6 | 55.1 | 43.8 | 80.3 | 70.2 | - | - |
| ISP (double dagger) | 95.3 | 88.6 | 89.6 | 80.0 | 62.8 | 52.3 | - | - | - | - |
| PAT (double dagger) | 95.4 | 88.0 | 88.8 | 78.2 | 64.5 | 53.6 | 81.6 | 72.1 | - | - |
| PGFL (double dagger) | 95.3 | 87.2 | 89.6 | 79.5 | 63.0 | 54.1 | 80.7 | 70.3 | 81.1 | 64.2 |
| HPNet (double dagger) | - | - | - | - | - | - | 87.3 | 77.4 | - | - |
| SSGR (dagger) | 96.1 | 89.3 | 91.1 | 81.3 | 69.0 | 57.2 | 78.5 | 72.9 | - | - |
| FED (dagger) | 95.0 | 86.3 | 89.4 | 78.0 | 68.1 | 56.4 | 86.3 | 79.3 | - | - |
| LDS (dagger) | 95.8 | 90.3 | 91.5 | 82.5 | 64.3 | 55.7 | - | - | 91.9 | 82.9 |
| PFD (double dagger) | 95.5 | 89.7 | 91.2 | 83.2 | 69.5 | 61.8 | 81.5 | 83.0 | - | - |
| BPBreID RI (double dagger) | 95.7 | 88.4 | 91.7 | 81.3 | 71.3 | 57.5 | 77.0 | 70.9 | 91.3 | 79.2 |
| BPBreID HR-W32 (double dagger) | 95.7 | 89.4 | 92.4 | 84.2 | 75.1 | 62.5 | 82.9 | 75.2 | 93.0 | 83.2 |
The paper says it outperforms all part-based methods on Market-1501 except PFD, which uses a much heavier architecture: a ViT backbone and an HRNet-W48 branch for pose estimation §4.3. Global methods such as SSGR and LDS score higher than the ResNet-50 model on Market-1501 tab. 1. On Occluded-ReID the paper notes that the strongest methods use an external pose model at inference or occlusion augmentation, and BPBreID uses neither §4.3.
Paper vs code
Code: official repository github.com/VlSomers/bpbreid at commit a2dc430, read by hand. The paper also names github.com/VlSomers/person-reid in its experiments footnote §4.2; that repository was not checked.
- Test-time visibility. The paper sets v_i = 1 when the part map's maximum exceeds 0.4 §3.2.2 eq. 4. The code, with default settings, marks a part visible when at least one pixel's argmax over the K+1 classes is that part bpbreid.py default_config.py. The engine uses these scores at test time when
mask_filtering_testingis set, which the Occluded-Duke test config does part_based_engine.py bpbreid_occ_duke_test.yaml. - Holistic visibility. The paper sets the foreground and concatenated visibility to 1 §3.2.2. The code takes the maximum of the part visibilities for both bpbreid.py.
- Distance weight. The paper weights each pair by v_q × v_g §3.4 eq. 9. The code uses sqrt(v_q × v_g) inside the masked mean distance.py. The two are the same for binary visibility only.
- Pairs with no mutually visible part. The paper gives an infinite distance §3.4. The code sets them to the largest value in the matrix plus one distance.py. This is effectively infinite for ranking.
- Test features. The paper does not state which embeddings are batch-normalised at test time. The code uses the batch-normalised foreground embedding and the un-normalised part embeddings part_based_engine.py bpbreid.py. The code also L2-normalises features before the distance by default default_config.py part_based_engine.py. The paper states neither.
- Attention-loss normalisation. The paper's eq. 2 is a sum over k, h and w eq. 2. The code uses PyTorch cross-entropy, which averages over all pixels in the batch body_part_attention_loss.py body_part_attention_loss.py.
- Label smoothing N. The paper calls N the batch size in eq. 2 §3.1.3. The code smooths over K+1 classes body_part_attention_loss.py.
- Warm-up. The paper starts the warm-up at 3.5e-5 §4.2. The code scales the peak learning rate by 0.01 at the start, which gives 3.5e-6 with the default
warmup_factorlr_scheduler.py. The scheduler is stepped byupdate_lrengine.py. The call site was not traced, so the per-epoch step is an inference. - Holistic part grouping, K=5. The paper's K=5 grouping is head, torso, arms, legs and feet § Supplementary materials (Study on K). That matches the code's
fivetransform pifpaf_mask_transform.py. The holistic configs usefive_v, a different five-part vertical split pifpaf_mask_transform.py bpbreid_market1501_train.yaml. - Occluded-Duke test config. The train config uses
eight(K=8) bpbreid_occ_duke_train.yaml. The test config usesfive_vbpbreid_occ_duke_test.yaml. Part count comes from the preprocess setting [code: torchreid/data/masks_transforms/init.py#L55-L64], so as written the test config would build K=5 parts. This was read, not run. - Part-label resolution. The paper defines Y at input resolution §3.1.2. The code resizes the masks to the feature map bilinearly and then takes the argmax part_based_engine.py.
- Loss weights. λ_pa = 0.35 and the triplet margin 0.3 match bpbreid_occ_duke_train.yaml GiLt_loss.py.
- Training and the paper's equations. The GiLt weights in the config match the paper's identity-on-holistic, triplet-on-parts placement bpbreid_occ_duke_train.yaml GiLt_loss.py.
Pitfalls
- Label smoothing N. Eq. 2 is the standard smoothing formula with N as the number of classes, K+1, not the batch size §3.1.3. Use K+1, as the code does.
- Attention loss scale. Eq. 2 sums over pixels, but the code averages. The 0.35 weight is the code's value, so match the averaging.
- Visibility rule. Implement either the paper's 0.4 threshold or the code's argmax rule and state which one. The two are different functions of the same attention maps.
- Test embeddings. Batch-norm on the foreground embedding and L2 normalisation change distances. The paper does not state either choice.
- Warm-up start. The paper's start (3.5e-5) and the code's default (3.5e-6) differ by ten times.
- Part grouping. The paper's K=5 and the holistic configs'
five_vare different groupings. The paper's K=6 embedding study §4.4.3 also differs from its K=8 headline results §4.4.1. - Occluded-Duke test config. It builds K=5 as written, while the checkpoints are K=8. Check the preprocess setting before evaluating.
- Headline margins. The 0.7 mAP and 5.6 rank-1 margins §1 use the HRNet-W32 model. The ResNet-50 model is below PFD on Occluded-Duke tab. 1.
- Label generation. The paper's uncommented text does not give the PifPaf weights used for labels §3.1.2. The repository contains
torchreid/scripts/get_labels.pyandrequirements_labels.txt; they were not reviewed for this card. - Numerical guards. The code adds epsilon 1e-16 to zero distances before the square root part_averaged_triplet_loss.py part_averaged_triplet_loss.py. The weighted average pooling clamps the mask sum at 1e-6 bpbreid.py, so an empty part mask gives a near-zero embedding. The paper does not mention either.
- Compute. The best results use HRNet-W32 at 384×128 §4.2 tab. 1. Training ran for 120 epochs on one GPU §4.2. The paper gives no timing.
- Licence of the code. The repository is under the Hippocratic License 3.0, which is not an OSI licence and carries ethical-use terms. This card quotes no code, only paths and lines. Whether the repository is acceptable as
codefor a commercially used page is a decision for the human reviewer.
Lineage
- Builds on: the BoT training scheme and ResNet-50 baseline arXiv:1903.07071 §4.2 §4.4.1; the batch-hard triplet loss arXiv:1703.07737 §3.3.2; PifPaf pose estimation arXiv:1903.06593 for the parsing labels §3.1.2.
- Compared against: PCB arXiv:1711.09349 tab. 4; and the methods in tab. 1 named PGFA, HOReID, PAT, ISP, PVPM, PFD, FED, LDS, OPReID (SSGR), HPNet, VGTri and HG.
Source and license
Adapted from “Body Part-Based Representation Learning for Occluded Person Re-Identification” by Vladimir Somers, Christophe De Vleeschouwer, Alexandre Alahi (arXiv:2211.03679), used under CC BY 4.0. Changes: condensed and restructured for implementation, with tables, equations and algorithms taken from the paper and its code, each cited to its source. Not affiliated with or endorsed by the authors. Code citations refer to https://github.com/VlSomers/bpbreid at commit a2dc43042847 (Hippocratic License 3.0 (ethical-use license, not OSI; no code quoted)). Any quoted code is shown under that license.