Struct Script 

pub struct Script { /* private fields */ }

Implementations

impl Script

pub fn new(name: String) -> Script

pub fn with_ir(ir: ScriptIR) -> Script

pub fn get_name(&self) -> Option<&str>

pub fn set_name(&mut self, name: String)

pub fn get_ir(&self) -> Option<&ScriptIR>

pub fn get_ir_mut(&mut self) -> Option<&mut ScriptIR>

pub fn get_backend(&self) -> Option<Backend>

pub fn set_backend(&mut self, backend: Backend)

pub fn get_device(&self) -> Option<Device>

pub fn set_device(&mut self, device: Device)

pub fn add_input(&mut self, name: &str, tensor: Tensor)

Add an input tensor for script execution

Arguments

• name - Name of the input (must match script’s input names)
• tensor - Input tensor

Example

script.add_input("x", tensor_x);
script.add_input("y", tensor_y);
let result = script.run()?;

Examples found in repository

examples/simple-linear-train-script.rs (line 57)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let input_data: Vec<Vec<f32>> = (0..10000)
        .map(|i| {
            vec![
                (i % 100) as f32 / 100.0,
                ((i % 100) + 1) as f32 / 100.0,
                ((i % 100) + 2) as f32 / 100.0,
            ]
        })
        .collect();
    let target_data: Vec<Vec<f32>> = (0..10000).map(|i| vec![((i % 100) * 10) as f32 / 1000.0]).collect();

    let input_tensor = Tensor::new(input_data)?;
    let target_tensor = Tensor::new(target_data)?;

    // Build script
    let builder = Builder::new("linear_training".to_string());
    builder.start()?;

    let mut linear = Linear::new(3, 1, true, DType::F32)?;
    let mse_loss = MSE::new();
    let mut optimizer = SGD::new(0.01);

    let input = Tensor::input("input", &[10000, 3])?;
    input.requires_grad()?;
    let target = Tensor::input("target", &[10000, 1])?;

    let epochs = 1000;
    let mut final_loss = Tensor::full(&[], 0.0)?;

    for _ in 0..epochs {
        let pred = linear.forward(&input)?;
        let loss = mse_loss.forward((&pred, &target))?;

        loss.backward()?;

        optimizer.step(&mut linear.parameters())?;
        optimizer.zero_grad(&mut linear.parameters())?;

        final_loss = loss;
    }

    let params = linear.parameters();
    builder.add_output("loss", final_loss)?;
    builder.add_output("weight", *params[0])?;
    builder.add_output("bias", *params[1])?;

    builder.end()?;

    let mut script = builder.build()?;
    #[cfg(feature = "xla")]
    script.set_backend(Backend::XLA);

    script.add_input("input", input_tensor);
    script.add_input("target", target_tensor);

    println!("Compiling script...");
    let compile_start = Instant::now();
    script.compile()?;
    let compile_elapsed = compile_start.elapsed();
    println!("Compilation time: {:?}", compile_elapsed);

    println!("Running script...");
    let run_start = Instant::now();
    let output = script.run()?;
    let run_elapsed = run_start.elapsed();

    println!("Loss: {}", output["loss"]);
    println!("Weight: {}", output["weight"]);
    println!("Bias: {}", output["bias"]);
    println!("Execution time: {:?}", run_elapsed);
    println!("Total time: {:?}", compile_elapsed + run_elapsed);

    Ok(())
}

pub fn with_input(self, name: &str, tensor: Tensor) -> Script

Builder-style method to add input (returns self for chaining)

Example

let result = script
    .with_input("x", tensor_x)
    .with_input("y", tensor_y)
    .run()?;

pub fn clear_inputs(&mut self)

Clear all runtime inputs

pub fn get_inputs(&self) -> &HashMap<String, Tensor>

Get current runtime inputs

pub fn compile(&mut self) -> Result<(), HoduError>

Compile the script for execution

This method compiles the script IR into an optimized executable form. The compiled result is cached, so subsequent calls to run() will reuse it.

Example

script.compile()?;  // Explicit compilation (optional)
script.run()?;      // Uses cached compilation

Examples found in repository

