Enum OptimizeCommands 

pub enum OptimizeCommands {
    Precision {
        script: String,
    },
    BatchSize {
        model: String,
        seq_len: u32,
        amp: bool,
        gpu: u32,
    },
    Checkpoint {
        script: String,
        target_mem: f32,
    },
    DataPipeline {
        script: String,
        steps: u32,
    },
    Memory,
    Numa,
    Scan {
        script: Option<String>,
    },
    Auto {
        script: String,
        output: String,
    },
}

Variants

Precision

Analyze model for mixed precision and auto-generate AMP wrapper

Fields

script: String

Training script to analyze and wrap

BatchSize

Calculate optimal batch size for your GPU and model

Fields

model: String

Model name or parameter count (e.g. “125M”, “1.3B”, “gpt2”, “llama-7b”)

seq_len: u32

Sequence length (default: 512)

amp: bool

Use mixed precision (halves memory per parameter)

gpu: u32

GPU ID (default: 0)

Checkpoint

Analyze and enable gradient checkpointing for large models

Fields

script: String

Training script or model path

target_mem: f32

Target memory usage fraction (0.0-1.0, default: 0.85)

DataPipeline

Profile data pipeline and detect bottlenecks

Fields

script: String

Training script to profile

steps: u32

Number of steps to profile (default: 20)

Memory

Configure CUDA memory allocator for optimal performance

Numa

Configure NUMA-aware data placement

Scan

Full optimization scan — analyzes everything and generates a report

Fields

script: Option<String>

Training script to analyze (optional — scans GPU environment if omitted)

Auto

Auto-optimize: generate a wrapper script with all optimizations applied

Fields

script: String

Training script to optimize

output: String

Output optimized wrapper script

Trait Implementations

impl FromArgMatches for OptimizeCommands

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 OptimizeCommands

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