use serde::Deserialize;
use std::sync::OnceLock;
#[derive(Deserialize)]
struct VocabEntry {
pfam: String,
#[serde(default)]
name: String,
}
#[derive(Deserialize)]
struct Weights {
#[serde(rename = "L")]
l: usize,
#[serde(rename = "C")]
c: usize,
k: usize,
nsym: usize,
aa_order: String,
vocab_size: usize,
conv1_w: Vec<Vec<Vec<f32>>>, conv1_b: Vec<f32>,
conv2_w: Vec<Vec<Vec<f32>>>, conv2_b: Vec<f32>,
conv3_w: Vec<Vec<Vec<f32>>>,
conv3_b: Vec<f32>,
conv4_w: Vec<Vec<Vec<f32>>>,
conv4_b: Vec<f32>,
head_w: Vec<Vec<f32>>, head_b: Vec<f32>, thresholds: Vec<f32>, vocab: Vec<VocabEntry>, }
#[derive(Debug, Clone)]
pub struct Call {
pub pfam: String,
pub name: String,
pub score: f32,
}
pub struct Model {
w: Weights,
aa_to_idx: [usize; 256],
}
const EMBEDDED_WEIGHTS_GZ: &[u8] = include_bytes!("../weights.json.gz");
impl Model {
pub fn embedded() -> &'static Model {
static M: OnceLock<Model> = OnceLock::new();
M.get_or_init(|| {
use std::io::Read;
let mut s = String::new();
flate2::read::GzDecoder::new(EMBEDDED_WEIGHTS_GZ)
.read_to_string(&mut s)
.expect("decompress embedded weights");
Model::from_json(&s).expect("embedded weights parse")
})
}
pub fn from_json(s: &str) -> Result<Model, String> {
let w: Weights = serde_json::from_str(s).map_err(|e| e.to_string())?;
let other = w.nsym; let mut aa_to_idx = [other; 256];
for (i, c) in w.aa_order.bytes().enumerate() {
aa_to_idx[c as usize] = i + 1;
aa_to_idx[c.to_ascii_lowercase() as usize] = i + 1;
}
Ok(Model { aa_to_idx, w })
}
pub fn vocab_size(&self) -> usize {
self.w.vocab_size
}
pub fn predict(&self, aa: &[u8]) -> Vec<Call> {
let l = self.w.l;
let c = self.w.c;
let nch = self.w.nsym;
let mut idx = vec![0usize; l];
for t in 0..l.min(aa.len()) {
idx[t] = self.aa_to_idx[aa[t] as usize];
}
let mut oh = vec![0.0f32; nch * l];
for t in 0..l {
let j = idx[t];
if j >= 1 && j <= nch {
oh[(j - 1) * l + t] = 1.0;
}
}
let h1 = conv1d_relu(&oh, nch, l, &self.w.conv1_w, &self.w.conv1_b, c, self.w.k);
let h2 = conv1d_relu(&h1, c, l, &self.w.conv2_w, &self.w.conv2_b, c, self.w.k);
let h3 = conv1d_relu(&h2, c, l, &self.w.conv3_w, &self.w.conv3_b, c, self.w.k);
let h = conv1d_relu(&h3, c, l, &self.w.conv4_w, &self.w.conv4_b, c, self.w.k);
let mut pooled = vec![0.0f32; c];
for ci in 0..c {
let mut s = 0.0;
let base = ci * l;
for t in 0..l {
s += h[base + t];
}
pooled[ci] = s / l as f32;
}
let mut calls = Vec::new();
for v in 0..self.w.vocab_size {
let mut logit = self.w.head_b[v];
let row = &self.w.head_w[v];
for ci in 0..c {
logit += row[ci] * pooled[ci];
}
let p = 1.0 / (1.0 + (-logit).exp());
if p > self.w.thresholds[v] {
calls.push(Call {
pfam: self.w.vocab[v].pfam.clone(),
name: self.w.vocab[v].name.clone(),
score: p,
});
}
}
calls.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap_or(std::cmp::Ordering::Equal));
calls
}
pub fn predict_many(&self, seqs: &[&[u8]]) -> Vec<Vec<Call>> {
use rayon::prelude::*;
seqs.par_iter().map(|s| self.predict(s)).collect()
}
}
fn conv1d_relu(
inp: &[f32],
cin: usize,
l: usize,
w: &[Vec<Vec<f32>>],
b: &[f32],
cout: usize,
k: usize,
) -> Vec<f32> {
let pad = k / 2;
let mut out = vec![0.0f32; cout * l];
for co in 0..cout {
let wco = &w[co];
let bias = b[co];
for t in 0..l {
let mut acc = bias;
for ci in 0..cin {
let wci = &wco[ci];
let base = ci * l;
for dk in 0..k {
let ii = t as isize + dk as isize - pad as isize;
if ii >= 0 && (ii as usize) < l {
acc += wci[dk] * inp[base + ii as usize];
}
}
}
out[co * l + t] = if acc > 0.0 { acc } else { 0.0 };
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn embedded_loads_and_predicts() {
let m = Model::embedded();
assert_eq!(m.vocab_size(), 1000);
let calls = m.predict(b"MSKIVKIIGREIIDSRGNPTVEAEVHLEGGFVGMAAAPSGASTGSREALELRDGDKSRFLGKG");
for w in calls.windows(2) {
assert!(w[0].score >= w[1].score);
}
}
}