> This page is for version Latest (default).
> For other versions, use one of these documentation indexes:
> - Latest (default): https://docs.nvidia.com/nemo-helix/latest/llms.txt
> - 0.8.0: https://docs.nvidia.com/nemo-helix/v0.8.0/llms.txt
> - 0.7.1: https://docs.nvidia.com/nemo-helix/v0.7.1/llms.txt
> - 0.7.0: https://docs.nvidia.com/nemo-helix/v0.7.0/llms.txt
> - 0.6.0: https://docs.nvidia.com/nemo-helix/v0.6.0/llms.txt
> - 0.5.1: https://docs.nvidia.com/nemo-helix/v0.5.1/llms.txt
> - 0.5.0: https://docs.nvidia.com/nemo-helix/v0.5.0/llms.txt
> - 0.4.0: https://docs.nvidia.com/nemo-helix/v0.4.0/llms.txt
> - 0.3.0: https://docs.nvidia.com/nemo-helix/v0.3.0/llms.txt
> - 0.2.0: https://docs.nvidia.com/nemo-helix/v0.2.0/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/nemo-helix/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/nemo-helix/_mcp/server.

# Training Configuration

> **Tip**
>
> Want to learn about training concepts at a high level? Check out the [Customization concepts](/documentation/customizer-reference/customization-concepts) page.

NeMo Customizer ships **two training backends**, and each accepts its own job configuration. Choose the backend that matches your hardware and training goal, then configure the hyperparameters from that backend's schema below.

| Backend                 | Best for                                                 | Training methods                                     | Hardware                                                                                 |
| ----------------------- | -------------------------------------------------------- | ---------------------------------------------------- | ---------------------------------------------------------------------------------------- |
| **Automodel** (default) | Production fine-tuning, larger models, multi-GPU scaling | SFT, distillation; LoRA, merged-LoRA, or full-weight | Single- or multi-GPU (tensor / pipeline / context / expert parallel)                     |
| **Unsloth**             | Memory-constrained single-GPU training                   | SFT; LoRA or full-weight                             | Single GPU; optional 4-bit / 8-bit loading for LoRA, unquantized loading for full-weight |

> **Note**
>
> The two backends do **not** share field names. For example, Automodel uses `batch.global_batch_size` / `batch.micro_batch_size` and a `parallelism` block; Unsloth uses `batch.per_device_train_batch_size` / `batch.gradient_accumulation_steps` and a `hardware` block. Both schemas reject unknown keys, so a field from one backend will not validate against the other.

Each backend can also print its live schema, and the generated REST shapes are in the [Customizer API Reference](/documentation/reference/api-reference) (search for `AutomodelJobInput` and `UnslothJobInput`).

## Start from a Reference Recipe

The training libraries publish benchmarked recipes per model. Start a job from the closest one instead of from defaults:

