ronn-api 0.1.0

High-level inference API for RONN - session management and async execution
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use crate::error::{Error, Result};
use crate::session::{SessionBuilder, SessionOptions};
use ronn_onnx::{LoadedModel, ModelLoader};
use std::path::Path;
use std::sync::Arc;
use tracing::info;

/// Represents a loaded ML model
pub struct Model {
    inner: Arc<LoadedModel>,
}

impl Model {
    /// Load a model from an ONNX file
    ///
    /// # Example
    /// ```no_run
    /// use ronn_api::Model;
    ///
    /// let model = Model::load("model.onnx")?;
    /// # Ok::<(), ronn_api::Error>(())
    /// ```
    pub fn load<P: AsRef<Path>>(path: P) -> Result<Self> {
        info!("Loading model from: {:?}", path.as_ref());
        let loaded = ModelLoader::load_from_file(path)?;
        Ok(Self {
            inner: Arc::new(loaded),
        })
    }

    /// Load a model from bytes
    ///
    /// # Example
    /// ```no_run
    /// use ronn_api::Model;
    ///
    /// let bytes = std::fs::read("model.onnx")?;
    /// let model = Model::from_bytes(&bytes)?;
    /// # Ok::<(), ronn_api::Error>(())
    /// ```
    pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
        info!("Loading model from bytes ({} bytes)", bytes.len());
        let loaded = ModelLoader::load_from_bytes(bytes)?;
        Ok(Self {
            inner: Arc::new(loaded),
        })
    }

    /// Create an inference session with default options
    ///
    /// # Example
    /// ```no_run
    /// use ronn_api::Model;
    ///
    /// let model = Model::load("model.onnx")?;
    /// let session = model.create_session_default()?;
    /// # Ok::<(), ronn_api::Error>(())
    /// ```
    pub fn create_session_default(&self) -> Result<crate::session::InferenceSession> {
        self.create_session(SessionOptions::default())
    }

    /// Create an inference session with custom options
    ///
    /// # Example
    /// ```no_run
    /// use ronn_api::{Model, SessionOptions, OptimizationLevel};
    /// use ronn_providers::ProviderType;
    ///
    /// let model = Model::load("model.onnx")?;
    /// let options = SessionOptions::new()
    ///     .with_optimization_level(OptimizationLevel::O3)
    ///     .with_provider(ProviderType::GPU);
    /// let session = model.create_session(options)?;
    /// # Ok::<(), ronn_api::Error>(())
    /// ```
    pub fn create_session(
        &self,
        options: SessionOptions,
    ) -> Result<crate::session::InferenceSession> {
        SessionBuilder::new(self.inner.clone(), options).build()
    }

    /// Get model metadata
    pub fn producer_name(&self) -> Option<&str> {
        self.inner.producer_name.as_deref()
    }

    /// Get IR version
    pub fn ir_version(&self) -> i64 {
        self.inner.ir_version
    }

    /// Get input names
    pub fn input_names(&self) -> Vec<&str> {
        self.inner
            .inputs()
            .iter()
            .map(|i| i.name.as_str())
            .collect()
    }

    /// Get output names
    pub fn output_names(&self) -> Vec<&str> {
        self.inner
            .outputs()
            .iter()
            .map(|o| o.name.as_str())
            .collect()
    }
}