Struct Model 

pub struct Model { /* private fields */ }

Implementations

impl Model

pub fn load_async( _path: impl AsRef<Path>, _compute_units: ComputeUnits, ) -> Result<CompletionFuture<Self>>

Load a compiled model asynchronously (stub for non-Apple platforms).

pub fn load_from_bytes( _data: &[u8], _compute_units: ComputeUnits, ) -> Result<CompletionFuture<Self>>

Load a model from in-memory bytes (stub for non-Apple platforms).

pub fn predict_async( &self, _inputs: &[(&str, &dyn AsMultiArray)], ) -> Result<CompletionFuture<Prediction>>

Run a prediction asynchronously (stub for non-Apple platforms).

impl Model

pub fn load( _path: impl AsRef<Path>, _compute_units: ComputeUnits, ) -> Result<Self>

Examples found in repository

examples/load_and_predict.rs (line 13)

fn main() {
    let model_path = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "tests/fixtures/test_linear.mlmodelc".to_string());

    println!("Loading model: {model_path}");
    let model = Model::load(&model_path, ComputeUnits::All).expect("Failed to load model");

    // Create a simple input tensor
    let input_data = vec![1.0f32, 2.0, 3.0, 4.0];
    let tensor =
        BorrowedTensor::from_f32(&input_data, &[1, 4]).expect("Failed to create tensor");

    println!("Running prediction...");
    let prediction = model.predict(&[("input", &tensor)]).expect("Prediction failed");

    let (output, shape) = prediction.get_f32("output").expect("Failed to get output");
    println!("Output shape: {shape:?}");
    println!("Output data: {output:?}");
}

examples/inspect_model.rs (line 13)

fn main() {
    let model_path = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "tests/fixtures/test_linear.mlmodelc".to_string());

    println!("Loading model: {model_path}");
    let model = Model::load(&model_path, ComputeUnits::All).expect("Failed to load model");

    println!("\n--- Inputs ---");
    for desc in model.inputs() {
        println!(
            "  {}: {:?} shape={:?} optional={}",
            desc.name(),
            desc.feature_type(),
            desc.shape(),
            desc.is_optional(),
        );
        if let Some(dt) = desc.data_type() {
            println!("    data_type: {dt}");
        }
    }

    println!("\n--- Outputs ---");
    for desc in model.outputs() {
        println!(
            "  {}: {:?} shape={:?}",
            desc.name(),
            desc.feature_type(),
            desc.shape(),
        );
        if let Some(dt) = desc.data_type() {
            println!("    data_type: {dt}");
        }
    }

    let meta = model.metadata();
    println!("\n--- Metadata ---");
    println!("  author: {:?}", meta.author);
    println!("  description: {:?}", meta.description);
    println!("  version: {:?}", meta.version);
    println!("  license: {:?}", meta.license);
}

pub fn path(&self) -> &Path

The filesystem path this model was loaded from.

pub fn predict( &self, _inputs: &[(&str, &dyn AsMultiArray)], ) -> Result<Prediction>

Examples found in repository

examples/load_and_predict.rs (line 21)

fn main() {
    let model_path = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "tests/fixtures/test_linear.mlmodelc".to_string());

    println!("Loading model: {model_path}");
    let model = Model::load(&model_path, ComputeUnits::All).expect("Failed to load model");

    // Create a simple input tensor
    let input_data = vec![1.0f32, 2.0, 3.0, 4.0];
    let tensor =
        BorrowedTensor::from_f32(&input_data, &[1, 4]).expect("Failed to create tensor");

    println!("Running prediction...");
    let prediction = model.predict(&[("input", &tensor)]).expect("Prediction failed");

    let (output, shape) = prediction.get_f32("output").expect("Failed to get output");
    println!("Output shape: {shape:?}");
    println!("Output data: {output:?}");
}

pub fn new_state(&self) -> Result<State>

pub fn predict_stateful( &self, _inputs: &[(&str, &dyn AsMultiArray)], _state: &State, ) -> Result<Prediction>

