图片
  ↓ RGB / 裁剪 / 缩放 / 归一化
模型输出 logits
  ↓ 解码
候选框 + objectness + class probability
  ↓ 置信度筛选 + NMS
食材类别
  ↓ 拒识规则 / 连续帧 / UI 状态机
入库，或 UNKNOWN

prob = torch.softmax(logits, dim=1)
class_id = prob.argmax(dim=1)

tx, ty, tw, th   框的位置和尺寸
to               objectness：这里是不是目标
tc[0..C-1]       类别 logits

原图 → RGB
     → 中心裁剪成正方形
     → resize 到 224×224（或 YOLO 明确指定的尺寸）
     → HWC 转 NCHW
     → float32 / 0~1 或 0~255
     → 是否减 mean、除 std 必须写死

# NCHW、0~1
x = np.asarray(im, dtype=np.float32).transpose(2, 0, 1)[None] / 255.0

# HWC、0~255；如果模型按前一种训练，这就是错的
x = np.asarray(im, dtype=np.uint8)[None]

gx, gy = cx * S, cy * S
ix, iy = int(gx), int(gy)
tx, ty = gx - ix, gy - iy

L = λxy Lxy + λwh Lwh + λobj Lobj + λcls Lcls

bx = (sigmoid(tx) + ix) / S
by = (sigmoid(ty) + iy) / S
bw = anchor_w * exp(tw) / S
bh = anchor_h * exp(th) / S
score = sigmoid(to) * sigmoid(tc[class_id])

PyTorch checkpoint → ONNX → nncase → KModel / INT8 → K210 实机

q = round(x / scale) + zero_point
x ≈ scale × (q - zero_point)

第 1 步：logits、softmax、阈值和 UNKNOWN
第 2 步：RGB/裁剪/resize/归一化输入契约
第 3 步：手算一个 YOLO 目标怎样落到 grid/anchor
第 4 步：理解 objectness、ignore、focal、CIoU
第 5 步：用同一 manifest 比较 FP32、ONNX、INT8
第 6 步：最后做 K210 摄像头、连续帧和产品 UI 验收

import numpy as np

def classify_with_threshold(logits: np.ndarray, names: list[str], threshold: float):
    logits = logits - logits.max()
    probs = np.exp(logits)
    probs /= probs.sum() + 1e-9
    class_id = int(probs.argmax())
    score = float(probs[class_id])
    if score < threshold:
        return {"label": "UNKNOWN", "score": score}
    return {"label": names[class_id], "score": score}

with Image.open(r["image"]) as im:
    im = im.convert("RGB")
    w, h = im.size
    side = min(w, h)
    x = (w - side) // 2
    y = (h - side) // 2
    im = im.crop((x, y, x + side, y + side))
    im = im.resize((INPUT_SIZE, INPUT_SIZE), Image.Resampling.BILINEAR)

x = np.asarray(im, dtype=np.float32).transpose(2, 0, 1).copy()

RGB，不是 BGR
float32 NCHW
中心裁剪后 resize
是否除以 255、是否折叠 ImageNet mean/std，必须和 KModel 一致

def make_targets(boxes_batch, device):
    shape = (len(boxes_batch), ANCHOR_COUNT, GRID, GRID)
    xy = np.zeros((*shape, 2), dtype=np.float32)
    wh = np.zeros((*shape, 2), dtype=np.float32)
    obj = np.zeros(shape, dtype=np.float32)
    cls = np.full(shape, -1, dtype=np.int64)

    for bi, boxes in enumerate(boxes_batch):
        for box in boxes:
            cx = min(max(float(box["cx"]), 1e-5), 1 - 1e-5)
            cy = min(max(float(box["cy"]), 1e-5), 1 - 1e-5)
            gw = max(float(box["w"]) * GRID, 1e-4)
            gh = max(float(box["h"]) * GRID, 1e-4)

            inter = np.minimum(ANCH[:, 0], gw) * np.minimum(ANCH[:, 1], gh)
            iou = inter / (ANCH[:, 0] * ANCH[:, 1] + gw * gh - inter + 1e-9)
            ai = int(iou.argmax())

            gx, gy = cx * GRID, cy * GRID
            ix, iy = min(int(gx), GRID - 1), min(int(gy), GRID - 1)
            if obj[bi, ai, iy, ix] > 0.5:
                continue

            obj[bi, ai, iy, ix] = 1
            xy[bi, ai, iy, ix] = [gx - ix, gy - iy]
            wh[bi, ai, iy, ix] = np.log(
                np.asarray([gw, gh], dtype=np.float32) / (ANCH[ai] + 1e-9)
            )
            cls[bi, ai, iy, ix] = int(box["class_id"])

    return tuple(torch.from_numpy(v).to(device) for v in (xy, wh, obj, cls))

