企业官网建设流程全解析

1. 这不是又一个“Hello World”式Demo，而是一套能直接进项目的PyTorch图像分类框架

你有没有遇到过这样的情况：项目刚启动，团队里有人甩出一句“用ResNet50跑个baseline”，结果三天过去，数据加载器还在报DataLoader线程卡死，torchvision.transforms的归一化参数写错了导致模型完全不收敛，更别说换模型时要重写整个训练循环——最后发现，真正花时间的不是调参，而是把数据喂进去、把loss算出来、把模型存下来这一整套“基础设施”。这个标题里的“PyTorch图像分类框架”，说的就是这样一套开箱即用、可插拔、经生产环境验证的工程化骨架。它不教你怎么推导反向传播，也不讲ResNet的残差连接有多精妙，它解决的是“今天下午三点前必须跑通第一个epoch”的现实问题。核心关键词——PyTorch、图像分类、主流模型、框架化、可复用——每一个都指向一个明确的工程诉求：减少重复造轮子，加速从想法到验证的闭环。适合三类人：刚学完《深度学习入门》想动手但被工程细节劝退的新手；带实习生的工程师，需要一套干净、有注释、能当教学模板的基线代码；还有正在技术选型的算法负责人，需要快速横向对比EfficientNet、ViT、ConvNeXt在自家数据集上的吞吐与精度表现。我把它部署在某高校实验室的医学影像分析项目中，从接入新数据集到产出首份AUC报告，耗时从平均2.7天压缩到4小时——关键不在模型多炫酷，而在框架把90%的脏活累活封装成了几行配置。

2. 框架设计思路：为什么放弃“手写训练循环”，选择模块化分层架构

2.1 不是为炫技，而是为解决真实协作中的断点问题

很多教程教你怎么用nn.Sequential搭个CNN，再用torch.optim.SGD跑起来。这在单机单卡、单数据集、单模型的笔记本环境里没问题。但一旦进入真实场景，问题立刻暴露：

• 数据侧断点：医学影像用DICOM格式，工业质检图是16位灰度图，卫星图动辄上G，PIL.Image.open()直接OOM；
• 模型侧断点：同事A用torchvision.models.resnet50(pretrained=True)，同事B用timm.create_model('resnet50', pretrained=True)，权重加载方式不同，微调时state_dict键名对不上；
• 训练侧断点：有人习惯for epoch in range(epochs): for batch in dataloader:，有人用pytorch_lightning的Trainer，交接时得重写整个训练逻辑。

这套框架的底层设计哲学就一条：把变化点隔离，把稳定点固化。我们把整个流程拆成四个不可变接口层：

1. 数据接口层（DataInterface）：只定义get_train_dataloader()、get_val_dataloader()两个方法，具体怎么读DICOM、怎么做CLAHE增强、怎么处理长尾标签，全由子类实现；
2. 模型接口层（ModelInterface）：只暴露build_model()和get_model_config()，内部自动处理pretrained权重下载、num_classes适配、classifier头替换；
3. 训练接口层（TrainerInterface）：统一管理optimizer、scheduler、criterion的创建与更新逻辑，支持amp混合精度、梯度裁剪、早停等开关；
4. 配置驱动层（Config）：所有参数——从batch_size=32到model_name='vit_base_patch16_224'——全部集中在一个YAML文件里，改模型不用动代码，改学习率不用找optimizer.py。

提示：这种分层不是为了“高大上”，而是让实习生改模型时，只需修改config.yaml里的model_name字段，其他代码零改动；让算法研究员加新数据集时，只需继承DataInterface写一个MyMedicalDataset类，训练脚本完全复用。

2.2 主流模型支持不是“列个清单”，而是解决加载兼容性这个真痛点

标题里“支持多种主流分类模型”，绝不是简单地在if model_name == 'resnet50': return models.resnet50()里堆砌elif。真正的难点在于：不同来源的模型权重，其state_dict结构千差万别。比如：

• torchvision的ResNet，classifier层叫fc；
• timm的ResNet，classifier层叫head；
• HuggingFace的ViT，classifier层叫classifier，但输入维度是[batch, seq_len, dim]，需要先取[cls]token；
• 自研的ConvNeXt，classifier可能嵌套在head.norm和head.linear两层里。

框架的解决方案是：为每个模型注册一个“适配器”（Adapter）。以ViT为例，ViTAdapter类会自动：

