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.

Returns a CompletionFuture that resolves when loading completes. Use .await in async contexts or .block_on() for synchronous callers.

Requires macOS 12+ / iOS 15+.

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

Load a model from in-memory specification bytes asynchronously.

Creates an MLModelAsset from the specification data (synchronously), then loads the model asynchronously via the completion handler API.

The data parameter should contain the contents of a .mlmodel file (the protobuf specification, not a compiled .mlmodelc).

Requires macOS 14.4+ / iOS 17.4+.

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

Run a prediction asynchronously.

Builds the feature provider from the input tensors, then calls the async prediction API with a completion handler.

Requires macOS 14+ / iOS 17+.

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>

Run a synchronous prediction with named input tensors.

Accepts any type implementing AsMultiArray (both BorrowedTensor and OwnedTensor).

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 inputs(&self) -> Vec<FeatureDescription>

Get descriptions of all model inputs.

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>

Get descriptions of all model outputs.

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

Get model metadata (author, description, version, license).

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);
}

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

Create a new state for stateful prediction (macOS 15+ / iOS 18+).

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

Run prediction with persistent state (macOS 15+ / iOS 18+).

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

Run batch prediction for multiple input sets at once.

More efficient than calling predict() in a loop.

Trait Implementations

impl Debug for Model

Available on Apple only.

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

Formats the value using the given formatter.

impl Send for Model

Available on Apple only.

impl Sync for Model

Available on Apple only.