Stage 4: specialist student (3.27M params, F1 0.710 vs 0.894 baseline)

stage_4/README.md

@@ -1,5 +1,73 @@
 # Stage 4: Specialist Backbone
 
-Reserved. See repo root README for plan.
+Train a compact student to reproduce the 40 target dimensions (20 person-positive + 20 person-negative) that the Stage 0 classifier reads out of EUPE-ViT-B. The student takes the same 768 pixel input as the teacher and emits a 40-D vector per image. Composed with the Stage 0 ternary classifier, this gives a full person-detection pipeline of **3.27M parameters**, versus 85.64M for the teacher.
 
-Scope: train a small student network that emits only the 100 target dims of EUPE-ViT-B, supervised against those dims on a large image corpus.
+## Student architecture
+
+Compact ViT, defined in `student.py`:
+
+- Patch size 16, input 768 px → 48×48 = 2304 tokens
+- Embed dim 192, depth 6 blocks, 3 heads per block, MLP ratio 4
+- Final LayerNorm → max-pool over patches → Linear(192, 40)
+- Total: 3,267,304 parameters (3.27M)
+
+## Training recipe
+
+- Data: COCO train 2017 (117,266 images), resized to 768×768, ImageNet normalization
+- Teacher targets: pre-computed by `prepare_targets.py` from the existing EUPE-ViT-B feature cache
+- Loss: MSE on the 40-D output
+- Optimizer: AdamW, lr 3e-4, weight decay 1e-4
+- Schedule: cosine with 3% warmup
+- Batch 16, 10 epochs, bfloat16 autocast
+- Wall time: 26 minutes on one RTX 6000 Ada
+
+## Result
+
+F1 = 0.710 on the 1000-image COCO val subset (Stage 0 classifier applied on top of the student's 40-D output, threshold swept).
+
+```
+epoch   loss   F1      P      R
+  1    2.25   0.707  0.55  1.00
+  3    2.01   0.717  0.57  0.97
+  5    2.00   0.712  0.56  0.98
+ 10    1.99   0.710  0.57  0.95
+```
+
+Loss plateaus around 2.0 after epoch 2. F1 converges near 0.71. Precision stays ~0.57 across all epochs while recall is >0.95 — the student learns "when in doubt, call it person" and rarely misses a true positive, but fires false on about half of person-negatives.
+
+## Comparison
+
+```
+model                                params       F1 on COCO val 1K
+Stage 0 (EUPE-ViT-B + classifier)    85.64M       0.894
+Stage 2 K=10 head prune + classifier 83.67M       0.916
+Stage 4 student + classifier          3.27M       0.710
+```
+
+26× smaller than the full EUPE-ViT-B pipeline, F1 drop of 0.18 from baseline. A proof that the 40-D target manifold is learnable by a compact specialist but not yet a drop-in replacement for the teacher.
+
+## What this stage ships
+
+- `student.py` — architecture definition
+- `prepare_targets.py` — builds teacher target tensor from ViT-B feature cache
+- `train.py` — distillation loop
+- `student_final.safetensors` — trained student weights (10 epochs)
+- `student_ep*.safetensors` — per-epoch checkpoints
+- `training_log.json` — loss + F1 per epoch
+
+## Where the F1 gap comes from
+
+The student converged on a high-recall / low-precision operating mode. Three likely contributors:
+
+1. **Capacity mismatch.** Going from 85.6M to 3.27M is an aggressive compression ratio. The EUPE teacher itself was distilled from a 1.9B proxy, then again to 86M — a further order-of-magnitude compression to 3M is harder than it looks.
+2. **Data limit.** Training on 117K COCO images is narrow. The teacher was trained on LVD-1689M (1.7B images) and absorbs much broader scene statistics. Re-training with a larger image corpus (ImageNet-1k or OpenImages) would likely help.
+3. **Loss choice.** MSE on 40 dimensions is a coarse target. Cosine similarity or a reconstruction-plus-contrastive loss over the teacher's full 768-D pooled vector would preserve more structure.
+
+## Natural next iteration (Stage 4B)
+
+1. Scale the student to 10–15M params (depth 8, dim 256).
+2. Add ImageNet as a second training corpus once its cache finishes.
+3. Switch loss to cosine on full 768-D pooled teacher output, project to 40-D only at inference.
+4. Longer schedule: 30 epochs.
+
+Target: bring F1 above 0.85 at ≤15M total specialist-pipeline parameters.

stage_4/prepare_targets.py

@@ -0,0 +1,64 @@
+"""Build the per-image 100-D teacher target tensor from the existing ViT-B
+COCO train feature cache. One-time, ~5 min.
+
+For each image in /home/zootest/datasets/coco/feature_cache_768 (the 419 GB
+train cache of EUPE-ViT-B at 768 px), apply LayerNorm across the 768 channel
+axis, max-pool across 2304 patches, and select the 100 classifier-relevant
+dims (pos + neg). Save as a flat (N, 100) float16 tensor + index list.
+
+Output: /home/zootest/datasets/coco/stage4_teacher_targets/targets.pt
+        containing {'targets': (N, 100) float16, 'img_ids': list, 'dims': (100,) long}
+"""
+import os, glob, json, time
+import torch
+import torch.nn.functional as F
+
+COCO_ROOT = '/home/zootest/datasets/coco'
+CACHE = f'{COCO_ROOT}/feature_cache_768'
+CLASSIFIER = '/mnt/d/_tmp/1pc_repo/stage_0/classifier.json'
+OUT_DIR = f'{COCO_ROOT}/stage4_teacher_targets'
+D = 768
+
+
+def main():
+    os.makedirs(OUT_DIR, exist_ok=True)
+    with open(CLASSIFIER) as f:
+        c = json.load(f)
+    dims = torch.tensor(c['pos_dims'] + c['neg_dims'], dtype=torch.long)
+    print(f'[init] using {len(dims)} target dims', flush=True)
+
+    shards = sorted(glob.glob(f'{CACHE}/shard_*.pt'))
+    print(f'[init] {len(shards)} teacher shards to process', flush=True)
+
+    all_targets = []
+    all_img_ids = []
+    t0 = time.time()
+    for si, spath in enumerate(shards):
+        shard = torch.load(spath, map_location='cpu', weights_only=False)
+        for entry in shard:
+            sp = entry['spatial'].float()                            # (768, 48, 48)
+            ln = F.layer_norm(sp.permute(1, 2, 0).reshape(-1, D), [D])
+            pooled = ln.max(dim=0).values                             # (768,)
+            target = pooled[dims].half()                              # (100,)
+            all_targets.append(target)
+            # Some caches may not have img_id; use an ordinal if missing
+            img_id = entry.get('img_id', len(all_img_ids))
+            all_img_ids.append(int(img_id) if isinstance(img_id, (int, float)) else len(all_img_ids))
+        elapsed = time.time() - t0
+        rate = (si + 1) / max(elapsed, 1e-6)
+        eta = (len(shards) - si - 1) / max(rate, 1e-6)
+        print(f'  shard {si+1}/{len(shards)}  cumulative n={len(all_targets)}  '
+              f'{elapsed:.0f}s  ETA {eta:.1f}s', flush=True)
+
+    targets = torch.stack(all_targets)
+    torch.save({
+        'targets': targets,
+        'img_ids': all_img_ids,
+        'dims': dims,
+    }, f'{OUT_DIR}/targets.pt')
+    print(f'[done] {targets.shape[0]} targets shape {tuple(targets.shape)} '
+          f'-> {OUT_DIR}/targets.pt', flush=True)
+
+
+if __name__ == '__main__':
+    main()

stage_4/student.py

@@ -0,0 +1,75 @@
+"""Stage 4 specialist student architecture.
+
+Compact ViT designed to reproduce the 100 target dims of EUPE-ViT-B that
+feed the Stage 0 classifier. Depth 6, embed 192, patch 16, 3 heads. Emits a
+100-D vector per image via a final projection from the max-pooled patch
+tokens (plus global pool of CLS). Designed to pair with a frozen ternary
+classifier head.
+"""
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class PatchEmbed(nn.Module):
+    def __init__(self, in_ch=3, embed_dim=192, patch_size=16):
+        super().__init__()
+        self.proj = nn.Conv2d(in_ch, embed_dim, patch_size, stride=patch_size)
+
+    def forward(self, x):
+        x = self.proj(x)
+        B, C, H, W = x.shape
+        return x.flatten(2).transpose(1, 2), H, W  # (B, HW, C)
+
+
+class Block(nn.Module):
+    def __init__(self, dim, heads, mlp_ratio=4.0):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(dim)
+        self.attn = nn.MultiheadAttention(dim, heads, batch_first=True)
+        self.norm2 = nn.LayerNorm(dim)
+        hidden = int(dim * mlp_ratio)
+        self.mlp = nn.Sequential(
+            nn.Linear(dim, hidden), nn.GELU(), nn.Linear(hidden, dim))
+
+    def forward(self, x):
+        h = self.norm1(x)
+        h, _ = self.attn(h, h, h, need_weights=False)
+        x = x + h
+        x = x + self.mlp(self.norm2(x))
+        return x
+
+
+class SpecialistStudent(nn.Module):
+    """Compact ViT that outputs a 100-D vector per image."""
+
+    def __init__(self, out_dim=40, embed_dim=192, depth=6, heads=3,
+                 patch_size=16, img_size=768, mlp_ratio=4.0):
+        super().__init__()
+        self.patch = PatchEmbed(3, embed_dim, patch_size)
+        self.num_patches = (img_size // patch_size) ** 2
+        self.pos = nn.Parameter(torch.zeros(1, self.num_patches, embed_dim))
+        nn.init.trunc_normal_(self.pos, std=0.02)
+        self.blocks = nn.ModuleList([Block(embed_dim, heads, mlp_ratio) for _ in range(depth)])
+        self.norm = nn.LayerNorm(embed_dim)
+        self.head = nn.Linear(embed_dim, out_dim)
+
+    def forward(self, x):
+        """x: (B, 3, H, W). Returns (B, out_dim)."""
+        tokens, H, W = self.patch(x)
+        tokens = tokens + self.pos[:, :tokens.shape[1]]
+        for blk in self.blocks:
+            tokens = blk(tokens)
+        tokens = self.norm(tokens)               # (B, HW, embed_dim)
+        pooled = tokens.max(dim=1).values        # (B, embed_dim) max-pool per image
+        return self.head(pooled)                  # (B, out_dim)
+
+
+if __name__ == '__main__':
+    m = SpecialistStudent()
+    total = sum(p.numel() for p in m.parameters())
+    print(f'Specialist student total params: {total:,} = {total/1e6:.2f}M')
+    x = torch.randn(2, 3, 768, 768)
+    y = m(x)
+    print(f'forward OK  output shape: {tuple(y.shape)}')

stage_4/student_ep1.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1c1ecaa9ba94f1bd27b168caeecbb9ad358579d5c649f47eedc3ff9bcdc0eee
+size 13076256

stage_4/student_ep10.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ecaec32943f4fef9b213af254789ac975418835a4ec0785f9e2ecc7e91abd831
+size 13076256

stage_4/student_ep2.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:611b0be943b75d267c86f4b354ed0cbcb02d6f9d40f22ea4c0c21e63eda54575
+size 13076256

stage_4/student_ep3.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8326f6df6637e0d5b1c4219fa4f7b731a2d6707a4969378eddf6429074085273
+size 13076256

stage_4/student_ep4.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:51952f8338bb9f8c59de5f4f80eeaa69258c17daafa35bb9330e197b2f1aa615
+size 13076256

stage_4/student_ep5.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2159c00b9a59c23fa0acfcd29c320c0bb09c7cdc246e107e2e7b38194aa058b
+size 13076256

stage_4/student_ep6.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1cc56f6025185e2ba31c9303db151fb1c1f1531b4fba679751cfaffdbc7623b2
+size 13076256

stage_4/student_ep7.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8b9c7130ef5986d9190a173a7af0b0b0421f5d85a25b213006562b501bddc203
+size 13076256

stage_4/student_ep8.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07835d3a06a5c128d86e174830ec3d77148e0c067a60bcc76190395d4a65af0d
+size 13076256

stage_4/student_ep9.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2896d19e53ef2ad5d5be9e19c7df64702446f1d8053a3f1492923758464d0e2
+size 13076256

stage_4/student_final.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ecaec32943f4fef9b213af254789ac975418835a4ec0785f9e2ecc7e91abd831
+size 13076256

stage_4/train.py

@@ -0,0 +1,199 @@
+"""Stage 4 training loop.
+
+Train the compact specialist student to reproduce the 100 target dims that
+EUPE-ViT-B produces for each COCO train image, using the per-image raw image
+(resized to 768) as input. Target tensor is pre-computed by prepare_targets.py.
+
+Loss: MSE on the 100-D output.
+Optimizer: AdamW.
+Schedule: cosine with 3% warmup.
+
+Saves:
+  student_final.safetensors  — best student weights
+  training_log.json          — per-epoch loss + held-out F1 via Stage 0 classifier
+"""
+import os, sys, time, json, math
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from PIL import Image
+from pycocotools.coco import COCO
+from safetensors.torch import save_file
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+from student import SpecialistStudent
+
+COCO_ROOT = '/home/zootest/datasets/coco'
+TARGETS = f'{COCO_ROOT}/stage4_teacher_targets/targets.pt'
+CLASSIFIER = '/mnt/d/_tmp/1pc_repo/stage_0/classifier.json'
+OUT_DIR = '/mnt/d/_tmp/1pc_repo/stage_4'
+DEVICE = 'cuda'
+RES = 768
+BATCH = 16
+LR = 3e-4
+WD = 1e-4
+EPOCHS = 10
+WARMUP_FRAC = 0.03
+
+
+class CocoImgDataset(torch.utils.data.Dataset):
+    def __init__(self, coco_root, targets_pack):
+        self.root = f'{coco_root}/train2017'
+        self.coco = COCO(f'{coco_root}/annotations/instances_train2017.json')
+        self.img_ids = targets_pack['img_ids']
+        self.targets = targets_pack['targets']
+        # Build filename lookup
+        self.id_to_file = {info['id']: info['file_name']
+                           for info in self.coco.loadImgs(self.coco.getImgIds())}
+
+    def __len__(self):
+        return len(self.img_ids)
+
+    def __getitem__(self, i):
+        img_id = self.img_ids[i]
+        target = self.targets[i].float()
+        fname = self.id_to_file.get(img_id, None)
+        if fname is None:
+            return None
+        path = f'{self.root}/{fname}'
+        try:
+            img = Image.open(path).convert('RGB').resize((RES, RES), Image.BILINEAR)
+        except Exception:
+            return None
+        arr = np.asarray(img, dtype=np.uint8).copy()
+        x = torch.from_numpy(arr).permute(2, 0, 1).float() / 255.0
+        mean = torch.tensor([0.485, 0.456, 0.406]).view(3, 1, 1)
+        std = torch.tensor([0.229, 0.224, 0.225]).view(3, 1, 1)
+        x = (x - mean) / std
+        return x, target
+
+
+def collate(batch):
+    batch = [b for b in batch if b is not None]
+    if len(batch) == 0:
+        return None
+    xs, ts = zip(*batch)
+    return torch.stack(xs), torch.stack(ts)
+
+
+def eval_f1(student, classifier_json):
+    """Eval on COCO val 2017 image-level person classification."""
+    with open(classifier_json) as f:
+        c = json.load(f)
+    pos = c['pos_dims']
+    neg = c['neg_dims']
+    # Targets for student output are dims = pos + neg → 100-D. Inside that 100,
+    # pos is [0..19], neg is [20..39].
+    pos_idx = list(range(len(pos)))
+    neg_idx = list(range(len(pos), len(pos) + len(neg)))
+
+    coco = COCO(f'{COCO_ROOT}/annotations/instances_val2017.json')
+    img_ids = sorted(coco.getImgIds())[:1000]
+    id_to_file = {info['id']: info['file_name']
+                  for info in coco.loadImgs(coco.getImgIds())}
+    MEAN = torch.tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1).to(DEVICE)
+    STD = torch.tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1).to(DEVICE)
+    scores = []
+    labels = []
+    with torch.inference_mode():
+        for img_id in img_ids:
+            fname = id_to_file.get(img_id)
+            if fname is None:
+                continue
+            img = Image.open(f'{COCO_ROOT}/val2017/{fname}').convert('RGB').resize((RES, RES), Image.BILINEAR)
+            arr = np.asarray(img, dtype=np.uint8).copy()
+            x = torch.from_numpy(arr).permute(2, 0, 1).unsqueeze(0).to(DEVICE).float() / 255.0
+            x = (x - MEAN) / STD
+            out = student(x).squeeze(0)
+            s = out[pos_idx].sum() - out[neg_idx].sum()
+            scores.append(s.item())
+            labels.append(any(a['category_id'] == 1
+                              for a in coco.loadAnns(coco.getAnnIds(imgIds=img_id, iscrowd=False))))
+    scores = torch.tensor(scores)
+    labels = torch.tensor(labels, dtype=torch.bool)
+    # Sweep threshold
+    uniq = torch.unique(scores).sort().values
+    best = (0, 0, 0, 0)
+    for t in uniq.tolist()[::max(1, len(uniq) // 500)]:
+        pred = scores > t
+        tp = (pred & labels).sum().float()
+        fp = (pred & ~labels).sum().float()
+        fn = (~pred & labels).sum().float()
+        prec = tp / (tp + fp).clamp(min=1)
+        rec = tp / (tp + fn).clamp(min=1)
+        f1 = (2 * prec * rec / (prec + rec).clamp(min=1e-9)).item()
+        if f1 > best[0]:
+            best = (f1, t, prec.item(), rec.item())
+    return best
+
+
+def main():
+    os.makedirs(OUT_DIR, exist_ok=True)
+    print('[init] loading targets', flush=True)
+    pack = torch.load(TARGETS, map_location='cpu', weights_only=False)
+    print(f'  {pack["targets"].shape[0]} teacher targets', flush=True)
+
+    dataset = CocoImgDataset(COCO_ROOT, pack)
+    loader = torch.utils.data.DataLoader(
+        dataset, batch_size=BATCH, shuffle=True, num_workers=4,
+        pin_memory=True, collate_fn=collate, drop_last=True,
+    )
+
+    student = SpecialistStudent().to(DEVICE)
+    print(f'[student] {sum(p.numel() for p in student.parameters())/1e6:.2f}M params', flush=True)
+
+    total_steps = EPOCHS * len(loader)
+    warmup = int(total_steps * WARMUP_FRAC)
+    opt = torch.optim.AdamW(student.parameters(), lr=LR, weight_decay=WD)
+    sched = torch.optim.lr_scheduler.LambdaLR(
+        opt, lambda s: s / max(1, warmup) if s < warmup
+        else 0.5 * (1 + math.cos(math.pi * (s - warmup) / max(1, total_steps - warmup))))
+
+    log = {'epochs': [], 'student_params': int(sum(p.numel() for p in student.parameters()))}
+    step = 0
+    t0 = time.time()
+    for ep in range(EPOCHS):
+        student.train()
+        ep_loss, n_batches = 0.0, 0
+        for batch in loader:
+            if batch is None:
+                continue
+            x, y = batch
+            x = x.to(DEVICE, non_blocking=True)
+            y = y.to(DEVICE, non_blocking=True)
+            with torch.autocast('cuda', dtype=torch.bfloat16):
+                pred = student(x)
+            loss = F.mse_loss(pred.float(), y)
+            opt.zero_grad(set_to_none=True)
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(student.parameters(), 1.0)
+            opt.step()
+            sched.step()
+            ep_loss += loss.item()
+            n_batches += 1
+            step += 1
+            if step % 200 == 0:
+                print(f'  ep {ep+1}/{EPOCHS}  step {step}/{total_steps}  '
+                      f'loss={loss.item():.4f}  lr={opt.param_groups[0]["lr"]:.2e}  '
+                      f'{(time.time()-t0)/60:.1f} min', flush=True)
+        avg = ep_loss / max(1, n_batches)
+        student.eval()
+        f1, thr, p, r = eval_f1(student, CLASSIFIER)
+        print(f'[ep {ep+1}] loss={avg:.4f}  F1={f1:.4f}  P={p:.4f}  R={r:.4f}  θ={thr:.3f}',
+              flush=True)
+        log['epochs'].append({'epoch': ep + 1, 'loss': avg,
+                              'F1': f1, 'precision': p, 'recall': r, 'threshold': thr})
+        # Save after each epoch
+        save_file(student.state_dict(), f'{OUT_DIR}/student_ep{ep+1}.safetensors')
+        with open(f'{OUT_DIR}/training_log.json', 'w') as f:
+            json.dump(log, f, indent=2)
+
+    # Final save
+    save_file(student.state_dict(), f'{OUT_DIR}/student_final.safetensors')
+    print(f'[done] total time {(time.time()-t0)/60:.1f} min', flush=True)
+
+
+if __name__ == '__main__':
+    main()

stage_4/training_log.json

@@ -0,0 +1,85 @@
+{
+  "epochs": [
+    {
+      "epoch": 1,
+      "loss": 2.2497359863064306,
+      "F1": 0.7068741917610168,
+      "precision": 0.5471887588500977,
+      "recall": 0.9981684684753418,
+      "threshold": 27.844703674316406
+    },
+    {
+      "epoch": 2,
+      "loss": 2.006192959226011,
+      "F1": 0.7077131867408752,
+      "precision": 0.5611587762832642,
+      "recall": 0.9578754305839539,
+      "threshold": 29.012691497802734
+    },
+    {
+      "epoch": 3,
+      "loss": 2.0050793833516254,
+      "F1": 0.7173912525177002,
+      "precision": 0.5701943635940552,
+      "recall": 0.9670329689979553,
+      "threshold": 26.3531494140625
+    },
+    {
+      "epoch": 4,
+      "loss": 2.008850994551679,
+      "F1": 0.7111111283302307,
+      "precision": 0.5528455376625061,
+      "recall": 0.9963369965553284,
+      "threshold": 26.654373168945312
+    },
+    {
+      "epoch": 5,
+      "loss": 1.9956948308571767,
+      "F1": 0.7116155028343201,
+      "precision": 0.5598739385604858,
+      "recall": 0.976190447807312,
+      "threshold": 26.531875610351562
+    },
+    {
+      "epoch": 6,
+      "loss": 2.001336439533982,
+      "F1": 0.7114093899726868,
+      "precision": 0.5614407062530518,
+      "recall": 0.970695972442627,
+      "threshold": 25.896560668945312
+    },
+    {
+      "epoch": 7,
+      "loss": 1.9895635365096358,
+      "F1": 0.7127659916877747,
+      "precision": 0.5594989657402039,
+      "recall": 0.9816849827766418,
+      "threshold": 26.533084869384766
+    },
+    {
+      "epoch": 8,
+      "loss": 1.9920095616759776,
+      "F1": 0.7133058905601501,
+      "precision": 0.5701754093170166,
+      "recall": 0.9523809552192688,
+      "threshold": 26.670108795166016
+    },
+    {
+      "epoch": 9,
+      "loss": 1.9944281049740566,
+      "F1": 0.7095890045166016,
+      "precision": 0.5667396187782288,
+      "recall": 0.9487179517745972,
+      "threshold": 26.39623260498047
+    },
+    {
+      "epoch": 10,
+      "loss": 1.9913188398937247,
+      "F1": 0.7101648449897766,
+      "precision": 0.5681318640708923,
+      "recall": 0.946886420249939,
+      "threshold": 26.328819274902344
+    }
+  ],
+  "student_params": 3267304
+}