1. 检查原始权重是否含pos_embed，若缺失则按img_size和patch_size动态生成；
2. 将classifier层的输入维度从768（ViT-base）或1024（ViT-large）映射到你的数据集类别数；
3. 在forward中插入x = x[:, 0]提取[CLS]token，避免用户手动写output.logits[:, 0]。

实测下来，这套适配器机制让模型切换成本趋近于零。上周有位同事要把ResNet50换成ConvNeXt-Tiny，他只做了三件事：①pip install timm；② 把config.yaml里model_name: resnet50改成convnext_tiny；③ 运行python train.py --config config.yaml。整个过程没改一行模型相关代码，连import语句都没动。

2.3 为什么坚持用YAML而非Python字典？一次配置失误的代价

你可能会问：为什么不用Python字典写配置？写起来更灵活啊。答案来自一次真实的翻车：某次模型上线前压测，运维同学把config.py里的batch_size = 64错写成batch_size = 64.0（浮点数），PyTorch的DataLoader没报错，但GPU显存分配异常，训练速度慢了3倍，排查了两天才发现是配置类型错误。YAML强制类型约束解决了这个问题：batch_size: 64就是整数，lr: 1e-4就是浮点，use_amp: true就是布尔值，解析时类型错误直接抛异常，而不是在训练第100个epoch时静默失败。

更关键的是YAML的可继承性。框架内置了base.yaml（通用参数）、medical.yaml（医学影像专用：resize: [512, 512],augment: ['clahe', 'random_rotate']）、industrial.yaml（工业质检专用：resize: [256, 256],augment: ['grid_mask', 'motion_blur']）。你的项目配置只需写：

# my_project.yaml include: ["base.yaml", "medical.yaml"] model_name: "efficientnet_b3" num_classes: 4 # 病理切片四分类

include机制自动合并所有父配置，my_project.yaml里只保留差异化参数。这种设计让跨项目复用配置成为可能——某实验室的皮肤镜图像分类项目，直接include了medical.yaml，只改了num_classes: 7和data_root: "/path/to/derm"，5分钟完成配置迁移。

3. 核心模块详解：从数据加载到模型保存，每一步都踩过坑

3.1 数据加载器：如何让16位医学影像不炸显存

图像分类框架最常被低估的环节就是数据加载。新手常犯的错误是：直接用transforms.ToTensor()处理DICOM文件，结果torch.uint16转成torch.float32后，单张图内存暴涨4倍，batch_size=16直接触发CUDA OOM。框架的数据模块（data/dataset.py）为此做了三层防护：

第一层：格式感知加载器

def load_image(path: str) -> np.ndarray: if path.endswith('.dcm') or path.endswith('.dicom'): import pydicom ds = pydicom.dcmread(path) img = ds.pixel_array.astype(np.float32) # 保留原始位深 if hasattr(ds, 'RescaleSlope') and hasattr(ds, 'RescaleIntercept'): img = img * ds.RescaleSlope + ds.RescaleIntercept return img elif path.endswith('.tif') or path.endswith('.tiff'): from tifffile import imread return imread(path).astype(np.float32) else: return np.array(Image.open(path).convert('RGB'))

这段代码的关键在于：不盲目转uint8，而是根据源格式保留信息量。DICOM的CT值范围可能是[-1024, 3071]，硬转uint8会丢失所有诊断信息。

第二层：内存感知预处理
所有transforms操作都在np.ndarray层面完成，避免过早转torch.Tensor：

class Normalize: def __init__(self, mean: List[float], std: List[float]): self.mean = np.array(mean, dtype=np.float32).reshape(1, 1, -1) self.std = np.array(std, dtype=np.float32).reshape(1, 1, -1) def __call__(self, img: np.ndarray) -> np.ndarray: # img shape: (H, W, C) or (H, W) for grayscale if img.ndim == 2: img = np.stack([img] * 3, axis=-1) # (H, W) -> (H, W, 3) img = (img - self.mean) / self.std # numpy broadcast, no GPU mem return img

这里Normalize不继承torchvision.transforms.Transform，而是纯NumPy实现。实测在处理512×512×3的DICOM图像时，内存占用比torchvision.transforms.Normalize低62%，因为后者会在__call__里隐式创建torch.Tensor。

第三层：智能批处理
DataLoader的collate_fn做了动态裁剪：

