Struct Classifier 

pub struct Classifier<C> { /* private fields */ }

A Naive Bayes classifier, optionally upgraded with TF-IDF weights.

Plain Naive Bayes is always available via [classify], [log_scores], and [prob_scores]. After calling [build_tfidf] the TF-IDF variants become available. You may call [build_tfidf] again at any time after learning more documents — it recomputes from scratch over all accumulated data.

Implementations

impl<C: Eq + Hash + Clone> Classifier<C>

pub fn new(classes: Vec<C>) -> Self

Creates a new classifier.

Panics if fewer than two classes are given, or if they are not unique.

Examples found in repository

examples/names.rs (line 60)

fn main() {
    use Sex::*;

    let mut classifier = Classifier::new(vec![Male, Female]);

    for (name, sex) in training_data() {
        classifier.learn(&featurize(&name), &sex);
    }

    let test_cases: &[(&str, Sex)] = &[
        // Unambiguous male
        ("james", Male),
        ("michael", Male),
        ("bob", Male),
        ("joe", Male),
        ("corey", Male),
        ("tyler", Male),
        ("brad", Male),
        ("chad", Male),
        ("derek", Male),
        ("lance", Male),
        // Unambiguous female
        ("sara", Female),
        ("whitney", Female),
        ("jessica", Female),
        ("emily", Female),
        ("tiffany", Female),
        ("brittany", Female),
        ("amanda", Female),
        ("natalie", Female),
        // Genuinely ambiguous / androgynous
        ("sam", Male),
        ("alex", Male),
        ("morgan", Female),
        ("taylor", Female),
        ("jordan", Male),
        ("casey", Male),
        ("riley", Female),
        ("charlie", Male),
        ("robin", Female),
        ("drew", Male),
    ];

    let male_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Male)
        .unwrap();

    let female_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Female)
        .unwrap();

    println!("Trained on {} names\n", classifier.learned());
    println!("{}", "-".repeat(56));

    let mut correct = 0;

    for (name, expected) in test_cases {
        let features = featurize(name);
        let predicted = classifier.classify(&features);
        let probs = classifier.prob_scores(&features);

        if predicted == expected {
            correct += 1;
        }

        println!(
            "[{}] {name:<12} predicted={predicted:?}  expected={expected:?}  male={:.1}%  female={:.1}%",
            if predicted == expected { "✓" } else { "✗" },
            probs[male_idx] * 100.0,
            probs[female_idx] * 100.0,
        );
    }

    println!("{}", "-".repeat(56));
    println!(
        "Accuracy: {correct}/{}  ({:.0}%)",
        test_cases.len(),
        correct as f64 / test_cases.len() as f64 * 100.0
    );
}

examples/spam.rs (line 23)

fn main() {
    use Category::*;

    let mut classifier = Classifier::new(vec![Spam, Ham]);

    let training: &[(&str, Category)] = &[
        ("Buy cheap pills online now limited offer", Spam),
        ("You have won a free prize click here to claim", Spam),
        ("Make money fast work from home guaranteed", Spam),
        ("Exclusive deal buy now huge discount sale", Spam),
        ("Free Viagra cheap meds no prescription needed", Spam),
        ("Congratulations you are our lucky winner click", Spam),
        ("Earn cash fast no experience required apply now", Spam),
        ("Special offer buy one get one free today only", Spam),
        ("Hey are you coming to the meeting tomorrow", Ham),
        ("Can we schedule a call this afternoon to catch up", Ham),
        ("The project report is due on Friday please review", Ham),
        ("Let me know if you need anything from the store", Ham),
        ("Dinner tonight at the usual place around seven", Ham),
        ("Just wanted to check in hope everything is well", Ham),
        (
            "The presentation went really well thanks for your help",
            Ham,
        ),
        ("Could you send me the notes from this morning", Ham),
    ];

    for (text, category) in training {
        classifier.learn(&tokenize(text), category);
    }

    let test_cases: &[(&str, Category)] = &[
        ("Free money click now buy cheap online offer", Spam),
        ("Hey can we meet tomorrow morning for coffee", Ham),
        ("You won a prize claim your free gift now", Spam),
        ("The report looks good nice work on the project", Ham),
        ("Limited time offer buy now get discount pills", Spam),
        ("Just checking in let me know how you are doing", Ham),
    ];

    let spam_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Spam)
        .unwrap();
    let ham_idx = classifier.classes().iter().position(|c| c == &Ham).unwrap();

    println!("Trained on {} documents\n", classifier.learned());
    println!("{}", "-".repeat(60));

    let mut correct = 0;

    for (text, expected) in test_cases {
        let tokens = tokenize(text);
        let predicted = classifier.classify(&tokens);
        let probs = classifier.prob_scores(&tokens);

        if predicted == expected {
            correct += 1;
        }

        println!(
            "[{}] \"{text}\"",
            if predicted == expected { "✓" } else { "✗" }
        );
        println!(
            "    predicted={predicted:?}  expected={expected:?}  spam={:.1}%  ham={:.1}%\n",
            probs[spam_idx] * 100.0,
            probs[ham_idx] * 100.0,
        );
    }

    println!("{}", "-".repeat(60));
    println!("Accuracy: {correct}/{}", test_cases.len());
}

