Struct TrainedModel 

pub struct TrainedModel {
    pub classifier: Option<RandomForestClassifier>,
    pub tfidf_extractor: Option<TfidfFeatureExtractor>,
    pub category_to_label: HashMap<String, usize>,
    pub label_to_category: HashMap<usize, String>,
    pub metadata: TrainingMetadata,
    pub tfidf_vocabulary: Vec<String>,
    pub max_features: usize,
}

Trained ML classifier model with metadata

Fields

classifier: Option<RandomForestClassifier>

Random Forest classifier

tfidf_extractor: Option<TfidfFeatureExtractor>

TF-IDF feature extractor

category_to_label: HashMap<String, usize>

Mapping from category to label index

label_to_category: HashMap<usize, String>

Mapping from label index to category

metadata: TrainingMetadata

Training metadata

tfidf_vocabulary: Vec<String>

TF-IDF vocabulary (for reconstruction)

max_features: usize

Max features for TF-IDF

Implementations

impl TrainedModel

pub fn predict(&self, message: &str) -> Result<Option<(DefectCategory, f32)>>

Predict defect category for a single commit message

Arguments

• message - Commit message to classify

Returns

• Ok(Some((DefectCategory, f32))) - Predicted category and confidence
• Ok(None) - Model components not available (deserialized model)
• Err - Prediction error

Examples

if let Some((category, confidence)) = model.predict("fix: null pointer in parser")? {
    println!("Predicted: {:?} ({:.2})", category, confidence);
}

pub fn predict_top_n( &self, message: &str, _top_n: usize, ) -> Result<Vec<(DefectCategory, f32)>>

Predict top-N defect categories for a commit message

Arguments

• message - Commit message to classify
• top_n - Number of top categories to return

Returns

• Ok(Vec<(DefectCategory, f32)>) - Top-N categories with confidences

Examples

let predictions = model.predict_top_n("fix: null pointer in parser", 3)?;
for (category, confidence) in predictions {
    println!("{:?}: {:.2}", category, confidence);
}

Trait Implementations

impl<'de> Deserialize<'de> for TrainedModel

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TrainedModel

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.