def collate_fn(batch): # batch: list of (img_tensor, label) imgs, labels = zip(*batch) # 找出batch内最小尺寸，pad到统一大小，避免resize失真 min_h = min(img.shape[0] for img in imgs) min_w = min(img.shape[1] for img in imgs) padded_imgs = [] for img in imgs: h, w = img.shape[:2] pad_h = (min_h - h) // 2 pad_w = (min_w - w) // 2 padded = F.pad(img, (pad_w, pad_w, pad_h, pad_h), mode='reflect') padded_imgs.append(padded) return torch.stack(padded_imgs), torch.tensor(labels)

这个collate_fn让框架能同时处理不同分辨率的工业缺陷图（有的200×200，有的1920×1080），无需提前统一resize——这对保留微小缺陷特征至关重要。

3.2 模型构建器：一行代码切换Backbone，背后是23个适配器

框架的模型模块（models/builder.py）核心是build_model(config: Dict)函数。它的执行流程像一个精密的流水线：

1. 模型源识别：根据config['model_name']前缀判断来源

   • resnet50,vgg16→torchvision.models
   • vit_base_patch16_224,convnext_small→timm.create_model
   • beit_base_patch16_224→transformers.BeitForImageClassification

2. 权重加载策略：

   if config.get('pretrained', True): if 'timm' in model_source: model = timm.create_model(model_name, pretrained=True, num_classes=0) # 先不加head # 后续用Adapter注入自定义head elif 'torchvision' in model_source: model = getattr(torchvision.models, model_name)(pretrained=True) # 自动替换fc层 in_features = model.fc.in_features model.fc = nn.Linear(in_features, config['num_classes'])

3. Head注入与适配：这是最体现工程价值的部分。以ConvNeXtAdapter为例：

   class ConvNeXtAdapter: def inject_head(self, model, num_classes: int): # ConvNeXt的head是norm + linear，需保持原有norm参数 original_norm = model.head.norm model.head = nn.Sequential( original_norm, nn.Linear(model.head.linear.in_features, num_classes) ) return model

   这段代码确保：即使你用timm加载的ConvNeXt权重，其head.norm的running_mean和running_var也会被完整保留，不会因重置head而丢失BN统计量——这对小样本微调精度影响极大。

实操心得：我们曾对比过同一组肺结节CT数据，在ResNet50上微调时，用框架的Adapter加载比手动model.load_state_dict()精度高1.2%（AUC），原因正是Adapter保留了原始BN层的统计参数，而手动加载会重置它们。

3.3 训练引擎：为什么把torch.cuda.amp封装成开关而不是示例代码

训练模块（trainers/base_trainer.py）的train_epoch()方法，表面看只是个循环，但内部藏着三个关键设计：

第一，混合精度的无感集成

def train_epoch(self): scaler = torch.cuda.amp.GradScaler(enabled=self.config.get('use_amp', False)) for batch_idx, (data, target) in enumerate(self.train_loader): data, target = data.to(self.device), target.to(self.device) with torch.cuda.amp.autocast(enabled=self.config.get('use_amp', False)): output = self.model(data) loss = self.criterion(output, target) scaler.scale(loss).backward() scaler.step(self.optimizer) scaler.update() self.optimizer.zero_grad()

注意autocast和GradScaler的enabled参数完全由config.yaml控制。这意味着：当你在config.yaml里把use_amp: false改成true，框架自动启用FP16训练，无需修改任何训练逻辑。实测在RTX 3090上，ViT-Base训练速度提升1.8倍，显存占用降低35%，且精度无损（<0.1% drop）。

第二，梯度裁剪的智能阈值

if self.config.get('grad_clip', 0) > 0: torch.nn.utils.clip_grad_norm_( self.model.parameters(), max_norm=self.config['grad_clip'], norm_type=2.0 )

这里的grad_clip不是固定值。在医疗影像项目中，我们设为1.0（防止梯度爆炸）；在工业质检项目中，因图像噪声大，设为5.0（允许更大梯度更新）。这个参数直接写在配置里，比在代码里硬编码clip_grad_norm_(model.parameters(), 1.0)灵活得多。

第三，检查点保存的原子性保障

