{ "nbformat": 4, "nbformat_minor": 5, "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python", "version": "3.12" }, "lecture_validation": { "status": "executed-top-to-bottom-local-cpu", "cloud_execution": false, "executor": "standard Python exec per cell in fresh notebook namespace; stdout/stderr and plt.show captured", "format_check": "v4.5 required notebook/cell/output fields checked", "code_cells": 7, "figure_inspection": "All eight output figures visually inspected locally as PNG; HTML/notebook frontend not browser-inspected" }, "title": "LAB 11 · 何时继续计算" }, "cells": [ { "cell_type": "markdown", "metadata": { "html_anchor": "cell-1", "deepnote": { "block_id": "aec2f6678c2e437e86f6df49ce7b7b46" } }, "source": [ "# LAB 11 · 何时继续计算\n", "\n", "[返回第二讲 · 早退与错停风险](https://codingai-lec02.pages.dev/#/frontier-adaptive-early-exits/0) · [网页阅读版](https://codingai-lec02.pages.dev/course/lab13.html) · [第二讲导读](https://codingai-lec02.pages.dev/course/guide.html) · [问卷作业 ↗](https://tally.so/r/VLroVv)（右键在新标签页打开，保留当前材料）\n", "\n", "**什么时候值得继续计算？** 固定训练好的两个出口，先预测阈值变化，再看保存的验证选择与测试错停。最简单的固定浅出口也要参加比较。\n", "\n", "| 课堂动作 | 看哪里 | 完成什么 |\n", "|---|---|---|\n", "| 先读不运行 | 第 2 节三条路径账本与准确率—MAC 图 | 解释动态规则为何没有赢过固定浅出口 |\n", "| 只改一条规则 | 第 3 节阈值练习 | 写出预期，再按验证数据重新选择 |\n", "| 观察具体失败 | 错停样本图 | 区分“浅头答错”与“继续能纠正” |\n", "\n", "数据是 sklearn digits 的 1797 张 8×8 图像，模型为 `DigitsMultiExitBN-integration-20260918-lcde-r1`，与主讲前面的 MNIST 机制输入不是一次连续运行。保存结果来自 2026-09-18：程序先计算两个出口，再离线回放阈值，因此 MAC 账本不是实测早退加速。\n", "\n", "可直接读保存图；独立运行依赖 `numpy torch scikit-learn matplotlib`，从 `load_digits()` 与本册可读代码重建，不依赖另一册的 checkpoint。若顺序运行全本，会重新训练源模型并写出本地结果，课程保存输出仍用于对照。" ], "id": "cell-000" }, { "cell_type": "markdown", "metadata": { "html_anchor": "cell-2", "deepnote": { "block_id": "d45a314e8a0d45009818149d71eb0a07" } }, "source": [ "## 先读这次保存运行，再作预测\n", "\n", "先记下你的预测：动态出口是否一定比固定浅出口更划算？\n", "\n", "保存运行用验证集选出 τ=0.50；测试全深度 97.22%，动态 95.83%，固定浅出口也是 95.83%。动态平均 3091.73 MAC，而固定浅出口为 2944 MAC。**相同准确率下，动态规则没有在这份乘加账本上占优。**\n", "\n", "随后用第 2 节的三条路径解释额外成本，再看错停：357/360 张图早退，14 张错停，其中 6 张本可由深出口纠正。验证允许下降 1 个百分点，测试下降 1.39 个百分点；留出评价并不继承验证集上的约束保证。\n" ], "id": "saved-reference-findings" }, { "cell_type": "markdown", "metadata": { "html_anchor": "cell-3" }, "source": "## 1. 什么在训练，什么在部署时改变？\n\n模型：输入 N×1×8×8 → Conv(1→4,3×3)+BN+ReLU+平均池化 → N×4×4×4。浅出口 flatten→10；深路径再 Conv(4→16,3×3)+BN+ReLU→flatten256→MLP32→10。两个出口一起用源标签训练 `0.35 CE(early)+CE(final)`，50 轮中选验证集最终出口 CE 最低的 checkpoint。\n\n这里训练参数是固定的，部署决策只选择用哪个出口的预测；与 Tent 更新 BN 参数的实验不同。固定划分约 60／20／20，分层随机按图像划分，**不是按书写者隔离**。测试标签不参与选 checkpoint 或选阈值。\n", "id": "cell-001" }, { "cell_type": "code", "metadata": { "html_anchor": "cell-4" }, "source": "LAB_ID='LAB13-D'\n\nfrom pathlib import Path\nfrom copy import deepcopy\nimport csv, hashlib, json, platform, sys, time\nimport numpy as np\nimport torch\nfrom torch import nn\nimport torch.nn.functional as F\nimport sklearn\nfrom sklearn.datasets import load_digits\nfrom sklearn.model_selection import train_test_split\nimport matplotlib.pyplot as plt\nSEED = 20260918\nnp.random.seed(SEED); torch.manual_seed(SEED)\ntorch.set_num_threads(1)\ntorch.use_deterministic_algorithms(True)\nOUTPUT = Path('outputs') / LAB_ID\nOUTPUT.mkdir(parents=True, exist_ok=True)\nplt.rcParams.update({'figure.dpi':120, 'font.size':10, 'axes.spines.top':False, 'axes.spines.right':False})\ndef save_json(name, obj):\n (OUTPUT/name).write_text(json.dumps(obj,ensure_ascii=False,indent=2))\ndef save_csv(name, rows):\n with (OUTPUT/name).open('w',newline='') as f:\n w=csv.DictWriter(f, fieldnames=list(rows[0])); w.writeheader(); w.writerows(rows)\ndef digest_array(a): return hashlib.sha256(np.ascontiguousarray(a).tobytes()).hexdigest()\ndef print_table(rows, cols=None):\n cols=cols or list(rows[0]); print(' | '.join(cols)); print(' | '.join(['---']*len(cols)))\n for row in rows:\n print(' | '.join(f'{row[c]:.5f}' if isinstance(row[c],float) else str(row[c]) for c in cols))\ncpu_lines=Path('/proc/cpuinfo').read_text().splitlines() if Path('/proc/cpuinfo').exists() else []\ncpu_name=next((line.split(':',1)[1].strip() for line in cpu_lines if line.startswith('model name')),platform.processor())\nenvironment={'python':sys.version.split()[0],'torch':torch.__version__,'numpy':np.__version__,\n 'sklearn':sklearn.__version__,'cpu':cpu_name,'platform':platform.platform(),\n 'torch_threads':torch.get_num_threads(),'device':'cpu','dtype':'float32',\n 'seed':SEED,'exclusive_hardware':False}\nsave_json('environment.json',environment)\nprint(json.dumps(environment,ensure_ascii=False,indent=2))\n", "execution_count": 1, "outputs": [ { "output_type": "stream", "name": "stdout", "text": "{\n \"python\": \"3.12.14\",\n \"torch\": \"2.14.0+cpu\",\n \"numpy\": \"2.3.5\",\n \"sklearn\": \"1.8.0\",\n \"cpu\": \"INTEL(R) XEON(R) PLATINUM 8573C\",\n \"platform\": \"Linux-6.18.44-x86_64-with-glibc2.39\",\n \"torch_threads\": 1,\n \"device\": \"cpu\",\n \"dtype\": \"float32\",\n \"seed\": 20260918,\n \"exclusive_hardware\": false\n}\n" } ], "id": "cell-002" }, { "cell_type": "code", "metadata": { "html_anchor": "cell-5" }, "source": "dataset = load_digits()\nX = torch.tensor(dataset.images[:,None,:,:] / 16.0, dtype=torch.float32)\ny = torch.tensor(dataset.target, dtype=torch.long)\nall_ids = np.arange(len(y))\ntrainval_ids, test_ids = train_test_split(all_ids, test_size=0.2, random_state=SEED, stratify=y.numpy())\ntrain_ids, val_ids = train_test_split(trainval_ids, test_size=0.25, random_state=SEED, stratify=y.numpy()[trainval_ids])\nassert not (set(train_ids)&set(val_ids) or set(train_ids)&set(test_ids) or set(val_ids)&set(test_ids))\nassert len(train_ids)+len(val_ids)+len(test_ids)==len(y)\nsplit_manifest={'dataset':'sklearn.datasets.load_digits; 1797 real 8x8 images; pixel/16',\n 'counts':{'train':len(train_ids),'validation':len(val_ids),'test':len(test_ids)},\n 'train_ids':train_ids.tolist(),'validation_ids':val_ids.tolist(),'test_ids':test_ids.tolist(),\n 'input_sha256':digest_array(X.numpy()),'labels_sha256':digest_array(y.numpy()),\n 'split_policy':'stratified random by sample, NOT writer-disjoint', 'test_labels':'evaluation only'}\nsave_json('split-manifest.json',split_manifest)\nprint('Split:',split_manifest['counts'])\n", "execution_count": 2, "outputs": [ { "output_type": "stream", "name": "stdout", "text": "Split: {'train': 1077, 'validation': 360, 'test': 360}\n" } ], "id": "cell-003" }, { "cell_type": "code", "metadata": { "html_anchor": "cell-6" }, "source": "MODEL_ID = 'DigitsMultiExitBN-integration-20260918-lcde-r1'\nclass DigitsMultiExitBN(nn.Module):\n def __init__(self):\n super().__init__()\n self.conv1=nn.Conv2d(1,4,3,padding=1,bias=False)\n self.bn1=nn.BatchNorm2d(4)\n self.early=nn.Linear(4*4*4,10)\n self.conv2=nn.Conv2d(4,16,3,padding=1,bias=False)\n self.bn2=nn.BatchNorm2d(16)\n self.fc=nn.Linear(16*4*4,32)\n self.final=nn.Linear(32,10)\n def forward(self,x):\n h=F.avg_pool2d(F.relu(self.bn1(self.conv1(x))),2)\n early=self.early(h.flatten(1))\n h=F.relu(self.bn2(self.conv2(h)))\n final=self.final(F.relu(self.fc(h.flatten(1))))\n return early,final\n\ndef train_source():\n torch.manual_seed(SEED)\n model=DigitsMultiExitBN()\n optimizer=torch.optim.Adam(model.parameters(),lr=0.003)\n order_generator=torch.Generator().manual_seed(SEED+1)\n best_loss=float('inf'); best_state=None; best_epoch=None; history=[]\n for epoch in range(1,51):\n model.train()\n order=torch.as_tensor(train_ids)[torch.randperm(len(train_ids),generator=order_generator)]\n total=0.0\n for ids in order.split(64):\n optimizer.zero_grad(set_to_none=True)\n early,final=model(X[ids]); loss=0.35*F.cross_entropy(early,y[ids])+F.cross_entropy(final,y[ids])\n loss.backward(); optimizer.step(); total += loss.item()*len(ids)\n model.eval()\n with torch.no_grad():\n ve,vf=model(X[val_ids]); val_loss=F.cross_entropy(vf,y[val_ids]).item()\n history.append({'epoch':epoch,'train_weighted_loss':total/len(train_ids),\n 'validation_final_ce':val_loss,'validation_early_acc':(ve.argmax(1)==y[val_ids]).float().mean().item(),\n 'validation_final_acc':(vf.argmax(1)==y[val_ids]).float().mean().item()})\n if val_loss < best_loss:\n best_loss=val_loss; best_state=deepcopy(model.state_dict()); best_epoch=epoch\n model.load_state_dict(best_state); model.eval()\n return model,history,best_epoch\nsource_model,train_history,best_epoch=train_source()\nsource_state=deepcopy(source_model.state_dict())\nstate_hash=hashlib.sha256(b''.join(k.encode()+v.cpu().numpy().tobytes() for k,v in sorted(source_state.items()))).hexdigest()\nsave_csv('source-training.csv',train_history)\n# Transparent JSON state is a local convenience; notebook always reconstructs from readable code.\nsave_json('source-state.json',{k:v.tolist() for k,v in source_state.items()})\nmodel_manifest={'model_id':MODEL_ID,'state_sha256':state_hash,'best_epoch':best_epoch,\n 'checkpoint_selection':'minimum validation final-exit CE over 50 epochs',\n 'train_loss':'0.35*CE(early)+CE(final)','optimizer':'Adam lr=0.003 batch=64',\n 'initialization_seed':SEED,'params':sum(p.numel() for p in source_model.parameters()),\n 'old_LAB02_dependency':False,'data_split_sha256':hashlib.sha256(json.dumps(split_manifest,sort_keys=True).encode()).hexdigest()}\nsave_json('model-manifest.json',model_manifest)\nprint(json.dumps(model_manifest,indent=2))\n", "execution_count": 3, "outputs": [ { "output_type": "stream", "name": "stdout", "text": "{\n \"model_id\": \"DigitsMultiExitBN-integration-20260918-lcde-r1\",\n \"state_sha256\": \"544bb0f79f5759b66656565e3e4c5a59a5dd8f2893a067d93a7fe331439c685c\",\n \"best_epoch\": 48,\n \"checkpoint_selection\": \"minimum validation final-exit CE over 50 epochs\",\n \"train_loss\": \"0.35*CE(early)+CE(final)\",\n \"optimizer\": \"Adam lr=0.003 batch=64\",\n \"initialization_seed\": 20260918,\n \"params\": 9856,\n \"old_LAB02_dependency\": false,\n \"data_split_sha256\": \"6f705c12f1651f0c5b871f8ff65f4241bdbc1ffbd61a5f0fc56ac95bbb0cf129\"\n}\n" } ], "id": "cell-004" }, { "cell_type": "code", "metadata": { "html_anchor": "cell-7" }, "source": "fig,ax=plt.subplots(figsize=(7.5,3))\nax.plot([r['epoch'] for r in train_history],[r['validation_early_acc'] for r in train_history],label='early')\nax.plot([r['epoch'] for r in train_history],[r['validation_final_acc'] for r in train_history],label='final')\nax.axvline(best_epoch,color='gray',linestyle='--',label='selected by final CE')\nax.set(xlabel='Source training epoch',ylabel='Validation accuracy',ylim=(0,1)); ax.legend()\nfig.tight_layout(); fig.savefig(OUTPUT/'training.png'); plt.show()\nwith torch.inference_mode():\n val_early,val_final=source_model(X[val_ids]); test_early,test_final=source_model(X[test_ids])\nfor split,ids,e,f in [('validation',val_ids,val_early,val_final),('test',test_ids,test_early,test_final)]:\n rows=[]\n for i,sample_id in enumerate(ids):\n row={'sample_id':int(sample_id),'target':int(y[sample_id])}\n row.update({f'early_logit_{k}':float(e[i,k]) for k in range(10)})\n row.update({f'final_logit_{k}':float(f[i,k]) for k in range(10)})\n rows.append(row)\n save_csv(f'{split}-exit-logits.csv',rows)\nprint('Both exits computed and saved; no runtime early exit implemented.')\n", "execution_count": 4, "outputs": [ { "output_type": "stream", "name": "stdout", "text": "Both exits computed and saved; no runtime early exit implemented.\n" }, { "output_type": "display_data", "data": { "image/png": "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", "text/plain": "Matplotlib figure" }, "metadata": {} } ], "id": "cell-005" }, { "cell_type": "markdown", "metadata": { "html_anchor": "cell-8", "deepnote": { "block_id": "86d1e71d2f8e4d83aabd27b0b1f7700d" } }, "source": [ "## 2. 阈值只在验证集选，出口开销也记账\n", "\n", "用浅出口最大 softmax 概率作为停止分数。候选阈值 0.50–0.99；另加 1.01 表示不早退。先满足验证准确率不低于全深度基线 1 个百分点，再选期望 MAC 最低的阈值；这只是预先固定的教学决策规则，不是置信保证。\n", "\n", "卷积／线性 MAC：block1=2304，浅头=640，block2+深头=17728。全深度直接路径为 20032；动态拒绝早退还额外付浅头，总计 20672；早退为 2944。表中包含浅出口开销，**不包含 BN／激活／池化、softmax／门控／数据搬运与排队**，所以叫 conv/linear MAC 代理而非完整执行成本。全深度基线跳过浅头。随机策略以验证得到的早退比例为概率，每个样本随机选择，100 个预定 seed，不据测试表现挑 seed。\n", "\n", "![LAB11卷积线性乘加账本：全深度20032，早退2944，尝试早退但继续20672，浅出口头成本640不能省略。](https://codingai-lec02.pages.dev/course/visuals/v26/early-exit-mac-ledger.png)\n", "\n", "**先看什么。** 比较全深度与“尝试后继续”：后者多了哪一个框？再检查早退路径为什么不含深路径和深头。\n", "\n", "**改变一个条件。** 提高退出阈值，更多样本选择继续。平均乘加次数与错停数量可能各怎样变化？先作预测，再按验证规则观察保存曲线。\n", "\n", "[查看清晰矢量图](https://codingai-lec02.pages.dev/course/visuals/v26/early-exit-mac-ledger.svg)\n", "\n", "**从当前代码核对每一笔。** 第一层卷积为 $8\\times8\\times4\\times1\\times3\\times3=2304$；浅头为 $64\\times10=640$。尾部为第二层卷积 $4\\times4\\times16\\times4\\times3\\times3=9216$，加 $256\\times32=8192$ 与 $32\\times10=320$，合计 $17728$。BN、ReLU、池化等没有被改写成零开销，只是不属于这份 conv/linear 乘加口径。\n", "\n", "当前保存程序先算两只出口，再离线回放规则；这些和数表示候选执行路径应付的账，不是已测运行时间。保持下方保存结果：测试集 360 张，选定动态策略与固定浅出口同为 **95.83%**，动态平均 **3091.73 MAC** 高于固定浅出口的 **2944 MAC**。因此这个例子里的动态规则没有在准确率与该计算账本上优于固定浅出口。\n" ], "id": "cell-006" }, { "cell_type": "code", "metadata": { "html_anchor": "cell-9" }, "source": "SHARED,EARLY_HEAD,TAIL=2304,640,17728\nEARLY_MAC=SHARED+EARLY_HEAD\nDYNAMIC_LATE_MAC=SHARED+EARLY_HEAD+TAIL\nFULL_MAC=SHARED+TAIL\nTHRESHOLDS=np.r_[np.arange(.50,1.0,.01),1.01]\ndef policy(early,final,labels,threshold):\n stopped=early.softmax(1).max(1).values.numpy()>=threshold\n ep,fp=early.argmax(1).numpy(),final.argmax(1).numpy()\n pred=np.where(stopped,ep,fp); truth=labels.numpy()\n return {'threshold':float(threshold),'accuracy':float(np.mean(pred==truth)),\n 'early_fraction':float(stopped.mean()),'mean_conv_linear_mac':float(np.where(stopped,EARLY_MAC,DYNAMIC_LATE_MAC).mean()),\n 'wrong_early_count':int(np.sum(stopped&(ep!=truth))),\n 'avoidable_wrong_early_count':int(np.sum(stopped&(ep!=truth)&(fp==truth)))},stopped,pred\nval_rows=[policy(val_early,val_final,y[val_ids],t)[0] for t in THRESHOLDS]\nval_full_acc=float((val_final.argmax(1)==y[val_ids]).float().mean())\nfeasible=[r for r in val_rows if r['accuracy']>=val_full_acc-.01]\nchosen=min(feasible,key=lambda r:(r['mean_conv_linear_mac'],-r['accuracy'],-r['threshold']))\nchosen_t=chosen['threshold']; random_probability=chosen['early_fraction']\nsave_csv('validation-thresholds.csv',val_rows)\nsave_json('threshold-selection.json',{'chosen':chosen,'full_validation_acc':val_full_acc,'max_validation_accuracy_drop':.01,\n 'test_labels_used':False,'mac_scope':'conv/linear only; includes early head for dynamic policy; gate omitted',\n 'counts':{'shared':SHARED,'early_head':EARLY_HEAD,'tail':TAIL,'direct_full':FULL_MAC}})\nprint('Selected using validation only:',json.dumps(chosen,indent=2))\n", "execution_count": 5, "outputs": [ { "output_type": "stream", "name": "stdout", "text": "Selected using validation only: {\n \"threshold\": 0.5,\n \"accuracy\": 0.975,\n \"early_fraction\": 0.9805555555555555,\n \"mean_conv_linear_mac\": 3288.711111111111,\n \"wrong_early_count\": 7,\n \"avoidable_wrong_early_count\": 4\n}\n" } ], "id": "cell-007" }, { "cell_type": "code", "metadata": { "html_anchor": "cell-10" }, "source": "test_rows=[]\nfor t in THRESHOLDS: test_rows.append(policy(test_early,test_final,y[test_ids],t)[0])\nchosen_test,stopped,pred=policy(test_early,test_final,y[test_ids],chosen_t)\nep=test_early.argmax(1).numpy(); fp=test_final.argmax(1).numpy(); truth=y[test_ids].numpy()\nrandom_rows=[]\nfor seed in range(100):\n take_early=np.random.default_rng(SEED+100+seed).random(len(test_ids))