[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7F3P8Z8MN78H0KACTBM12FT":3,"skill-same:01M7F3P8Z8MN78H0KACTBM12FT":47},{"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":6,"ownerDescription":31,"updatedAt":32,"install":33,"resources":46},"01M7F3P8Z8MN78H0KACTBM12FT","pytorch-patterns",null,"PyTorch deep learning patterns and best practices for building robust, efficient, and reproducible training pipelines, model architectures, and data loading.","lza6\u002FArmor-piercing-system-prompts","lza6","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F128880206?v=4","01M7EB3K7WPX5T28EJ2NVHE6EG","Chinese-tingfeng","01M7EB3K97E1KQ16QWKJMFNGX8",11,"MIT","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F05-技能与代理开发\u002Fpytorch-patterns\u002FSKILL.md",[],[],"2026-11-16 10:05:34",false,"---\nname: pytorch-patterns\ndescription: PyTorch deep learning patterns and best practices for building robust, efficient, and reproducible training pipelines, model architectures, and data loading.\norigin: ECC\n---\n\n# PyTorch Development Patterns\n\nIdiomatic PyTorch patterns and best practices for building robust, efficient, and reproducible deep learning applications.\n\n## When to Activate\n\n- Writing new PyTorch models or training scripts\n- Reviewing deep learning code\n- Debugging training loops or data pipelines\n- Optimizing GPU memory usage or training speed\n- Setting up reproducible experiments\n\n## Core Principles\n\n### 1. Device-Agnostic Code\n\nAlways write code that works on both CPU and GPU without hardcoding devices.\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. Reproducibility First\n\nSet all random seeds for reproducible results.\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. Explicit Shape Management\n\nAlways document and verify tensor shapes.\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## Model Architecture Patterns\n\n### Clean nn.Module Structure\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### Proper Weight Initialization\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## Training Loop Patterns\n\n### Standard Training Loop\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### Validation Loop\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## Data Pipeline Patterns\n\n### Custom Dataset\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### Efficient DataLoader Configuration\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### Custom Collate for Variable-Length Data\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## Checkpointing Patterns\n\n### Save and Load Checkpoints\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## Performance Optimization\n\n### Mixed Precision Training\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### Gradient Checkpointing for Large Models\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 for Speed\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## Quick Reference: PyTorch Idioms\n\n| Idiom | Description |\n|-------|-------------|\n| `model.train()` \u002F `model.eval()` | Always set mode before train\u002Feval |\n| `torch.no_grad()` | Disable gradients for inference |\n| `optimizer.zero_grad(set_to_none=True)` | More efficient gradient clearing |\n| `.to(device)` | Device-agnostic tensor\u002Fmodel placement |\n| `torch.amp.autocast` | Mixed precision for 2x speed |\n| `pin_memory=True` | Faster CPU→GPU data transfer |\n| `torch.compile` | JIT compilation for speed (2.0+) |\n| `weights_only=True` | Secure model loading |\n| `torch.manual_seed` | Reproducible experiments |\n| `gradient_checkpointing` | Trade compute for memory |\n\n## Anti-Patterns to Avoid\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__Remember__: PyTorch code should be device-agnostic, reproducible, and memory-conscious. When in doubt, profile with `torch.profiler` and check GPU memory with `torch.cuda.memory_summary()`.\n","# PyTorch Development Patterns\n\nIdiomatic PyTorch patterns and best practices for building robust, efficient, and reproducible deep learning applications.\n\n## When to Activate\n\n- Writing new PyTorch models or training scripts\n- Reviewing deep learning code\n- Debugging training loops or data pipelines\n- Optimizing GPU memory usage or training speed\n- Setting up reproducible experiments\n\n## Core Principles\n\n### 1. Device-Agnostic Code\n\nAlways write code that works on both CPU and GPU without hardcoding devices.\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. Reproducibility First\n\nSet all random seeds for reproducible results.\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. Explicit Shape Management\n\nAlways document and verify tensor shapes.\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## Model Architecture Patterns\n\n### Clean nn.Module Structure\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### Proper Weight Initialization\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## Training Loop Patterns\n\n### Standard Training Loop\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### Validation Loop\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## Data Pipeline Patterns\n\n### Custom Dataset\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### Efficient DataLoader Configuration\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### Custom Collate for Variable-Length Data\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## Checkpointing Patterns\n\n### Save and Load Checkpoints\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## Performance Optimization\n\n### Mixed Precision Training\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### Gradient Checkpointing for Large Models\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 for Speed\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## Quick Reference: PyTorch Idioms\n\n| Idiom | Description |\n|-------|-------------|\n| `model.train()` \u002F `model.eval()` | Always set mode before train\u002Feval |\n| `torch.no_grad()` | Disable gradients for inference |\n| `optimizer.zero_grad(set_to_none=True)` | More efficient gradient clearing |\n| `.to(device)` | Device-agnostic tensor\u002Fmodel placement |\n| `torch.amp.autocast` | Mixed precision for 2x speed |\n| `pin_memory=True` | Faster CPU→GPU data transfer |\n| `torch.compile` | JIT compilation for speed (2.0+) |\n| `weights_only=True` | Secure model loading |\n| `torch.manual_seed` | Reproducible experiments |\n| `gradient_checkpointing` | Trade compute for memory |\n\n## Anti-Patterns to Avoid\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__Remember__: PyTorch code should be device-agnostic, reproducible, and memory-conscious. When in doubt, profile with `torch.profiler` and check GPU memory with `torch.cuda.memory_summary()`.\n",{"name":5,"origin":24,"description":7},"ECC","main","d69096e239f2a89aabc2cd078c47664a9d3b1e11","05-技能与代理开发\u002Fpytorch-patterns",3,"https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts","https:\u002F\u002Fgithub.com\u002Flza6","个人vx：Tf00798\r\n个人✈：@TFGY999","2026-10-08 14:29:22",{"source":8,"skillName":5,"commands":34,"prompt":44,"zipAvailable":45},[35,38,41],{"tool":36,"command":37},"npx","npx skills add lza6\u002FArmor-piercing-system-prompts --skill pytorch-patterns",{"tool":39,"command":40},"bunx","bunx skills add lza6\u002FArmor-piercing-system-prompts --skill pytorch-patterns",{"tool":42,"command":43},"pnpm","pnpm dlx skills add lza6\u002FArmor-piercing-system-prompts --skill pytorch-patterns","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F05-技能与代理开发\u002Fpytorch-patterns\u002FSKILL.md",true,[],[48,55,60,67,74,81],{"skillNo":49,"name":50,"nameZh":6,"description":51,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":52,"categories":53,"keywords":54,"publishedAt":19},"01M7FFG485KY83TD6HSC4YPCMC","obsidian-clipper-template-creator","Guide for creating templates for the Obsidian Web Clipper. Use when you want to create a new clipping template, understand available variables, or format clipped content.","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fobsidian-clipper-template-creator\u002FSKILL.md",[],[],{"skillNo":56,"name":50,"nameZh":6,"description":51,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":57,"categories":58,"keywords":59,"publishedAt":19},"01M7FFG0T6AZ0STEJPSB3CX84K","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fobsidian-clipper-template-creator-antigravity-awesome-skills-main\u002FSKILL.md",[],[],{"skillNo":61,"name":62,"nameZh":6,"description":63,"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},"01M7FFFY0QEM14SKWPDYGMXM2P","python-api","Programmatic Object-Detection-Metrics API guidance for BoundingBox, BoundingBoxes, Evaluator, enums, coordinate conversion, AP\u002FmAP semantics, and source-style import diagnostics.","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fobject-detection-metrics\u002Fsub-skills\u002Fpython-api\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},"01M7FFFVZQZ2GJ0C0TGP7JHD20","file-evaluation","Folder-based PASCAL VOC AP\u002FmAP evaluation from ground-truth and detection text files.","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fobject-detection-metrics\u002Fsub-skills\u002Ffile-evaluation\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},"01M7FFFSFNYSE77SJ6PE1CK2DA","object-detection-metrics","Guides legacy Object-Detection-Metrics PASCAL VOC AP\u002FmAP evaluation from detection text folders and direct Python API classes.","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fobject-detection-metrics\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},"01M7FFFP0GCK1RVXBCPQ8APBMT","nx-workspace-patterns","Configure and optimize Nx monorepo workspaces. Use when setting up Nx, configuring project boundaries, optimizing build caching, or implementing affected commands.","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fnx-workspace-patterns\u002FSKILL.md",[],[]]