def save_checkpoint(self, epoch: int, is_best: bool = False): state = { 'epoch': epoch, 'model_state_dict': self.model.state_dict(), 'optimizer_state_dict': self.optimizer.state_dict(), 'scheduler_state_dict': self.scheduler.state_dict() if self.scheduler else None, 'best_acc': self.best_acc, 'config': self.config } # 先写临时文件，再原子性rename，避免训练中断时保存损坏的ckpt tmp_path = f"{self.checkpoint_dir}/checkpoint_tmp.pth" torch.save(state, tmp_path) os.replace(tmp_path, f"{self.checkpoint_dir}/checkpoint_last.pth") if is_best: os.replace(tmp_path, f"{self.checkpoint_dir}/checkpoint_best.pth")

这个os.replace()调用是Linux/Unix系统下的原子操作，确保即使训练进程被kill -9强制终止，也不会留下半截损坏的.pth文件。我们在某次服务器断电事故中验证过：checkpoint_last.pth完好无损，恢复训练零损失。

3.4 推理与评估：为什么evaluate.py比训练脚本还复杂

很多人以为训练完就结束了，其实推理才是落地瓶颈。框架的评估模块（eval/evaluator.py）专门处理三类真实场景：

场景一：单图推理的低延迟要求

class SingleImageInference: def __init__(self, config_path: str, checkpoint_path: str): self.config = load_config(config_path) self.model = build_model(self.config) self.model.load_state_dict(torch.load(checkpoint_path)['model_state_dict']) self.model.eval() # 预热GPU，避免首次推理延迟高 dummy_input = torch.randn(1, 3, 224, 224).to('cuda') with torch.no_grad(): _ = self.model(dummy_input) def predict(self, image_path: str) -> Dict[str, float]: img = load_and_preprocess(image_path, self.config) # 复用数据模块 img_tensor = torch.from_numpy(img).unsqueeze(0).to('cuda') with torch.no_grad(): logits = self.model(img_tensor) probs = torch.nn.functional.softmax(logits, dim=1)[0] return {f'class_{i}': float(p) for i, p in enumerate(probs)}

这个类的关键是dummy_input预热——实测在Jetson AGX Orin上，首次推理耗时120ms，预热后稳定在23ms，满足实时检测需求。

场景二：大规模数据集的内存友好评估

def evaluate_large_dataset(model, dataloader, device, batch_size=32): all_preds, all_targets = [], [] # 分块处理，避免一次性加载所有预测结果到内存 for batch_idx, (data, target) in enumerate(dataloader): data, target = data.to(device), target.to(device) with torch.no_grad(): output = model(data) pred = output.argmax(dim=1) all_preds.append(pred.cpu().numpy()) all_targets.append(target.cpu().numpy()) # 每100个batch计算一次中间指标，释放内存 if (batch_idx + 1) % 100 == 0: preds_chunk = np.concatenate(all_preds) targets_chunk = np.concatenate(all_targets) acc = accuracy_score(targets_chunk, preds_chunk) print(f"Batch {batch_idx+1}: Acc={acc:.4f}") # 清空列表，只保留当前chunk all_preds, all_targets = [], []

当评估10万张卫星图时，这个分块策略把峰值内存从48GB压到6.2GB，且不影响最终指标计算。

场景三：细粒度错误分析

def generate_error_report(model, dataloader, class_names: List[str], output_dir: str): misclassified = defaultdict(list) for data, target in dataloader: data, target = data.to('cuda'), target.to('cuda') with torch.no_grad(): output = model(data) pred = output.argmax(dim=1) for i, (p, t) in enumerate(zip(pred, target)): if p != t: # 记录错误样本路径、预测置信度、真实标签 misclassified[f'{class_names[t.item()]}_to_{class_names[p.item()]}'].append({ 'path': dataloader.dataset.samples[i][0], 'confidence': float(torch.nn.functional.softmax(output[i], dim=0)[p].item()), 'pred_prob': float(output[i][p].item()) }) # 生成HTML报告，支持点击查看原图 render_error_html(misclassified, output_dir)

这个报告直接输出error_report.html，里面按“把肺癌误判为肺炎”、“把裂纹误判为划痕”等错误类型分组，每组展示TOP5最难样本及模型置信度——这是算法迭代最需要的输入。

4. 实战全流程：从零开始跑通一个工业缺陷分类项目

4.1 环境准备与依赖安装：为什么推荐conda而非pip

虽然PyTorch官网推荐pip install torch，但在工业场景中，我们坚持用conda，原因有三：

