agentic-flow 1.9.0 → 1.9.1

package/agentic-flow/examples/crispr-cas13-pipeline/crates/offtarget-predictor/src/ml_model.rs

@@ -1,264 +0,0 @@
-//! Machine learning model for off-target prediction
-
-use crate::error::{PredictionError, Result};
-use crate::features::FeatureExtractor;
-use data_models::targets::CrisprTarget;
-use ndarray::{Array1, Array2};
-use std::path::Path;
-
-/// ML model interface for off-target scoring
-pub trait MlModel: Send + Sync {
-    /// Predict scores for feature vectors
-    fn predict(&self, features: &Array2<f64>) -> Result<Array1<f64>>;
-
-    /// Predict score for a single feature vector
-    fn predict_single(&self, features: &Array1<f64>) -> Result<f64>;
-
-    /// Get model metadata
-    fn metadata(&self) -> ModelMetadata;
-}
-
-/// Model metadata
-#[derive(Debug, Clone)]
-pub struct ModelMetadata {
-    pub name: String,
-    pub version: String,
-    pub num_features: usize,
-    pub trained_on: String,
-}
-
-/// Ensemble model combining multiple prediction methods
-pub struct EnsembleModel {
-    models: Vec<Box<dyn MlModel>>,
-    weights: Vec<f64>,
-}
-
-impl EnsembleModel {
-    pub fn new() -> Self {
-        Self {
-            models: Vec::new(),
-            weights: Vec::new(),
-        }
-    }
-
-    pub fn add_model(&mut self, model: Box<dyn MlModel>, weight: f64) {
-        self.models.push(model);
-        self.weights.push(weight);
-    }
-}
-
-impl MlModel for EnsembleModel {
-    fn predict(&self, features: &Array2<f64>) -> Result<Array1<f64>> {
-        if self.models.is_empty() {
-            return Err(PredictionError::Model("No models in ensemble".to_string()));
-        }
-
-        let mut weighted_sum = Array1::zeros(features.nrows());
-        let weight_sum: f64 = self.weights.iter().sum();
-
-        for (model, &weight) in self.models.iter().zip(self.weights.iter()) {
-            let predictions = model.predict(features)?;
-            weighted_sum = weighted_sum + predictions * (weight / weight_sum);
-        }
-
-        Ok(weighted_sum)
-    }
-
-    fn predict_single(&self, features: &Array1<f64>) -> Result<f64> {
-        if self.models.is_empty() {
-            return Err(PredictionError::Model("No models in ensemble".to_string()));
-        }
-
-        let mut weighted_sum = 0.0;
-        let weight_sum: f64 = self.weights.iter().sum();
-
-        for (model, &weight) in self.models.iter().zip(self.weights.iter()) {
-            let prediction = model.predict_single(features)?;
-            weighted_sum += prediction * (weight / weight_sum);
-        }
-
-        Ok(weighted_sum)
-    }
-
-    fn metadata(&self) -> ModelMetadata {
-        ModelMetadata {
-            name: "EnsembleModel".to_string(),
-            version: "1.0.0".to_string(),
-            num_features: 0,
-            trained_on: "Multiple datasets".to_string(),
-        }
-    }
-}
-
-/// Simple linear model for off-target scoring
-pub struct LinearModel {
-    weights: Array1<f64>,
-    bias: f64,
-    metadata: ModelMetadata,
-}
-
-impl LinearModel {
-    /// Create a new linear model with given weights and bias
-    pub fn new(weights: Array1<f64>, bias: f64) -> Self {
-        let num_features = weights.len();
-        Self {
-            weights,
-            bias,
-            metadata: ModelMetadata {
-                name: "LinearModel".to_string(),
-                version: "1.0.0".to_string(),
-                num_features,
-                trained_on: "CRISPR-Cas13 dataset".to_string(),
-            },
-        }
-    }
-
-    /// Create a default model with pre-trained weights
-    pub fn default_model() -> Self {
-        // Default weights tuned for CRISPR-Cas13 off-target prediction
-        let weights = Array1::from(vec![
-            -0.5,  // mismatches (negative correlation)
-            -0.3,  // position-weighted score
-            0.1,   // target GC
-            0.1,   // candidate GC
-            -0.2,  // GC difference
-            -0.4,  // seed mismatches
-            -0.1,  // Tm difference
-            -0.15, // homopolymers
-            0.2,   // complexity
-            -0.1,  // dinucleotide repeats
-            0.05,  // purine content
-        ]);
-        let bias = 0.8;
-
-        Self::new(weights, bias)
-    }
-
-    /// Load model from file
-    pub fn load<P: AsRef<Path>>(path: P) -> Result<Self> {
-        // In production, this would load from a serialized model file
-        // For now, return the default model
-        Ok(Self::default_model())
-    }
-
-    /// Save model to file
-    pub fn save<P: AsRef<Path>>(&self, path: P) -> Result<()> {
-        // In production, this would serialize the model to a file
-        Ok(())
-    }
-}
-
-impl MlModel for LinearModel {
-    fn predict(&self, features: &Array2<f64>) -> Result<Array1<f64>> {
-        // Linear prediction: y = Xw + b
-        let predictions = features.dot(&self.weights) + self.bias;
-
-        // Apply sigmoid activation to bound between 0 and 1
-        Ok(predictions.mapv(|x| 1.0 / (1.0 + (-x).exp())))
-    }
-
-    fn predict_single(&self, features: &Array1<f64>) -> Result<f64> {
-        if features.len() != self.weights.len() {
-            return Err(PredictionError::FeatureExtraction(format!(
-                "Feature dimension mismatch: expected {}, got {}",
-                self.weights.len(),
-                features.len()
-            )));
-        }
-
-        let linear_output = features.dot(&self.weights) + self.bias;
-        // Apply sigmoid
-        Ok(1.0 / (1.0 + (-linear_output).exp()))
-    }
-
-    fn metadata(&self) -> ModelMetadata {
-        self.metadata.clone()
-    }
-}
-
-/// Neural network model (placeholder for future ONNX integration)
-pub struct NeuralNetworkModel {
-    model_path: String,
-    metadata: ModelMetadata,
-}
-
-impl NeuralNetworkModel {
-    pub fn load<P: AsRef<Path>>(path: P) -> Result<Self> {
-        let model_path = path.as_ref().to_string_lossy().to_string();
-
-        Ok(Self {
-            model_path,
-            metadata: ModelMetadata {
-                name: "NeuralNetwork".to_string(),
-                version: "1.0.0".to_string(),
-                num_features: 0,
-                trained_on: "Large-scale CRISPR dataset".to_string(),
-            },
-        })
-    }
-}
-
-impl MlModel for NeuralNetworkModel {
-    fn predict(&self, features: &Array2<f64>) -> Result<Array1<f64>> {
-        // Placeholder for ONNX Runtime integration
-        // For now, return random scores
-        Err(PredictionError::Model(
-            "Neural network inference not yet implemented".to_string(),
-        ))
-    }
-
-    fn predict_single(&self, features: &Array1<f64>) -> Result<f64> {
-        Err(PredictionError::Model(
-            "Neural network inference not yet implemented".to_string(),
-        ))
-    }
-
-    fn metadata(&self) -> ModelMetadata {
-        self.metadata.clone()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_linear_model_prediction() {
-        let model = LinearModel::default_model();
-        let features = Array1::from(vec![
-            1.0, 0.5, 50.0, 48.0, 2.0, 1.0, 5.0, 2.0, 1.5, 1.0, 55.0,
-        ]);
-
-        let score = model.predict_single(&features).unwrap();
-        assert!(score >= 0.0 && score <= 1.0);
-    }
-
-    #[test]
-    fn test_batch_prediction() {
-        let model = LinearModel::default_model();
-        let features = Array2::from_shape_vec(
-            (2, 11),
-            vec![
-                1.0, 0.5, 50.0, 48.0, 2.0, 1.0, 5.0, 2.0, 1.5, 1.0, 55.0, 2.0, 1.0, 52.0, 50.0,
-                2.0, 2.0, 8.0, 3.0, 1.2, 2.0, 58.0,
-            ],
-        )
-        .unwrap();
-
-        let scores = model.predict(&features).unwrap();
-        assert_eq!(scores.len(), 2);
-        assert!(scores.iter().all(|&s| s >= 0.0 && s <= 1.0));
-    }
-
-    #[test]
-    fn test_ensemble_model() {
-        let mut ensemble = EnsembleModel::new();
-        ensemble.add_model(Box::new(LinearModel::default_model()), 1.0);
-
-        let features = Array1::from(vec![
-            1.0, 0.5, 50.0, 48.0, 2.0, 1.0, 5.0, 2.0, 1.5, 1.0, 55.0,
-        ]);
-        let score = ensemble.predict_single(&features).unwrap();
-        assert!(score >= 0.0 && score <= 1.0);
-    }
-}

package/agentic-flow/examples/crispr-cas13-pipeline/crates/offtarget-predictor/src/scoring.rs

@@ -1,292 +0,0 @@
-//! Scoring algorithms for off-target sites
-
-use crate::error::Result;
-use crate::features::FeatureExtractor;
-use crate::ml_model::{LinearModel, MlModel};
-use crate::{OffTargetPredictor, PredictionConfig};
-use async_trait::async_trait;
-use data_models::sequencing::GenomicCoordinate;
-use data_models::targets::{
-    CrisprTarget, OffTargetFeatures, OffTargetPrediction, OffTargetSite, PredictionMetadata,
-};
-use rayon::prelude::*;
-use std::sync::Arc;
-use uuid::Uuid;
-
-/// Default off-target predictor implementation
-pub struct DefaultPredictor {
-    config: PredictionConfig,
-    feature_extractor: Arc<FeatureExtractor>,
-    ml_model: Arc<Box<dyn MlModel>>,
-}
-
-impl DefaultPredictor {
-    /// Create a new predictor with configuration
-    pub fn new(config: PredictionConfig) -> Result<Self> {
-        let feature_extractor = Arc::new(FeatureExtractor::new());
-
-        let ml_model: Box<dyn MlModel> = if config.use_ml_model {
-            if let Some(ref path) = config.model_path {
-                Box::new(LinearModel::load(path)?)
-            } else {
-                Box::new(LinearModel::default_model())
-            }
-        } else {
-            Box::new(LinearModel::default_model())
-        };
-
-        Ok(Self {
-            config,
-            feature_extractor,
-            ml_model: Arc::new(ml_model),
-        })
-    }
-
-    /// Search for potential off-target sites
-    fn search_off_targets(&self, target: &CrisprTarget) -> Vec<String> {
-        // In production, this would:
-        // 1. Use a k-mer index of the reference genome
-        // 2. Find all sequences within max_mismatches of the guide RNA
-        // 3. Filter by genomic context
-
-        // Mock implementation: generate some test candidates
-        let mut candidates = Vec::new();
-
-        // Perfect match
-        candidates.push(target.guide_rna.clone());
-
-        // Single mismatches at different positions
-        for i in 0..target.guide_rna.len().min(5) {
-            let mut mutated = target.guide_rna.clone();
-            if let Some(ch) = mutated.chars().nth(i) {
-                let new_char = match ch.to_ascii_uppercase() {
-                    'A' => 'G',
-                    'G' => 'A',
-                    'C' => 'U',
-                    'U' => 'C',
-                    _ => 'N',
-                };
-                mutated.replace_range(i..=i, &new_char.to_string());
-                candidates.push(mutated);
-            }
-        }
-
-        candidates
-    }
-
-    /// Score off-target candidates
-    fn score_candidates(
-        &self,
-        target: &CrisprTarget,
-        candidates: Vec<String>,
-    ) -> Result<Vec<(String, f64, OffTargetFeatures)>> {
-        let scored: Vec<_> = candidates
-            .par_iter()
-            .filter_map(|candidate| {
-                // Extract features
-                let features = self.feature_extractor.extract(target, candidate).ok()?;
-
-                // Predict score
-                let score = self.ml_model.predict_single(&features).ok()?;
-
-                // Create OffTargetFeatures
-                let mismatch_positions: Vec<usize> = target
-                    .guide_rna
-                    .chars()
-                    .zip(candidate.chars())
-                    .enumerate()
-                    .filter_map(|(i, (a, b))| {
-                        if a.to_ascii_uppercase() != b.to_ascii_uppercase() {
-                            Some(i)
-                        } else {
-                            None
-                        }
-                    })
-                    .collect();
-
-                let target_gc = self
-                    .feature_extractor
-                    .calculate_gc_content(&target.guide_rna);
-                let candidate_gc = self.feature_extractor.calculate_gc_content(candidate);
-
-                let off_target_features =
-                    OffTargetFeatures::from_mismatches(mismatch_positions, target_gc, candidate_gc);
-
-                Some((candidate.clone(), score, off_target_features))
-            })
-            .collect();
-
-        Ok(scored)
-    }
-
-    /// Convert scored candidates to OffTargetSite objects
-    fn create_off_target_sites(
-        &self,
-        target: &CrisprTarget,
-        scored: Vec<(String, f64, OffTargetFeatures)>,
-    ) -> Vec<OffTargetSite> {
-        scored
-            .into_iter()
-            .enumerate()
-            .filter_map(|(i, (sequence, score, features))| {
-                // Filter by minimum score threshold
-                if score < self.config.min_score {
-                    return None;
-                }
-
-                // Create mock genomic location
-                // In production, this would come from genome alignment
-                let location = GenomicCoordinate::new(
-                    0,
-                    2000 + (i as u64 * 100),
-                    2000 + (i as u64 * 100) + sequence.len() as u64,
-                    true,
-                )
-                .ok()?;
-
-                let mismatches = features.mismatch_positions.len() as u8;
-
-                Some(OffTargetSite {
-                    id: Uuid::new_v4(),
-                    target_id: target.id,
-                    sequence,
-                    location,
-                    mismatches,
-                    score,
-                    gene_context: None,
-                    features,
-                })
-            })
-            .collect()
-    }
-}
-
-#[async_trait]
-impl OffTargetPredictor for DefaultPredictor {
-    async fn predict(&self, target: &CrisprTarget) -> Result<OffTargetPrediction> {
-        let start = std::time::Instant::now();
-
-        // Search for potential off-targets
-        let candidates = self.search_off_targets(target);
-
-        // Score candidates
-        let scored = self.score_candidates(target, candidates)?;
-
-        // Create OffTargetSite objects
-        let off_targets = self.create_off_target_sites(target, scored);
-
-        let processing_time = start.elapsed().as_secs_f64();
-
-        let metadata = PredictionMetadata {
-            timestamp: chrono::Utc::now(),
-            model_version: self.ml_model.metadata().version,
-            reference_genome: self.config.reference_genome.clone(),
-            max_mismatches: self.config.max_mismatches,
-            processing_time,
-        };
-
-        Ok(OffTargetPrediction {
-            target: target.clone(),
-            off_targets,
-            metadata,
-        })
-    }
-
-    async fn predict_batch(&self, targets: Vec<CrisprTarget>) -> Result<Vec<OffTargetPrediction>> {
-        let mut predictions = Vec::new();
-
-        for target in targets {
-            let prediction = self.predict(&target).await?;
-            predictions.push(prediction);
-        }
-
-        Ok(predictions)
-    }
-
-    fn name(&self) -> &str {
-        "DefaultPredictor"
-    }
-
-    fn version(&self) -> &str {
-        "1.0.0"
-    }
-}
-
-/// CFD (Cutting Frequency Determination) scoring algorithm
-/// Based on Doench et al. 2016
-pub struct CfdScorer;
-
-impl CfdScorer {
-    /// Calculate CFD score for a sequence pair
-    pub fn score(guide: &str, target: &str) -> f64 {
-        if guide.len() != target.len() {
-            return 0.0;
-        }
-
-        let mut score = 1.0;
-
-        for (pos, (g, t)) in guide.chars().zip(target.chars()).enumerate() {
-            if g.to_ascii_uppercase() != t.to_ascii_uppercase() {
-                // Apply position-specific mismatch penalty
-                let penalty = Self::mismatch_penalty(pos, g, t);
-                score *= penalty;
-            }
-        }
-
-        score
-    }
-
-    /// Get mismatch penalty for specific position and mismatch type
-    fn mismatch_penalty(position: usize, guide_base: char, target_base: char) -> f64 {
-        // Simplified CFD penalties
-        // Real implementation would use experimentally-derived matrix
-        let position_weight = 1.0 - (position as f64 / 23.0);
-
-        // Higher penalty for PAM-proximal mismatches
-        let base_penalty = match (
-            guide_base.to_ascii_uppercase(),
-            target_base.to_ascii_uppercase(),
-        ) {
-            ('A', 'G') | ('G', 'A') => 0.6, // Purine-purine transition
-            ('C', 'U') | ('U', 'C') => 0.6, // Pyrimidine-pyrimidine transition
-            _ => 0.3,                       // Transversion
-        };
-
-        base_penalty * position_weight
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use data_models::sequencing::GenomicCoordinate;
-
-    fn create_test_target() -> CrisprTarget {
-        let location = GenomicCoordinate::new(0, 1000, 1023, true).unwrap();
-        CrisprTarget::new(
-            "GUUUUAGAGCUAUGCUGUUUUG".to_string(),
-            "GUUUUAGAGCUAUGCUGUUUUG".to_string(),
-            location,
-        )
-        .unwrap()
-    }
-
-    #[tokio::test]
-    async fn test_default_predictor() {
-        let config = PredictionConfig::default();
-        let predictor = DefaultPredictor::new(config).unwrap();
-        let target = create_test_target();
-
-        let prediction = predictor.predict(&target).await.unwrap();
-        assert!(!prediction.off_targets.is_empty());
-    }
-
-    #[test]
-    fn test_cfd_scoring() {
-        let score = CfdScorer::score("ACGT", "ACGT");
-        assert_eq!(score, 1.0);
-
-        let score_mismatch = CfdScorer::score("ACGT", "ACCT");
-        assert!(score_mismatch < 1.0);
-    }
-}