objloss = nn.functional.binary_cross_entropy_with_logits(
    p[..., 4],
    target_obj,
    reduction="none",
    pos_weight=torch.tensor(8.0, device=raw.device),
).mean()

import torch.nn.functional as F

boxes_pred = decoded_boxes(p)
ignore = torch.zeros_like(pos)

with torch.no_grad():
    for bi, boxes in enumerate(boxes_batch):
        if not boxes:
            continue
        gt = torch.tensor([
            [z["cx"] - z["w"] / 2,
             z["cy"] - z["h"] / 2,
             z["cx"] + z["w"] / 2,
             z["cy"] + z["h"] / 2]
            for z in boxes
        ], device=raw.device, dtype=raw.dtype)
        max_iou = pairwise_iou(
            boxes_pred[bi].reshape(-1, 4).detach(), gt
        ).amax(1)
        ignore[bi] = max_iou.reshape(ANCHOR_COUNT, GRID, GRID).gt(0.5)

obj_logits = p[..., 4]
pos_obj = F.binary_cross_entropy_with_logits(obj_logits[pos], torch.ones_like(obj_logits[pos]))
neg = ~pos & ~ignore
neg_prob = obj_logits[neg].sigmoid()
neg_bce = F.binary_cross_entropy_with_logits(
    obj_logits[neg], torch.zeros_like(obj_logits[neg]), reduction="none"
)
neg_obj = (neg_bce * neg_prob.square()).sum() / npos

ciou_loss = (1.0 - ciou_aligned(
    boxes_pred[pos], target_boxes(txy, twh, pos)
)).mean()

total = (
    2.0 * pos_obj
    + 0.5 * neg_obj
    + xy_loss
    + 0.5 * wh_loss
    + 2.0 * ciou_loss
    + cls_loss
)

sigmoid = lambda x: 1.0 / (1.0 + np.exp(-np.clip(x, -40, 40)))
cx = (sigmoid(tx) + grid_x) / GRID
cy = (sigmoid(ty) + grid_y) / GRID
w = np.exp(np.clip(tw, -6, 4)) * anchor_w / GRID
h = np.exp(np.clip(th, -6, 4)) * anchor_h / GRID
box = [cx - w / 2, cy - h / 2, cx + w / 2, cy + h / 2]

if best_iou >= 0.5 and not matched[image_id][best_index]:
    tp.append(1)
else:
    fp.append(1)

IoU 匹配阈值：0.50
置信度工作点：例如 0.25
NMS IoU：例如 0.45 或 0.30
类别集合和类别顺序
评估 decoder 版本
评估数据 manifest 的 SHA-256

import sensor
import time
import KPU as kpu

MODEL = 0x400000
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.set_windowing((224, 224))
sensor.run(1)

task = kpu.load(MODEL)
while True:
    img = sensor.snapshot()
    t0 = time.ticks_ms()
    values = kpu.forward(task, img)[:]
    elapsed_ms = time.ticks_ms() - t0
    order = sorted(range(100), key=lambda i: values[i], reverse=True)[:5]
    print("V3_FORWARD n=%d elapsed_ms=%d top5=%s" %
          (len(values), elapsed_ms,
           [(labels[i]["en"], values[i]) for i in order]))

banana_frames = 0
nonempty_frames = 0

