Struct CompiledInstinct 

pub struct CompiledInstinct {
    pub name: String,
    pub decision_type: String,
    pub options: Vec<String>,
    pub weights: HashMap<String, [f32; 384]>,
    pub biases: HashMap<String, f32>,
    pub temperature: f32,
    /* private fields */
}

Portable, self-contained compiled decision model evaluating in <10us.

Fields

name: String

decision_type: String

options: Vec<String>

weights: HashMap<String, [f32; 384]>

biases: HashMap<String, f32>

temperature: f32

Implementations

impl CompiledInstinct

pub fn from_bytes(bytes: &[u8]) -> Result<Self, String>

Loads and verifies a .reflex binary model from a byte buffer.

pub fn from_file(path: &str) -> Result<Self, String>

Loads a .reflex file from the filesystem.

Examples found in repository

examples/compiled_parity.rs (line 11)

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: compiled_parity <model_path> [query1] [query2] ...");
        std::process::exit(1);
    }
    let model_path = &args[1];
    let model = match CompiledInstinct::from_file(model_path) {
        Ok(m) => m,
        Err(e) => {
            eprintln!("Error loading model: {}", e);
            std::process::exit(1);
        }
    };

    let queries = if args.len() > 2 {
        args[2..].to_vec()
    } else {
        Vec::new()
    };

    print!("[");
    for (i, q) in queries.iter().enumerate() {
        let res = model.predict(q);
        print!("{{\"query\":");
        print!("\"{}\",", q.replace('\\', "\\\\").replace('"', "\\\""));
        print!("\"selected\":\"{}\",", res.selected);
        print!("\"distribution\":{{");
        for (j, (opt, prob)) in res.distribution.iter().enumerate() {
            print!("\"{}\":{:.6}", opt, prob);
            if j + 1 < res.distribution.len() {
                print!(",");
            }
        }
        print!("}}}}");
        if i + 1 < queries.len() {
            print!(",");
        }
    }
    println!("]");
}

pub fn predict(&self, state: &str) -> CompiledResult

Executes sub-10 microsecond inference on state input.

Examples found in repository

examples/compiled_parity.rs (line 27)

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: compiled_parity <model_path> [query1] [query2] ...");
        std::process::exit(1);
    }
    let model_path = &args[1];
    let model = match CompiledInstinct::from_file(model_path) {
        Ok(m) => m,
        Err(e) => {
            eprintln!("Error loading model: {}", e);
            std::process::exit(1);
        }
    };

    let queries = if args.len() > 2 {
        args[2..].to_vec()
    } else {
        Vec::new()
    };

    print!("[");
    for (i, q) in queries.iter().enumerate() {
        let res = model.predict(q);
        print!("{{\"query\":");
        print!("\"{}\",", q.replace('\\', "\\\\").replace('"', "\\\""));
        print!("\"selected\":\"{}\",", res.selected);
        print!("\"distribution\":{{");
        for (j, (opt, prob)) in res.distribution.iter().enumerate() {
            print!("\"{}\":{:.6}", opt, prob);
            if j + 1 < res.distribution.len() {
                print!(",");
            }
        }
        print!("}}}}");
        if i + 1 < queries.len() {
            print!(",");
        }
    }
    println!("]");
}

Trait Implementations

impl Clone for CompiledInstinct

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CompiledInstinct

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

Formats the value using the given formatter.