pub fn learn<S: AsRef<str>>(&mut self, document: &[S], class: &C)

Trains the classifier on a document (a slice of words) for the given class.

Accumulates both raw word counts (used by plain Naive Bayes) and per-document TF samples (used by [build_tfidf]). The two sets of data are kept separate, so calling [build_tfidf] never destroys the raw counts and plain classification always remains available.

Examples found in repository

examples/names.rs (line 63)

fn main() {
    use Sex::*;

    let mut classifier = Classifier::new(vec![Male, Female]);

    for (name, sex) in training_data() {
        classifier.learn(&featurize(&name), &sex);
    }

    let test_cases: &[(&str, Sex)] = &[
        // Unambiguous male
        ("james", Male),
        ("michael", Male),
        ("bob", Male),
        ("joe", Male),
        ("corey", Male),
        ("tyler", Male),
        ("brad", Male),
        ("chad", Male),
        ("derek", Male),
        ("lance", Male),
        // Unambiguous female
        ("sara", Female),
        ("whitney", Female),
        ("jessica", Female),
        ("emily", Female),
        ("tiffany", Female),
        ("brittany", Female),
        ("amanda", Female),
        ("natalie", Female),
        // Genuinely ambiguous / androgynous
        ("sam", Male),
        ("alex", Male),
        ("morgan", Female),
        ("taylor", Female),
        ("jordan", Male),
        ("casey", Male),
        ("riley", Female),
        ("charlie", Male),
        ("robin", Female),
        ("drew", Male),
    ];

    let male_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Male)
        .unwrap();

    let female_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Female)
        .unwrap();

    println!("Trained on {} names\n", classifier.learned());
    println!("{}", "-".repeat(56));

    let mut correct = 0;

    for (name, expected) in test_cases {
        let features = featurize(name);
        let predicted = classifier.classify(&features);
        let probs = classifier.prob_scores(&features);

        if predicted == expected {
            correct += 1;
        }

        println!(
            "[{}] {name:<12} predicted={predicted:?}  expected={expected:?}  male={:.1}%  female={:.1}%",
            if predicted == expected { "✓" } else { "✗" },
            probs[male_idx] * 100.0,
            probs[female_idx] * 100.0,
        );
    }

    println!("{}", "-".repeat(56));
    println!(
        "Accuracy: {correct}/{}  ({:.0}%)",
        test_cases.len(),
        correct as f64 / test_cases.len() as f64 * 100.0
    );
}

examples/spam.rs (line 48)