for _ in range(30):
    img = sensor.snapshot()
    boxes = kpu.run_yolo2(task, img)
    decoded = [] if not boxes else [
        (b.classid(), b.value(), b.rect()) for b in boxes
    ]
    if decoded:
        nonempty_frames += 1
        best = max(decoded, key=lambda item: item[1])
        if int(best[0]) == BANANA_CLASS_ID:
            banana_frames += 1

assert banana_frames >= 24       # 目标场景至少 80% 帧正确
assert nonempty_frames == 0      # 背景/空场景不能误接受

冻结 taxonomy 和类别顺序
        ↓
冻结 train / dev / board_acceptance 三份 manifest
        ↓
固定 RGB、尺寸、归一化和模型 SHA-256
        ↓
PC FP32 评估
        ↓
量化模拟器评估
        ↓
K210 实机目标场景 + 拒识场景 30 帧验收
        ↓
只有三层结果一致，才允许进入产品 UI

严格测试中出现明显的跨类误识别
简单香蕉图没有稳定得到香蕉 Top-1
复杂拼图图像贡献了大量错误
不同阈值无法同时满足召回、误接受率和已接受样本准确率

def load_teacher(row: dict, classes: int):
    if row.get("teacher_valid") is not True:
        return None
    value = row.get("teacher_logits_file") or row.get("teacher_logits_path")
    if not value:
        return None

    logits = np.load(resolve_path(str(value))).astype(np.float32).reshape(-1)
    if not np.isfinite(logits).all():
        return None
    if logits.shape != (classes,):
        return None

    mask = np.asarray(row.get("teacher_class_mask", np.ones(classes)), dtype=bool)
    if mask.shape != (classes,) or int(mask.sum()) < 2:
        return None
    return logits, mask

teacher_valid 不成立 → 不使用
logits 形状不匹配 → 不使用
含 NaN/Inf → 不使用
教师只覆盖部分类别 → 只在 mask 范围内蒸馏

PC 教师：86.11% Top-1
K210 学生：13.89% Top-1

E:\embedded\pretrained_food_pc\student_k210\train_student.py

def build_student(model_id: str, classes: int,
                  depth_multiplier: float = 0.75,
                  hidden_act: str = "relu6"):
    config = MobileNetV1Config.from_pretrained(
        model_id, local_files_only=True
    )
    config.depth_multiplier = depth_multiplier
    config.hidden_act = hidden_act
    config.num_labels = classes
    config.image_size = 224
    config.tf_padding = False

    model = MobileNetV1ForImageClassification(config)
    official = MobileNetV1ForImageClassification.from_pretrained(
        model_id, local_files_only=True
    )
    model.mobilenet_v1.load_state_dict(
        official.mobilenet_v1.state_dict()
    )

    # 分类头重新随机初始化，避免把旧分类器权重带入新类表。
    nn.init.normal_(model.classifier.weight, mean=0.0, std=0.01)
    nn.init.zeros_(model.classifier.bias)
    return model

self.transform = transforms.Compose([
    transforms.RandomResizedCrop(size, scale=(0.65, 1.0))
        if train else transforms.Resize(size + 32),
    transforms.RandomHorizontalFlip() if train
        else transforms.CenterCrop(size),
    transforms.ToTensor(),
    transforms.Normalize(
        [0.485, 0.456, 0.406],
        [0.229, 0.224, 0.225]
    ),
])

模型输出：100
模型大小：1,070,440 bytes
Flash 地址：0x400000
设备：Sipeed M1 / OV5642
实测 forward：25 ms
COM9 烧录和加载：通过

PC FP32 86.28% → K210 74.96%

class Wrapper(torch.nn.Module):
    def __init__(self, model, raw_uint8=False):
        super().__init__()
        self.model = model
        self.raw_uint8 = raw_uint8
        self.register_buffer(
            "mean", torch.tensor([0.485, 0.456, 0.406])
            .view(1, 3, 1, 1)
        )
        self.register_buffer(
            "std", torch.tensor([0.229, 0.224, 0.225])
            .view(1, 3, 1, 1)
        )

    def forward(self, pixel_values):
        if self.raw_uint8:
            pixel_values = (pixel_values / 255.0 - self.mean) / self.std
        return self.model(pixel_values=pixel_values).logits