examples/simple-linear-train-script.rs (line 62)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let input_data: Vec<Vec<f32>> = (0..10000)
        .map(|i| {
            vec![
                (i % 100) as f32 / 100.0,
                ((i % 100) + 1) as f32 / 100.0,
                ((i % 100) + 2) as f32 / 100.0,
            ]
        })
        .collect();
    let target_data: Vec<Vec<f32>> = (0..10000).map(|i| vec![((i % 100) * 10) as f32 / 1000.0]).collect();

    let input_tensor = Tensor::new(input_data)?;
    let target_tensor = Tensor::new(target_data)?;

    // Build script
    let builder = Builder::new("linear_training".to_string());
    builder.start()?;

    let mut linear = Linear::new(3, 1, true, DType::F32)?;
    let mse_loss = MSE::new();
    let mut optimizer = SGD::new(0.01);

    let input = Tensor::input("input", &[10000, 3])?;
    input.requires_grad()?;
    let target = Tensor::input("target", &[10000, 1])?;

    let epochs = 1000;
    let mut final_loss = Tensor::full(&[], 0.0)?;

    for _ in 0..epochs {
        let pred = linear.forward(&input)?;
        let loss = mse_loss.forward((&pred, &target))?;

        loss.backward()?;

        optimizer.step(&mut linear.parameters())?;
        optimizer.zero_grad(&mut linear.parameters())?;

        final_loss = loss;
    }

    let params = linear.parameters();
    builder.add_output("loss", final_loss)?;
    builder.add_output("weight", *params[0])?;
    builder.add_output("bias", *params[1])?;

    builder.end()?;

    let mut script = builder.build()?;
    #[cfg(feature = "xla")]
    script.set_backend(Backend::XLA);

    script.add_input("input", input_tensor);
    script.add_input("target", target_tensor);

    println!("Compiling script...");
    let compile_start = Instant::now();
    script.compile()?;
    let compile_elapsed = compile_start.elapsed();
    println!("Compilation time: {:?}", compile_elapsed);

    println!("Running script...");
    let run_start = Instant::now();
    let output = script.run()?;
    let run_elapsed = run_start.elapsed();

    println!("Loss: {}", output["loss"]);
    println!("Weight: {}", output["weight"]);
    println!("Bias: {}", output["bias"]);
    println!("Execution time: {:?}", run_elapsed);
    println!("Total time: {:?}", compile_elapsed + run_elapsed);

    Ok(())
}

pub fn run(&mut self) -> Result<HashMap<String, Tensor>, HoduError>

Execute the script with previously added inputs

If the script hasn’t been compiled yet, it will be compiled automatically. Subsequent calls will reuse the cached compilation.

Returns

• HoduResult<ExecutionOutputs> - Output tensors mapped by name

Example

script.add_input("x", tensor_x);
script.add_input("y", tensor_y);
let outputs = script.run()?;
let result = &outputs["result"];

Examples found in repository

examples/simple-linear-train-script.rs (line 68)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let input_data: Vec<Vec<f32>> = (0..10000)
        .map(|i| {
            vec![
                (i % 100) as f32 / 100.0,
                ((i % 100) + 1) as f32 / 100.0,
                ((i % 100) + 2) as f32 / 100.0,
            ]
        })
        .collect();
    let target_data: Vec<Vec<f32>> = (0..10000).map(|i| vec![((i % 100) * 10) as f32 / 1000.0]).collect();

    let input_tensor = Tensor::new(input_data)?;
    let target_tensor = Tensor::new(target_data)?;

    // Build script
    let builder = Builder::new("linear_training".to_string());
    builder.start()?;

    let mut linear = Linear::new(3, 1, true, DType::F32)?;
    let mse_loss = MSE::new();
    let mut optimizer = SGD::new(0.01);

    let input = Tensor::input("input", &[10000, 3])?;
    input.requires_grad()?;
    let target = Tensor::input("target", &[10000, 1])?;

    let epochs = 1000;
    let mut final_loss = Tensor::full(&[], 0.0)?;

    for _ in 0..epochs {
        let pred = linear.forward(&input)?;
        let loss = mse_loss.forward((&pred, &target))?;

        loss.backward()?;

        optimizer.step(&mut linear.parameters())?;
        optimizer.zero_grad(&mut linear.parameters())?;

        final_loss = loss;
    }

    let params = linear.parameters();
    builder.add_output("loss", final_loss)?;
    builder.add_output("weight", *params[0])?;
    builder.add_output("bias", *params[1])?;

    builder.end()?;

    let mut script = builder.build()?;
    #[cfg(feature = "xla")]
    script.set_backend(Backend::XLA);

    script.add_input("input", input_tensor);
    script.add_input("target", target_tensor);

    println!("Compiling script...");
    let compile_start = Instant::now();
    script.compile()?;
    let compile_elapsed = compile_start.elapsed();
    println!("Compilation time: {:?}", compile_elapsed);

    println!("Running script...");
    let run_start = Instant::now();
    let output = script.run()?;
    let run_elapsed = run_start.elapsed();

    println!("Loss: {}", output["loss"]);
    println!("Weight: {}", output["weight"]);
    println!("Bias: {}", output["bias"]);
    println!("Execution time: {:?}", run_elapsed);
    println!("Total time: {:?}", compile_elapsed + run_elapsed);

    Ok(())
}

pub fn to_bytes(&self) -> Result<Vec<u8>, HoduError>

Serialize the script to compressed bytes (works in also no-std)

pub fn from_bytes(data: &[u8]) -> Result<Script, HoduError>

Deserialize the script from bytes (works in also no-std)

pub fn save<P>(&self, path: P) -> Result<(), HoduError>

where P: AsRef<Path>,

Save the script to a file (requires std feature)

pub fn load<P>(path: P) -> Result<Script, HoduError>

where P: AsRef<Path>,

Load a script from a file (requires std feature)

Trait Implementations

impl Debug for Script

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

Formats the value using the given formatter.

impl Default for Script

fn default() -> Script

Returns the “default value” for a type.