Struct Decoder 

pub struct Decoder { /* private fields */ }

载入好的解码器。

Implementations

impl Decoder

pub fn load(dir: &Path) -> Result<Decoder, String>

dir 是模型目录：model.safetensors、config.json、generation_config.json。

pub fn from_weights( w: &Weights, text: &Value, generation: &Value, ) -> Result<Decoder, String>

从已读入的权重构造（和图像编码器共用一次读文件时用）。 text 是 config.json 的 text_config，generation 是 generation_config.json。

Examples found in repository

examples/formula_check.rs (lines 46-50)

fn main() {
    let a: Vec<String> = std::env::args().skip(1).collect();
    let dir = Path::new(&a[0]);
    let t = Instant::now();
    let cfg = json(dir, "config.json");
    let w = Weights::from_bytes(&std::fs::read(dir.join("model.safetensors")).unwrap()).unwrap();
    let dec = Decoder::from_weights(
        &w,
        &cfg["text_config"],
        &json(dir, "generation_config.json"),
    )
    .unwrap();
    let enc = Encoder::from_weights(&w, Config::from_json(&cfg).unwrap()).unwrap();
    drop(w);
    let tok = Tokenizer::load(dir).unwrap();
    println!("载入 {:.0} ms", t.elapsed().as_secs_f64() * 1e3);

    if a.len() == 1 {
        // 固定种子的随机 memory
        let mut s = 0x9E37_79B9_7F4A_7C15u64;
        let data = (0..144 * 512)
            .map(|_| {
                s ^= s << 13;
                s ^= s >> 7;
                s ^= s << 17;
                (s >> 40) as f32 / (1u64 << 23) as f32 - 1.0
            })
            .collect();
        let mem = Tensor::new(vec![144, 512], data);
        let t = Instant::now();
        let ids = dec.generate(&mem, 200).unwrap();
        let ms = t.elapsed().as_secs_f64() * 1e3;
        println!(
            "随机 memory：{} 个 token，{ms:.0} ms，{:.1} ms/token",
            ids.len(),
            ms / (ids.len() + 1) as f64
        );
        println!("{}", to_latex(&tok.decode(&ids)));
        return;
    }

    for p in &a[1..] {
        let img = read_ppm(p);
        let t = Instant::now();
        let x = preprocess(&img);
        let t_pre = t.elapsed().as_secs_f64() * 1e3;
        let t = Instant::now();
        let mem = enc.encode(&x).unwrap();
        let t_enc = t.elapsed().as_secs_f64() * 1e3;
        let t = Instant::now();
        let ids = dec.generate(&mem, dec.max_length()).unwrap();
        let t_dec = t.elapsed().as_secs_f64() * 1e3;
        let name = Path::new(p).file_name().unwrap().to_string_lossy();
        println!(
            "{name}\t预处理 {t_pre:.0} ms\t编码 {t_enc:.0} ms\t解码 {t_dec:.0} ms（{} 个 token，{:.1} ms/token）",
            ids.len(),
            t_dec / (ids.len() + 1) as f64
        );
        println!("  原始：{}", tok.decode(&ids));
        println!("  LaTeX：{}", to_latex(&tok.decode(&ids)));
    }
    // 内存峰值（Linux 才有这个文件）
    if let Ok(s) = std::fs::read_to_string("/proc/self/status")
        && let Some(l) = s.lines().find(|l| l.starts_with("VmHWM"))
    {
        println!("{l}");
    }
}

pub fn max_length(&self) -> usize

generation_config.json 的 max_length（含起始 token 的序列总长），传给 generate。

Examples found in repository

examples/formula_check.rs (line 90)