fn main() {
    use Category::*;

    let mut classifier = Classifier::new(vec![Spam, Ham]);

    let training: &[(&str, Category)] = &[
        ("Buy cheap pills online now limited offer", Spam),
        ("You have won a free prize click here to claim", Spam),
        ("Make money fast work from home guaranteed", Spam),
        ("Exclusive deal buy now huge discount sale", Spam),
        ("Free Viagra cheap meds no prescription needed", Spam),
        ("Congratulations you are our lucky winner click", Spam),
        ("Earn cash fast no experience required apply now", Spam),
        ("Special offer buy one get one free today only", Spam),
        ("Hey are you coming to the meeting tomorrow", Ham),
        ("Can we schedule a call this afternoon to catch up", Ham),
        ("The project report is due on Friday please review", Ham),
        ("Let me know if you need anything from the store", Ham),
        ("Dinner tonight at the usual place around seven", Ham),
        ("Just wanted to check in hope everything is well", Ham),
        (
            "The presentation went really well thanks for your help",
            Ham,
        ),
        ("Could you send me the notes from this morning", Ham),
    ];

    for (text, category) in training {
        classifier.learn(&tokenize(text), category);
    }

    let test_cases: &[(&str, Category)] = &[
        ("Free money click now buy cheap online offer", Spam),
        ("Hey can we meet tomorrow morning for coffee", Ham),
        ("You won a prize claim your free gift now", Spam),
        ("The report looks good nice work on the project", Ham),
        ("Limited time offer buy now get discount pills", Spam),
        ("Just checking in let me know how you are doing", Ham),
    ];

    let spam_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Spam)
        .unwrap();
    let ham_idx = classifier.classes().iter().position(|c| c == &Ham).unwrap();

    println!("Trained on {} documents\n", classifier.learned());
    println!("{}", "-".repeat(60));

    let mut correct = 0;

    for (text, expected) in test_cases {
        let tokens = tokenize(text);
        let predicted = classifier.classify(&tokens);
        let probs = classifier.prob_scores(&tokens);

        if predicted == expected {
            correct += 1;
        }

        println!(
            "[{}] \"{text}\"",
            if predicted == expected { "✓" } else { "✗" }
        );
        println!(
            "    predicted={predicted:?}  expected={expected:?}  spam={:.1}%  ham={:.1}%\n",
            probs[spam_idx] * 100.0,
            probs[ham_idx] * 100.0,
        );
    }

    println!("{}", "-".repeat(60));
    println!("Accuracy: {correct}/{}", test_cases.len());
}

pub fn build_tfidf(&mut self)

Computes TF-IDF weights from all documents learned so far and stores them internally, enabling the _tfidf family of classification methods.

Safe to call multiple times — each call recomputes from scratch over the full accumulated training set, so you can learn more documents and call this again to refresh the weights without losing anything.

IDF formula: ln(1 + N / df) where N is the total number of documents learned and df is the number of documents (across all classes) that contain the word.

Per-word weight: Σ ln(1 + tf) * idf summed over every training document in the class that contains the word.

pub fn has_tfidf(&self) -> bool

Returns true if [build_tfidf] has been called and TF-IDF weights are ready for classification.

pub fn learned(&self) -> usize

Returns the total number of documents the classifier has been trained on.

Examples found in repository

examples/names.rs (line 112)

fn main() {
    use Sex::*;

    let mut classifier = Classifier::new(vec![Male, Female]);

    for (name, sex) in training_data() {
        classifier.learn(&featurize(&name), &sex);
    }

    let test_cases: &[(&str, Sex)] = &[
        // Unambiguous male
        ("james", Male),
        ("michael", Male),
        ("bob", Male),
        ("joe", Male),
        ("corey", Male),
        ("tyler", Male),
        ("brad", Male),
        ("chad", Male),
        ("derek", Male),
        ("lance", Male),
        // Unambiguous female
        ("sara", Female),
        ("whitney", Female),
        ("jessica", Female),
        ("emily", Female),
        ("tiffany", Female),
        ("brittany", Female),
        ("amanda", Female),
        ("natalie", Female),
        // Genuinely ambiguous / androgynous
        ("sam", Male),
        ("alex", Male),
        ("morgan", Female),
        ("taylor", Female),
        ("jordan", Male),
        ("casey", Male),
        ("riley", Female),
        ("charlie", Male),
        ("robin", Female),
        ("drew", Male),
    ];

    let male_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Male)
        .unwrap();

    let female_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Female)
        .unwrap();

    println!("Trained on {} names\n", classifier.learned());
    println!("{}", "-".repeat(56));

    let mut correct = 0;

    for (name, expected) in test_cases {
        let features = featurize(name);
        let predicted = classifier.classify(&features);
        let probs = classifier.prob_scores(&features);

        if predicted == expected {
            correct += 1;
        }

        println!(
            "[{}] {name:<12} predicted={predicted:?}  expected={expected:?}  male={:.1}%  female={:.1}%",
            if predicted == expected { "✓" } else { "✗" },
            probs[male_idx] * 100.0,
            probs[female_idx] * 100.0,
        );
    }

    println!("{}", "-".repeat(56));
    println!(
        "Accuracy: {correct}/{}  ({:.0}%)",
        test_cases.len(),
        correct as f64 / test_cases.len() as f64 * 100.0
    );
}

