Data analysis, machine learning, LLM apps, and prompt design (9.1K skills)
Guides experiments that change internal values in PyTorch models to test what causes their behavior. Uses pyvene to swap or remove activations, locate influential components, train interventions, and save experiments for reuse.
Guides reinforcement learning, where models learn from rewards, using torchforge and PyTorch. Covers reward design, custom loss functions, and distributed training so researchers can experiment with algorithms while keeping infrastructure concerns separate.
Guides large language model reinforcement learning with miles, including MoE models that route work to specialized components. Covers low-precision training, matching training and inference behavior, and accelerating training response generation with draft models.
Explore training workflows that reduce harmful model responses using a written set of principles. The skill covers self-critique, revised training examples, and RLAIF, reinforcement learning from AI feedback, with implementation examples and hardware guidance.
Compress large language model weights to four bits with AWQ, a method that uses model activation patterns to limit quality loss. Follow workflows for quantization, loading compressed models, and serving them with vLLM using less GPU memory.
Use LitGPT to explore language model implementations and train models on custom data. Covers pretrained model loading, LoRA fine-tuning that updates a small set of parameters, pretraining, and preparing trained models for deployment.
Add safety checks to LLM applications with NeMo Guardrails. This skill guides input and output validation, detection of attempts to bypass safety rules, personal information masking, and checks for unsupported or inaccurate answers.
Guide language model training with TRL, from learning to follow instructions to matching human preferences. Covers method selection, training data, reward models that score responses, evaluation, and adjustments for memory limits or unstable training.
Guide language model training with SimPO using pairs of preferred and rejected answers. Covers configuration, learning rate tuning, and memory troubleshooting for preference alignment, which adjusts model responses toward human preferences without a separate reference model.
Set up reinforcement learning, training guided by rewards, for language models with slime. The skill covers Megatron-LM training, SGLang response generation, data preparation, asynchronous execution, and custom workflows for agents that use tools across multiple turns.
Implement Mamba, a model architecture that processes sequences through an internal state with computation scaling linearly with input length. Covers pretrained text generation, Mamba-1 and Mamba-2 configuration, speed comparisons with Transformers, and GPU memory troubleshooting.
Learn how GPT language models work by preparing text, training a small model, and generating samples. Covers CPU experiments, custom datasets, further training of pretrained GPT-2 models, and reproducing GPT-2 with multiple GPUs.
Guides you through setting up RWKV, generating text, processing long documents in chunks, and fine-tuning models. Explains how to carry context between steps and compare memory use with Transformer models.
Configure large language model pretraining with torchtitan across multiple GPUs. Covers ways to split training work, launch jobs on computing clusters, enable Float8 numerical processing, and save or resume training through distributed checkpoints.
Guides LLM training with verl using rewards to improve model responses. Covers data preparation, reward functions, GRPO and PPO configuration, distributed GPU training, and troubleshooting memory shortages or unstable training.
Prepare large text collections for AI models with fast tokenizers, which split text into model inputs. Train custom vocabularies, trace tokens to original text positions, adjust input lengths, and integrate the results with transformers.
Use SAELens to train and analyze sparse autoencoders, which break model activations into a small set of interpretable features. Explore pretrained features, evaluate reconstruction quality, troubleshoot training, and test how individual features influence generated text.
Compress large language models to 4-bit weights to reduce GPU memory needs and accelerate text generation. Covers loading compressed models, converting your own models, choosing settings, and preparing memory-efficient fine-tuning with transformers and PEFT.
Apply HQQ quantization, which stores language model weights using fewer bits without calibration examples. Covers precision settings, inference backends, saving compressed models, deployment with HuggingFace Transformers or vLLM, and further training with LoRA.
Helps adapt machine learning training to multiple GPUs and machines with Ray Train. Covers resource allocation, recovery from saved training states, and Ray Tune searches that compare settings such as learning rate and batch size.
Helps reduce GPU memory use by loading large language models in 4-bit or 8-bit formats, a technique called quantization. Covers bitsandbytes configuration, memory checks, QLoRA fine-tuning, and training with memory-saving optimizers.
Guides PyTorch model training and fine-tuning, from choosing architectures to configuring optimizers and learning rates. Provides troubleshooting steps for unstable loss and memory shortages, plus methods for improving GPU throughput and comparing experiments.
Evaluate code generation models with HumanEval, MBPP, and multilingual benchmarks. The skill guides test execution and model comparisons using pass@k, an estimate of whether at least one of k generated solutions passes the tests.
Organize PyTorch training code with LightningModule and Trainer. This skill guides training, validation, logging, model checkpoint saving, early stopping when progress stalls, and configuration for running the same model across multiple GPUs.