fn main() {
    let a: Vec<String> = std::env::args().skip(1).collect();
    let dir = Path::new(&a[0]);
    let t = Instant::now();
    let cfg = json(dir, "config.json");
    let w = Weights::from_bytes(&std::fs::read(dir.join("model.safetensors")).unwrap()).unwrap();
    let dec = Decoder::from_weights(
        &w,
        &cfg["text_config"],
        &json(dir, "generation_config.json"),
    )
    .unwrap();
    let enc = Encoder::from_weights(&w, Config::from_json(&cfg).unwrap()).unwrap();
    drop(w);
    let tok = Tokenizer::load(dir).unwrap();
    println!("载入 {:.0} ms", t.elapsed().as_secs_f64() * 1e3);

    if a.len() == 1 {
        // 固定种子的随机 memory
        let mut s = 0x9E37_79B9_7F4A_7C15u64;
        let data = (0..144 * 512)
            .map(|_| {
                s ^= s << 13;
                s ^= s >> 7;
                s ^= s << 17;
                (s >> 40) as f32 / (1u64 << 23) as f32 - 1.0
            })
            .collect();
        let mem = Tensor::new(vec![144, 512], data);
        let t = Instant::now();
        let ids = dec.generate(&mem, 200).unwrap();
        let ms = t.elapsed().as_secs_f64() * 1e3;
        println!(
            "随机 memory：{} 个 token，{ms:.0} ms，{:.1} ms/token",
            ids.len(),
            ms / (ids.len() + 1) as f64
        );
        println!("{}", to_latex(&tok.decode(&ids)));
        return;
    }

    for p in &a[1..] {
        let img = read_ppm(p);
        let t = Instant::now();
        let x = preprocess(&img);
        let t_pre = t.elapsed().as_secs_f64() * 1e3;
        let t = Instant::now();
        let mem = enc.encode(&x).unwrap();
        let t_enc = t.elapsed().as_secs_f64() * 1e3;
        let t = Instant::now();
        let ids = dec.generate(&mem, dec.max_length()).unwrap();
        let t_dec = t.elapsed().as_secs_f64() * 1e3;
        let name = Path::new(p).file_name().unwrap().to_string_lossy();
        println!(
            "{name}\t预处理 {t_pre:.0} ms\t编码 {t_enc:.0} ms\t解码 {t_dec:.0} ms（{} 个 token，{:.1} ms/token）",
            ids.len(),
            t_dec / (ids.len() + 1) as f64
        );
        println!("  原始：{}", tok.decode(&ids));
        println!("  LaTeX：{}", to_latex(&tok.decode(&ids)));
    }
    // 内存峰值（Linux 才有这个文件）
    if let Ok(s) = std::fs::read_to_string("/proc/self/status")
        && let Some(l) = s.lines().find(|l| l.starts_with("VmHWM"))
    {
        println!("{l}");
    }
}

pub fn generate( &self, memory: &Tensor, max_len: usize, ) -> Result<Vec<u32>, String>

贪心生成。memory 是编码器输出 [L, d_model]（参考实现的 encoder_hidden_states）。

max_len 的含义同 generate(max_length=…)：序列总长的上限，含起始 token；序列长到 max_len − 1 时下一个 token 强制为 forced_eos_token_id （ForcedEOSTokenLogitsProcessor）。超过位置向量表的长度时取表长。

返回生成的 token，不含起始 token 和结尾的 eos。

Examples found in repository

examples/formula_check.rs (line 70)

fn main() {
    let a: Vec<String> = std::env::args().skip(1).collect();
    let dir = Path::new(&a[0]);
    let t = Instant::now();
    let cfg = json(dir, "config.json");
    let w = Weights::from_bytes(&std::fs::read(dir.join("model.safetensors")).unwrap()).unwrap();
    let dec = Decoder::from_weights(
        &w,
        &cfg["text_config"],
        &json(dir, "generation_config.json"),
    )
    .unwrap();
    let enc = Encoder::from_weights(&w, Config::from_json(&cfg).unwrap()).unwrap();
    drop(w);
    let tok = Tokenizer::load(dir).unwrap();
    println!("载入 {:.0} ms", t.elapsed().as_secs_f64() * 1e3);

    if a.len() == 1 {
        // 固定种子的随机 memory
        let mut s = 0x9E37_79B9_7F4A_7C15u64;
        let data = (0..144 * 512)
            .map(|_| {
                s ^= s << 13;
                s ^= s >> 7;
                s ^= s << 17;
                (s >> 40) as f32 / (1u64 << 23) as f32 - 1.0
            })
            .collect();
        let mem = Tensor::new(vec![144, 512], data);
        let t = Instant::now();
        let ids = dec.generate(&mem, 200).unwrap();
        let ms = t.elapsed().as_secs_f64() * 1e3;
        println!(
            "随机 memory：{} 个 token，{ms:.0} ms，{:.1} ms/token",
            ids.len(),
            ms / (ids.len() + 1) as f64
        );
        println!("{}", to_latex(&tok.decode(&ids)));
        return;
    }

    for p in &a[1..] {
        let img = read_ppm(p);
        let t = Instant::now();
        let x = preprocess(&img);
        let t_pre = t.elapsed().as_secs_f64() * 1e3;
        let t = Instant::now();
        let mem = enc.encode(&x).unwrap();
        let t_enc = t.elapsed().as_secs_f64() * 1e3;
        let t = Instant::now();
        let ids = dec.generate(&mem, dec.max_length()).unwrap();
        let t_dec = t.elapsed().as_secs_f64() * 1e3;
        let name = Path::new(p).file_name().unwrap().to_string_lossy();
        println!(
            "{name}\t预处理 {t_pre:.0} ms\t编码 {t_enc:.0} ms\t解码 {t_dec:.0} ms（{} 个 token，{:.1} ms/token）",
            ids.len(),
            t_dec / (ids.len() + 1) as f64
        );
        println!("  原始：{}", tok.decode(&ids));
        println!("  LaTeX：{}", to_latex(&tok.decode(&ids)));
    }
    // 内存峰值（Linux 才有这个文件）
    if let Ok(s) = std::fs::read_to_string("/proc/self/status")
        && let Some(l) = s.lines().find(|l| l.starts_with("VmHWM"))
    {
        println!("{l}");
    }
}