机器学习算法之朴素贝叶斯：Naive Bayes 手动计算公式 + 垃圾邮件过滤案例 + Python/Java完整代码

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

# 数据
texts = [
    "免费 赢 大奖",
    "免费 课程",
    "会议 安排 明天",
    "项目 进展 顺利"
]
labels = [1, 1, 0, 0]  # 1=垃圾, 0=正常

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

# 训练
clf = BernoulliNB(alpha=1.0)  # alpha=1 即拉普拉斯平滑
clf.fit(X, labels)

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

import numpy as np

class NaiveBayes:
    def __init__(self):
        self.vocab = {}
        self.prior = {}
        self.cond_prob = {}
    
    def fit(self, docs, labels, alpha=1):
        # 构建词汇表
        words = set(w for doc in docs for w in doc)
        self.vocab = {w: i for i, w in enumerate(words)}
        n_vocab = len(self.vocab)
        
        # 统计类别
        unique_labels = list(set(labels))
        label_count = {l: labels.count(l) for l in unique_labels}
        total = len(labels)
        
        # 先验概率
        self.prior = {l: count / total for l, count in label_count.items()}
        
        # 条件概率（伯努利）
        self.cond_prob = {l: np.zeros(n_vocab) for l in unique_labels}
        for doc, label in zip(docs, labels):
            doc_vec = np.zeros(n_vocab)
            for w in doc:
                if w in self.vocab:
                    doc_vec[self.vocab[w]] = 1
            self.cond_prob[label] += doc_vec
        
        # 拉普拉斯平滑
        for label in unique_labels:
            n_docs = label_count[label]
            self.cond_prob[label] = (self.cond_prob[label] + alpha) / (n_docs + 2 * alpha)
    
    def predict(self, doc):
        scores = {}
        for label in self.prior:
            log_prob = np.log(self.prior[label])
            for w in doc:
                if w in self.vocab:
                    idx = self.vocab[w]
                    log_prob += np.log(self.cond_prob[label][idx])
            scores[label] = log_prob
        return max(scores, key=scores.get)

# 使用
docs = [["免费","赢","大奖"], ["免费","课程"], ["会议","安排","明天"], ["项目","进展","顺利"]]
nb = NaiveBayes()
nb.fit(docs, [1,1,0,0])
print(nb.predict(["免费", "会议"]))  # 输出: 1

import java.util.*;

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

    public void fit(List<List<String>> docs, List<Integer> labels, double alpha) {
        // 构建词汇表
        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> labelCount = new HashMap<>();
        for (int label : labels) {
            labelCount.put(label, labelCount.getOrDefault(label, 0) + 1);
        }

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

        // 条件概率（伯努利）
        for (int label : labelCount.keySet()) {
            double[] prob = new double[vocabSize];
            int docsWithLabel = labelCount.get(label);
            
            // 统计每个词在该类中出现次数
            for (int i = 0; i < docs.size(); i++) {
                if (labels.get(i) == label) {
                    Set<String> docWords = new HashSet<>(docs.get(i));
                    for (String word : docWords) {
                        if (vocab.containsKey(word)) {
                            int wIdx = vocab.get(word);
                            prob[wIdx] += 1.0;
                        }
                    }
                }
            }
            
            // 拉普拉斯平滑
            for (int i = 0; i < vocabSize; i++) {
                prob[i] = (prob[i] + alpha) / (docsWithLabel + 2 * alpha);
            }
            condProb.put(label, prob);
        }
    }

    public int predict(List<String> doc) {
        Map<Integer, Double> scores = new HashMap<>();
        for (int label : prior.keySet()) {
            double logProb = Math.log(prior.get(label));
            Set<String> docWords = new HashSet<>(doc);
            for (String word : docWords) {
                if (vocab.containsKey(word)) {
                    int wIdx = vocab.get(word);
                    logProb += Math.log(condProb.get(label)[wIdx]);
                }
            }
            scores.put(label, logProb);
        }

        // 返回概率最大的标签
        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("项目", "进展", "顺利")
        );
        List<Integer> labels = Arrays.asList(1, 1, 0, 0);

        NaiveBayes nb = new NaiveBayes();
        nb.fit(docs, labels, 1.0); // alpha=1

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