[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7D2WQASA2HCNQ46TDRQFQWR":3,"skill-same:01M7D2WQASA2HCNQ46TDRQFQWR":74},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":18,"linkOnly":19,"markdownContent":20,"markdownBody":21,"frontMatter":22,"refName":40,"commitSha":41,"skillDirectory":42,"forksCount":13,"repositoryHtmlUrl":43,"repositoryHomepageUrl":6,"ownerHtmlUrl":44,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":45,"install":46,"resources":59},"01M7D2WQASA2HCNQ46TDRQFQWR","pytorch-lightning",null,"High-level PyTorch framework with Trainer class, automatic distributed training (DDP\u002FFSDP\u002FDeepSpeed), callbacks system, and minimal boilerplate. Scales from laptop to supercomputer with same code. Use when you want clean training loops with built-in best practices.","beyondai\u002Fsandbox","beyondai","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F2845958?v=4","01M7D24SBNM47BJGJ9J2HB13BP","01M7D24SCDC9DYE005XH6R553S",0,"MIT","https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.codex\u002Fskills\u002Fpytorch-lightning\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: pytorch-lightning\ndescription: High-level PyTorch framework with Trainer class, automatic distributed training (DDP\u002FFSDP\u002FDeepSpeed), callbacks system, and minimal boilerplate. Scales from laptop to supercomputer with same code. Use when you want clean training loops with built-in best practices.\nversion: 1.0.0\nauthor: Orchestra Research\nlicense: MIT\ntags: [PyTorch Lightning, Training Framework, Distributed Training, DDP, FSDP, DeepSpeed, High-Level API, Callbacks, Best Practices, Scalable]\ndependencies: [lightning, torch, transformers]\n---\n\n# PyTorch Lightning - High-Level Training Framework\n\n## Quick start\n\nPyTorch Lightning organizes PyTorch code to eliminate boilerplate while maintaining flexibility.\n\n**Installation**:\n```bash\npip install lightning\n```\n\n**Convert PyTorch to Lightning** (3 steps):\n\n```python\nimport lightning as L\nimport torch\nfrom torch import nn\nfrom torch.utils.data import DataLoader, Dataset\n\n# Step 1: Define LightningModule (organize your PyTorch code)\nclass LitModel(L.LightningModule):\n    def __init__(self, hidden_size=128):\n        super().__init__()\n        self.model = nn.Sequential(\n            nn.Linear(28 * 28, hidden_size),\n            nn.ReLU(),\n            nn.Linear(hidden_size, 10)\n        )\n\n    def training_step(self, batch, batch_idx):\n        x, y = batch\n        y_hat = self.model(x)\n        loss = nn.functional.cross_entropy(y_hat, y)\n        self.log('train_loss', loss)  # Auto-logged to TensorBoard\n        return loss\n\n    def configure_optimizers(self):\n        return torch.optim.Adam(self.parameters(), lr=1e-3)\n\n# Step 2: Create data\ntrain_loader = DataLoader(train_dataset, batch_size=32)\n\n# Step 3: Train with Trainer (handles everything else!)\ntrainer = L.Trainer(max_epochs=10, accelerator='gpu', devices=2)\nmodel = LitModel()\ntrainer.fit(model, train_loader)\n```\n\n**That's it!** Trainer handles:\n- GPU\u002FTPU\u002FCPU switching\n- Distributed training (DDP, FSDP, DeepSpeed)\n- Mixed precision (FP16, BF16)\n- Gradient accumulation\n- Checkpointing\n- Logging\n- Progress bars\n\n## Common workflows\n\n### Workflow 1: From PyTorch to Lightning\n\n**Original PyTorch code**:\n```python\nmodel = MyModel()\noptimizer = torch.optim.Adam(model.parameters())\nmodel.to('cuda')\n\nfor epoch in range(max_epochs):\n    for batch in train_loader:\n        batch = batch.to('cuda')\n        optimizer.zero_grad()\n        loss = model(batch)\n        loss.backward()\n        optimizer.step()\n```\n\n**Lightning version**:\n```python\nclass LitModel(L.LightningModule):\n    def __init__(self):\n        super().__init__()\n        self.model = MyModel()\n\n    def training_step(self, batch, batch_idx):\n        loss = self.model(batch)  # No .to('cuda') needed!\n        return loss\n\n    def configure_optimizers(self):\n        return torch.optim.Adam(self.parameters())\n\n# Train\ntrainer = L.Trainer(max_epochs=10, accelerator='gpu')\ntrainer.fit(LitModel(), train_loader)\n```\n\n**Benefits**: 40+ lines → 15 lines, no device management, automatic distributed\n\n### Workflow 2: Validation and testing\n\n```python\nclass LitModel(L.LightningModule):\n    def __init__(self):\n        super().__init__()\n        self.model = MyModel()\n\n    def training_step(self, batch, batch_idx):\n        x, y = batch\n        y_hat = self.model(x)\n        loss = nn.functional.cross_entropy(y_hat, y)\n        self.log('train_loss', loss)\n        return loss\n\n    def validation_step(self, batch, batch_idx):\n        x, y = batch\n        y_hat = self.model(x)\n        val_loss = nn.functional.cross_entropy(y_hat, y)\n        acc = (y_hat.argmax(dim=1) == y).float().mean()\n        self.log('val_loss', val_loss)\n        self.log('val_acc', acc)\n\n    def test_step(self, batch, batch_idx):\n        x, y = batch\n        y_hat = self.model(x)\n        test_loss = nn.functional.cross_entropy(y_hat, y)\n        self.log('test_loss', test_loss)\n\n    def configure_optimizers(self):\n        return torch.optim.Adam(self.parameters(), lr=1e-3)\n\n# Train with validation\ntrainer = L.Trainer(max_epochs=10)\ntrainer.fit(model, train_loader, val_loader)\n\n# Test\ntrainer.test(model, test_loader)\n```\n\n**Automatic features**:\n- Validation runs every epoch by default\n- Metrics logged to TensorBoard\n- Best model checkpointing based on val_loss\n\n### Workflow 3: Distributed training (DDP)\n\n```python\n# Same code as single GPU!\nmodel = LitModel()\n\n# 8 GPUs with DDP (automatic!)\ntrainer = L.Trainer(\n    accelerator='gpu',\n    devices=8,\n    strategy='ddp'  # Or 'fsdp', 'deepspeed'\n)\n\ntrainer.fit(model, train_loader)\n```\n\n**Launch**:\n```bash\n# Single command, Lightning handles the rest\npython train.py\n```\n\n**No changes needed**:\n- Automatic data distribution\n- Gradient synchronization\n- Multi-node support (just set `num_nodes=2`)\n\n### Workflow 4: Callbacks for monitoring\n\n```python\nfrom lightning.pytorch.callbacks import ModelCheckpoint, EarlyStopping, LearningRateMonitor\n\n# Create callbacks\ncheckpoint = ModelCheckpoint(\n    monitor='val_loss',\n    mode='min',\n    save_top_k=3,\n    filename='model-{epoch:02d}-{val_loss:.2f}'\n)\n\nearly_stop = EarlyStopping(\n    monitor='val_loss',\n    patience=5,\n    mode='min'\n)\n\nlr_monitor = LearningRateMonitor(logging_interval='epoch')\n\n# Add to Trainer\ntrainer = L.Trainer(\n    max_epochs=100,\n    callbacks=[checkpoint, early_stop, lr_monitor]\n)\n\ntrainer.fit(model, train_loader, val_loader)\n```\n\n**Result**:\n- Auto-saves best 3 models\n- Stops early if no improvement for 5 epochs\n- Logs learning rate to TensorBoard\n\n### Workflow 5: Learning rate scheduling\n\n```python\nclass LitModel(L.LightningModule):\n    # ... (training_step, etc.)\n\n    def configure_optimizers(self):\n        optimizer = torch.optim.Adam(self.parameters(), lr=1e-3)\n\n        # Cosine annealing\n        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(\n            optimizer,\n            T_max=100,\n            eta_min=1e-5\n        )\n\n        return {\n            'optimizer': optimizer,\n            'lr_scheduler': {\n                'scheduler': scheduler,\n                'interval': 'epoch',  # Update per epoch\n                'frequency': 1\n            }\n        }\n\n# Learning rate auto-logged!\ntrainer = L.Trainer(max_epochs=100)\ntrainer.fit(model, train_loader)\n```\n\n## When to use vs alternatives\n\n**Use PyTorch Lightning when**:\n- Want clean, organized code\n- Need production-ready training loops\n- Switching between single GPU, multi-GPU, TPU\n- Want built-in callbacks and logging\n- Team collaboration (standardized structure)\n\n**Key advantages**:\n- **Organized**: Separates research code from engineering\n- **Automatic**: DDP, FSDP, DeepSpeed with 1 line\n- **Callbacks**: Modular training extensions\n- **Reproducible**: Less boilerplate = fewer bugs\n- **Tested**: 1M+ downloads\u002Fmonth, battle-tested\n\n**Use alternatives instead**:\n- **Accelerate**: Minimal changes to existing code, more flexibility\n- **Ray Train**: Multi-node orchestration, hyperparameter tuning\n- **Raw PyTorch**: Maximum control, learning purposes\n- **Keras**: TensorFlow ecosystem\n\n## Common issues\n\n**Issue: Loss not decreasing**\n\nCheck data and model setup:\n```python\n# Add to training_step\ndef training_step(self, batch, batch_idx):\n    if batch_idx == 0:\n        print(f\"Batch shape: {batch[0].shape}\")\n        print(f\"Labels: {batch[1]}\")\n    loss = ...\n    return loss\n```\n\n**Issue: Out of memory**\n\nReduce batch size or use gradient accumulation:\n```python\ntrainer = L.Trainer(\n    accumulate_grad_batches=4,  # Effective batch = batch_size × 4\n    precision='bf16'  # Or 'fp16', reduces memory 50%\n)\n```\n\n**Issue: Validation not running**\n\nEnsure you pass val_loader:\n```python\n# WRONG\ntrainer.fit(model, train_loader)\n\n# CORRECT\ntrainer.fit(model, train_loader, val_loader)\n```\n\n**Issue: DDP spawns multiple processes unexpectedly**\n\nLightning auto-detects GPUs. Explicitly set devices:\n```python\n# Test on CPU first\ntrainer = L.Trainer(accelerator='cpu', devices=1)\n\n# Then GPU\ntrainer = L.Trainer(accelerator='gpu', devices=1)\n```\n\n## Advanced topics\n\n**Callbacks**: See [references\u002Fcallbacks.md](references\u002Fcallbacks.md) for EarlyStopping, ModelCheckpoint, custom callbacks, and callback hooks.\n\n**Distributed strategies**: See [references\u002Fdistributed.md](references\u002Fdistributed.md) for DDP, FSDP, DeepSpeed ZeRO integration, multi-node setup.\n\n**Hyperparameter tuning**: See [references\u002Fhyperparameter-tuning.md](references\u002Fhyperparameter-tuning.md) for integration with Optuna, Ray Tune, and WandB sweeps.\n\n## Hardware requirements\n\n- **CPU**: Works (good for debugging)\n- **Single GPU**: Works\n- **Multi-GPU**: DDP (default), FSDP, or DeepSpeed\n- **Multi-node**: DDP, FSDP, DeepSpeed\n- **TPU**: Supported (8 cores)\n- **Apple MPS**: Supported\n\n**Precision options**:\n- FP32 (default)\n- FP16 (V100, older GPUs)\n- BF16 (A100\u002FH100, recommended)\n- FP8 (H100)\n\n## Resources\n\n- Docs: https:\u002F\u002Flightning.ai\u002Fdocs\u002Fpytorch\u002Fstable\u002F\n- GitHub: https:\u002F\u002Fgithub.com\u002FLightning-AI\u002Fpytorch-lightning ⭐ 29,000+\n- Version: 2.5.5+\n- Examples: https:\u002F\u002Fgithub.com\u002FLightning-AI\u002Fpytorch-lightning\u002Ftree\u002Fmaster\u002Fexamples\n- Discord: https:\u002F\u002Fdiscord.gg\u002Flightning-ai\n- Used by: Kaggle winners, research labs, production teams\n\n\n","# PyTorch Lightning - High-Level Training Framework\n\n## Quick start\n\nPyTorch Lightning organizes PyTorch code to eliminate boilerplate while maintaining flexibility.\n\n**Installation**:\n```bash\npip install lightning\n```\n\n**Convert PyTorch to Lightning** (3 steps):\n\n```python\nimport lightning as L\nimport torch\nfrom torch import nn\nfrom torch.utils.data import DataLoader, Dataset\n\n# Step 1: Define LightningModule (organize your PyTorch code)\nclass LitModel(L.LightningModule):\n    def __init__(self, hidden_size=128):\n        super().__init__()\n        self.model = nn.Sequential(\n            nn.Linear(28 * 28, hidden_size),\n            nn.ReLU(),\n            nn.Linear(hidden_size, 10)\n        )\n\n    def training_step(self, batch, batch_idx):\n        x, y = batch\n        y_hat = self.model(x)\n        loss = nn.functional.cross_entropy(y_hat, y)\n        self.log('train_loss', loss)  # Auto-logged to TensorBoard\n        return loss\n\n    def configure_optimizers(self):\n        return torch.optim.Adam(self.parameters(), lr=1e-3)\n\n# Step 2: Create data\ntrain_loader = DataLoader(train_dataset, batch_size=32)\n\n# Step 3: Train with Trainer (handles everything else!)\ntrainer = L.Trainer(max_epochs=10, accelerator='gpu', devices=2)\nmodel = LitModel()\ntrainer.fit(model, train_loader)\n```\n\n**That's it!** Trainer handles:\n- GPU\u002FTPU\u002FCPU switching\n- Distributed training (DDP, FSDP, DeepSpeed)\n- Mixed precision (FP16, BF16)\n- Gradient accumulation\n- Checkpointing\n- Logging\n- Progress bars\n\n## Common workflows\n\n### Workflow 1: From PyTorch to Lightning\n\n**Original PyTorch code**:\n```python\nmodel = MyModel()\noptimizer = torch.optim.Adam(model.parameters())\nmodel.to('cuda')\n\nfor epoch in range(max_epochs):\n    for batch in train_loader:\n        batch = batch.to('cuda')\n        optimizer.zero_grad()\n        loss = model(batch)\n        loss.backward()\n        optimizer.step()\n```\n\n**Lightning version**:\n```python\nclass LitModel(L.LightningModule):\n    def __init__(self):\n        super().__init__()\n        self.model = MyModel()\n\n    def training_step(self, batch, batch_idx):\n        loss = self.model(batch)  # No .to('cuda') needed!\n        return loss\n\n    def configure_optimizers(self):\n        return torch.optim.Adam(self.parameters())\n\n# Train\ntrainer = L.Trainer(max_epochs=10, accelerator='gpu')\ntrainer.fit(LitModel(), train_loader)\n```\n\n**Benefits**: 40+ lines → 15 lines, no device management, automatic distributed\n\n### Workflow 2: Validation and testing\n\n```python\nclass LitModel(L.LightningModule):\n    def __init__(self):\n        super().__init__()\n        self.model = MyModel()\n\n    def training_step(self, batch, batch_idx):\n        x, y = batch\n        y_hat = self.model(x)\n        loss = nn.functional.cross_entropy(y_hat, y)\n        self.log('train_loss', loss)\n        return loss\n\n    def validation_step(self, batch, batch_idx):\n        x, y = batch\n        y_hat = self.model(x)\n        val_loss = nn.functional.cross_entropy(y_hat, y)\n        acc = (y_hat.argmax(dim=1) == y).float().mean()\n        self.log('val_loss', val_loss)\n        self.log('val_acc', acc)\n\n    def test_step(self, batch, batch_idx):\n        x, y = batch\n        y_hat = self.model(x)\n        test_loss = nn.functional.cross_entropy(y_hat, y)\n        self.log('test_loss', test_loss)\n\n    def configure_optimizers(self):\n        return torch.optim.Adam(self.parameters(), lr=1e-3)\n\n# Train with validation\ntrainer = L.Trainer(max_epochs=10)\ntrainer.fit(model, train_loader, val_loader)\n\n# Test\ntrainer.test(model, test_loader)\n```\n\n**Automatic features**:\n- Validation runs every epoch by default\n- Metrics logged to TensorBoard\n- Best model checkpointing based on val_loss\n\n### Workflow 3: Distributed training (DDP)\n\n```python\n# Same code as single GPU!\nmodel = LitModel()\n\n# 8 GPUs with DDP (automatic!)\ntrainer = L.Trainer(\n    accelerator='gpu',\n    devices=8,\n    strategy='ddp'  # Or 'fsdp', 'deepspeed'\n)\n\ntrainer.fit(model, train_loader)\n```\n\n**Launch**:\n```bash\n# Single command, Lightning handles the rest\npython train.py\n```\n\n**No changes needed**:\n- Automatic data distribution\n- Gradient synchronization\n- Multi-node support (just set `num_nodes=2`)\n\n### Workflow 4: Callbacks for monitoring\n\n```python\nfrom lightning.pytorch.callbacks import ModelCheckpoint, EarlyStopping, LearningRateMonitor\n\n# Create callbacks\ncheckpoint = ModelCheckpoint(\n    monitor='val_loss',\n    mode='min',\n    save_top_k=3,\n    filename='model-{epoch:02d}-{val_loss:.2f}'\n)\n\nearly_stop = EarlyStopping(\n    monitor='val_loss',\n    patience=5,\n    mode='min'\n)\n\nlr_monitor = LearningRateMonitor(logging_interval='epoch')\n\n# Add to Trainer\ntrainer = L.Trainer(\n    max_epochs=100,\n    callbacks=[checkpoint, early_stop, lr_monitor]\n)\n\ntrainer.fit(model, train_loader, val_loader)\n```\n\n**Result**:\n- Auto-saves best 3 models\n- Stops early if no improvement for 5 epochs\n- Logs learning rate to TensorBoard\n\n### Workflow 5: Learning rate scheduling\n\n```python\nclass LitModel(L.LightningModule):\n    # ... (training_step, etc.)\n\n    def configure_optimizers(self):\n        optimizer = torch.optim.Adam(self.parameters(), lr=1e-3)\n\n        # Cosine annealing\n        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(\n            optimizer,\n            T_max=100,\n            eta_min=1e-5\n        )\n\n        return {\n            'optimizer': optimizer,\n            'lr_scheduler': {\n                'scheduler': scheduler,\n                'interval': 'epoch',  # Update per epoch\n                'frequency': 1\n            }\n        }\n\n# Learning rate auto-logged!\ntrainer = L.Trainer(max_epochs=100)\ntrainer.fit(model, train_loader)\n```\n\n## When to use vs alternatives\n\n**Use PyTorch Lightning when**:\n- Want clean, organized code\n- Need production-ready training loops\n- Switching between single GPU, multi-GPU, TPU\n- Want built-in callbacks and logging\n- Team collaboration (standardized structure)\n\n**Key advantages**:\n- **Organized**: Separates research code from engineering\n- **Automatic**: DDP, FSDP, DeepSpeed with 1 line\n- **Callbacks**: Modular training extensions\n- **Reproducible**: Less boilerplate = fewer bugs\n- **Tested**: 1M+ downloads\u002Fmonth, battle-tested\n\n**Use alternatives instead**:\n- **Accelerate**: Minimal changes to existing code, more flexibility\n- **Ray Train**: Multi-node orchestration, hyperparameter tuning\n- **Raw PyTorch**: Maximum control, learning purposes\n- **Keras**: TensorFlow ecosystem\n\n## Common issues\n\n**Issue: Loss not decreasing**\n\nCheck data and model setup:\n```python\n# Add to training_step\ndef training_step(self, batch, batch_idx):\n    if batch_idx == 0:\n        print(f\"Batch shape: {batch[0].shape}\")\n        print(f\"Labels: {batch[1]}\")\n    loss = ...\n    return loss\n```\n\n**Issue: Out of memory**\n\nReduce batch size or use gradient accumulation:\n```python\ntrainer = L.Trainer(\n    accumulate_grad_batches=4,  # Effective batch = batch_size × 4\n    precision='bf16'  # Or 'fp16', reduces memory 50%\n)\n```\n\n**Issue: Validation not running**\n\nEnsure you pass val_loader:\n```python\n# WRONG\ntrainer.fit(model, train_loader)\n\n# CORRECT\ntrainer.fit(model, train_loader, val_loader)\n```\n\n**Issue: DDP spawns multiple processes unexpectedly**\n\nLightning auto-detects GPUs. Explicitly set devices:\n```python\n# Test on CPU first\ntrainer = L.Trainer(accelerator='cpu', devices=1)\n\n# Then GPU\ntrainer = L.Trainer(accelerator='gpu', devices=1)\n```\n\n## Advanced topics\n\n**Callbacks**: See [references\u002Fcallbacks.md](references\u002Fcallbacks.md) for EarlyStopping, ModelCheckpoint, custom callbacks, and callback hooks.\n\n**Distributed strategies**: See [references\u002Fdistributed.md](references\u002Fdistributed.md) for DDP, FSDP, DeepSpeed ZeRO integration, multi-node setup.\n\n**Hyperparameter tuning**: See [references\u002Fhyperparameter-tuning.md](references\u002Fhyperparameter-tuning.md) for integration with Optuna, Ray Tune, and WandB sweeps.\n\n## Hardware requirements\n\n- **CPU**: Works (good for debugging)\n- **Single GPU**: Works\n- **Multi-GPU**: DDP (default), FSDP, or DeepSpeed\n- **Multi-node**: DDP, FSDP, DeepSpeed\n- **TPU**: Supported (8 cores)\n- **Apple MPS**: Supported\n\n**Precision options**:\n- FP32 (default)\n- FP16 (V100, older GPUs)\n- BF16 (A100\u002FH100, recommended)\n- FP8 (H100)\n\n## Resources\n\n- Docs: https:\u002F\u002Flightning.ai\u002Fdocs\u002Fpytorch\u002Fstable\u002F\n- GitHub: https:\u002F\u002Fgithub.com\u002FLightning-AI\u002Fpytorch-lightning ⭐ 29,000+\n- Version: 2.5.5+\n- Examples: https:\u002F\u002Fgithub.com\u002FLightning-AI\u002Fpytorch-lightning\u002Ftree\u002Fmaster\u002Fexamples\n- Discord: https:\u002F\u002Fdiscord.gg\u002Flightning-ai\n- Used by: Kaggle winners, research labs, production teams\n\n\n",{"name":5,"tags":23,"author":34,"license":14,"version":35,"description":7,"dependencies":36},[24,25,26,27,28,29,30,31,32,33],"PyTorch Lightning","Training Framework","Distributed Training","DDP","FSDP","DeepSpeed","High-Level API","Callbacks","Best Practices","Scalable","Orchestra Research","1.0.0",[37,38,39],"lightning","torch","transformers","main","46e03791269608c5ac886a64c08f5d94147e8786","labs\u002F.codex\u002Fskills\u002Fpytorch-lightning","https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox","https:\u002F\u002Fgithub.com\u002Fbeyondai","2026-11-08 04:18:42",{"source":8,"skillName":5,"commands":47,"prompt":57,"zipAvailable":58},[48,51,54],{"tool":49,"command":50},"npx","npx skills add beyondai\u002Fsandbox --skill pytorch-lightning",{"tool":52,"command":53},"bunx","bunx skills add beyondai\u002Fsandbox --skill pytorch-lightning",{"tool":55,"command":56},"pnpm","pnpm dlx skills add beyondai\u002Fsandbox --skill pytorch-lightning","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.codex\u002Fskills\u002Fpytorch-lightning\u002FSKILL.md",true,[60,66,70],{"path":61,"resourceType":62,"resourceTypeDesc":63,"sizeBytes":64,"sourceHtmlUrl":65},"references\u002Fcallbacks.md","REFERENCE","参考文档",12031,"https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.codex\u002Fskills\u002Fpytorch-lightning\u002Freferences\u002Fcallbacks.md",{"path":67,"resourceType":62,"resourceTypeDesc":63,"sizeBytes":68,"sourceHtmlUrl":69},"references\u002Fdistributed.md",10818,"https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.codex\u002Fskills\u002Fpytorch-lightning\u002Freferences\u002Fdistributed.md",{"path":71,"resourceType":62,"resourceTypeDesc":63,"sizeBytes":72,"sourceHtmlUrl":73},"references\u002Fhyperparameter-tuning.md",12517,"https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.codex\u002Fskills\u002Fpytorch-lightning\u002Freferences\u002Fhyperparameter-tuning.md",[75,82,89,96,103,110],{"skillNo":76,"name":77,"nameZh":6,"description":78,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":79,"categories":80,"keywords":81,"publishedAt":18},"01M7D3GMPGJZRG8EPY404YF8TR","weights-and-biases","Track ML experiments with automatic logging, visualize training in real-time, optimize hyperparameters with sweeps, and manage model registry with W&B - collaborative MLOps platform","https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.opencode\u002Fskills\u002Fweights-and-biases\u002FSKILL.md",[],[],{"skillNo":83,"name":84,"nameZh":6,"description":85,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":86,"categories":87,"keywords":88,"publishedAt":18},"01M7D3GFZH440V2J532BSZMPVP","serving-llms-vllm","Serves LLMs with high throughput using vLLM's PagedAttention and continuous batching. Use when deploying production LLM APIs, optimizing inference latency\u002Fthroughput, or serving models with limited GPU memory. Supports OpenAI-compatible endpoints, quantization (GPTQ\u002FAWQ\u002FFP8), and tensor parallelism.","https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.opencode\u002Fskills\u002Fvllm\u002FSKILL.md",[],[],{"skillNo":90,"name":91,"nameZh":6,"description":92,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":93,"categories":94,"keywords":95,"publishedAt":18},"01M7D3GAE8MQCPGF72EP9G9GKY","verl-rl-training","Provides guidance for training LLMs with reinforcement learning using verl (Volcano Engine RL). Use when implementing RLHF, GRPO, PPO, or other RL algorithms for LLM post-training at scale with flexible infrastructure backends.","https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.opencode\u002Fskills\u002Fverl\u002FSKILL.md",[],[],{"skillNo":97,"name":98,"nameZh":6,"description":99,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":100,"categories":101,"keywords":102,"publishedAt":18},"01M7D3G7KKNE5RGNYJNXV4F0MM","unsloth","Expert guidance for fast fine-tuning with Unsloth - 2-5x faster training, 50-80% less memory, LoRA\u002FQLoRA optimization","https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.opencode\u002Fskills\u002Funsloth\u002FSKILL.md",[],[],{"skillNo":104,"name":105,"nameZh":6,"description":106,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":107,"categories":108,"keywords":109,"publishedAt":18},"01M7D3G2RCZQ08GS0KAW5CBWSC","fine-tuning-with-trl","Fine-tune LLMs using reinforcement learning with TRL - SFT for instruction tuning, DPO for preference alignment, PPO\u002FGRPO for reward optimization, and reward model training. Use when need RLHF, align model with preferences, or train from human feedback. Works with HuggingFace Transformers.","https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.opencode\u002Fskills\u002Ftrl-fine-tuning\u002FSKILL.md",[],[],{"skillNo":111,"name":112,"nameZh":6,"description":113,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":114,"categories":115,"keywords":116,"publishedAt":18},"01M7D3FX08BPB172CYGM597NZF","torchforge-rl-training","Provides guidance for PyTorch-native agentic RL using torchforge, Meta's library separating infra from algorithms. Use when you want clean RL abstractions, easy algorithm experimentation, or scalable training with Monarch and TorchTitan.","https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.opencode\u002Fskills\u002Ftorchforge\u002FSKILL.md",[],[]]