use serde::Deserialize;
use std::sync::OnceLock;
#[derive(Deserialize)]
struct Weights {
#[serde(rename = "L")]
l: usize,
#[serde(rename = "C")]
c: usize,
k: usize,
#[allow(dead_code)] nsym: usize,
aa_order: String,
dilations: Vec<usize>,
embed_w: Vec<Vec<f32>>, 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>,
score_w: Vec<Vec<f32>>, score_b: Vec<f32>, }
pub struct Model {
w: Weights,
aa_to_idx: [usize; 256],
conv_wf: Vec<Vec<f32>>,
}
fn flatten3(w: &[Vec<Vec<f32>>]) -> Vec<f32> {
let mut v = Vec::with_capacity(w.len() * w.first().map_or(0, |a| a.len() * a.first().map_or(0, |b| b.len())));
for a in w {
for b in a {
v.extend_from_slice(b);
}
}
v
}
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 mut aa_to_idx = [0usize; 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;
}
let conv_wf = vec![
flatten3(&w.conv1_w),
flatten3(&w.conv2_w),
flatten3(&w.conv3_w),
flatten3(&w.conv4_w),
];
Ok(Model { aa_to_idx, conv_wf, w })
}
pub fn score_many(&self, seqs: &[&[u8]]) -> Vec<f32> {
use rayon::prelude::*;
seqs.par_iter().map(|s| self.score(s)).collect()
}
pub fn score(&self, aa: &[u8]) -> f32 {
let l = self.w.l;
let c = self.w.c;
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 h = vec![0.0f32; c * l];
for t in 0..l {
let row = &self.w.embed_w[idx[t]];
for ch in 0..c {
h[ch * l + t] = row[ch];
}
}
let cbs = [
&self.w.conv1_b,
&self.w.conv2_b,
&self.w.conv3_b,
&self.w.conv4_b,
];
for bi in 0..4 {
let d = self.w.dilations[bi];
h = dilated_conv1d_relu(&h, c, l, &self.conv_wf[bi], cbs[bi], self.w.k, d);
}
let mut nvalid = 0usize;
for t in 0..l {
if idx[t] != 0 {
nvalid += 1;
}
}
let denom = nvalid.max(1) as f32;
let mut pooled = vec![0.0f32; c];
for ch in 0..c {
let mut s = 0.0;
for t in 0..l {
if idx[t] != 0 {
s += h[ch * l + t];
}
}
pooled[ch] = s / denom;
}
let mut logit = self.w.score_b[0];
for ch in 0..c {
logit += self.w.score_w[0][ch] * pooled[ch];
}
1.0 / (1.0 + (-logit).exp())
}
}
fn dilated_conv1d_relu(
inp: &[f32],
c: usize,
l: usize,
w: &[f32],
b: &[f32],
k: usize,
d: usize,
) -> Vec<f32> {
let pad = (d * (k / 2)) as isize;
let mut out = vec![0.0f32; c * l];
for co in 0..c {
let orow = &mut out[co * l..co * l + l];
for o in orow.iter_mut() {
*o = b[co];
}
let wco = &w[co * c * k..(co + 1) * c * k];
for ci in 0..c {
let irow = &inp[ci * l..ci * l + l];
let wci = &wco[ci * k..ci * k + k];
for dk in 0..k {
let wt = wci[dk];
let shift = (dk * d) as isize - pad;
let (t0, t1) = if shift >= 0 {
(0usize, l.saturating_sub(shift as usize))
} else {
(((-shift) as usize).min(l), l)
};
if t0 >= t1 {
continue;
}
let src = (t0 as isize + shift) as usize;
for (o, &x) in orow[t0..t1].iter_mut().zip(&irow[src..src + (t1 - t0)]) {
*o += wt * x;
}
}
}
for o in orow.iter_mut() {
if *o < 0.0 {
*o = 0.0;
}
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn embedded_scores_in_range() {
let m = Model::embedded();
let s = m.score(b"MSKIVKIIGREIIDSRGNPTVEAEVHLEGGFVGMAAAPSGASTGSREALELRDGDKSRFLGKG");
assert!((0.0..=1.0).contains(&s), "score {s}");
}
}