Struct Model 

pub struct Model { /* private fields */ }

A compiled, runnable model with by-name weight binding. Available with the eval feature. A compiled graph plus its parameter roster — a runnable model.

Bind weights with set / load by name (for an rlx! graph that name is the param’s @ "…" key or, absent that, its binding ident), then run. Weight sources that carry extra tensors (a whole checkpoint) are fine — only the params this model declares are bound, and unbound reports any it still needs.

let mut m = Model::on(graph, Device::Cpu);
m.load(weights.iter().map(|(k, v)| (k.as_str(), v.as_slice())));
assert!(m.unbound().is_empty(), "missing weights: {:?}", m.unbound());
let out = m.run(&[("input_ids", &ids)]);

Implementations

impl Model

pub fn new(graph: Graph) -> Self

Compile on the fastest backend this build can run the graph on.

pub fn on(graph: Graph, device: Device) -> Self

Compile on an explicit device.

pub fn param_names(&self) -> impl Iterator<Item = &str>

Every parameter name the model expects.

pub fn unbound(&self) -> Vec<&str>

Parameters not yet bound (in arbitrary order) — check this is empty after load to catch a missing / misnamed weight loudly.

pub fn set(&mut self, name: &str, data: &[f32]) -> &mut Self

Bind one parameter by name. A name the model doesn’t declare is ignored (so binding straight from a superset checkpoint is safe).

pub fn load<'a, I>(&mut self, weights: I) -> &mut Self

where I: IntoIterator<Item = (&'a str, &'a [f32])>,

Bind every parameter the model declares from a name → data source (a HashMap, a slice of pairs, …); extra entries are ignored.

pub fn run(&mut self, inputs: &[(&str, &[f32])]) -> Vec<Vec<f32>>

Run with named inputs, returning one Vec<f32> per graph output.