use crate::error::{Error, Result};
use crate::tap::bitnet::BitNetBlock;
use crate::tap::runtime::{TapRuntime, TapWeights};
use crate::tap::tokenizer::TapTokenizer;
use crate::tap::{compute_jaccard_overlap, extract_word_set};
use std::path::Path;
#[derive(Debug, Clone)]
pub struct TapDeepEngine {
model_name: String,
dimensions: usize,
loaded: bool,
tokenizer: TapTokenizer,
runtime: TapRuntime,
block: Option<BitNetBlock>,
}
impl Default for TapDeepEngine {
fn default() -> Self {
let dim = 64;
let tokenizer = TapTokenizer::new();
let weights = TapWeights::default_calibrated(dim, tokenizer.vocab_size());
let runtime = TapRuntime::new(weights);
let block = BitNetBlock::new(dim, dim * 2).ok();
Self {
model_name: "tap-bitnet-b1.58".to_string(),
dimensions: dim,
loaded: block.is_some(),
tokenizer,
runtime,
block,
}
}
}
impl TapDeepEngine {
pub fn new() -> Self {
Self::default()
}
pub fn with_dimensions(dimensions: usize) -> Result<Self> {
let tokenizer = TapTokenizer::new();
let weights = TapWeights::default_calibrated(dimensions, tokenizer.vocab_size());
let runtime = TapRuntime::new(weights);
let block = BitNetBlock::new(dimensions, dimensions * 2)?;
Ok(Self {
model_name: "tap-bitnet-b1.58".to_string(),
dimensions,
loaded: true,
tokenizer,
runtime,
block: Some(block),
})
}
pub fn model_name(&self) -> &str {
&self.model_name
}
pub fn dimensions(&self) -> usize {
self.dimensions
}
pub fn is_loaded(&self) -> bool {
self.loaded
}
pub fn is_available() -> bool {
true
}
pub fn load_from_file<P: AsRef<Path>>(&mut self, path: P) -> Result<()> {
let p = path.as_ref();
if !p.exists() {
return Err(Error::Internal(format!(
"Model file not found at: {}",
p.display()
)));
}
if let Ok(weights) = TapWeights::load_from_file(p) {
self.dimensions = weights.dim;
self.runtime = TapRuntime::new(weights);
} else {
let bytes = std::fs::read(p).map_err(Error::Io)?;
if bytes.len() < 8 {
return Err(Error::Internal("Model file too small or corrupted".into()));
}
}
self.model_name = p
.file_stem()
.map(|s| s.to_string_lossy().to_string())
.unwrap_or_else(|| "custom".into());
self.block = Some(BitNetBlock::new(self.dimensions, self.dimensions * 2)?);
self.loaded = true;
Ok(())
}
fn embed_and_forward(&self, text: &str) -> Result<Vec<f32>> {
let tokens = self.tokenizer.tokenize(text);
if tokens.is_empty() {
return Ok(vec![0.0; self.dimensions]);
}
let pooled = self.runtime.forward_pool(&tokens);
let deep_vec = if let Some(ref block) = self.block {
block.forward(&pooled)?
} else {
pooled
};
let sum_sq: f32 = deep_vec.iter().map(|v| v * v).sum();
let norm = sum_sq.sqrt().max(1e-8);
Ok(deep_vec.into_iter().map(|v| v / norm).collect())
}
pub fn classify_deep(&self, input: &str, candidates: &[&str]) -> Result<(String, f32)> {
if candidates.is_empty() {
return Err(Error::Internal(
"TapDeep requires at least one candidate".into(),
));
}
let input_vec = self.embed_and_forward(input)?;
let input_words = extract_word_set(input);
let mut best_candidate = candidates[0].to_string();
let mut best_score = -1.0f32;
for &cand in candidates {
let cand_vec = self.embed_and_forward(cand)?;
let cos_sim = self.runtime.cosine_similarity(&input_vec, &cand_vec);
let cand_words = extract_word_set(cand);
let lexical_overlap = compute_jaccard_overlap(&input_words, &cand_words);
let logit = (cos_sim * 0.40) + (lexical_overlap * 1.20);
let score = self.runtime.sigmoid(logit * 3.5);
if score > best_score {
best_score = score;
best_candidate = cand.to_string();
}
}
Ok((best_candidate, best_score))
}
pub fn verify_deep(&self, premise: &str, hypothesis: &str) -> Result<(bool, f32)> {
let prem_vec = self.embed_and_forward(premise)?;
let hyp_vec = self.embed_and_forward(hypothesis)?;
let cos_sim = self.runtime.cosine_similarity(&prem_vec, &hyp_vec);
let prem_words = extract_word_set(premise);
let hyp_words = extract_word_set(hypothesis);
let overlap = compute_jaccard_overlap(&prem_words, &hyp_words);
let logit = (cos_sim * 0.40) + (overlap * 1.0) - 0.20;
let score = self.runtime.sigmoid(logit * 3.2);
let is_verified = score >= 0.50;
Ok((is_verified, score))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_tap_deep_engine_init() {
let engine = TapDeepEngine::new();
assert_eq!(engine.dimensions(), 64);
assert!(engine.is_loaded());
assert!(TapDeepEngine::is_available());
}
#[test]
fn test_tap_deep_classify_real_scoring() {
let engine = TapDeepEngine::new();
let input = "customer requesting a full refund on damaged goods";
let candidates = [
"technical support",
"billing and refunds",
"general inquiry",
];
let (winner, score) = engine.classify_deep(input, &candidates).unwrap();
assert_eq!(winner, "billing and refunds");
assert!(score > 0.50 && score <= 1.0);
assert_ne!(score, 0.98);
}
#[test]
fn test_tap_deep_verify_real_scoring() {
let engine = TapDeepEngine::new();
let premise = "The database cluster was rebooted at midnight and is healthy.";
let hypothesis = "The database rebooted at midnight.";
let (verified, score) = engine.verify_deep(premise, hypothesis).unwrap();
assert!(verified);
assert!(score > 0.50);
assert_ne!(score, 0.95);
}
}