* **Automodel jobs**: [Automodel `r0.6.0` LLM fine-tuning recipes](https://github.com/NVIDIA-NeMo/Automodel/tree/r0.6.0/examples/llm_finetune). Nemotron recipes are under [`llm_finetune/nemotron`](https://github.com/NVIDIA-NeMo/Automodel/tree/r0.6.0/examples/llm_finetune/nemotron).
* **RL jobs (DPO, GRPO)**: [NeMo-RL `r0.8.0` recipes](https://github.com/NVIDIA-NeMo/RL/tree/r0.8.0/examples/configs/recipes/llm). Only the `fsdp2` and `automodel` recipes apply; Megatron recipes do not.

Copy the learning rate, LoRA rank and alpha, batch sizes, sequence length, and parallel layout into the job, then scale the batch to your GPU count. Ignore `max_steps` and the `ci` block; those are CI smoke-test settings.

---

## Automodel Configuration

An Automodel job is configured with the following top-level sections: `model`, `dataset`, `training`, `schedule`, `batch`, `optimizer`, `parallelism`, `output`, and (optionally) `integrations`.

### Model and Dataset

| Field                     | Description                                                               | Default      |
| ------------------------- | ------------------------------------------------------------------------- | ------------ |
| `model`                   | Base **Model Entity** reference (`name` or `workspace/name`) to fine-tune | *(required)* |
| `dataset.training`        | Training fileset reference (`name` or `workspace/name`)                   | *(required)* |
| `dataset.validation`      | Optional validation fileset reference                                     | `null`       |
| `dataset.prompt_template` | Optional prompt template for custom dataset schemas                       | `null`       |

### Training Method

| Parameter                  | Values                                   | Description                                                                                                                          | Default       |
| -------------------------- | ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ | ------------- |
| `training.training_type`   | `sft`, `distillation`                    | Training method                                                                                                                      | `sft`         |
| `training.finetuning_type` | `lora`, `lora_merged`, `all_weights`     | Adapter regime. `lora` trains an adapter; `lora_merged` merges it into the base weights; `all_weights` performs full-weight training | `lora`        |
| `training.lora`            | `{ rank, alpha, merge, target_modules }` | LoRA configuration (auto-filled with defaults when `finetuning_type` is a LoRA variant)                                              | *(see below)* |
| `training.max_seq_length`  | integer                                  | Maximum sequence length                                                                                                              | `2048`        |

LoRA parameters (`training.lora`):

| Parameter        | Description                                                                | Default |
| ---------------- | -------------------------------------------------------------------------- | ------- |
| `rank`           | LoRA rank (low-rank dimension). Higher = more capacity and memory          | `16`    |
| `alpha`          | LoRA scaling factor                                                        | `32`    |
| `merge`          | Merge the adapter into the base model at the end of training               | `false` |
| `target_modules` | List of module patterns to adapt; `null` applies LoRA to all linear layers | `null`  |

### Schedule

| Parameter                     | Description                                                                                                                       | Default |
| ----------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ------- |
| `schedule.epochs`             | Number of passes over the training data                                                                                           | `1`     |
| `schedule.max_steps`          | Optional cap on training steps. When set, training stops at this many steps even if `epochs` is not reached                       | `null`  |
| `schedule.val_check_interval` | Validation cadence. Use a fractional value (e.g. `0.5` for twice per epoch); avoid integer step counts that may not divide evenly | `null`  |
| `schedule.seed`               | Random seed                                                                                                                       | `null`  |

### Batch

| Parameter                 | Description                                               | Default |
| ------------------------- | --------------------------------------------------------- | ------- |
| `batch.global_batch_size` | Effective batch size across all data-parallel ranks       | `8`     |
| `batch.micro_batch_size`  | Per-step batch size on each device                        | `1`     |
| `batch.sequence_packing`  | Pack multiple samples into one sequence to reduce padding | `false` |

### Optimizer

| Parameter                 | Description                                  | Default |
| ------------------------- | -------------------------------------------- | ------- |
| `optimizer.learning_rate` | Step size for weight updates                 | `5e-6`  |
| `optimizer.weight_decay`  | L2 regularization strength                   | `0.01`  |
| `optimizer.warmup_steps`  | Linear warmup steps before the main schedule | `0`     |

### Parallelism

The `parallelism` block scales Automodel training across GPUs and nodes.

| Parameter                            | Description                                                                                          | Default |
| ------------------------------------ | ---------------------------------------------------------------------------------------------------- | ------- |
| `parallelism.num_nodes`              | Number of training nodes                                                                             | `1`     |
| `parallelism.num_gpus_per_node`      | GPUs per node                                                                                        | `1`     |
| `parallelism.tensor_parallel_size`   | GPUs for tensor parallelism (splits layers across GPUs for large models)                             | `1`     |
| `parallelism.pipeline_parallel_size` | GPUs for pipeline parallelism (splits model stages across GPUs)                                      | `1`     |
| `parallelism.context_parallel_size`  | GPUs for context parallelism (for very long sequences)                                               | `1`     |
| `parallelism.expert_parallel_size`   | Expert parallelism for MoE models; must divide the number of experts. Leave unset for non-MoE models | `null`  |

> **Note**
>
> **GPU relationships and constraints:**
>
> * `total_gpus = num_gpus_per_node × num_nodes`.
> * `total_gpus` must be divisible by `tensor_parallel_size × pipeline_parallel_size × context_parallel_size`.
> * `data_parallel_size` is derived as `total_gpus / (TP × PP × CP)`, and `global_batch_size` must be divisible by `micro_batch_size × data_parallel_size`.
> * For MoE models, when `expert_parallel_size` is set: the number of experts must be divisible by `expert_parallel_size`, `(data_parallel_size × context_parallel_size)` must be divisible by `expert_parallel_size`, and `tensor_parallel_size` must be `1` when `expert_parallel_size > 1`.

### Distillation

When `training.training_type` is `"distillation"`, the following additional fields configure knowledge distillation from a teacher model:

| Parameter                           | Description                                                                                                  | Default      |
| ----------------------------------- | ------------------------------------------------------------------------------------------------------------ | ------------ |
| `training.teacher_model`            | Teacher Model Entity reference. Required for distillation. Must share the student's tokenizer and vocabulary | *(required)* |
| `training.teacher_precision`        | Precision for loading the frozen teacher (`bf16`, `fp16`, `fp32`)                                            | `bf16`       |
| `training.distillation_ratio`       | Balance between cross-entropy loss and KD loss. `0.0` = CE only, `1.0` = KD only                             | `0.5`        |
| `training.distillation_temperature` | Softmax temperature for KD. Higher = softer distributions                                                    | `1.0`        |
| `training.offload_teacher`          | Offload the teacher model to save GPU memory                                                                 | `false`      |

> **Note**
>
> * Knowledge distillation uses **logit-pair distillation** — the student learns to match the teacher's output probability distribution.
> * Both student and teacher must be **full-weight Model Entities** and **share the same tokenizer and vocabulary**. Use models from the same family (for example, Qwen3 0.6B + Qwen3 8B).
> * Both models are loaded during training; plan GPU memory accordingly (or set `offload_teacher`).

---

## Unsloth Configuration

An Unsloth job is configured with the following top-level sections: `model`, `dataset`, `training`, `schedule`, `batch`, `optimizer`, `hardware`, `output`, and (optionally) `integrations`. Unsloth runs on a **single GPU** and supports 4-bit / 8-bit quantized loading for LoRA. Full-weight training must load the model without quantization.

### Model

| Parameter                 | Description                                                                                                                                                       | Default      |
| ------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------ |
| `model.name`              | Base Model Entity reference (`name` or `workspace/name`)                                                                                                          | *(required)* |
| `model.max_seq_length`    | Maximum sequence length                                                                                                                                           | `2048`       |
| `model.load_in_4bit`      | Load the base model in 4-bit (bitsandbytes). Mutually exclusive with `load_in_8bit`                                                                               | `true`       |
| `model.load_in_8bit`      | Load the base model in 8-bit                                                                                                                                      | `false`      |
| `model.dtype`             | Compute dtype (`auto`, `bfloat16`, `float16`, `float32`)                                                                                                          | `auto`       |
| `model.trust_remote_code` | Allow custom model code from the checkpoint                                                                                                                       | `false`      |
| `model.device_map`        | Device placement forwarded to Unsloth. Accepts `auto`, `balanced`, `sequential`, a device index, or a custom map. `null` pins the model to the single visible GPU | `null`       |
| `model.rope_scaling`      | RoPE scaling configuration for long-context extension, such as `{"type": "linear", "factor": 2.0}`                                                                | `null`       |

> **Note**
>
> Full-weight training (`training.finetuning_type: "all_weights"`) cannot be combined with quantized loading. Set `load_in_4bit` and `load_in_8bit` to `false` for full-weight runs.

### Dataset

| Parameter                     | Description                                                               | Default      |
| ----------------------------- | ------------------------------------------------------------------------- | ------------ |
| `dataset.path`                | Training fileset reference (`name` or `workspace/name`)                   | *(required)* |
| `dataset.text_field`          | Row field consumed by the trainer                                         | `text`       |
| `dataset.apply_chat_template` | Apply the tokenizer's chat template to rows containing a `messages` field | `false`      |
| `dataset.validation_path`     | Optional validation fileset reference                                     | `null`       |
| `dataset.packing`             | Pack multiple samples into one sequence to reduce padding                 | `false`      |

### Training Method

| Parameter                             | Values                     | Description                                                                           | Default       |
| ------------------------------------- | -------------------------- | ------------------------------------------------------------------------------------- | ------------- |
| `training.training_type`              | `sft`                      | Training method                                                                       | `sft`         |
| `training.finetuning_type`            | `lora`, `all_weights`      | Adapter regime. `lora` trains an adapter; `all_weights` performs full-weight training | `lora`        |
| `training.lora`                       | `LoRAParams` object        | LoRA configuration (auto-filled with defaults when `finetuning_type` is `lora`)       | *(see below)* |
| `training.use_gradient_checkpointing` | `unsloth`, `true`, `false` | Gradient checkpointing mode. `unsloth` uses Unsloth's optimized implementation        | `unsloth`     |

LoRA parameters (`training.lora`):

| Parameter             | Description                                                                                           | Default                                                                                             |
| --------------------- | ----------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
| `rank`                | LoRA rank                                                                                             | `16`                                                                                                |
| `alpha`               | LoRA scaling factor                                                                                   | `16`                                                                                                |
| `dropout`             | LoRA dropout probability                                                                              | `0.0`                                                                                               |
| `target_modules`      | Modules to adapt                                                                                      | Unsloth's 7-module set: `q_proj`, `k_proj`, `v_proj`, `o_proj`, `gate_proj`, `up_proj`, `down_proj` |
| `bias`                | Bias training mode (`none`, `all`, `lora_only`)                                                       | `none`                                                                                              |
| `use_rslora`          | Use rank-stabilized LoRA                                                                              | `false`                                                                                             |
| `random_state`        | LoRA initialization seed                                                                              | `3407`                                                                                              |
| `use_dora`            | Use weight-decomposed LoRA (DoRA). Can improve quality at low ranks with additional training overhead | `false`                                                                                             |
| `loftq_config`        | LoftQ initialization configuration for quantized base models                                          | `null`                                                                                              |
| `modules_to_save`     | Additional non-LoRA modules to train and save in full, such as `embed_tokens` or `lm_head`            | `null`                                                                                              |
| `layers_to_transform` | Layer index or list of layer indexes to receive LoRA; `null` applies LoRA to all layers               | `null`                                                                                              |
| `layer_replication`   | Layer-replication ranges, such as `[[0, 16], [8, 24]]`                                                | `null`                                                                                              |
| `init_lora_weights`   | LoRA initialization: `true`, `false`, `gaussian`, `pissa`, `olora`, or `loftq`                        | `true`                                                                                              |

### Schedule

| Parameter                      | Description                                                                            | Default  |
| ------------------------------ | -------------------------------------------------------------------------------------- | -------- |
| `schedule.epochs`              | Number of passes over the training data                                                | `1`      |
| `schedule.max_steps`           | Optional cap on training steps (overrides `epochs` when set)                           | `null`   |
| `schedule.warmup_steps`        | Linear warmup steps. Mutually exclusive with `warmup_ratio`                            | `0`      |
| `schedule.warmup_ratio`        | Warmup as a fraction of total steps                                                    | `null`   |
| `schedule.lr_scheduler_type`   | `linear`, `cosine`, `constant`, `constant_with_warmup`, `cosine_with_restarts`         | `linear` |
| `schedule.logging_steps`       | Logging cadence (steps)                                                                | `1`      |
| `schedule.save_steps`          | Checkpoint cadence (steps)                                                             | `null`   |
| `schedule.eval_steps`          | Evaluation cadence (steps)                                                             | `null`   |
| `schedule.seed`                | Random seed                                                                            | `3407`   |
| `schedule.lr_scheduler_kwargs` | Additional scheduler arguments, such as `{"num_cycles": 3}` for `cosine_with_restarts` | `null`   |

### Batch

| Parameter                           | Description                                | Default |
| ----------------------------------- | ------------------------------------------ | ------- |
| `batch.per_device_train_batch_size` | Per-step batch size on the GPU             | `1`     |
| `batch.gradient_accumulation_steps` | Steps to accumulate before a weight update | `1`     |

### Optimizer

| Parameter                          | Description                                                                                                                             | Default      |
| ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | ------------ |
| `optimizer.learning_rate`          | Step size for weight updates                                                                                                            | `2e-4`       |
| `optimizer.weight_decay`           | L2 regularization strength                                                                                                              | `0.0`        |
| `optimizer.optim`                  | Optimizer (`adamw_torch`, `adamw_torch_fused`, `adamw_8bit`, `paged_adamw_8bit`, `sgd`). 8-bit optimizers reduce optimizer-state memory | `adamw_8bit` |
| `optimizer.adam_beta1`             | Adam/AdamW first-moment decay                                                                                                           | `0.9`        |
| `optimizer.adam_beta2`             | Adam/AdamW second-moment decay                                                                                                          | `0.999`      |
| `optimizer.adam_epsilon`           | Adam/AdamW epsilon for numerical stability                                                                                              | `1e-8`       |
| `optimizer.max_grad_norm`          | Maximum gradient norm for clipping                                                                                                      | `1.0`        |
| `optimizer.label_smoothing_factor` | Cross-entropy label smoothing factor; `0.0` disables smoothing                                                                          | `0.0`        |
| `optimizer.neftune_noise_alpha`    | NEFTune embedding-noise alpha; `null` disables NEFTune                                                                                  | `null`       |

### Hardware

| Parameter            | Description                                                                                        | Default |
| -------------------- | -------------------------------------------------------------------------------------------------- | ------- |
| `hardware.gpus`      | Comma-separated GPU indices (`0` or `0,1`) for `CUDA_VISIBLE_DEVICES` (selection, not reservation) | `null`  |
| `hardware.precision` | Mixed-precision dtype (`bf16`, `fp16`). `bf16` recommended for Ampere+                             | `bf16`  |

### Output

| Parameter            | Description                                                              | Default                          |
| -------------------- | ------------------------------------------------------------------------ | -------------------------------- |
| `output.name`        | Output Model Entity or adapter name                                      | Auto-generated from the job name |
| `output.description` | Optional description for the generated artifact                          | `null`                           |
| `output.save_method` | LoRA checkpoint serialization (see below); omit for full-weight training | `lora`                           |

The `output.save_method` field accepts:

| `save_method`  | Result                                                         |
| -------------- | -------------------------------------------------------------- |
| `lora`         | Saves the LoRA adapter (default)                               |
| `merged_16bit` | Merges the adapter into the base and saves a 16-bit checkpoint |
| `merged_4bit`  | Merges the adapter into the base and saves a 4-bit checkpoint  |

The `merged_*` methods are only valid when `training.finetuning_type` is `lora`. When `training.finetuning_type` is `all_weights`, omit `output.save_method`; the training driver saves the full trained checkpoint.

---

## Reinforcement Learning Configuration (DPO and GRPO)

The `rl` backend runs two methods on a Ray cluster, selected by `training.type`. It requires a platform configured with `platform.runtime: kubernetes` and has no local Docker fallback.

| `training.type` | Trains on            | Dataset                                                              |
| --------------- | -------------------- | -------------------------------------------------------------------- |
| `"dpo"`         | Preference pairs     | One fileset holding `training.jsonl` and `validation.jsonl`          |
| `"grpo"`        | A reward environment | One dataset fileset of rollout rows, **plus** an environment fileset |

> **Note**
>
> `training.type` is required. It is the union discriminator, so a payload that omits it is rejected with `union_tag_not_found` rather than defaulting to one of the two.

Unlike the other backends, `model`, `dataset`, and (for GRPO) `environment` are plain string references rather than objects:

```json
{
  "model": "default/qwen3-0.6b",
  "dataset": "default/ascii-tree-dataset",
  "environment": "default/ascii-tree",
  "training": { "type": "grpo", "epochs": 1, "batch_size": 32, "num_generations_per_prompt": 8 },
  "output": { "name": "qwen3-0.6b-ascii-tree" }
}
```

### Shared Fields

| Field                             | Description                                                                                  | Default    |
| --------------------------------- | -------------------------------------------------------------------------------------------- | ---------- |
| `learning_rate`                   | Peak learning rate. DPO uses a low value (`5e-6`–`1e-5`); GRPO lower still                   | `1e-4`     |
| `epochs`                          | Passes over the dataset                                                                      | `1`        |
| `max_steps`                       | Global step cap. Caps the run at `min(max_steps, epochs × steps_per_epoch)`                  | `null`     |
| `batch_size` / `micro_batch_size` | Global batch across all GPUs / per-GPU micro batch                                           | `32` / `1` |
| `max_seq_length`                  | Maximum token sequence length                                                                | `2048`     |
| `activation_checkpointing`        | Recompute activations in the backward pass to cut memory. The first setting to enable on OOM | `false`    |
| `val_check_interval`              | Float ≤ 1.0 is a fraction of an epoch; above 1.0 is a step count                             | `null`     |
| `keep_top_k`                      | Best checkpoints to retain                                                                   | `1`        |

### DPO Fields

| Field                    | Description                                                                                        | Default |
| ------------------------ | -------------------------------------------------------------------------------------------------- | ------- |
| `ref_policy_kl_penalty`  | **β** — how strongly the policy stays tied to the reference model. The main DPO control            | `0.05`  |
| `preference_loss_weight` | Weight on the preference loss term                                                                 | `1.0`   |
| `sft_loss_weight`        | Weight on an auxiliary SFT regularization loss. Raise to anchor the policy to the chosen responses | `0.0`   |

DPO is full-weight only.

### GRPO Fields

| Field                               | Description                                                                                   | Default        |
| ----------------------------------- | --------------------------------------------------------------------------------------------- | -------------- |
| `num_generations_per_prompt`        | Group size. The spread of rewards within a group is the entire learning signal                | `8`            |
| `num_prompts_per_step`              | Prompts sampled per step. Derived from `batch_size / num_generations_per_prompt` when omitted | `null`         |
| `temperature`                       | Rollout sampling temperature. Must exceed 0                                                   | `1.0`          |
| `top_k`                             | Restrict sampling to the k most likely tokens. Unset samples the full distribution            | `null`         |
| `max_rollout_turns`                 | Maximum agent turns per rollout                                                               | `1`            |
| `overlong_filtering`                | Zero the loss contribution of responses truncated at the generation cap                       | `false`        |
| `ref_policy_kl_penalty`             | KL coefficient against the reference policy                                                   | `0.0`          |
| `ratio_clip_min` / `ratio_clip_max` | PPO-style importance ratio clip bounds                                                        | `0.2` / `0.28` |
| `val_at_start`                      | Run validation before the first step, so baseline and result come from one job                | `false`        |

Advanced controls, collapsed by default in most workflows:

| Field                                        | Description                                                                                                      | Default |
| -------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | ------- |
| `ratio_clip_c`                               | Dual-clip bound. Puts a floor under the loss for tokens with a negative advantage. Must exceed 1; `3` is typical | `null`  |
| `advantage_clip_low` / `advantage_clip_high` | Bounds applied to advantages after normalization. `low` must be below `high`                                     | `null`  |
| `normalize_rewards`                          | Divide each group's advantages by their standard deviation                                                       | `true`  |
| `use_leave_one_out_baseline`                 | Compare each response against the mean of the others in its group rather than a mean including itself            | `true`  |
| `use_on_policy_kl_approximation`             | Estimate KL against the policy that generated the rollouts                                                       | `true`  |
| `use_importance_sampling_correction`         | Reweight tokens by the likelihood ratio between training and rollout policies                                    | `true`  |

### Parameter Efficiency (GRPO)

DPO is full-weight only. GRPO trains either way, selected by `training.finetuning_type`.

| Value                   | Trains       | Produces                                                     |
| ----------------------- | ------------ | ------------------------------------------------------------ |
| `all_weights` (default) | Every weight | A model entity                                               |
| `lora`                  | An adapter   | An HF PEFT adapter entity, registered against the base model |
| `lora_merged`           | —            | Rejected — GRPO does not merge adapters at export            |

The output type is inferred from this field; `output` carries only `name`.

| `lora` field      | Default                                  | Description                                                                                                                                                                    |
| ----------------- | ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `rank`            | `16`                                     | LoRA rank                                                                                                                                                                      |
| `alpha`           | `32`                                     | Scaling factor. Effective adapter learning-rate multiplier is `alpha / rank`                                                                                                   |
| `dropout`         | `0.0`                                    | Dropout applied after the adapter                                                                                                                                              |
| `target_modules`  | `null`                                   | Module names to adapt                                                                                                                                                          |
| `exclude_modules` | `null`                                   | Module name patterns to skip                                                                                                                                                   |
| `use_triton`      | unset, compiler picks default at runtime | Triton LoRA kernels: `true` at `tensor_parallel_size` 1, `false` for greater than 1. Leave unset; an explicit `true` with `tensor_parallel_size` above 1 is rejected at submit |

> **Note**
>
> Leaving both `target_modules` and `exclude_modules` unset adapts every linear layer. Setting either one turns that off, so `exclude_modules` alone does not mean "all linear layers except these." Supplying a `lora` block alongside `all_weights` is rejected.

> **Tip**
>
> GRPO progress is read on **reward**, not loss — the surrogate loss oscillates near zero and says nothing about run quality. See [GRPO and Reward Environments](/documentation/customizer-reference/grpo-and-reward-environments) for environment packaging, dataset format, and the metrics to monitor.

---

## GPU Memory Guidelines

Estimated GPU requirements by model size:

| Model Size | LoRA (1 GPU) | Full FT (min GPUs) |
| ---------- | ------------ | ------------------ |
| 1B         | 16 GB        | 1 × 24 GB          |
| 3B         | 24 GB        | 2 × 24 GB          |
| 7-8B       | 40 GB        | 2-4 × 80 GB        |
| 13B        | 80 GB        | 4 × 80 GB          |
| 70B        | 2 × 80 GB    | 8+ × 80 GB         |

> **Tip**
>
> Use LoRA for most fine-tuning tasks — it is significantly more memory-efficient and often achieves results comparable to full fine-tuning. On a single memory-constrained GPU, the Unsloth backend with 4-bit loading fits the largest adapters.