Results for “gpu”

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.

• Load a larger model within available GPU memory
• Compare 4-bit and 8-bit quantization settings
• Fine-tune a quantized model with QLoRA

Configure machine learning training and batch jobs across multiple clouds with SkyPilot. The skill guides GPU selection, lower-cost cloud and region choices, and automatic recovery when discounted spot instances are interrupted.

• Choose a lower-cost cloud for GPU training
• Run long training jobs with recovery after interruptions
• Configure distributed training across multiple machines

Optimize MATLAB design files for GPU Coder to generate faster CUDA code. Iteratively profiles, rewrites, and benchmarks until performance targets are met or diagnostics are resolved. Use when asked to: optimize for GPU Coder, improve GPU codegen performance, profile generated GPU/CUDA code, profile GPU MEX, fix gpuPerformanceAnalyzer diagnostics, speed up GPU MEX, reduce GPU memory transfers, improve kernel parallelism, rewrite MATLAB for CUDA, or run gpuPerformanceAnalyzer.

The English summary is being prepared. Showing the original description.

Get guidance for fine-tuning large language models with Axolotl, adapting them through additional training. Use YAML configuration examples, dataset references, and training methods such as LoRA to set up training and investigate problems.

• Preparing YAML configuration for model fine-tuning
• Exploring LoRA and QLoRA training methods
• Checking dataset formats and API usage

Helps you use Unsloth for language model fine-tuning with LoRA and QLoRA, methods that adapt models with fewer trainable parameters. Supports API questions, implementation, and debugging using reference material drawn from official documentation.

• Learning how to fine-tune models with LoRA or QLoRA
• Looking up Unsloth features and APIs
• Investigating errors in training code

Organize PyTorch models and data pipelines with PyTorch Lightning, automate training, save checkpoints, and track experiments. Includes templates and guidance for configuring training across multiple GPUs or TPUs.

• Restructure PyTorch training code into LightningModules
• Build reusable data preparation and loading pipelines
• Configure checkpoints, early stopping, and experiment logs

Integrate Flash Attention into transformer models to reduce processing time and GPU memory use for long sequences. Covers PyTorch integration, advanced attention options, and benchmarks that compare speed, memory use, and output accuracy.

• Speeding up transformer training on long sequences
• Reducing GPU memory use during attention
• Adding Flash Attention to a PyTorch model

Fine-tune large language models with LoRA and QLoRA while limiting GPU memory use. Guides training settings and adapter management, using small sets of task-specific weights that can be saved, switched, or merged into a base model.

• Fine-tuning an LLM with limited GPU memory
• Choosing LoRA settings and training layers
• Switching task-specific adapters on one base model

Reduce GPU memory use by loading language models in 8-bit or 4-bit formats with bitsandbytes and HuggingFace Transformers. Includes configuration examples, QLoRA fine-tuning of compressed models, and optimizers that reduce memory needed during training.

• Load larger models within limited GPU memory
• Compare 8-bit and 4-bit model settings
• Fine-tune a model with QLoRA

Adapt machine learning training to run across multiple GPUs or machines with Ray Train. Covers changes to existing code, comparing training settings with Ray Tune, and saving checkpoints so training can resume after failures.

• Adapting existing PyTorch code for multiple GPUs
• Training HuggingFace models across multiple machines
• Comparing learning rates and batch sizes with Ray Tune

Build data processing pipelines for machine learning, from preprocessing to batch predictions. Uses Ray Data to handle datasets larger than memory, distribute work across CPUs and GPUs, and feed data into training frameworks.

• Preprocessing datasets larger than memory
• Running batch predictions across multiple GPUs
• Preparing image and tabular data for training

Turn a research experiment plan into training and evaluation code, run a small setup check, and launch GPU experiments. Collect initial metrics and update progress records so the results are ready for further review.

• Implementing experiments from a written plan
• Checking a small run before full GPU experiments
• Collecting baseline and main-method results

Guide MNN Metal backend development and optimization, from finding performance bottlenecks to changing GPU computation, combining operators, and adjusting execution scheduling. A task-based document index directs work toward relevant implementation rules, benchmarks, and correctness checks.

• Finding bottlenecks in Metal inference
• Adding or modifying Metal kernels
• Combining operators into one GPU dispatch

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.

• Train math reasoning models with GRPO and answer-based rewards
• Configure PPO training with a separate value-estimation model
• Run large-model training across multiple GPU nodes

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.

• Train mathematical reasoning models with GRPO
• Experiment with custom loss functions
• Scale training across multiple GPUs or nodes

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.

• Adapt existing PyTorch training to multiple GPUs
• Run HuggingFace training across multiple machines
• Compare learning rates and batch sizes with Ray Tune

Guides LLM fine-tuning with Axolotl, from YAML configuration and dataset formats to distributed training across GPUs. Covers LoRA and QLoRA, methods that train on preferences, multimodal support, and troubleshooting using documentation references and code examples.

• Prepare YAML settings for LLM fine-tuning
• Explore LoRA, QLoRA, and preference training options
• Check dataset formats and input handling

Optimize transformer attention, the calculation that relates tokens to one another, using Flash Attention. The skill guides PyTorch integration, GPU memory reduction, performance measurement, and output comparisons for training or inference with long sequences.

• Reducing GPU memory use with long sequences
• Integrating Flash Attention into PyTorch models
• Comparing runtime and outputs before and after changes

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.

• Choose model architectures for the available data type and scale
• Configure optimizers and learning-rate schedules
• Investigate loss spikes, NaNs, and GPU memory shortages

Build data processing pipelines for machine learning, from preprocessing to batch predictions. Uses Ray Data to handle datasets larger than memory, distribute work across CPUs and GPUs, and feed data into training frameworks.

• Preprocessing datasets larger than memory
• Running batch predictions across multiple GPUs
• Preparing image and tabular data for training

Fine-tune vision models on custom images using Hugging Face Jobs cloud GPUs. Covers object detection, image classification, and segmentation—identifying image regions—with dataset validation, hardware selection, cost estimates, monitoring, and saving trained models to the Hub.

• Train an object detector on custom images
• Fine-tune an image classifier
• Adapt SAM/SAM2 to custom image masks

Analyze GPU operation timings and execution traces to find costly data access, repeated computation, launch overhead, and synchronization waits. Check whether improving an individual operation actually reduces the time needed to complete a full request.

• Investigating slow GPU operations
• Assessing whether combining operations reduces data access
• Checking pipeline dependencies and buffer reuse

Metal/wgpu/WGSL shader surfaces for native Rust gpui apps (Zed-family, pd-console), stockpiled with beautiful copy-pasteable shader-toy examples. Use for custom GPU fragment passes behind/around gpui panes: ocean/water shaders, pixelated waves and boats, a living harbor, dithered chrome borders, sonar sweeps, aurora/starfields, CRT/scanline post. Trigger on: wgsl, wgpu, metal shader, gpui shader, shadertoy, fragment shader, SDF, noise/fbm, ordered dithering, pixelation, render-to-texture, "pixelated waves and boats", living harbor water. NOT for: web/GLSL/three.js shaders (use a web tool), non-shader gpui motion (use rust-gpui-motion), general GUI layout/color (use beautiful-gui-design), CLI/TUI (use beautiful-cli-design).

The English summary is being prepared. Showing the original description.

Integrate Flash Attention into Transformer models to speed up attention, the calculation that relates input elements, while reducing GPU memory use. Covers PyTorch integration, performance measurement, output comparison, and a separate H100 optimization path.

• Optimize training with long input sequences
• Reduce memory use during long-context inference
• Measure speed and compare model outputs