examples/spam.rs (line 67)

fn main() {
    use Category::*;

    let mut classifier = Classifier::new(vec![Spam, Ham]);

    let training: &[(&str, Category)] = &[
        ("Buy cheap pills online now limited offer", Spam),
        ("You have won a free prize click here to claim", Spam),
        ("Make money fast work from home guaranteed", Spam),
        ("Exclusive deal buy now huge discount sale", Spam),
        ("Free Viagra cheap meds no prescription needed", Spam),
        ("Congratulations you are our lucky winner click", Spam),
        ("Earn cash fast no experience required apply now", Spam),
        ("Special offer buy one get one free today only", Spam),
        ("Hey are you coming to the meeting tomorrow", Ham),
        ("Can we schedule a call this afternoon to catch up", Ham),
        ("The project report is due on Friday please review", Ham),
        ("Let me know if you need anything from the store", Ham),
        ("Dinner tonight at the usual place around seven", Ham),
        ("Just wanted to check in hope everything is well", Ham),
        (
            "The presentation went really well thanks for your help",
            Ham,
        ),
        ("Could you send me the notes from this morning", Ham),
    ];

    for (text, category) in training {
        classifier.learn(&tokenize(text), category);
    }

    let test_cases: &[(&str, Category)] = &[
        ("Free money click now buy cheap online offer", Spam),
        ("Hey can we meet tomorrow morning for coffee", Ham),
        ("You won a prize claim your free gift now", Spam),
        ("The report looks good nice work on the project", Ham),
        ("Limited time offer buy now get discount pills", Spam),
        ("Just checking in let me know how you are doing", Ham),
    ];

    let spam_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Spam)
        .unwrap();
    let ham_idx = classifier.classes().iter().position(|c| c == &Ham).unwrap();

    println!("Trained on {} documents\n", classifier.learned());
    println!("{}", "-".repeat(60));

    let mut correct = 0;

    for (text, expected) in test_cases {
        let tokens = tokenize(text);
        let predicted = classifier.classify(&tokens);
        let probs = classifier.prob_scores(&tokens);

        if predicted == expected {
            correct += 1;
        }

        println!(
            "[{}] \"{text}\"",
            if predicted == expected { "✓" } else { "✗" }
        );
        println!(
            "    predicted={predicted:?}  expected={expected:?}  spam={:.1}%  ham={:.1}%\n",
            probs[spam_idx] * 100.0,
            probs[ham_idx] * 100.0,
        );
    }

    println!("{}", "-".repeat(60));
    println!("Accuracy: {correct}/{}", test_cases.len());
}

pub fn classes(&self) -> &[C]

Returns the ordered slice of class labels used to build this classifier.

Examples found in repository

examples/names.rs (line 101)