pub fn predict_batch(&self, _batch: &BatchProvider) -> Result<BatchPrediction>

pub fn inputs(&self) -> Vec<FeatureDescription>

Examples found in repository

examples/inspect_model.rs (line 16)

fn main() {
    let model_path = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "tests/fixtures/test_linear.mlmodelc".to_string());

    println!("Loading model: {model_path}");
    let model = Model::load(&model_path, ComputeUnits::All).expect("Failed to load model");

    println!("\n--- Inputs ---");
    for desc in model.inputs() {
        println!(
            "  {}: {:?} shape={:?} optional={}",
            desc.name(),
            desc.feature_type(),
            desc.shape(),
            desc.is_optional(),
        );
        if let Some(dt) = desc.data_type() {
            println!("    data_type: {dt}");
        }
    }

    println!("\n--- Outputs ---");
    for desc in model.outputs() {
        println!(
            "  {}: {:?} shape={:?}",
            desc.name(),
            desc.feature_type(),
            desc.shape(),
        );
        if let Some(dt) = desc.data_type() {
            println!("    data_type: {dt}");
        }
    }

    let meta = model.metadata();
    println!("\n--- Metadata ---");
    println!("  author: {:?}", meta.author);
    println!("  description: {:?}", meta.description);
    println!("  version: {:?}", meta.version);
    println!("  license: {:?}", meta.license);
}

pub fn outputs(&self) -> Vec<FeatureDescription>

Examples found in repository

examples/inspect_model.rs (line 30)

fn main() {
    let model_path = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "tests/fixtures/test_linear.mlmodelc".to_string());

    println!("Loading model: {model_path}");
    let model = Model::load(&model_path, ComputeUnits::All).expect("Failed to load model");

    println!("\n--- Inputs ---");
    for desc in model.inputs() {
        println!(
            "  {}: {:?} shape={:?} optional={}",
            desc.name(),
            desc.feature_type(),
            desc.shape(),
            desc.is_optional(),
        );
        if let Some(dt) = desc.data_type() {
            println!("    data_type: {dt}");
        }
    }

    println!("\n--- Outputs ---");
    for desc in model.outputs() {
        println!(
            "  {}: {:?} shape={:?}",
            desc.name(),
            desc.feature_type(),
            desc.shape(),
        );
        if let Some(dt) = desc.data_type() {
            println!("    data_type: {dt}");
        }
    }

    let meta = model.metadata();
    println!("\n--- Metadata ---");
    println!("  author: {:?}", meta.author);
    println!("  description: {:?}", meta.description);
    println!("  version: {:?}", meta.version);
    println!("  license: {:?}", meta.license);
}

pub fn metadata(&self) -> ModelMetadata

Examples found in repository

examples/inspect_model.rs (line 42)

fn main() {
    let model_path = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "tests/fixtures/test_linear.mlmodelc".to_string());

    println!("Loading model: {model_path}");
    let model = Model::load(&model_path, ComputeUnits::All).expect("Failed to load model");

    println!("\n--- Inputs ---");
    for desc in model.inputs() {
        println!(
            "  {}: {:?} shape={:?} optional={}",
            desc.name(),
            desc.feature_type(),
            desc.shape(),
            desc.is_optional(),
        );
        if let Some(dt) = desc.data_type() {
            println!("    data_type: {dt}");
        }
    }

    println!("\n--- Outputs ---");
    for desc in model.outputs() {
        println!(
            "  {}: {:?} shape={:?}",
            desc.name(),
            desc.feature_type(),
            desc.shape(),
        );
        if let Some(dt) = desc.data_type() {
            println!("    data_type: {dt}");
        }
    }

    let meta = model.metadata();
    println!("\n--- Metadata ---");
    println!("  author: {:?}", meta.author);
    println!("  description: {:?}", meta.description);
    println!("  version: {:?}", meta.version);
    println!("  license: {:?}", meta.license);
}

Trait Implementations

impl Debug for Model

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

Formats the value using the given formatter.