1. CUDA版本强绑定：conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia会自动安装匹配的cudnn和cuda-toolkit，避免pip安装后出现CUDA error: no kernel image is available for execution on the device；
2. 环境隔离彻底：conda create -n defect-classify python=3.9创建的环境，pip list里看不到任何全局包，杜绝sklearn版本冲突；
3. 二进制包优化：conda-forge的opencv编译时启用了Intel IPP和OpenVINO加速，图像预处理比pip版快2.3倍。

安装命令（实测通过）：

# 创建环境 conda create -n defect-classify python=3.9 conda activate defect-classify # 安装PyTorch（以CUDA 11.8为例） conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia # 安装框架依赖 pip install timm scikit-learn tensorboard pyyaml opencv-python-headless # 注意：opencv-python-headless 无GUI依赖，适合服务器部署

注意：如果服务器没有NVIDIA驱动，或只有CPU，把pytorch-cuda=11.8换成cpuonly，框架会自动降级到CPU模式，所有代码零修改。

4.2 数据准备：工业缺陷图的特殊处理流程

假设你的数据集结构如下：

data/defects/ ├── train/ │ ├── crack/ # 裂纹 │ │ ├── 001.jpg │ │ └── 002.jpg │ ├── scratch/ # 划痕 │ └── normal/ # 正常 ├── val/ └── test/

框架要求你写一个data/defects_dataset.py：

from .base_dataset import BaseDataset class DefectsDataset(BaseDataset): def __init__(self, root: str, split: str = 'train', **kwargs): super().__init__(root, split, **kwargs) # 工业图常有严重光照不均，加CLAHE增强 if split == 'train': self.transform = transforms.Compose([ transforms.Resize((256, 256)), transforms.RandomHorizontalFlip(p=0.5), transforms.RandomRotation(degrees=15), # 关键：CLAHE专治金属反光 transforms.Lambda(lambda x: self.clahe_enhance(x)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) def clahe_enhance(self, img: Image.Image) -> Image.Image: # 转灰度做CLAHE，再转回RGB保持通道数 gray = img.convert('L') clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8)) enhanced = clahe.apply(np.array(gray)) return Image.fromarray(enhanced).convert('RGB')

这个clahe_enhance方法是工业质检的灵魂。实测在某汽车零部件表面检测中，加入CLAHE后，微小裂纹的检出率从68%提升到89%——因为原始图像在强光下，裂纹区域像素值被压缩在[240, 245]窄区间，CLAHE把它拉伸到[0, 255]，模型才看得清。

4.3 配置编写：一份完整的config.yaml实战解读

# config_defects.yaml include: ["base.yaml"] # 数据配置 data: root: "./data/defects" train_split: "train" val_split: "val" test_split: "test" resize: [256, 256] # 工业图不需要大尺寸 batch_size: 64 num_workers: 8 augment: - "random_horizontal_flip" - "random_rotation" - "clahe" # 框架内置的CLAHE增强 # 模型配置 model: name: "convnext_tiny" # 选tiny因工业图纹理简单，large易过拟合 pretrained: true num_classes: 3 # crack, scratch, normal # 训练配置 train: epochs: 100 lr: 1e-4 weight_decay: 1e-5 use_amp: true # 必开！工业图分辨率高，AMP收益大 grad_clip: 5.0 # 允许更大梯度，适应噪声数据 scheduler: name: "cosine" # 余弦退火，比StepLR更适合小数据集 T_max: 100 # 日志与检查点 logging: tensorboard_dir: "./logs/defects" checkpoint_dir: "./checkpoints/defects" save_freq: 10 # 每10个epoch存一次

这份配置的关键点：

• augment: ["clahe"]直接启用CLAHE，无需写代码；
• scheduler.name: "cosine"让学习率从1e-4平滑降到1e-6，避免后期震荡；
• save_freq: 10确保即使训练中断，最多损失10个epoch，而非全部重来。

4.4 模型训练与监控：如何读懂TensorBoard里的关键曲线

运行训练：

python train.py --config config_defects.yaml

启动TensorBoard：

tensorboard --logdir=./logs/defects --bind_all

重点关注三个曲线：

Loss曲线：

• 理想状态：训练loss（蓝色）和验证loss（橙色）同步下降，且验证loss始终略高于训练loss（gap < 0.1）；
• 危险信号：验证loss在第30epoch后开始上升，而训练loss继续下降——这是过拟合，需立即启用早停（在config.yaml加early_stopping: {patience: 10}）；
• 异常信号：训练loss在0.01附近剧烈抖动（±0.05），说明batch_size太小或lr太大，应调小lr或增大batch_size。

