Enum FinetuneCommand 

pub enum FinetuneCommand {
    Plan {

        data: PathBuf,
        model_path: Option<PathBuf>,
        model_size: String,
        num_classes: usize,
        output_dir: PathBuf,
        strategy: String,
        budget: usize,
        scout: bool,
        max_epochs: usize,
        lr: Option<f32>,
        lora_rank: Option<usize>,
        batch_size: Option<usize>,
        lora_alpha: Option<f32>,
        warmup: Option<f32>,
        gradient_clip: Option<f32>,
        lr_min_ratio: Option<f32>,
        class_weights: Option<String>,
        target_modules: Option<String>,
    
},
    Apply {
        plan: PathBuf,
        model_path: PathBuf,
        data: PathBuf,
        output_dir: PathBuf,
    },
}

Finetune subcommands (forjar-style plan/apply)

Variants

Plan

Generate a training plan (validate data, estimate resources, build HPO config)

Fields

data: PathBuf

Path to training data (JSONL with {“input”: …, “label”: N})

model_path: Option<PathBuf>

Path to model weights directory (e.g., Qwen2.5-Coder-0.5B)

model_size: String

Model size hint (e.g., “0.5B”, “9B”)

num_classes: usize

Number of output classes

output_dir: PathBuf

Output directory for plan and checkpoints

strategy: String

HPO strategy: tpe, grid, random, or manual

budget: usize

HPO budget (number of trials)

scout: bool

Scout mode (1 epoch per trial for fast HPO)

max_epochs: usize

Maximum epochs per trial

lr: Option<f32>

Manual learning rate (for strategy=manual)

lora_rank: Option<usize>

Manual LoRA rank (for strategy=manual)

batch_size: Option<usize>

Manual batch size (for strategy=manual)

lora_alpha: Option<f32>

LoRA alpha (for strategy=manual; defaults to lora_rank)

warmup: Option<f32>

Warmup fraction (for strategy=manual; default 0.1)

gradient_clip: Option<f32>

Gradient clip norm (for strategy=manual; default 1.0)

lr_min_ratio: Option<f32>

LR min ratio for cosine decay (for strategy=manual; default 0.01)

class_weights: Option<String>

Class weight strategy: uniform, inverse_freq, sqrt_inverse

target_modules: Option<String>

Target modules: qv, qkv, all_linear

Apply

Execute a training plan (load model, run trials, save checkpoints)

Fields

plan: PathBuf

Path to plan YAML/JSON (generated by finetune plan)

model_path: PathBuf

Path to model weights directory

data: PathBuf

Path to training data (JSONL)

output_dir: PathBuf

Output directory for checkpoints and leaderboard

Trait Implementations

impl Clone for FinetuneCommand

fn clone(&self) -> FinetuneCommand

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FinetuneCommand

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for FinetuneCommand

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl PartialEq for FinetuneCommand

fn eq(&self, other: &FinetuneCommand) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Subcommand for FinetuneCommand

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand

impl StructuralPartialEq for FinetuneCommand