Jaguar Re-ID

The challenge

Kaggle hands you train.csv — every image labeled with the jaguar identity it depicts — and test.csv, which contains millions of (query_image, gallery_image) pairs. For each pair, return a single similarity value. The leaderboard scores those similarities directly. Not classification accuracy. Similarity. Most entrants walked in treating it as classification — but this is a re-identification task, and that was the trap.

The dataset shape

1,895 training rows across 31 unique jaguars — Marcela (183 frames), Ousado (179), Medrosa (170) at one end; Bernard and Ipepo (13 each) at the other. Mean is 61 frames per identity, median 45. That long tail dictates how the offline validation split has to be built: stratify per identity or your val set will under-sample the minority animals and your selection metric will pick the wrong checkpoint.

Four identities · four frames each

Marcela 183 total frames

Ousado 179 total frames

Lua 120 total frames

Abril 21 total frames

Real training frames at 96×96. Same individual, different lighting, posture, occlusion — this is why the task is similarity, not classification.

The architectural pivot — classification to retrieval

The first local baseline was an ImageNet-pretrained ResNet-50 with a triplet loss + cross-entropy combo. Public score: 0.421. It plateaued fast.

The unlock was reframing the task. The leaderboard scores similarity geometry, so the model should be optimized for embedding structure, not for class accuracy. Three moves followed in lockstep:

1. Replace the offline metric. pair_auc and retrieval_map computed on a fixed validation split with leaderboard-like pair sampling. Without this, every cloud-trained model looked roughly the same and we were burning GPU-hours ranking noise.
2. Replace the architecture stack. EVA-02 Large at 448², GeM pooling, ArcFace head. The backbone choice mattered more than any single hyperparameter; ArcFace structured the embedding space the way the leaderboard actually scored it.
3. Postprocess the similarity matrix. TTA by horizontal flip; average query expansion; k-reciprocal reranking; a final blend of raw and reranked scores.

Model architecture

The baseline model, kept on disk for reproducibility, is just a ResNet-50 with embedding_dim=512, cross-entropy + 0.2 · triplet_loss (batch-hard, margin=0.2), label smoothing 0.1. It exists to be beaten.

Training protocol

Validation strategy

Score progression

The inference pipeline

The 0.807 → 0.871 leap was not in the model. It was in what the model’s embeddings get fed through after they leave the GPU. The postprocessing is transductive — it exploits the full structure of the test set, not just per-query nearest neighbors.

A representative slice of the loss

The baseline combines softmax cross-entropy with a batch-hard triplet term. The eva02 plan turns the triplet weight off (ArcFace structures the embedding geometry on its own); the snippet below shows the fallback path that the lighter ConvNeXt sweeps still rely on.

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import inspect
import json
import sys
from contextlib import nullcontext
from datetime import datetime, timezone
from pathlib import Path

import numpy as np
import torch
from torch import nn
from torch.utils.data import DataLoader
from tqdm import tqdm

sys.path.append(str(Path(__file__).resolve().parent / "src"))

from jaguar_reid_utils import (  # noqa: E402
    JaguarTrainDataset,
    PKBatchSampler,
    batch_hard_triplet_loss,
    build_model,
    build_transforms,
    compute_retrieval_metrics,
    load_label_mapping,
    load_train_rows,
    make_split,
)


def parse_args():
    root = Path(__file__).resolve().parent
    parser = argparse.ArgumentParser()
    parser.add_argument("--train-csv", type=Path, default=root / "data" / "extracted" / "train.csv")
    parser.add_argument("--image-dir", type=Path, default=root / "data" / "extracted" / "train" / "train")
    parser.add_argument("--output-dir", type=Path, default=root / "outputs" / "baseline")
    parser.add_argument("--model", default="resnet50.a1_in1k")
    parser.add_argument("--epochs", type=int, default=8)

Lessons banked for next time

• Validate the way the leaderboard scores. A wrong offline metric costs more than a wrong hyperparameter; it can hide a 0.2 mAP gap for weeks.
• Embedding geometry beats label accuracy. Once the head moved from softmax to ArcFace, the score curve resumed.
• Transductive postprocessing was the second engine. AQE + k-reciprocal reranking + blending added more in postproc than another epoch of training ever did.
• Decouple split-seed and train-seed. It is the cheapest reform a Kaggle pipeline can make.
• Cheap GPUs first, expensive GPUs only for high-value hypotheses. The retrospective in apps/kaggle/docs/jaguar-retrospective.md is blunt: long speculative remote sweeps had poor ROI.