fn main() {
    use Sex::*;

    let mut classifier = Classifier::new(vec![Male, Female]);

    for (name, sex) in training_data() {
        classifier.learn(&featurize(&name), &sex);
    }

    let test_cases: &[(&str, Sex)] = &[
        // Unambiguous male
        ("james", Male),
        ("michael", Male),
        ("bob", Male),
        ("joe", Male),
        ("corey", Male),
        ("tyler", Male),
        ("brad", Male),
        ("chad", Male),
        ("derek", Male),
        ("lance", Male),
        // Unambiguous female
        ("sara", Female),
        ("whitney", Female),
        ("jessica", Female),
        ("emily", Female),
        ("tiffany", Female),
        ("brittany", Female),
        ("amanda", Female),
        ("natalie", Female),
        // Genuinely ambiguous / androgynous
        ("sam", Male),
        ("alex", Male),
        ("morgan", Female),
        ("taylor", Female),
        ("jordan", Male),
        ("casey", Male),
        ("riley", Female),
        ("charlie", Male),
        ("robin", Female),
        ("drew", Male),
    ];

    let male_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Male)
        .unwrap();

    let female_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Female)
        .unwrap();

    println!("Trained on {} names\n", classifier.learned());
    println!("{}", "-".repeat(56));

    let mut correct = 0;

    for (name, expected) in test_cases {
        let features = featurize(name);
        let predicted = classifier.classify(&features);
        let probs = classifier.prob_scores(&features);

        if predicted == expected {
            correct += 1;
        }

        println!(
            "[{}] {name:<12} predicted={predicted:?}  expected={expected:?}  male={:.1}%  female={:.1}%",
            if predicted == expected { "✓" } else { "✗" },
            probs[male_idx] * 100.0,
            probs[female_idx] * 100.0,
        );
    }

    println!("{}", "-".repeat(56));
    println!(
        "Accuracy: {correct}/{}  ({:.0}%)",
        test_cases.len(),
        correct as f64 / test_cases.len() as f64 * 100.0
    );
}

examples/spam.rs (line 61)

fn main() {
    use Category::*;

    let mut classifier = Classifier::new(vec![Spam, Ham]);

    let training: &[(&str, Category)] = &[
        ("Buy cheap pills online now limited offer", Spam),
        ("You have won a free prize click here to claim", Spam),
        ("Make money fast work from home guaranteed", Spam),
        ("Exclusive deal buy now huge discount sale", Spam),
        ("Free Viagra cheap meds no prescription needed", Spam),
        ("Congratulations you are our lucky winner click", Spam),
        ("Earn cash fast no experience required apply now", Spam),
        ("Special offer buy one get one free today only", Spam),
        ("Hey are you coming to the meeting tomorrow", Ham),
        ("Can we schedule a call this afternoon to catch up", Ham),
        ("The project report is due on Friday please review", Ham),
        ("Let me know if you need anything from the store", Ham),
        ("Dinner tonight at the usual place around seven", Ham),
        ("Just wanted to check in hope everything is well", Ham),
        (
            "The presentation went really well thanks for your help",
            Ham,
        ),
        ("Could you send me the notes from this morning", Ham),
    ];

    for (text, category) in training {
        classifier.learn(&tokenize(text), category);
    }

    let test_cases: &[(&str, Category)] = &[
        ("Free money click now buy cheap online offer", Spam),
        ("Hey can we meet tomorrow morning for coffee", Ham),
        ("You won a prize claim your free gift now", Spam),
        ("The report looks good nice work on the project", Ham),
        ("Limited time offer buy now get discount pills", Spam),
        ("Just checking in let me know how you are doing", Ham),
    ];

    let spam_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Spam)
        .unwrap();
    let ham_idx = classifier.classes().iter().position(|c| c == &Ham).unwrap();

    println!("Trained on {} documents\n", classifier.learned());
    println!("{}", "-".repeat(60));

    let mut correct = 0;

    for (text, expected) in test_cases {
        let tokens = tokenize(text);
        let predicted = classifier.classify(&tokens);
        let probs = classifier.prob_scores(&tokens);

        if predicted == expected {
            correct += 1;
        }

        println!(
            "[{}] \"{text}\"",
            if predicted == expected { "✓" } else { "✗" }
        );
        println!(
            "    predicted={predicted:?}  expected={expected:?}  spam={:.1}%  ham={:.1}%\n",
            probs[spam_idx] * 100.0,
            probs[ham_idx] * 100.0,
        );
    }

    println!("{}", "-".repeat(60));
    println!("Accuracy: {correct}/{}", test_cases.len());
}