with torch.no_grad():
    torch_logits = wrapper(dummy).numpy()

onnx_logits = session.run(
    ["logits"],
    {"pixel_values": dummy.numpy()}
)[0]

max_abs_diff = float(np.max(np.abs(torch_logits - onnx_logits)))
assert max_abs_diff < 1e-4

by_class = defaultdict(list)
for row in rows:
    by_class[int(row["target_id"])].append(row)

selected = []
index = 0
class_ids = sorted(by_class)
while len(selected) < samples:
    added = False
    for class_id in class_ids:
        if index < len(by_class[class_id]):
            selected.append(by_class[class_id][index])
            added = True
        if len(selected) >= samples:
            break
    if not added:
        break
    index += 1

校准图片数量
覆盖类别数
每类最少/最多样本
原始图像来源组数量
是否包含不同曝光、背景和目标尺度

x / 255 - mean / std → depthwise 1×1 Conv
ReLU6 Clip → ReLU + Min(6)
GlobalAveragePool → ReduceMean 或固定 7×7 Conv
Gemm → 1×1 Conv

ONNX checker
shape inference
PyTorch/ONNX 数值对照
独立 FP32 评估
nncase 模拟器评估

100 类闭集分类
40 类研究分类
44 类 YOLOv2 检测
旧 decoder / +0.5
修正 decoder / 无 +0.5
旧 loss
loss v2：ignore + focal + CIoU
小数据集同训同测
全量 train / dev

{
  "experiment_id": "yolo44_lossv2_full_e01",
  "taxonomy_id": "contest60_common_fresh_yolov2_probe_v1",
  "train_manifest_sha256": "...",
  "dev_manifest_sha256": "...",
  "input_contract": "RGB float32 NCHW center-crop 224",
  "decoder": "center_decode_without_plus_0_5",
  "loss": "ignore_focal_ciou_v2",
  "nms_iou": 0.30,
  "match_iou": 0.50,
  "research_only": true
}

Get-CimInstance Win32_Process -Filter "name = 'python.exe'" |
    Where-Object { $_.CommandLine -match 'train_yolo' } |
    Select-Object ProcessId, CommandLine

payload["epoch"]
payload["model_state"]
payload["optimizer_state"]
payload.get("scheduler_state")
payload.get("scaler_state")
payload["manifest_sha256"]

banana_top1_frames >= 24 / 30

false_accept_frames == 0 / 30

E:\embedded\pretrained_food_pc\student_k210\train_student.py
E:\embedded\pretrained_food_pc\student_k210\export_student.py
E:\embedded\pretrained_food_pc\student_k210\eval_onnx_manifest.py
E:\embedded\pretrained_food_pc\student_k210\prepare_calibration.py
E:\embedded\pretrained_food_pc\student_k210\verify_kmodel_runtime.py

E:\embedded\pretrained_food_pc\student_k210\research\yolo_common_20260922\build_yolov2_probe.py
E:\embedded\pretrained_food_pc\student_k210\research\yolo_common_20260922\train_yolov2_44c.py
E:\embedded\pretrained_food_pc\student_k210\research\yolo_common_20260922\train_yolov2_lossv2_smoke.py
E:\embedded\pretrained_food_pc\student_k210\research\yolo_common_20260922\diagnostics\assignment_ignore_audit.py
E:\embedded\pretrained_food_pc\student_k210\research\yolo_common_20260922\board_scene_acceptance.py

E:\embedded\pretrained_food_pc\student_k210\make_nncase_v4_compatible_onnx.py
E:\embedded\pretrained_food_pc\student_k210\build_relu6_v3_input01_runtime.py
E:\embedded\pretrained_food_pc\student_k210\runs\alpha05_relu6_from_relu_v1\runtime_v3_input01_scalar_floatfc\V3_RUNTIME_REPORT.json