Results for “llm training data”

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.

• Train a model on instruction and response examples
• Align responses using preferred and rejected answer pairs
• Build a training pipeline using human feedback

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.

• Train a model on instruction and response examples
• Align responses using preferred and rejected answer pairs
• Build a training pipeline using human feedback

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

Train or fine-tune language and vision models on Hugging Face Jobs without a local GPU. Covers dataset checks, hardware and cost planning, training monitoring, Hub storage, and GGUF conversion for local use.

• Fine-tune a language model without a local GPU
• Validate preference data before DPO training
• Estimate training costs and choose GPU hardware

Extract sensitive training data (PII, API keys, intellectual property, or code) directly from a deployed Large Language Model (LLM). This AI Red Teaming skill focuses on forcing models to regurgitate memorized, unredacted data from their massive internet-scraped datasets through repetition attacks, prefix continuation, and context window manipulation.

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

GPU-accelerated data curation for LLM training. Supports text/image/video/audio. Features fuzzy deduplication (16× faster), quality filtering (30+ heuristics), semantic deduplication, PII redaction, NSFW detection. Scales across GPUs with RAPIDS. Use for preparing high-quality training datasets, cleaning web data, or deduplicating large corpora.

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

GPU-accelerated data curation for LLM training. Supports text/image/video/audio. Features fuzzy deduplication (16× faster), quality filtering (30+ heuristics), semantic deduplication, PII redaction, NSFW detection. Scales across GPUs with RAPIDS. Use for preparing high-quality training datasets, cleaning web data, or deduplicating large corpora.

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

Set up reinforcement learning, training guided by response rewards, for large language models. Use Megatron-LM and SGLang to prepare data, configure training and response generation, and build asynchronous or multi-turn experiments.

• Setting up GRPO training for a language model
• Overlapping response generation and training
• Training agents that use tools across multiple turns

Decide whether an LLM needs additional training or whether retrieval and better prompts will suffice. Match available examples, preferences, or verifiable results to a training method, then assess model size and memory requirements before starting.

• Comparing fine-tuning with retrieval and prompt changes
• Choosing a training method for available data
• Assessing model size and memory requirements

Guides language model training with GRPO in TRL, comparing several responses and rewarding better results. Covers dataset preparation, scoring rules for correctness and format, training configuration, monitoring, and saving models for later use.

• Training models to follow JSON or XML formats
• Designing rewards for math and coding tasks
• Adjusting training to available GPU memory

Get guidance on adapting LLMs with Unsloth, including implementation, API usage, and debugging. Covers LoRA and QLoRA, methods for adjusting models with fewer trainable parameters, with a focus on training speed and memory use.

• Learning how to fine-tune models with Unsloth
• Exploring LoRA and QLoRA for efficient training
• Implementing features using Unsloth APIs

Plan and troubleshoot large language and vision model training and inference. This guide uses hardware measurements to identify bottlenecks, address memory shortages and unstable training, and improve checkpointing, recovery, and performance across multiple GPUs and machines.

• Diagnosing slow training and GPU memory shortages
• Investigating loss spikes and invalid numerical values
• Debugging communication hangs across GPUs and machines

Run model training, fine-tuning, inference, and batch jobs on Modal’s cloud GPUs. Estimate hardware needs and cost, generate Python launch scripts, run or deploy workloads, monitor logs, and retrieve results without managing remote servers.

• Test CUDA code without a local GPU
• Run model training or LoRA fine-tuning on cloud GPUs
• Deploy a model inference API or vLLM service

Execute sophisticated Data Extraction and Privacy Leakage attacks explicitly against Large Language Models (LLMs) to natively force the neural network entirely into organically regurgitating exact, verbatim strings of Highly Confidential Personally Identifiable Information (PII), proprietary source code, or copyrighted material categorically memorized intrinsically during its foundational pre-training phase.

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

Guide language model training with TRL using example answers, preferred response pairs, or reward scores. The skill covers data preparation, method selection, reward model training, evaluation, and adjustments for memory limits or unstable training.

• Train a language model to follow instructions using example answers
• Train on preferred and rejected responses with DPO
• Build a reward model and run an RLHF training pipeline

Plan and audit HypoGeniC workflows that use language models to propose patterns from labeled text. Check configurations, dataset splits, cost limits, and saved predictions while keeping candidate hypotheses separate from scientific confirmation.

• Reviewing task settings before a HypoGeniC run
• Checking duplicates across training and test data
• Estimating token and cost limits before model calls

Design scheduled AI workflows for document ingestion, batch processing, and model training using Prefect, Airflow, or Dagster. Compare orchestration tools and plan task dependencies, retries, caching, and monitoring through implementation fragments.

• Schedule document ingestion and RAG index refreshes
• Design batch workflows for LLM requests
• Connect model training with quality evaluation

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.

• Studying language model architecture through readable code
• Fine-tuning a model on custom instruction data
• Configuring LoRA training for a single GPU

Adapt large language models to specific tasks using LoRA and QLoRA, methods that train a small set of added parameters. Get guidance on preparing examples, choosing training settings, evaluating outputs, and saving or merging trained adapters.

• Adapting models to specialized terminology and output formats
• Planning training with limited GPU memory
• Preparing instruction-response datasets

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.

• Studying language model architecture through readable code
• Fine-tuning a model on custom instruction data
• Configuring LoRA training for a single GPU

Collect Trustpilot reviews for a company domain, with filters for ratings, language, dates, and reply status. Get structured review text, reviewer details, and company responses across pages to support reputation research and customer service analysis.

• Collect low-rated reviews to study customer complaints
• Gather reviews for competitor reputation comparisons
• Collect company replies and their publication dates

Run training with mock or real data in Megatron-LM and Megatron Bridge, match their settings, and compare loss curves, which show training error over time. Includes recipes and multi-GPU examples for checking training behavior.

• Compare Megatron-LM and Bridge loss curves
• Translate MLM command-line arguments into Bridge settings
• Check training on multiple GPUs

Use this skill when conditioning, loading, preparing, or labeling signal data for analysis or ML training. Covers: cleaning a single signal (fill gaps, remove drift, deoutlier, denoise, resample/align a time base) BEFORE analysis; building a `signalDatastore` pipeline; creating a `labeledSignalSet` for Signal Labeler; deriving labels (filename, folder, in-file, ROI, time-frequency ROI); stratified train/val/test splits; framing long signals; parallel processing; and shaping datastore output for `trainnet`. Triggers include "clean up this signal", "remove drift / detrend", "fill gaps", "remove spikes / outliers", "denoise", "resample to a uniform rate", "align channels", "labels from filenames", "stratified split", "prepare for Signal Labeler", and function names like `fillgaps`, `fillmissing`, `detrend`, `filloutliers`, `smoothdata`, `resample`, `synchronize`, `signalDatastore`, `labeledSignalSet`, `filenames2labels`, `folders2labels`, `splitlabels`, `framesig`, `framelbl`, `createDatastores`.

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