pub fn log_scores<S: AsRef<str>>(&self, document: &[S]) -> Vec<f64>

Returns the log-likelihood score for each class using raw word counts. Index i corresponds to classes()[i].

pub fn prob_scores<S: AsRef<str>>(&self, document: &[S]) -> Vec<f64>

Returns normalised probability scores for each class using raw word counts (sum to 1.0). Index i corresponds to classes()[i].

Examples found in repository

examples/names.rs (line 120)

fn main() {
    use Sex::*;

    let mut classifier = Classifier::new(vec![Male, Female]);

    for (name, sex) in training_data() {
        classifier.learn(&featurize(&name), &sex);
    }

    let test_cases: &[(&str, Sex)] = &[
        // Unambiguous male
        ("james", Male),
        ("michael", Male),
        ("bob", Male),
        ("joe", Male),
        ("corey", Male),
        ("tyler", Male),
        ("brad", Male),
        ("chad", Male),
        ("derek", Male),
        ("lance", Male),
        // Unambiguous female
        ("sara", Female),
        ("whitney", Female),
        ("jessica", Female),
        ("emily", Female),
        ("tiffany", Female),
        ("brittany", Female),
        ("amanda", Female),
        ("natalie", Female),
        // Genuinely ambiguous / androgynous
        ("sam", Male),
        ("alex", Male),
        ("morgan", Female),
        ("taylor", Female),
        ("jordan", Male),
        ("casey", Male),
        ("riley", Female),
        ("charlie", Male),
        ("robin", Female),
        ("drew", Male),
    ];

    let male_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Male)
        .unwrap();

    let female_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Female)
        .unwrap();

    println!("Trained on {} names\n", classifier.learned());
    println!("{}", "-".repeat(56));

    let mut correct = 0;

    for (name, expected) in test_cases {
        let features = featurize(name);
        let predicted = classifier.classify(&features);
        let probs = classifier.prob_scores(&features);

        if predicted == expected {
            correct += 1;
        }

        println!(
            "[{}] {name:<12} predicted={predicted:?}  expected={expected:?}  male={:.1}%  female={:.1}%",
            if predicted == expected { "✓" } else { "✗" },
            probs[male_idx] * 100.0,
            probs[female_idx] * 100.0,
        );
    }

    println!("{}", "-".repeat(56));
    println!(
        "Accuracy: {correct}/{}  ({:.0}%)",
        test_cases.len(),
        correct as f64 / test_cases.len() as f64 * 100.0
    );
}

examples/spam.rs (line 75)