Accuracy曲线：

• 工业质检的精度常卡在92%~95%，此时看precision和recall更重要：
  • 若crack类precision=98%但recall=75%，说明模型不敢预测裂纹（保守），需降低threshold或加focal_loss；
  • 若scratch类recall=96%但precision=62%，说明模型乱标划痕，需检查数据标注质量或增强grid_mask。

GPU Util曲线：

• 健康状态：GPU利用率稳定在85%~95%；
• 瓶颈信号：利用率长期<50%，说明DataLoader拖慢了训练，应增大num_workers或启用pin_memory: true（框架已默认开启）。

实操心得：我们在某次训练中发现GPU利用率仅30%，排查后发现是num_workers=4不够，调到8后利用率升至92%，单epoch耗时从42秒降到23秒——这比调参带来的收益更实在。

4.5 模型部署：如何把.pth变成可调用的API服务

训练完的checkpoint_best.pth不能直接用，需导出为torchscript或ONNX。框架提供一键导出脚本：

python export.py --config config_defects.yaml \ --checkpoint ./checkpoints/defects/checkpoint_best.pth \ --export_format onnx \ --input_shape "[1,3,256,256]"

生成model.onnx后，用ONNX Runtime部署：

import onnxruntime as ort import numpy as np # 加载ONNX模型 session = ort.InferenceSession("model.onnx", providers=['CUDAExecutionProvider']) # 预处理（复用框架的transform） def preprocess(image_path: str) -> np.ndarray: img = Image.open(image_path).convert('RGB').resize((256, 256)) img = np.array(img).transpose(2, 0, 1) # HWC -> CHW img = img.astype(np.float32) / 255.0 img = (img - [0.485, 0.456, 0.406]) / [0.229, 0.224, 0.225] return img[np.newaxis, ...] # add batch dim # 推理 input_data = preprocess("test_crack.jpg") outputs = session.run(None, {"input": input_data}) probs = softmax(outputs[0][0]) # outputs[0] is logits print(f"Crack prob: {probs[0]:.4f}, Scratch prob: {probs[1]:.4f}, Normal prob: {probs[2]:.4f}")

这个ONNX模型在T4 GPU上，单图推理耗时仅17ms，QPS达58，满足产线实时检测需求。关键点：providers=['CUDAExecutionProvider']确保用GPU加速，比CPU快23倍。

5. 常见问题与避坑指南：那些文档里不会写的血泪教训

5.1 数据加载卡死？90%是num_workers和共享内存的锅

现象：DataLoader启动后，GPU显存没占满，CPU使用率100%，程序卡住不动。

根本原因：Linux系统默认/dev/shm（共享内存）只有64MB，而num_workers>0时，每个worker进程需独立拷贝数据到/dev/shm。一张256×256×3的图，float32格式占786KB，num_workers=8时，理论需6.3MB，但实际因缓冲区碎片，常超限。

解决方案：

1. 临时扩容（重启失效）：

   sudo mount -o remount,size=2G /dev/shm

2. 永久扩容（写入/etc/fstab）：

   echo "none /dev/shm tmpfs defaults,size=2G 0 0" | sudo tee -a /etc/fstab sudo mount -o remount /dev/shm

3. 框架内优雅降级：在config.yaml中加

   data: num_workers: 0 # Windows/macOS必须设0，Linux可设4~8 pin_memory: true # 加速GPU数据传输

实测：某次在Docker容器中训练，/dev/shm默认64MB，num_workers=4必卡死；扩容到1G后，num_workers=8稳定运行，训练速度提升40%。

5.2 模型不收敛？先检查这三个隐藏开关

新手常以为不收敛是模型或数据问题，其实80%是配置陷阱：

特别提醒：torchvision.models.resnet50(pretrained=False)会用kaiming_normal初始化，但工业缺陷图纹理与ImageNet差异大，务必设pretrained: true。我们在某项目中对比：pretrained=False时，50个epoch后Acc=41%；pretrained=True时，同样50个epoch，Acc=89%。

5.3 多卡训练报错Expected all tensors to be on the same device？分布式训练的设备陷阱

现象：用python -m torch.distributed.launch --nproc_per_node=2 train.py启动，报错Expected all tensors to be on the same device。

根源：框架默认把模型放到cuda:0，但DistributedDataParallel要求模型在cuda:local_rank。

修复方案：在train.py入口