机器学习经典算法：伯努利朴素贝叶斯（Bernoulli Naive Bayes）原理、手动计算与Python/Java双代码实战

from sklearn.naive_bayes import BernoulliNB
from sklearn.feature_extraction.text import CountVectorizer

# 数据
texts = [
    "免费 赢",
    "免费",
    "会议 安排",
    "项目 进展",
    "免费 会议"
]
labels = [1, 1, 0, 0, 1]  # 1=垃圾, 0=正常

# 向量化（二值化）
vectorizer = CountVectorizer(binary=True)  # 关键：binary=True
X = vectorizer.fit_transform(texts)

# 训练
clf = BernoulliNB(alpha=1.0)
clf.fit(X, labels)

# 预测
new_text = vectorizer.transform(["赢 项目"])
pred = clf.predict(new_text)
print("预测结果:", "垃圾邮件" if pred[0] == 1 else "正常邮件")
# 输出: 垃圾邮件

import numpy as np
from collections import defaultdict

class BernoulliNB:
    def __init__(self, alpha=1.0):
        self.alpha = alpha
    
    def fit(self, docs, labels):
        # 构建词汇表
        vocab = set(word for doc in docs for word in doc)
        self.vocab = {word: i for i, word in enumerate(vocab)}
        self.n_vocab = len(vocab)
        
        # 统计
        class_doc_count = defaultdict(int)
        word_doc_count = defaultdict(lambda: np.zeros(self.n_vocab))
        
        for doc, label in zip(docs, labels):
            class_doc_count[label] += 1
            unique_words = set(doc)
            for word in unique_words:
                if word in self.vocab:
                    word_doc_count[label][self.vocab[word]] += 1
        
        # 先验概率
        total_docs = len(labels)
        self.priors = {label: count / total_docs for label, count in class_doc_count.items()}
        
        # 条件概率（伯努利，带平滑）
        self.cond_prob = {}
        for label in class_doc_count:
            n_docs = class_doc_count[label]
            smoothed_count = word_doc_count[label] + self.alpha
            smoothed_total = n_docs + 2 * self.alpha
            self.cond_prob[label] = smoothed_count / smoothed_total
    
    def predict(self, docs):
        predictions = []
        for doc in docs:
            scores = {}
            unique_words = set(doc)
            for label in self.priors:
                log_score = np.log(self.priors[label])
                for word in self.vocab:
                    idx = self.vocab[word]
                    if word in unique_words:
                        log_score += np.log(self.cond_prob[label][idx])
                    else:
                        log_score += np.log(1 - self.cond_prob[label][idx])
                scores[label] = log_score
            predictions.append(max(scores, key=scores.get))
        return predictions

# 使用
docs = [["免费","赢"], ["免费"], ["会议","安排"], ["项目","进展"], ["免费","会议"]]
nb = BernoulliNB(alpha=1.0)
nb.fit(docs, [1,1,0,0,1])
print(nb.predict())  # 输出: [1]

import java.util.*;

public class BernoulliNaiveBayes {
    private Map<String, Integer> vocab = new HashMap<>();
    private Map<Integer, Double> priors = new HashMap<>();
    private Map<Integer, double[]> condProb = new HashMap<>();
    private int vocabSize;
    private double alpha;

    public BernoulliNaiveBayes(double alpha) {
        this.alpha = alpha;
    }

    public void fit(List<List<String>> docs, List<Integer> labels) {
        // 构建词汇表
        Set<String> wordSet = new HashSet<>();
        for (List<String> doc : docs) {
            wordSet.addAll(doc);
        }
        int idx = 0;
        for (String word : wordSet) {
            vocab.put(word, idx++);
        }
        vocabSize = vocab.size();

        // 统计每个类别的文档数
        Map<Integer, Integer> classDocCount = new HashMap<>();
        for (int label : labels) {
            classDocCount.put(label, classDocCount.getOrDefault(label, 0) + 1);
        }

        // 统计每个词在各类中出现的文档数
        Map<Integer, int[]> wordDocCount = new HashMap<>();
        for (int label : classDocCount.keySet()) {
            wordDocCount.put(label, new int[vocabSize]);
        }

        for (int i = 0; i < docs.size(); i++) {
            int label = labels.get(i);
            Set<String> uniqueWords = new HashSet<>(docs.get(i));
            for (String word : uniqueWords) {
                if (vocab.containsKey(word)) {
                    int wIdx = vocab.get(word);
                    wordDocCount.get(label)[wIdx]++;
                }
            }
        }

        // 先验概率
        int totalDocs = labels.size();
        for (int label : classDocCount.keySet()) {
            priors.put(label, (double) classDocCount.get(label) / totalDocs);
        }

        // 条件概率（伯努利平滑）
        for (int label : classDocCount.keySet()) {
            double[] prob = new double[vocabSize];
            int nDocs = classDocCount.get(label);
            for (int i = 0; i < vocabSize; i++) {
                prob[i] = (wordDocCount.get(label)[i] + alpha) / (nDocs + 2 * alpha);
            }
            condProb.put(label, prob);
        }
    }

    public int predict(List<String> doc) {
        Set<String> uniqueWords = new HashSet<>(doc);
        Map<Integer, Double> scores = new HashMap<>();
        for (int label : priors.keySet()) {
            double logScore = Math.log(priors.get(label));
            for (String word : vocab.keySet()) {
                int wIdx = vocab.get(word);
                if (uniqueWords.contains(word)) {
                    logScore += Math.log(condProb.get(label)[wIdx]);
                } else {
                    logScore += Math.log(1 - condProb.get(label)[wIdx]);
                }
            }
            scores.put(label, logScore);
        }
        return Collections.max(scores.entrySet(), Map.Entry.comparingByValue()).getKey();
    }

    // 测试
    public static void main(String[] args) {
        List<List<String>> docs = Arrays.asList(
            Arrays.asList("免费", "赢"),
            Arrays.asList("免费"),
            Arrays.asList("会议", "安排"),
            Arrays.asList("项目", "进展"),
            Arrays.asList("免费", "会议")
        );
        List<Integer> labels = Arrays.asList(1, 1, 0, 0, 1);

        BernoulliNaiveBayes nb = new BernoulliNaiveBayes(1.0);
        nb.fit(docs, labels);

        List<String> testDoc = Arrays.asList("赢", "项目");
        int prediction = nb.predict(testDoc);
        System.out.println("预测结果: " + (prediction == 1 ? "垃圾邮件" : "正常邮件"));
        // 输出: 垃圾邮件
    }
}