fn main() {
    use Category::*;

    let mut classifier = Classifier::new(vec![Spam, Ham]);

    let training: &[(&str, Category)] = &[
        ("Buy cheap pills online now limited offer", Spam),
        ("You have won a free prize click here to claim", Spam),
        ("Make money fast work from home guaranteed", Spam),
        ("Exclusive deal buy now huge discount sale", Spam),
        ("Free Viagra cheap meds no prescription needed", Spam),
        ("Congratulations you are our lucky winner click", Spam),
        ("Earn cash fast no experience required apply now", Spam),
        ("Special offer buy one get one free today only", Spam),
        ("Hey are you coming to the meeting tomorrow", Ham),
        ("Can we schedule a call this afternoon to catch up", Ham),
        ("The project report is due on Friday please review", Ham),
        ("Let me know if you need anything from the store", Ham),
        ("Dinner tonight at the usual place around seven", Ham),
        ("Just wanted to check in hope everything is well", Ham),
        (
            "The presentation went really well thanks for your help",
            Ham,
        ),
        ("Could you send me the notes from this morning", Ham),
    ];

    for (text, category) in training {
        classifier.learn(&tokenize(text), category);
    }

    let test_cases: &[(&str, Category)] = &[
        ("Free money click now buy cheap online offer", Spam),
        ("Hey can we meet tomorrow morning for coffee", Ham),
        ("You won a prize claim your free gift now", Spam),
        ("The report looks good nice work on the project", Ham),
        ("Limited time offer buy now get discount pills", Spam),
        ("Just checking in let me know how you are doing", Ham),
    ];

    let spam_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Spam)
        .unwrap();
    let ham_idx = classifier.classes().iter().position(|c| c == &Ham).unwrap();

    println!("Trained on {} documents\n", classifier.learned());
    println!("{}", "-".repeat(60));

    let mut correct = 0;

    for (text, expected) in test_cases {
        let tokens = tokenize(text);
        let predicted = classifier.classify(&tokens);
        let probs = classifier.prob_scores(&tokens);

        if predicted == expected {
            correct += 1;
        }

        println!(
            "[{}] \"{text}\"",
            if predicted == expected { "✓" } else { "✗" }
        );
        println!(
            "    predicted={predicted:?}  expected={expected:?}  spam={:.1}%  ham={:.1}%\n",
            probs[spam_idx] * 100.0,
            probs[ham_idx] * 100.0,
        );
    }

    println!("{}", "-".repeat(60));
    println!("Accuracy: {correct}/{}", test_cases.len());
}

pub fn classify<S: AsRef<str>>(&self, document: &[S]) -> &C

Returns the most likely class for the given document using plain Naive Bayes.

Examples found in repository

examples/names.rs (line 119)

fn main() {
    use Sex::*;

    let mut classifier = Classifier::new(vec![Male, Female]);

    for (name, sex) in training_data() {
        classifier.learn(&featurize(&name), &sex);
    }

    let test_cases: &[(&str, Sex)] = &[
        // Unambiguous male
        ("james", Male),
        ("michael", Male),
        ("bob", Male),
        ("joe", Male),
        ("corey", Male),
        ("tyler", Male),
        ("brad", Male),
        ("chad", Male),
        ("derek", Male),
        ("lance", Male),
        // Unambiguous female
        ("sara", Female),
        ("whitney", Female),
        ("jessica", Female),
        ("emily", Female),
        ("tiffany", Female),
        ("brittany", Female),
        ("amanda", Female),
        ("natalie", Female),
        // Genuinely ambiguous / androgynous
        ("sam", Male),
        ("alex", Male),
        ("morgan", Female),
        ("taylor", Female),
        ("jordan", Male),
        ("casey", Male),
        ("riley", Female),
        ("charlie", Male),
        ("robin", Female),
        ("drew", Male),
    ];

    let male_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Male)
        .unwrap();

    let female_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Female)
        .unwrap();

    println!("Trained on {} names\n", classifier.learned());
    println!("{}", "-".repeat(56));

    let mut correct = 0;

    for (name, expected) in test_cases {
        let features = featurize(name);
        let predicted = classifier.classify(&features);
        let probs = classifier.prob_scores(&features);

        if predicted == expected {
            correct += 1;
        }

        println!(
            "[{}] {name:<12} predicted={predicted:?}  expected={expected:?}  male={:.1}%  female={:.1}%",
            if predicted == expected { "✓" } else { "✗" },
            probs[male_idx] * 100.0,
            probs[female_idx] * 100.0,
        );
    }

    println!("{}", "-".repeat(56));
    println!(
        "Accuracy: {correct}/{}  ({:.0}%)",
        test_cases.len(),
        correct as f64 / test_cases.len() as f64 * 100.0
    );
}

examples/spam.rs (line 74)

