Enum ModelOpsCommands 

pub enum ModelOpsCommands {
    Finetune {

        file: Option<PathBuf>,
        method: String,
        rank: Option<u32>,
        vram: f64,
        plan: bool,
        data: Option<PathBuf>,
        output: Option<PathBuf>,
        adapter: Option<PathBuf>,
        merge: bool,
        epochs: u32,
        learning_rate: f64,
        model_size: Option<String>,
        task: Option<String>,
        num_classes: usize,
        checkpoint_format: String,
        oversample: bool,
        max_seq_len: Option<usize>,
        quantize_nf4: bool,
        gpus: Option<String>,
        gpu_backend: String,
        role: Option<String>,
        bind: Option<String>,
        coordinator: Option<String>,
        expect_workers: Option<usize>,
        wait_gpu: u64,
        adapters: Vec<String>,
        adapters_config: Option<PathBuf>,
        experimental_mps: bool,
        gpu_share: u32,
    
},
    Prune {
        file: PathBuf,
        method: String,
        target_ratio: f32,
        sparsity: f32,
        output: Option<PathBuf>,
        remove_layers: Option<String>,
        analyze: bool,
        plan: bool,
        calibration: Option<PathBuf>,
    },
    Distill {
        teacher: Option<PathBuf>,
        student: Option<PathBuf>,
        data: Option<PathBuf>,
        output: Option<PathBuf>,
        strategy: String,
        temperature: f64,
        alpha: f64,
        epochs: u32,
        plan: bool,
        config: Option<PathBuf>,
        stage: Option<String>,
    },
}

Variants

Finetune

Fine-tune model with LoRA/QLoRA (GH-244)

Fields

file: Option<PathBuf>

Input model file

method: String

Fine-tuning method: auto, full, lora, qlora

rank: Option<u32>

LoRA rank (default: auto-selected)

vram: f64

Available VRAM in GB

plan: bool

Plan mode (estimate only)

data: Option<PathBuf>

Training data file (JSONL format)

output: Option<PathBuf>

Output path (adapter dir or merged model)

adapter: Option<PathBuf>

Adapter path for merge mode

merge: bool

Merge adapter into base model

epochs: u32

Training epochs

learning_rate: f64

Learning rate

model_size: Option<String>

Model size for planning (e.g., “7B”, “1.5B”)

task: Option<String>

Fine-tuning task: classify (sequence classification)

num_classes: usize

Number of classes for classification task

checkpoint_format: String

Output format for checkpoints: apr, safetensors, or both (comma-separated)

oversample: bool

Oversample minority classes to match majority (for imbalanced datasets)

max_seq_len: Option<usize>

Maximum sequence length for GPU buffer allocation (lower = less VRAM)

quantize_nf4: bool

Quantize frozen weights to NF4 (4-bit) for QLoRA training (~8x VRAM savings)

gpus: Option<String>

GPU indices for data-parallel training (e.g., “0,1” for dual GPU)

gpu_backend: String

GPU backend selection: auto, cuda, wgpu

role: Option<String>

Distributed training role: coordinator or worker

bind: Option<String>

Address to bind (coordinator) or connect to (worker)

coordinator: Option<String>

Coordinator address for worker nodes (e.g., “intel:9000”)

expect_workers: Option<usize>

Expected number of workers (coordinator only)

wait_gpu: u64

Wait for VRAM availability before training (timeout in seconds, 0 = no wait)

adapters: Vec<String>

Multi-adapter training: data:checkpoint pairs (GPU-SHARE Phase 2) Format: –adapters data/corpus-a.jsonl:checkpoints/adapter-a Can be specified multiple times for concurrent adapter training.

adapters_config: Option<PathBuf>

Multi-adapter config file: TOML with [[adapter]] entries (GPU-SHARE §2.4)

experimental_mps: bool

Enable experimental CUDA MPS for concurrent GPU sharing (GPU-SHARE §1.5). WARNING: A GPU fault in any MPS client will crash ALL clients on that GPU.

gpu_share: u32

MPS thread percentage (1-100). Controls SM allocation per process. Only effective with –experimental-mps. Default: 50.

Prune

Prune model (structured/unstructured pruning) (GH-247)

Fields

file: PathBuf

Input model file

method: String

Pruning method: magnitude, structured, depth, width, wanda, sparsegpt

target_ratio: f32

Target pruning ratio (0-1)

sparsity: f32

Sparsity level (0-1)

output: Option<PathBuf>

Output file path

remove_layers: Option<String>

Layers to remove for depth pruning (e.g., “20-24”)

analyze: bool

Analyze mode (identify pruning opportunities)

plan: bool

Plan mode (estimate only)

calibration: Option<PathBuf>

Calibration data file

Distill

Knowledge distillation (teacher -> student) (GH-247, ALB-011)

Fields

teacher: Option<PathBuf>

Teacher model file (positional, for file-based mode)

student: Option<PathBuf>

Student model file

data: Option<PathBuf>

Training data file

output: Option<PathBuf>

Output file path

strategy: String

Distillation strategy: standard, progressive, ensemble

temperature: f64

Temperature for softmax scaling

alpha: f64

Alpha weight for KL vs task loss

epochs: u32

Training epochs

plan: bool

Plan mode (estimate only)

config: Option<PathBuf>

YAML config file for two-stage distillation (ALB-011)

stage: Option<String>

Distillation stage: precompute, train (logit KD), or generate (text-based, GH-455)

Trait Implementations

impl Debug for ModelOpsCommands

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

Formats the value using the given formatter.

impl FromArgMatches for ModelOpsCommands

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 Subcommand for ModelOpsCommands

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