Add TAIC/C-TAIC codec test scripts and README testing section.

README.md

@@ -122,7 +122,9 @@ FlexICM/
 ├── scripts/
 │   ├── download_base_codecs.sh
 │   ├── train_taic.py
-│   └── train_ctaic.py
+│   ├── train_ctaic.py
+│   ├── eval_taic.py            # codec test (bpp / feature D)
+│   └── eval_ctaic.py           # codec test for C-TAIC
 ├── flexicm/
 │   ├── models/                 # TAIC / C-TAIC / SFMA / TaskConnector / Conditional
 │   ├── layers/                 # RSTB / WindowAttention (same lineage as AdaptiveICMH)
@@ -133,8 +135,7 @@ FlexICM/
                                 # see checkpoints/README.md
 ```
 
-Eval configs (stub until full metrics are implemented): `configs/eval/`.
-Eval entry points: `scripts/eval_taic.py`, `scripts/eval_ctaic.py` (currently only check that real checkpoints replaced `PLACEHOLDER` files).
+Eval / codec-test configs: `configs/eval/`.
 
 ---
 
@@ -292,6 +293,53 @@ stage1_checkpoint:     # Stage-1 result loaded in Stage 2
 
 ---
 
+## Codec Test
+
+
+For C-TAIC, reported `bpp` is **extension-layer only** (base-layer rate is excluded), matching the paper.
+
+### Prepare checkpoints
+
+1. Train models (or copy trained weights) into the `checkpoints/` tree — Download checkpoints.
+2. Edit `dataset_path` / `gpu_id` in `configs/eval/*.yaml`
+
+### Test TAIC (five tasks)
+
+```bash
+python scripts/eval_taic.py -c configs/eval/taic_detection.yaml
+python scripts/eval_taic.py -c configs/eval/taic_semantic.yaml
+python scripts/eval_taic.py -c configs/eval/taic_instance.yaml
+python scripts/eval_taic.py -c configs/eval/taic_panoptic.yaml
+python scripts/eval_taic.py -c configs/eval/taic_pose.yaml
+
+# optional: also measure actual entropy-coded bitstream bpp
+python scripts/eval_taic.py -c configs/eval/taic_detection.yaml --actual-bpp
+
+# optional: smoke test on a few batches
+python scripts/eval_taic.py -c configs/eval/taic_detection.yaml --max-batches 10
+```
+
+Results JSON is written under `logs/eval_taic/<task>/<quality>/`.
+
+### Test C-TAIC (three scenarios)
+
+```bash
+python scripts/eval_ctaic.py -c configs/eval/ctaic_s1.yaml
+python scripts/eval_ctaic.py -c configs/eval/ctaic_s2.yaml
+python scripts/eval_ctaic.py -c configs/eval/ctaic_s3.yaml
+
+# disable base-layer conditioning (TAIC-mode / graceful degradation)
+python scripts/eval_ctaic.py -c configs/eval/ctaic_s1.yaml --no-condition
+
+python scripts/eval_ctaic.py -c configs/eval/ctaic_s1.yaml --actual-bpp
+```
+
+Results JSON is written under `logs/eval_ctaic/<scenario>/<quality>/`.
+
+> Task rate–accuracy curves (mAP / mIoU / PQ / OKS vs bpp) are **not** included yet.
+
+---
+
 ## Code Map to the Paper
 
 | Paper component | Code location |
@@ -306,11 +354,3 @@ stage1_checkpoint:     # Stage-1 result loaded in Stage 2
 | Five teachers | `flexicm/tasks/__init__.py` |
 
 
----
-
-## Citation
-
-If you use this code or the paper, please cite FlexICM and acknowledge the base works:
-
-- TIC: Lu et al., Transformer-based Image Compression
-- TransTIC / AdaptiveICMH: task-adaptive SFMA tuning

checkpoints/README.md

@@ -60,5 +60,13 @@ cp logs/ctaic_s1_stage2/1/checkpoint_best_loss.pth.tar \
 ## Eval configs
 
 See `configs/eval/` — they point to these placeholder paths.
-Eval scripts will refuse to run if a `PLACEHOLDER` file is still present
-or if the `.pth.tar` is missing.
+
+Codec test (bpp / feature distortion):
+
+```bash
+python scripts/eval_taic.py -c configs/eval/taic_detection.yaml
+python scripts/eval_ctaic.py -c configs/eval/ctaic_s1.yaml
+```
+
+Scripts refuse to run if a `PLACEHOLDER` file is still present or if the `.pth.tar` is missing.
+Task rate–accuracy metrics are not implemented in these scripts yet.

configs/eval/ctaic_s1.yaml

@@ -1,6 +1,7 @@
-# Eval config (stub) — s1: detection (base) + instance (extension)
+# Codec test config for C-TAIC scenario s1 (det -> instance)
 scenario: "s1"
 dataset_path: "/data/coco2017"
+split: "val2017"
 quality_level: 1
 lmbda: 0.0035
 checkpoint: "./checkpoints/ctaic/s1_det_instance/stage2/1/checkpoint_best_loss.pth.tar"
@@ -10,3 +11,4 @@ gpu_id: 0
 cuda: true
 test_batch_size: 1
 num_workers: 4
+pretrained_backbone: true

configs/eval/ctaic_s2.yaml

@@ -1,5 +1,6 @@
 scenario: "s2"
 dataset_path: "/data/coco2017"
+split: "val2017"
 quality_level: 1
 lmbda: 0.0035
 checkpoint: "./checkpoints/ctaic/s2_sem_panoptic/stage2/1/checkpoint_best_loss.pth.tar"
@@ -9,3 +10,4 @@ gpu_id: 0
 cuda: true
 test_batch_size: 1
 num_workers: 4
+pretrained_backbone: true

configs/eval/ctaic_s3.yaml

@@ -1,5 +1,6 @@
 scenario: "s3"
 dataset_path: "/data/coco2017"
+split: "val2017"
 quality_level: 1
 lmbda: 0.0035
 checkpoint: "./checkpoints/ctaic/s3_det_pose/stage2/1/checkpoint_best_loss.pth.tar"
@@ -9,3 +10,4 @@ gpu_id: 0
 cuda: true
 test_batch_size: 1
 num_workers: 4
+pretrained_backbone: true

configs/eval/taic_detection.yaml

@@ -1,6 +1,8 @@
-# Eval config (stub) — replace PLACEHOLDER weights under checkpoints/taic/detection/
+# Codec test config for TAIC / detection
+# Place real weights at checkpoint path (replace PLACEHOLDER).
 task: "detection"
 dataset_path: "/data/coco2017"
+split: "val2017"
 quality_level: 1
 lmbda: 0.0035
 checkpoint: "./checkpoints/taic/detection/1/checkpoint_best_loss.pth.tar"
@@ -9,3 +11,4 @@ gpu_id: 0
 cuda: true
 test_batch_size: 1
 num_workers: 4
+pretrained_backbone: true

configs/eval/taic_instance.yaml

@@ -1,6 +1,8 @@
-# Eval config (stub) — replace PLACEHOLDER weights under checkpoints/taic/instance/
+# Codec test config for TAIC / instance
+# Place real weights at checkpoint path (replace PLACEHOLDER).
 task: "instance"
 dataset_path: "/data/coco2017"
+split: "val2017"
 quality_level: 1
 lmbda: 0.0035
 checkpoint: "./checkpoints/taic/instance/1/checkpoint_best_loss.pth.tar"
@@ -9,3 +11,4 @@ gpu_id: 0
 cuda: true
 test_batch_size: 1
 num_workers: 4
+pretrained_backbone: true

configs/eval/taic_panoptic.yaml

@@ -1,6 +1,8 @@
-# Eval config (stub) — replace PLACEHOLDER weights under checkpoints/taic/panoptic/
+# Codec test config for TAIC / panoptic
+# Place real weights at checkpoint path (replace PLACEHOLDER).
 task: "panoptic"
 dataset_path: "/data/coco2017"
+split: "val2017"
 quality_level: 1
 lmbda: 0.0035
 checkpoint: "./checkpoints/taic/panoptic/1/checkpoint_best_loss.pth.tar"
@@ -9,3 +11,4 @@ gpu_id: 0
 cuda: true
 test_batch_size: 1
 num_workers: 4
+pretrained_backbone: true

configs/eval/taic_pose.yaml

@@ -1,6 +1,8 @@
-# Eval config (stub) — replace PLACEHOLDER weights under checkpoints/taic/pose/
+# Codec test config for TAIC / pose
+# Place real weights at checkpoint path (replace PLACEHOLDER).
 task: "pose"
 dataset_path: "/data/coco2017"
+split: "val2017"
 quality_level: 1
 lmbda: 0.0035
 checkpoint: "./checkpoints/taic/pose/1/checkpoint_best_loss.pth.tar"
@@ -9,3 +11,4 @@ gpu_id: 0
 cuda: true
 test_batch_size: 1
 num_workers: 4
+pretrained_backbone: true

configs/eval/taic_semantic.yaml

@@ -1,6 +1,8 @@
-# Eval config (stub) — replace PLACEHOLDER weights under checkpoints/taic/semantic/
+# Codec test config for TAIC / semantic
+# Place real weights at checkpoint path (replace PLACEHOLDER).
 task: "semantic"
 dataset_path: "/data/coco2017"
+split: "val2017"
 quality_level: 1
 lmbda: 0.0035
 checkpoint: "./checkpoints/taic/semantic/1/checkpoint_best_loss.pth.tar"
@@ -9,3 +11,4 @@ gpu_id: 0
 cuda: true
 test_batch_size: 1
 num_workers: 4
+pretrained_backbone: true

flexicm/utils/codec_test.py

@@ -0,0 +1,228 @@
+"""Shared helpers for codec test / eval scripts."""
+
+from __future__ import annotations
+
+import os
+from typing import Dict, Optional, Tuple
+
+import torch
+
+from flexicm.utils.alignment import Alignment
+from flexicm.utils.train_utils import AverageMeter
+
+
+def resolve_ckpt(path: str, repo_root: str, label: str = "checkpoint") -> str:
+    if not path:
+        raise FileNotFoundError(f"{label}: path is empty")
+    if not os.path.isabs(path):
+        path = os.path.join(repo_root, path)
+    placeholder = os.path.join(os.path.dirname(path), "PLACEHOLDER")
+    if os.path.isfile(placeholder) and not os.path.isfile(path):
+        raise FileNotFoundError(
+            f"{label}: not ready (PLACEHOLDER still present):\n  {placeholder}\n"
+            f"Expected real weights at:\n  {path}\n"
+            "See checkpoints/README.md"
+        )
+    if not os.path.isfile(path):
+        raise FileNotFoundError(f"{label}: missing file: {path}")
+    if os.path.basename(path) == "PLACEHOLDER" or path.endswith(".txt"):
+        raise FileNotFoundError(f"{label}: refusing placeholder file: {path}")
+    return path
+
+
+def crop_feature_to_image(h: torch.Tensor, image_hw: Tuple[int, int]) -> torch.Tensor:
+    """Crop decoded feature h (H/4, W/4 of padded input) to original image size / 4."""
+    H, W = image_hw
+    return h[..., : H // 4, : W // 4]
+
+
+def pad_for_codec(images: torch.Tensor, divisor: int = 256, device=None):
+    align = Alignment(divisor=divisor, mode="pad", padding_mode="constant")
+    if device is not None:
+        align = align.to(device)
+    return align.align(images), align
+
+
+def likelihood_bpp(likelihoods: Dict[str, torch.Tensor], num_pixels: int) -> torch.Tensor:
+    import math
+
+    return sum(
+        (torch.log(lik).sum() / (-math.log(2) * num_pixels))
+        for lik in likelihoods.values()
+    )
+
+
+def actual_bitstream_bpp(strings, num_pixels: int) -> float:
+    """Estimate bpp from CompressAI byte strings: [[y_bytes...], [z_bytes...]]."""
+    total_bits = 0
+    for group in strings:
+        for s in group:
+            if isinstance(s, (bytes, bytearray)):
+                total_bits += len(s) * 8
+            elif torch.is_tensor(s):
+                total_bits += int(s.numel() * s.element_size() * 8)
+            else:
+                total_bits += len(s) * 8
+    return total_bits / float(num_pixels)
+
+
+@torch.no_grad()
+def test_taic_loader(
+    model,
+    teacher,
+    loader,
+    criterion,
+    device,
+    align_divisor: int = 256,
+    run_actual_bpp: bool = False,
+    max_batches: Optional[int] = None,
+    log_every: int = 50,
+):
+    """Run codec test: likelihood bpp + feature distortion (+ optional real bpp)."""
+    model.eval()
+    teacher.eval()
+    meters = {k: AverageMeter() for k in ("loss", "bpp", "distortion", "actual_bpp")}
+
+    if run_actual_bpp:
+        model.update(force=True)
+
+    for i, images in enumerate(loader):
+        if max_batches is not None and i >= max_batches:
+            break
+        images = images.to(device)
+        N, _, H, W = images.shape
+        num_pixels = N * H * W
+
+        x, _ = pad_for_codec(images, divisor=align_divisor, device=device)
+        out = model(x)
+        h = crop_feature_to_image(out["h"], (H, W))
+        out["h"] = h
+
+        gt = teacher.gt_features(images)
+        pred = teacher.pred_features(h)
+        stats = criterion(out, pred, gt, num_pixels=num_pixels)
+
+        meters["loss"].update(stats["loss"].item(), n=N)
+        meters["bpp"].update(stats["bpp"].item(), n=N)
+        meters["distortion"].update(stats["distortion"].item(), n=N)
+
+        if run_actual_bpp:
+            try:
+                enc = model.compress(x)
+                dec = model.decompress(
+                    enc["strings"], enc["shape"], x_size=(x.shape[2], x.shape[3])
+                )
+                abpp = actual_bitstream_bpp(enc["strings"], num_pixels)
+                meters["actual_bpp"].update(abpp, n=N)
+                # sanity: decoded h spatial size
+                _ = dec["h"]
+            except Exception as e:
+                if i == 0:
+                    print(f"[warn] actual bpp / compress-decompress failed: {e}")
+
+        if i % log_every == 0:
+            msg = (
+                f"[{i}/{len(loader)}] bpp={meters['bpp'].avg:.4f} "
+                f"D={meters['distortion'].avg:.6f} loss={meters['loss'].avg:.4f}"
+            )
+            if run_actual_bpp and meters["actual_bpp"].count > 0:
+                msg += f" actual_bpp={meters['actual_bpp'].avg:.4f}"
+            print(msg)
+
+    result = {
+        "bpp": meters["bpp"].avg,
+        "distortion": meters["distortion"].avg,
+        "loss": meters["loss"].avg,
+        "num_batches": meters["bpp"].count,
+    }
+    if run_actual_bpp and meters["actual_bpp"].count > 0:
+        result["actual_bpp"] = meters["actual_bpp"].avg
+    return result
+
+
+@torch.no_grad()
+def test_ctaic_loader(
+    ext_model,
+    base_model,
+    teacher,
+    loader,
+    criterion,
+    device,
+    use_condition: bool = True,
+    align_divisor: int = 256,
+    run_actual_bpp: bool = False,
+    max_batches: Optional[int] = None,
+    log_every: int = 50,
+):
+    """Codec test for C-TAIC; bpp is extension-layer only (paper Sec.IV.E.2)."""
+    ext_model.eval()
+    base_model.eval()
+    teacher.eval()
+    meters = {k: AverageMeter() for k in ("loss", "bpp", "distortion", "actual_bpp")}
+
+    if run_actual_bpp:
+        ext_model.update(force=True)
+
+    for i, images in enumerate(loader):
+        if max_batches is not None and i >= max_batches:
+            break
+        images = images.to(device)
+        N, _, H, W = images.shape
+        num_pixels = N * H * W
+
+        x, _ = pad_for_codec(images, divisor=align_divisor, device=device)
+        y_b = None
+        if use_condition:
+            base_out = base_model(x)
+            y_b = base_out["y_hat"]
+
+        out = ext_model(x, y_b_hat=y_b, use_condition=use_condition and y_b is not None)
+        h = crop_feature_to_image(out["h"], (H, W))
+        out["h"] = h
+
+        gt = teacher.gt_features(images)
+        pred = teacher.pred_features(h)
+        stats = criterion(out, pred, gt, num_pixels=num_pixels)
+
+        meters["loss"].update(stats["loss"].item(), n=N)
+        meters["bpp"].update(stats["bpp"].item(), n=N)
+        meters["distortion"].update(stats["distortion"].item(), n=N)
+
+        if run_actual_bpp:
+            try:
+                enc = ext_model.compress(
+                    x, y_b_hat=y_b, use_condition=use_condition and y_b is not None
+                )
+                dec = ext_model.decompress(
+                    enc["strings"],
+                    enc["shape"],
+                    x_size=(x.shape[2], x.shape[3]),
+                    y_b_hat=y_b,
+                    use_condition=use_condition and y_b is not None,
+                )
+                abpp = actual_bitstream_bpp(enc["strings"], num_pixels)
+                meters["actual_bpp"].update(abpp, n=N)
+                _ = dec["h"]
+            except Exception as e:
+                if i == 0:
+                    print(f"[warn] actual bpp / compress-decompress failed: {e}")
+
+        if i % log_every == 0:
+            msg = (
+                f"[{i}/{len(loader)}] bpp={meters['bpp'].avg:.4f} "
+                f"D={meters['distortion'].avg:.6f} loss={meters['loss'].avg:.4f}"
+            )
+            if run_actual_bpp and meters["actual_bpp"].count > 0:
+                msg += f" actual_bpp={meters['actual_bpp'].avg:.4f}"
+            print(msg)
+
+    result = {
+        "bpp": meters["bpp"].avg,
+        "distortion": meters["distortion"].avg,
+        "loss": meters["loss"].avg,
+        "num_batches": meters["bpp"].count,
+        "use_condition": use_condition,
+    }
+    if run_actual_bpp and meters["actual_bpp"].count > 0:
+        result["actual_bpp"] = meters["actual_bpp"].avg
+    return result

scripts/eval_ctaic.py

@@ -1,52 +1,167 @@
 #!/usr/bin/env python3
-"""Eval / test entry for C-TAIC (placeholder).
+"""Codec test for C-TAIC (extension layer).
 
-Full multi-task rate-accuracy evaluation will be added later.
-This script only validates that required checkpoints exist and are not PLACEHOLDERs.
+Reports extension-layer likelihood bpp and feature distortion D (paper: bpp excludes base layer).
+Optional actual bitstream bpp via compress/decompress.
+Does NOT compute task metrics (mAP / mIoU / PQ / OKS) — those come later.
+
+Example:
+  python scripts/eval_ctaic.py -c configs/eval/ctaic_s1.yaml
+  python scripts/eval_ctaic.py -c configs/eval/ctaic_s1.yaml --no-condition   # TAIC-mode ablation
+  python scripts/eval_ctaic.py -c configs/eval/ctaic_s1.yaml --actual-bpp
 """
 
 from __future__ import annotations
 
 import argparse
+import json
 import os
 import sys
+from datetime import datetime
 
-REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-sys.path.insert(0, REPO_ROOT)
+import torch
+from torch.utils.data import DataLoader
 
-from flexicm.utils.train_utils import load_yaml_config
+REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if REPO_ROOT not in sys.path:
+    sys.path.insert(0, REPO_ROOT)
 
+from flexicm.data import COCOImageDataset, COCOWholeBodyImageDataset, ImageFolderDataset, build_test_transform
+from flexicm.models import CTAIC, TAIC
+from flexicm.tasks import TASK_META, build_teacher
+from flexicm.tasks.losses import TAICCriterion
+from flexicm.utils.codec_test import resolve_ckpt, test_ctaic_loader
+from flexicm.utils.train_utils import load_checkpoint_dict, load_yaml_config, set_seed
 
-def resolve_ckpt(path: str, label: str) -> str:
-    if not path:
-        raise FileNotFoundError(f"{label}: checkpoint path is empty")
-    if not os.path.isabs(path):
-        path = os.path.join(REPO_ROOT, path)
-    placeholder = os.path.join(os.path.dirname(path), "PLACEHOLDER")
-    if os.path.isfile(placeholder) and not os.path.isfile(path):
-        raise FileNotFoundError(
-            f"{label}: checkpoint not ready (PLACEHOLDER still present):\n  {placeholder}\n"
-            f"Expected real weights at:\n  {path}\n"
-            "See checkpoints/README.md"
-        )
-    if not os.path.isfile(path):
-        raise FileNotFoundError(f"{label}: missing checkpoint: {path}")
-    return path
+SCENARIOS = {
+    "s1": {"base": "detection", "ext": "instance"},
+    "s2": {"base": "semantic", "ext": "panoptic"},
+    "s3": {"base": "detection", "ext": "pose"},
+}
 
 
-def main(argv):
-    parser = argparse.ArgumentParser("Eval FlexICM C-TAIC (stub)")
+def parse_args(argv):
+    parser = argparse.ArgumentParser("Codec test: FlexICM C-TAIC")
     parser.add_argument("-c", "--config", required=True, help="configs/eval/ctaic_*.yaml")
-    args = parser.parse_args(argv)
-    cfg_path = args.config if os.path.isabs(args.config) else os.path.join(REPO_ROOT, args.config)
+    given, remaining = parser.parse_known_args(argv)
+    cfg_path = given.config if os.path.isabs(given.config) else os.path.join(REPO_ROOT, given.config)
     cfg = load_yaml_config(cfg_path)
+    parser.set_defaults(**cfg)
+    parser.add_argument("--actual-bpp", action="store_true")
+    parser.add_argument("--no-condition", action="store_true", help="Disable base-layer conditioning (TAIC mode)")
+    parser.add_argument("--max-batches", type=int, default=None)
+    parser.add_argument("--split", type=str, default=None)
+    args = parser.parse_args(remaining)
+    args.config = cfg_path
+    if "--actual-bpp" in argv:
+        args.actual_bpp = True
+    if "--no-condition" in argv:
+        args.no_condition = True
+    return args
+
+
+def build_loader(args, ext_task, device):
+    split = args.split or getattr(args, "split", None) or "val2017"
+    tf = build_test_transform()
+    root = args.dataset_path
+    split_dir = os.path.join(root, split)
+    if os.path.isdir(split_dir):
+        if ext_task == "pose":
+            dataset = COCOWholeBodyImageDataset(root, split, tf)
+        else:
+            dataset = COCOImageDataset(root, split, tf)
+    else:
+        dataset = ImageFolderDataset(root, tf)
+    return DataLoader(
+        dataset,
+        batch_size=getattr(args, "test_batch_size", 1),
+        shuffle=False,
+        num_workers=getattr(args, "num_workers", 4),
+        pin_memory=(device == "cuda"),
+    )
+
+
+def main(argv):
+    args = parse_args(argv)
+    set_seed(getattr(args, "seed", 42))
+
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(getattr(args, "gpu_id", 0))
+    device = "cuda" if getattr(args, "cuda", True) and torch.cuda.is_available() else "cpu"
+
+    scenario = args.scenario
+    base_task = SCENARIOS[scenario]["base"]
+    ext_task = SCENARIOS[scenario]["ext"]
+    base_meta = TASK_META[base_task]
+    ext_meta = TASK_META[ext_task]
+    out_channels = getattr(args, "out_channels", ext_meta["out_channels"])
+    align_mode = getattr(args, "align_mode", ext_meta["align_mode"])
+    lmbda = getattr(args, "lmbda", 0.0035)
+    use_condition = not bool(getattr(args, "no_condition", False))
+
+    ext_ckpt = resolve_ckpt(args.checkpoint, REPO_ROOT, label="C-TAIC checkpoint")
+    base_ckpt = resolve_ckpt(args.base_taic_checkpoint, REPO_ROOT, label="base TAIC checkpoint")
+
+    print(f"Loading base TAIC ({base_task}): {base_ckpt}")
+    base = TAIC(N=128, M=192, out_channels=base_meta["out_channels"]).to(device)
+    state, _ = load_checkpoint_dict(base_ckpt, map_location=device)
+    base.load_state_dict(state, strict=False)
+    base.eval()
+    for p in base.parameters():
+        p.requires_grad = False
+
+    print(f"Loading C-TAIC extension ({ext_task}): {ext_ckpt}")
+    net = CTAIC(N=128, M=192, out_channels=out_channels).to(device)
+    state, _ = load_checkpoint_dict(ext_ckpt, map_location=device)
+    net.load_state_dict(state, strict=False)
+    net.eval()
+
+    teacher = build_teacher(ext_task, pretrained_backbone=getattr(args, "pretrained_backbone", True))
+    teacher = teacher.to(device).eval()
+    criterion = TAICCriterion(lmbda=lmbda, align_mode=align_mode)
+
+    loader = build_loader(args, ext_task, device)
+    print(
+        f"Test set size: {len(loader.dataset)}  device={device}  "
+        f"scenario={scenario}  use_condition={use_condition}"
+    )
+
+    result = test_ctaic_loader(
+        net,
+        base,
+        teacher,
+        loader,
+        criterion,
+        device,
+        use_condition=use_condition,
+        align_divisor=256,
+        run_actual_bpp=bool(getattr(args, "actual_bpp", False)),
+        max_batches=args.max_batches,
+    )
+
+    print("==== C-TAIC codec test summary ====")
+    for k, v in result.items():
+        if isinstance(v, float):
+            print(f"  {k}: {v:.6f}")
+        else:
+            print(f"  {k}: {v}")
 
-    ext = resolve_ckpt(cfg["checkpoint"], "extension C-TAIC")
-    base = resolve_ckpt(cfg["base_taic_checkpoint"], "base TAIC")
-    print(f"[eval_ctaic stub] extension ckpt ok: {ext}")
-    print(f"[eval_ctaic stub] base ckpt ok: {base}")
-    print(f"[eval_ctaic stub] scenario={cfg.get('scenario')} quality={cfg.get('quality_level')}")
-    print("[eval_ctaic stub] Full metric evaluation is not implemented yet.")
+    out_dir = getattr(args, "result_dir", None) or os.path.join(
+        REPO_ROOT, "logs", "eval_ctaic", scenario, str(getattr(args, "quality_level", 1))
+    )
+    os.makedirs(out_dir, exist_ok=True)
+    out_json = os.path.join(out_dir, f"codec_test_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json")
+    payload = {
+        "scenario": scenario,
+        "base_task": base_task,
+        "ext_task": ext_task,
+        "checkpoint": ext_ckpt,
+        "base_taic_checkpoint": base_ckpt,
+        "config": args.config,
+        "result": result,
+    }
+    with open(out_json, "w") as f:
+        json.dump(payload, f, indent=2)
+    print(f"Wrote {out_json}")
     return 0
 
 

scripts/eval_taic.py

@@ -1,51 +1,142 @@
 #!/usr/bin/env python3
-"""Eval / test entry for TAIC (placeholder).
+"""Codec test for TAIC (base layer).
 
-Full rate-accuracy evaluation (mAP / mIoU / PQ / OKS) will be added later.
-This script only validates that the requested checkpoint exists and is not a PLACEHOLDER.
+Reports likelihood bpp, feature-alignment distortion D, and optional actual bitstream bpp.
+Does NOT compute task metrics (mAP / mIoU / PQ / OKS) — those come later.
+
+Example:
+  python scripts/eval_taic.py -c configs/eval/taic_detection.yaml
+  python scripts/eval_taic.py -c configs/eval/taic_detection.yaml --actual-bpp
 """
 
 from __future__ import annotations
 
 import argparse
+import json
 import os
 import sys
+from datetime import datetime
+
+import torch
+from torch.utils.data import DataLoader
 
 REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-sys.path.insert(0, REPO_ROOT)
-
-from flexicm.utils.train_utils import load_yaml_config
-
-
-def resolve_ckpt(path: str) -> str:
-    if not path:
-        raise FileNotFoundError("checkpoint path is empty")
-    if not os.path.isabs(path):
-        path = os.path.join(REPO_ROOT, path)
-    placeholder = os.path.join(os.path.dirname(path), "PLACEHOLDER")
-    if os.path.isfile(placeholder) and not os.path.isfile(path):
-        raise FileNotFoundError(
-            f"Checkpoint not ready (PLACEHOLDER still present):\n  {placeholder}\n"
-            f"Expected real weights at:\n  {path}\n"
-            "See checkpoints/README.md"
-        )
-    if not os.path.isfile(path):
-        raise FileNotFoundError(f"Missing checkpoint: {path}")
-    if os.path.basename(path) == "PLACEHOLDER" or path.endswith(".txt"):
-        raise FileNotFoundError(f"Refusing to load placeholder file: {path}")
-    return path
+if REPO_ROOT not in sys.path:
+    sys.path.insert(0, REPO_ROOT)
 
+from flexicm.data import (
+    COCOImageDataset,
+    COCOWholeBodyImageDataset,
+    ImageFolderDataset,
+    build_test_transform,
+)
+from flexicm.models import TAIC
+from flexicm.tasks import TASK_META, build_teacher
+from flexicm.tasks.losses import TAICCriterion
+from flexicm.utils.codec_test import resolve_ckpt, test_taic_loader
+from flexicm.utils.train_utils import load_checkpoint_dict, load_yaml_config, set_seed
 
-def main(argv):
-    parser = argparse.ArgumentParser("Eval FlexICM TAIC (stub)")
+
+def parse_args(argv):
+    parser = argparse.ArgumentParser("Codec test: FlexICM TAIC")
     parser.add_argument("-c", "--config", required=True, help="configs/eval/taic_*.yaml")
-    args = parser.parse_args(argv)
-    cfg = load_yaml_config(args.config if os.path.isabs(args.config) else os.path.join(REPO_ROOT, args.config))
+    given, remaining = parser.parse_known_args(argv)
+    cfg_path = given.config if os.path.isabs(given.config) else os.path.join(REPO_ROOT, given.config)
+    cfg = load_yaml_config(cfg_path)
+    parser.set_defaults(**cfg)
+    parser.add_argument("--actual-bpp", action="store_true", help="Also run compress/decompress bpp")
+    parser.add_argument("--max-batches", type=int, default=None, help="Limit batches for a smoke test")
+    parser.add_argument("--split", type=str, default=None, help="Override image split folder, e.g. val2017")
+    args = parser.parse_args(remaining)
+    args.config = cfg_path
+    if given.__dict__.get("actual_bpp") or "--actual-bpp" in argv:
+        args.actual_bpp = True
+    return args
+
+
+def build_loader(args, device):
+    split = args.split or getattr(args, "split", None) or "val2017"
+    tf = build_test_transform()
+    root = args.dataset_path
+    split_dir = os.path.join(root, split)
+    if os.path.isdir(split_dir):
+        if args.task == "pose":
+            dataset = COCOWholeBodyImageDataset(root, split, tf)
+        else:
+            dataset = COCOImageDataset(root, split, tf)
+    else:
+        dataset = ImageFolderDataset(root, tf)
+
+    return DataLoader(
+        dataset,
+        batch_size=getattr(args, "test_batch_size", 1),
+        shuffle=False,
+        num_workers=getattr(args, "num_workers", 4),
+        pin_memory=(device == "cuda"),
+    )
+
+
+def main(argv):
+    args = parse_args(argv)
+    set_seed(getattr(args, "seed", 42))
+
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(getattr(args, "gpu_id", 0))
+    device = "cuda" if getattr(args, "cuda", True) and torch.cuda.is_available() else "cpu"
+
+    task = args.task
+    meta = TASK_META[task]
+    out_channels = getattr(args, "out_channels", meta["out_channels"])
+    align_mode = getattr(args, "align_mode", meta["align_mode"])
+    lmbda = getattr(args, "lmbda", 0.0035)
+
+    ckpt = resolve_ckpt(args.checkpoint, REPO_ROOT, label="TAIC checkpoint")
+    print(f"Loading TAIC checkpoint: {ckpt}")
+
+    net = TAIC(N=128, M=192, out_channels=out_channels).to(device)
+    state, _ = load_checkpoint_dict(ckpt, map_location=device)
+    missing = net.load_state_dict(state, strict=False)
+    print(f"load_state_dict: missing={len(missing.missing_keys)} unexpected={len(missing.unexpected_keys)}")
+    net.eval()
+
+    teacher = build_teacher(task, pretrained_backbone=getattr(args, "pretrained_backbone", True))
+    teacher = teacher.to(device).eval()
+    criterion = TAICCriterion(lmbda=lmbda, align_mode=align_mode)
+
+    loader = build_loader(args, device)
+    print(f"Test set size: {len(loader.dataset)}  device={device}  task={task}")
+
+    result = test_taic_loader(
+        net,
+        teacher,
+        loader,
+        criterion,
+        device,
+        align_divisor=256,
+        run_actual_bpp=bool(getattr(args, "actual_bpp", False)),
+        max_batches=args.max_batches,
+    )
+
+    print("==== TAIC codec test summary ====")
+    for k, v in result.items():
+        if isinstance(v, float):
+            print(f"  {k}: {v:.6f}")
+        else:
+            print(f"  {k}: {v}")
 
-    ckpt = resolve_ckpt(cfg["checkpoint"])
-    print(f"[eval_taic stub] checkpoint ok: {ckpt}")
-    print(f"[eval_taic stub] task={cfg.get('task')} quality={cfg.get('quality_level')}")
-    print("[eval_taic stub] Full metric evaluation is not implemented yet.")
+    out_dir = getattr(args, "result_dir", None) or os.path.join(
+        REPO_ROOT, "logs", "eval_taic", task, str(getattr(args, "quality_level", 1))
+    )
+    os.makedirs(out_dir, exist_ok=True)
+    out_json = os.path.join(out_dir, f"codec_test_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json")
+    payload = {
+        "task": task,
+        "checkpoint": ckpt,
+        "config": args.config,
+        "result": result,
+    }
+    with open(out_json, "w") as f:
+        json.dump(payload, f, indent=2)
+    print(f"Wrote {out_json}")
     return 0