fn main() {
    use Category::*;

    let mut classifier = Classifier::new(vec![Spam, Ham]);

    let training: &[(&str, Category)] = &[
        ("Buy cheap pills online now limited offer", Spam),
        ("You have won a free prize click here to claim", Spam),
        ("Make money fast work from home guaranteed", Spam),
        ("Exclusive deal buy now huge discount sale", Spam),
        ("Free Viagra cheap meds no prescription needed", Spam),
        ("Congratulations you are our lucky winner click", Spam),
        ("Earn cash fast no experience required apply now", Spam),
        ("Special offer buy one get one free today only", Spam),
        ("Hey are you coming to the meeting tomorrow", Ham),
        ("Can we schedule a call this afternoon to catch up", Ham),
        ("The project report is due on Friday please review", Ham),
        ("Let me know if you need anything from the store", Ham),
        ("Dinner tonight at the usual place around seven", Ham),
        ("Just wanted to check in hope everything is well", Ham),
        (
            "The presentation went really well thanks for your help",
            Ham,
        ),
        ("Could you send me the notes from this morning", Ham),
    ];

    for (text, category) in training {
        classifier.learn(&tokenize(text), category);
    }

    let test_cases: &[(&str, Category)] = &[
        ("Free money click now buy cheap online offer", Spam),
        ("Hey can we meet tomorrow morning for coffee", Ham),
        ("You won a prize claim your free gift now", Spam),
        ("The report looks good nice work on the project", Ham),
        ("Limited time offer buy now get discount pills", Spam),
        ("Just checking in let me know how you are doing", Ham),
    ];

    let spam_idx = classifier
        .classes()
        .iter()
        .position(|c| c == &Spam)
        .unwrap();
    let ham_idx = classifier.classes().iter().position(|c| c == &Ham).unwrap();

    println!("Trained on {} documents\n", classifier.learned());
    println!("{}", "-".repeat(60));

    let mut correct = 0;

    for (text, expected) in test_cases {
        let tokens = tokenize(text);
        let predicted = classifier.classify(&tokens);
        let probs = classifier.prob_scores(&tokens);

        if predicted == expected {
            correct += 1;
        }

        println!(
            "[{}] \"{text}\"",
            if predicted == expected { "✓" } else { "✗" }
        );
        println!(
            "    predicted={predicted:?}  expected={expected:?}  spam={:.1}%  ham={:.1}%\n",
            probs[spam_idx] * 100.0,
            probs[ham_idx] * 100.0,
        );
    }

    println!("{}", "-".repeat(60));
    println!("Accuracy: {correct}/{}", test_cases.len());
}

pub fn log_scores_tfidf<S: AsRef<str>>(&self, document: &[S]) -> Vec<f64>

Returns the log-likelihood score for each class using TF-IDF weights. Index i corresponds to classes()[i].

Panics if [build_tfidf] has not been called yet.

pub fn prob_scores_tfidf<S: AsRef<str>>(&self, document: &[S]) -> Vec<f64>

Returns normalised probability scores for each class using TF-IDF weights (sum to 1.0). Index i corresponds to classes()[i].

Panics if [build_tfidf] has not been called yet.

pub fn classify_tfidf<S: AsRef<str>>(&self, document: &[S]) -> &C

Returns the most likely class for the given document using TF-IDF weights.

Panics if [build_tfidf] has not been called yet.

pub fn serialize(&self) -> Result<Vec<u8>>

where C: Serialize,

Serializes the classifier (including any built TF-IDF weights) to a compressed binary blob (bincode + gzip).

The result can be stored to disk, sent over the wire, etc. Pass it back to Classifier::from_data to reconstruct an identical classifier.

pub fn from_data(data: impl AsRef<[u8]>) -> Result<Self>

where C: for<'de> Deserialize<'de>,

Reconstructs a Classifier from bytes previously produced by Classifier::serialize.

pub fn serialize_to_file(&self, path: impl AsRef<Path>) -> Result<()>

where C: Serialize,

Writes the serialized classifier to a file at the given path.

Creates the file if it does not exist, truncates it if it does.

pub fn from_file(path: impl AsRef<Path>) -> Result<Self>

where C: for<'de> Deserialize<'de>,

Reconstructs a Classifier from a file previously written by Classifier::serialize_to_file.

Trait Implementations

impl<'de, C> Deserialize<'de> for Classifier<C>

where C: Deserialize<'de> + Eq + Hash,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C> Serialize for Classifier<C>

where C: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.