[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7322NQFCPHXVVVZYSNDRASB":3,"skill-same:01M7322NQFCPHXVVVZYSNDRASB":48},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":25,"commitSha":26,"skillDirectory":27,"forksCount":28,"repositoryHtmlUrl":29,"repositoryHomepageUrl":6,"ownerHtmlUrl":30,"ownerBlogUrl":31,"ownerDescription":32,"updatedAt":33,"install":34,"resources":47},"01M7322NQFCPHXVVVZYSNDRASB","pytorch-patterns",null,"PyTorch深度学习模式与最佳实践，用于构建稳健、高效且可复现的训练流程、模型架构和数据加载。","SriramGandhiS\u002FSkills","SriramGandhiS","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F211849986?v=4","01M72WQCW12BYX71C6WN584TTA","Sriram S","01M72WQCWTJ2RD0ET1X31AF1RC",1,"MIT","https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills\u002Fblob\u002Fmaster\u002Fweb-assets\u002Fdocs\u002Fzh-CN\u002Fskills\u002Fpytorch-patterns\u002FSKILL.md",[],[],"2026-11-11 15:11:14",false,"---\nname: pytorch-patterns\ndescription: PyTorch深度学习模式与最佳实践，用于构建稳健、高效且可复现的训练流程、模型架构和数据加载。\norigin: ECC\n---\n\n# PyTorch 开发模式\n\n构建稳健、高效和可复现深度学习应用的 PyTorch 惯用模式与最佳实践。\n\n## 何时使用\n\n* 编写新的 PyTorch 模型或训练脚本时\n* 评审深度学习代码时\n* 调试训练循环或数据管道时\n* 优化 GPU 内存使用或训练速度时\n* 设置可复现实验时\n\n## 核心原则\n\n### 1. 设备无关代码\n\n始终编写能在 CPU 和 GPU 上运行且不硬编码设备的代码。\n\n```python\n## Good: Device-agnostic\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nmodel = MyModel().to(device)\ndata = data.to(device)\n\n## Bad: Hardcoded device\nmodel = MyModel().cuda()  # Crashes if no GPU\ndata = data.cuda()\n```\n\n### 2. 可复现性优先\n\n设置所有随机种子以获得可复现的结果。\n\n```python\n## Good: Full reproducibility setup\ndef set_seed(seed: int = 42) -> None:\n    torch.manual_seed(seed)\n    torch.cuda.manual_seed_all(seed)\n    np.random.seed(seed)\n    random.seed(seed)\n    torch.backends.cudnn.deterministic = True\n    torch.backends.cudnn.benchmark = False\n\n## Bad: No seed control\nmodel = MyModel()  # Different weights every run\n```\n\n### 3. 显式形状管理\n\n始终记录并验证张量形状。\n\n```python\n## Good: Shape-annotated forward pass\ndef forward(self, x: torch.Tensor) -> torch.Tensor:\n    # x: (batch_size, channels, height, width)\n    x = self.conv1(x)    # -> (batch_size, 32, H, W)\n    x = self.pool(x)     # -> (batch_size, 32, H\u002F\u002F2, W\u002F\u002F2)\n    x = x.view(x.size(0), -1)  # -> (batch_size, 32*H\u002F\u002F2*W\u002F\u002F2)\n    return self.fc(x)    # -> (batch_size, num_classes)\n\n## Bad: No shape tracking\ndef forward(self, x):\n    x = self.conv1(x)\n    x = self.pool(x)\n    x = x.view(x.size(0), -1)  # What size is this?\n    return self.fc(x)           # Will this even work?\n```\n\n## 模型架构模式\n\n### 清晰的 nn.Module 结构\n\n```python\n## Good: Well-organized module\nclass ImageClassifier(nn.Module):\n    def __init__(self, num_classes: int, dropout: float = 0.5) -> None:\n        super().__init__()\n        self.features = nn.Sequential(\n            nn.Conv2d(3, 64, kernel_size=3, padding=1),\n            nn.BatchNorm2d(64),\n            nn.ReLU(inplace=True),\n            nn.MaxPool2d(2),\n        )\n        self.classifier = nn.Sequential(\n            nn.Dropout(dropout),\n            nn.Linear(64 * 16 * 16, num_classes),\n        )\n\n    def forward(self, x: torch.Tensor) -> torch.Tensor:\n        x = self.features(x)\n        x = x.view(x.size(0), -1)\n        return self.classifier(x)\n\n## Bad: Everything in forward\nclass ImageClassifier(nn.Module):\n    def __init__(self):\n        super().__init__()\n\n    def forward(self, x):\n        x = F.conv2d(x, weight=self.make_weight())  # Creates weight each call!\n        return x\n```\n\n### 正确的权重初始化\n\n```python\n## Good: Explicit initialization\ndef _init_weights(self, module: nn.Module) -> None:\n    if isinstance(module, nn.Linear):\n        nn.init.kaiming_normal_(module.weight, mode=\"fan_out\", nonlinearity=\"relu\")\n        if module.bias is not None:\n            nn.init.zeros_(module.bias)\n    elif isinstance(module, nn.Conv2d):\n        nn.init.kaiming_normal_(module.weight, mode=\"fan_out\", nonlinearity=\"relu\")\n    elif isinstance(module, nn.BatchNorm2d):\n        nn.init.ones_(module.weight)\n        nn.init.zeros_(module.bias)\n\nmodel = MyModel()\nmodel.apply(model._init_weights)\n```\n\n## 训练循环模式\n\n### 标准训练循环\n\n```python\n## Good: Complete training loop with best practices\ndef train_one_epoch(\n    model: nn.Module,\n    dataloader: DataLoader,\n    optimizer: torch.optim.Optimizer,\n    criterion: nn.Module,\n    device: torch.device,\n    scaler: torch.amp.GradScaler | None = None,\n) -> float:\n    model.train()  # Always set train mode\n    total_loss = 0.0\n\n    for batch_idx, (data, target) in enumerate(dataloader):\n        data, target = data.to(device), target.to(device)\n\n        optimizer.zero_grad(set_to_none=True)  # More efficient than zero_grad()\n\n        # Mixed precision training\n        with torch.amp.autocast(\"cuda\", enabled=scaler is not None):\n            output = model(data)\n            loss = criterion(output, target)\n\n        if scaler is not None:\n            scaler.scale(loss).backward()\n            scaler.unscale_(optimizer)\n            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n            scaler.step(optimizer)\n            scaler.update()\n        else:\n            loss.backward()\n            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n            optimizer.step()\n\n        total_loss += loss.item()\n\n    return total_loss \u002F len(dataloader)\n```\n\n### 验证循环\n\n```python\n## Good: Proper evaluation\n@torch.no_grad()  # More efficient than wrapping in torch.no_grad() block\ndef evaluate(\n    model: nn.Module,\n    dataloader: DataLoader,\n    criterion: nn.Module,\n    device: torch.device,\n) -> tuple[float, float]:\n    model.eval()  # Always set eval mode — disables dropout, uses running BN stats\n    total_loss = 0.0\n    correct = 0\n    total = 0\n\n    for data, target in dataloader:\n        data, target = data.to(device), target.to(device)\n        output = model(data)\n        total_loss += criterion(output, target).item()\n        correct += (output.argmax(1) == target).sum().item()\n        total += target.size(0)\n\n    return total_loss \u002F len(dataloader), correct \u002F total\n```\n\n## 数据管道模式\n\n### 自定义数据集\n\n```python\n## Good: Clean Dataset with type hints\nclass ImageDataset(Dataset):\n    def __init__(\n        self,\n        image_dir: str,\n        labels: dict[str, int],\n        transform: transforms.Compose | None = None,\n    ) -> None:\n        self.image_paths = list(Path(image_dir).glob(\"*.jpg\"))\n        self.labels = labels\n        self.transform = transform\n\n    def __len__(self) -> int:\n        return len(self.image_paths)\n\n    def __getitem__(self, idx: int) -> tuple[torch.Tensor, int]:\n        img = Image.open(self.image_paths[idx]).convert(\"RGB\")\n        label = self.labels[self.image_paths[idx].stem]\n\n        if self.transform:\n            img = self.transform(img)\n\n        return img, label\n```\n\n### 高效的数据加载器配置\n\n```python\n## Good: Optimized DataLoader\ndataloader = DataLoader(\n    dataset,\n    batch_size=32,\n    shuffle=True,            # Shuffle for training\n    num_workers=4,           # Parallel data loading\n    pin_memory=True,         # Faster CPU->GPU transfer\n    persistent_workers=True, # Keep workers alive between epochs\n    drop_last=True,          # Consistent batch sizes for BatchNorm\n)\n\n## Bad: Slow defaults\ndataloader = DataLoader(dataset, batch_size=32)  # num_workers=0, no pin_memory\n```\n\n### 针对变长数据的自定义整理函数\n\n```python\n## Good: Pad sequences in collate_fn\ndef collate_fn(batch: list[tuple[torch.Tensor, int]]) -> tuple[torch.Tensor, torch.Tensor]:\n    sequences, labels = zip(*batch)\n    # Pad to max length in batch\n    padded = nn.utils.rnn.pad_sequence(sequences, batch_first=True, padding_value=0)\n    return padded, torch.tensor(labels)\n\ndataloader = DataLoader(dataset, batch_size=32, collate_fn=collate_fn)\n```\n\n## 检查点模式\n\n### 保存和加载检查点\n\n```python\n## Good: Complete checkpoint with all training state\ndef save_checkpoint(\n    model: nn.Module,\n    optimizer: torch.optim.Optimizer,\n    epoch: int,\n    loss: float,\n    path: str,\n) -> None:\n    torch.save({\n        \"epoch\": epoch,\n        \"model_state_dict\": model.state_dict(),\n        \"optimizer_state_dict\": optimizer.state_dict(),\n        \"loss\": loss,\n    }, path)\n\ndef load_checkpoint(\n    path: str,\n    model: nn.Module,\n    optimizer: torch.optim.Optimizer | None = None,\n) -> dict:\n    checkpoint = torch.load(path, map_location=\"cpu\", weights_only=True)\n    model.load_state_dict(checkpoint[\"model_state_dict\"])\n    if optimizer:\n        optimizer.load_state_dict(checkpoint[\"optimizer_state_dict\"])\n    return checkpoint\n\n## Bad: Only saving model weights (can't resume training)\ntorch.save(model.state_dict(), \"model.pt\")\n```\n\n## 性能优化\n\n### 混合精度训练\n\n```python\n## Good: AMP with GradScaler\nscaler = torch.amp.GradScaler(\"cuda\")\nfor data, target in dataloader:\n    with torch.amp.autocast(\"cuda\"):\n        output = model(data)\n        loss = criterion(output, target)\n    scaler.scale(loss).backward()\n    scaler.step(optimizer)\n    scaler.update()\n    optimizer.zero_grad(set_to_none=True)\n```\n\n### 大模型的梯度检查点\n\n```python\n## Good: Trade compute for memory\nfrom torch.utils.checkpoint import checkpoint\n\nclass LargeModel(nn.Module):\n    def forward(self, x: torch.Tensor) -> torch.Tensor:\n        # Recompute activations during backward to save memory\n        x = checkpoint(self.block1, x, use_reentrant=False)\n        x = checkpoint(self.block2, x, use_reentrant=False)\n        return self.head(x)\n```\n\n### 使用 torch.compile 加速\n\n```python\n## Good: Compile the model for faster execution (PyTorch 2.0+)\nmodel = MyModel().to(device)\nmodel = torch.compile(model, mode=\"reduce-overhead\")\n\n## Modes: \"default\" (safe), \"reduce-overhead\" (faster), \"max-autotune\" (fastest)\n```\n\n## 快速参考：PyTorch 惯用法\n\n| 惯用法 | 描述 |\n|-------|-------------|\n| `model.train()`\u002F`model.eval()` | 训练\u002F评估前始终设置模式 |\n| `torch.no_grad()` | 推理时禁用梯度 |\n| `optimizer.zero_grad(set_to_none=True)` | 更高效的梯度清零 |\n| `.to(device)` | 设备无关的张量\u002F模型放置 |\n| `torch.amp.autocast` | 混合精度以获得 2 倍速度 |\n| `pin_memory=True` | 更快的 CPU→GPU 数据传输 |\n| `torch.compile` | JIT 编译加速 (2.0+) |\n| `weights_only=True` | 安全的模型加载 |\n| `torch.manual_seed` | 可复现的实验 |\n| `gradient_checkpointing` | 以计算换取内存 |\n\n## 应避免的反模式\n\n```python\n## Bad: Forgetting model.eval() during validation\nmodel.train()\nwith torch.no_grad():\n    output = model(val_data)  # Dropout still active! BatchNorm uses batch stats!\n\n## Good: Always set eval mode\nmodel.eval()\nwith torch.no_grad():\n    output = model(val_data)\n\n## Bad: In-place operations breaking autograd\nx = F.relu(x, inplace=True)  # Can break gradient computation\nx += residual                  # In-place add breaks autograd graph\n\n## Good: Out-of-place operations\nx = F.relu(x)\nx = x + residual\n\n## Bad: Moving data to GPU inside the training loop repeatedly\nfor data, target in dataloader:\n    model = model.cuda()  # Moves model EVERY iteration!\n\n## Good: Move model once before the loop\nmodel = model.to(device)\nfor data, target in dataloader:\n    data, target = data.to(device), target.to(device)\n\n## Bad: Using .item() before backward\nloss = criterion(output, target).item()  # Detaches from graph!\nloss.backward()  # Error: can't backprop through .item()\n\n## Good: Call .item() only for logging\nloss = criterion(output, target)\nloss.backward()\nprint(f\"Loss: {loss.item():.4f}\")  # .item() after backward is fine\n\n## Bad: Not using torch.save properly\ntorch.save(model, \"model.pt\")  # Saves entire model (fragile, not portable)\n\n## Good: Save state_dict\ntorch.save(model.state_dict(), \"model.pt\")\n```\n\n**请记住**：PyTorch 代码应做到设备无关、可复现且内存意识强。如有疑问，请使用 `torch.profiler`进行分析，并使用`torch.cuda.memory_summary()` 检查 GPU 内存。\n","# PyTorch 开发模式\n\n构建稳健、高效和可复现深度学习应用的 PyTorch 惯用模式与最佳实践。\n\n## 何时使用\n\n* 编写新的 PyTorch 模型或训练脚本时\n* 评审深度学习代码时\n* 调试训练循环或数据管道时\n* 优化 GPU 内存使用或训练速度时\n* 设置可复现实验时\n\n## 核心原则\n\n### 1. 设备无关代码\n\n始终编写能在 CPU 和 GPU 上运行且不硬编码设备的代码。\n\n```python\n## Good: Device-agnostic\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nmodel = MyModel().to(device)\ndata = data.to(device)\n\n## Bad: Hardcoded device\nmodel = MyModel().cuda()  # Crashes if no GPU\ndata = data.cuda()\n```\n\n### 2. 可复现性优先\n\n设置所有随机种子以获得可复现的结果。\n\n```python\n## Good: Full reproducibility setup\ndef set_seed(seed: int = 42) -> None:\n    torch.manual_seed(seed)\n    torch.cuda.manual_seed_all(seed)\n    np.random.seed(seed)\n    random.seed(seed)\n    torch.backends.cudnn.deterministic = True\n    torch.backends.cudnn.benchmark = False\n\n## Bad: No seed control\nmodel = MyModel()  # Different weights every run\n```\n\n### 3. 显式形状管理\n\n始终记录并验证张量形状。\n\n```python\n## Good: Shape-annotated forward pass\ndef forward(self, x: torch.Tensor) -> torch.Tensor:\n    # x: (batch_size, channels, height, width)\n    x = self.conv1(x)    # -> (batch_size, 32, H, W)\n    x = self.pool(x)     # -> (batch_size, 32, H\u002F\u002F2, W\u002F\u002F2)\n    x = x.view(x.size(0), -1)  # -> (batch_size, 32*H\u002F\u002F2*W\u002F\u002F2)\n    return self.fc(x)    # -> (batch_size, num_classes)\n\n## Bad: No shape tracking\ndef forward(self, x):\n    x = self.conv1(x)\n    x = self.pool(x)\n    x = x.view(x.size(0), -1)  # What size is this?\n    return self.fc(x)           # Will this even work?\n```\n\n## 模型架构模式\n\n### 清晰的 nn.Module 结构\n\n```python\n## Good: Well-organized module\nclass ImageClassifier(nn.Module):\n    def __init__(self, num_classes: int, dropout: float = 0.5) -> None:\n        super().__init__()\n        self.features = nn.Sequential(\n            nn.Conv2d(3, 64, kernel_size=3, padding=1),\n            nn.BatchNorm2d(64),\n            nn.ReLU(inplace=True),\n            nn.MaxPool2d(2),\n        )\n        self.classifier = nn.Sequential(\n            nn.Dropout(dropout),\n            nn.Linear(64 * 16 * 16, num_classes),\n        )\n\n    def forward(self, x: torch.Tensor) -> torch.Tensor:\n        x = self.features(x)\n        x = x.view(x.size(0), -1)\n        return self.classifier(x)\n\n## Bad: Everything in forward\nclass ImageClassifier(nn.Module):\n    def __init__(self):\n        super().__init__()\n\n    def forward(self, x):\n        x = F.conv2d(x, weight=self.make_weight())  # Creates weight each call!\n        return x\n```\n\n### 正确的权重初始化\n\n```python\n## Good: Explicit initialization\ndef _init_weights(self, module: nn.Module) -> None:\n    if isinstance(module, nn.Linear):\n        nn.init.kaiming_normal_(module.weight, mode=\"fan_out\", nonlinearity=\"relu\")\n        if module.bias is not None:\n            nn.init.zeros_(module.bias)\n    elif isinstance(module, nn.Conv2d):\n        nn.init.kaiming_normal_(module.weight, mode=\"fan_out\", nonlinearity=\"relu\")\n    elif isinstance(module, nn.BatchNorm2d):\n        nn.init.ones_(module.weight)\n        nn.init.zeros_(module.bias)\n\nmodel = MyModel()\nmodel.apply(model._init_weights)\n```\n\n## 训练循环模式\n\n### 标准训练循环\n\n```python\n## Good: Complete training loop with best practices\ndef train_one_epoch(\n    model: nn.Module,\n    dataloader: DataLoader,\n    optimizer: torch.optim.Optimizer,\n    criterion: nn.Module,\n    device: torch.device,\n    scaler: torch.amp.GradScaler | None = None,\n) -> float:\n    model.train()  # Always set train mode\n    total_loss = 0.0\n\n    for batch_idx, (data, target) in enumerate(dataloader):\n        data, target = data.to(device), target.to(device)\n\n        optimizer.zero_grad(set_to_none=True)  # More efficient than zero_grad()\n\n        # Mixed precision training\n        with torch.amp.autocast(\"cuda\", enabled=scaler is not None):\n            output = model(data)\n            loss = criterion(output, target)\n\n        if scaler is not None:\n            scaler.scale(loss).backward()\n            scaler.unscale_(optimizer)\n            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n            scaler.step(optimizer)\n            scaler.update()\n        else:\n            loss.backward()\n            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n            optimizer.step()\n\n        total_loss += loss.item()\n\n    return total_loss \u002F len(dataloader)\n```\n\n### 验证循环\n\n```python\n## Good: Proper evaluation\n@torch.no_grad()  # More efficient than wrapping in torch.no_grad() block\ndef evaluate(\n    model: nn.Module,\n    dataloader: DataLoader,\n    criterion: nn.Module,\n    device: torch.device,\n) -> tuple[float, float]:\n    model.eval()  # Always set eval mode — disables dropout, uses running BN stats\n    total_loss = 0.0\n    correct = 0\n    total = 0\n\n    for data, target in dataloader:\n        data, target = data.to(device), target.to(device)\n        output = model(data)\n        total_loss += criterion(output, target).item()\n        correct += (output.argmax(1) == target).sum().item()\n        total += target.size(0)\n\n    return total_loss \u002F len(dataloader), correct \u002F total\n```\n\n## 数据管道模式\n\n### 自定义数据集\n\n```python\n## Good: Clean Dataset with type hints\nclass ImageDataset(Dataset):\n    def __init__(\n        self,\n        image_dir: str,\n        labels: dict[str, int],\n        transform: transforms.Compose | None = None,\n    ) -> None:\n        self.image_paths = list(Path(image_dir).glob(\"*.jpg\"))\n        self.labels = labels\n        self.transform = transform\n\n    def __len__(self) -> int:\n        return len(self.image_paths)\n\n    def __getitem__(self, idx: int) -> tuple[torch.Tensor, int]:\n        img = Image.open(self.image_paths[idx]).convert(\"RGB\")\n        label = self.labels[self.image_paths[idx].stem]\n\n        if self.transform:\n            img = self.transform(img)\n\n        return img, label\n```\n\n### 高效的数据加载器配置\n\n```python\n## Good: Optimized DataLoader\ndataloader = DataLoader(\n    dataset,\n    batch_size=32,\n    shuffle=True,            # Shuffle for training\n    num_workers=4,           # Parallel data loading\n    pin_memory=True,         # Faster CPU->GPU transfer\n    persistent_workers=True, # Keep workers alive between epochs\n    drop_last=True,          # Consistent batch sizes for BatchNorm\n)\n\n## Bad: Slow defaults\ndataloader = DataLoader(dataset, batch_size=32)  # num_workers=0, no pin_memory\n```\n\n### 针对变长数据的自定义整理函数\n\n```python\n## Good: Pad sequences in collate_fn\ndef collate_fn(batch: list[tuple[torch.Tensor, int]]) -> tuple[torch.Tensor, torch.Tensor]:\n    sequences, labels = zip(*batch)\n    # Pad to max length in batch\n    padded = nn.utils.rnn.pad_sequence(sequences, batch_first=True, padding_value=0)\n    return padded, torch.tensor(labels)\n\ndataloader = DataLoader(dataset, batch_size=32, collate_fn=collate_fn)\n```\n\n## 检查点模式\n\n### 保存和加载检查点\n\n```python\n## Good: Complete checkpoint with all training state\ndef save_checkpoint(\n    model: nn.Module,\n    optimizer: torch.optim.Optimizer,\n    epoch: int,\n    loss: float,\n    path: str,\n) -> None:\n    torch.save({\n        \"epoch\": epoch,\n        \"model_state_dict\": model.state_dict(),\n        \"optimizer_state_dict\": optimizer.state_dict(),\n        \"loss\": loss,\n    }, path)\n\ndef load_checkpoint(\n    path: str,\n    model: nn.Module,\n    optimizer: torch.optim.Optimizer | None = None,\n) -> dict:\n    checkpoint = torch.load(path, map_location=\"cpu\", weights_only=True)\n    model.load_state_dict(checkpoint[\"model_state_dict\"])\n    if optimizer:\n        optimizer.load_state_dict(checkpoint[\"optimizer_state_dict\"])\n    return checkpoint\n\n## Bad: Only saving model weights (can't resume training)\ntorch.save(model.state_dict(), \"model.pt\")\n```\n\n## 性能优化\n\n### 混合精度训练\n\n```python\n## Good: AMP with GradScaler\nscaler = torch.amp.GradScaler(\"cuda\")\nfor data, target in dataloader:\n    with torch.amp.autocast(\"cuda\"):\n        output = model(data)\n        loss = criterion(output, target)\n    scaler.scale(loss).backward()\n    scaler.step(optimizer)\n    scaler.update()\n    optimizer.zero_grad(set_to_none=True)\n```\n\n### 大模型的梯度检查点\n\n```python\n## Good: Trade compute for memory\nfrom torch.utils.checkpoint import checkpoint\n\nclass LargeModel(nn.Module):\n    def forward(self, x: torch.Tensor) -> torch.Tensor:\n        # Recompute activations during backward to save memory\n        x = checkpoint(self.block1, x, use_reentrant=False)\n        x = checkpoint(self.block2, x, use_reentrant=False)\n        return self.head(x)\n```\n\n### 使用 torch.compile 加速\n\n```python\n## Good: Compile the model for faster execution (PyTorch 2.0+)\nmodel = MyModel().to(device)\nmodel = torch.compile(model, mode=\"reduce-overhead\")\n\n## Modes: \"default\" (safe), \"reduce-overhead\" (faster), \"max-autotune\" (fastest)\n```\n\n## 快速参考：PyTorch 惯用法\n\n| 惯用法 | 描述 |\n|-------|-------------|\n| `model.train()`\u002F`model.eval()` | 训练\u002F评估前始终设置模式 |\n| `torch.no_grad()` | 推理时禁用梯度 |\n| `optimizer.zero_grad(set_to_none=True)` | 更高效的梯度清零 |\n| `.to(device)` | 设备无关的张量\u002F模型放置 |\n| `torch.amp.autocast` | 混合精度以获得 2 倍速度 |\n| `pin_memory=True` | 更快的 CPU→GPU 数据传输 |\n| `torch.compile` | JIT 编译加速 (2.0+) |\n| `weights_only=True` | 安全的模型加载 |\n| `torch.manual_seed` | 可复现的实验 |\n| `gradient_checkpointing` | 以计算换取内存 |\n\n## 应避免的反模式\n\n```python\n## Bad: Forgetting model.eval() during validation\nmodel.train()\nwith torch.no_grad():\n    output = model(val_data)  # Dropout still active! BatchNorm uses batch stats!\n\n## Good: Always set eval mode\nmodel.eval()\nwith torch.no_grad():\n    output = model(val_data)\n\n## Bad: In-place operations breaking autograd\nx = F.relu(x, inplace=True)  # Can break gradient computation\nx += residual                  # In-place add breaks autograd graph\n\n## Good: Out-of-place operations\nx = F.relu(x)\nx = x + residual\n\n## Bad: Moving data to GPU inside the training loop repeatedly\nfor data, target in dataloader:\n    model = model.cuda()  # Moves model EVERY iteration!\n\n## Good: Move model once before the loop\nmodel = model.to(device)\nfor data, target in dataloader:\n    data, target = data.to(device), target.to(device)\n\n## Bad: Using .item() before backward\nloss = criterion(output, target).item()  # Detaches from graph!\nloss.backward()  # Error: can't backprop through .item()\n\n## Good: Call .item() only for logging\nloss = criterion(output, target)\nloss.backward()\nprint(f\"Loss: {loss.item():.4f}\")  # .item() after backward is fine\n\n## Bad: Not using torch.save properly\ntorch.save(model, \"model.pt\")  # Saves entire model (fragile, not portable)\n\n## Good: Save state_dict\ntorch.save(model.state_dict(), \"model.pt\")\n```\n\n**请记住**：PyTorch 代码应做到设备无关、可复现且内存意识强。如有疑问，请使用 `torch.profiler`进行分析，并使用`torch.cuda.memory_summary()` 检查 GPU 内存。\n",{"name":5,"origin":24,"description":7},"ECC","master","d6ca01da0f24a3b0e26e4a8b7b66cbd25d429f5d","web-assets\u002Fdocs\u002Fzh-CN\u002Fskills\u002Fpytorch-patterns",0,"https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills","https:\u002F\u002Fgithub.com\u002FSriramGandhiS","https:\u002F\u002Fsriram.website\u002F","Curious guy who keeps tinkering until something works","2026-05-20 16:21:34",{"source":8,"skillName":5,"commands":35,"prompt":45,"zipAvailable":46},[36,39,42],{"tool":37,"command":38},"npx","npx skills add SriramGandhiS\u002FSkills --skill pytorch-patterns",{"tool":40,"command":41},"bunx","bunx skills add SriramGandhiS\u002FSkills --skill pytorch-patterns",{"tool":43,"command":44},"pnpm","pnpm dlx skills add SriramGandhiS\u002FSkills --skill pytorch-patterns","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills\u002Fblob\u002Fmaster\u002Fweb-assets\u002Fdocs\u002Fzh-CN\u002Fskills\u002Fpytorch-patterns\u002FSKILL.md",true,[],[49,56,61,67,74,81],{"skillNo":50,"name":51,"nameZh":6,"description":52,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":53,"categories":54,"keywords":55,"publishedAt":19},"01M732609EPJWV13PVTX3GT4TM","webgpu-threejs-tsl","Comprehensive guide for developing WebGPU-enabled Three.js applications using TSL (Three.js Shading Language). Covers WebGPU renderer setup, TSL syntax and node materials, compute shaders, post-processing effects, and WGSL integration. Use this skill when working with Three.js WebGPU, TSL shaders, node materials, or GPU compute in Three.js.","https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills\u002Fblob\u002Fmaster\u002Fwebgpu-threejs-tsl\u002Fskills\u002Fwebgpu-threejs-tsl\u002FSKILL.md",[],[],{"skillNo":57,"name":51,"nameZh":6,"description":52,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":58,"categories":59,"keywords":60,"publishedAt":19},"01M7325XM47AGWB6K6C4VXKE6B","https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills\u002Fblob\u002Fmaster\u002Fwebgpu-threejs-tsl\u002FSKILL.md",[],[],{"skillNo":62,"name":63,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":64,"categories":65,"keywords":66,"publishedAt":19},"01M7325WP6DES69JKC840VMFEP","verification-loop","https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills\u002Fblob\u002Fmaster\u002Fweb-assets\u002Fdocs\u002Fzh-TW\u002Fskills\u002Fverification-loop\u002FSKILL.md",[],[],{"skillNo":68,"name":69,"nameZh":6,"description":70,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":71,"categories":72,"keywords":73,"publishedAt":19},"01M7325TFQF1DZTQ6J3WGQQ1VR","tdd-workflow","Use this skill when writing new features, fixing bugs, or refactoring code. Enforces test-driven development with 80%+ coverage including unit, integration, and E2E tests.","https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills\u002Fblob\u002Fmaster\u002Fweb-assets\u002Fdocs\u002Fzh-TW\u002Fskills\u002Ftdd-workflow\u002FSKILL.md",[],[],{"skillNo":75,"name":76,"nameZh":6,"description":77,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":78,"categories":79,"keywords":80,"publishedAt":19},"01M7325RGV9AY9PK92D2V8KKPW","strategic-compact","Suggests manual context compaction at logical intervals to preserve context through task phases rather than arbitrary auto-compaction.","https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills\u002Fblob\u002Fmaster\u002Fweb-assets\u002Fdocs\u002Fzh-TW\u002Fskills\u002Fstrategic-compact\u002FSKILL.md",[],[],{"skillNo":82,"name":83,"nameZh":6,"description":84,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":85,"categories":86,"keywords":87,"publishedAt":19},"01M7325MZC28SE86E7NMCNEFS4","security-review","Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment\u002Fsensitive features. Provides comprehensive security checklist and patterns.","https:\u002F\u002Fgithub.com\u002FSriramGandhiS\u002FSkills\u002Fblob\u002Fmaster\u002Fweb-assets\u002Fdocs\u002Fzh-TW\u002Fskills\u002Fsecurity-review\u002FSKILL.md",[],[]]