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

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

# 数据
texts = [
    "科技 人工智能 发展 迅速",
    "科技 公司 发布 新产品",
    "体育 比赛 精彩 激烈"
]
labels = [0, 0, 1]  # 0=科技, 1=体育

# 向量化（词频计数）
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(texts)

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

# 预测
new_text = vectorizer.transform(["人工智能 比赛"])
pred = clf.predict(new_text)
print("预测结果:", "科技" if pred[0] == 0 else "体育")
# 输出: 科技

import numpy as np
from collections import defaultdict

class MultinomialNB:
    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_counts = defaultdict(int)
        word_counts = defaultdict(lambda: np.zeros(self.n_vocab))
        total_words = defaultdict(int)
        
        for doc, label in zip(docs, labels):
            class_counts[label] += 1
            for word in doc:
                if word in self.vocab:
                    word_counts[label][self.vocab[word]] += 1
                    total_words[label] += 1
        
        # 先验概率
        total_docs = len(labels)
        self.priors = {label: count / total_docs for label, count in class_counts.items()}
        
        # 条件概率（带平滑）
        self.cond_prob = {}
        for label in class_counts:
            smoothed_counts = word_counts[label] + self.alpha
            smoothed_total = total_words[label] + self.alpha * self.n_vocab
            self.cond_prob[label] = smoothed_counts / smoothed_total
    
    def predict(self, docs):
        predictions = []
        for doc in docs:
            scores = {}
            for label in self.priors:
                log_score = np.log(self.priors[label])
                for word in doc:
                    if word in self.vocab:
                        idx = self.vocab[word]
                        log_score += np.log(self.cond_prob[label][idx])
                scores[label] = log_score
            predictions.append(max(scores, key=scores.get))
        return predictions

# 使用
docs = [["科技","人工智能","发展","迅速"], ["科技","公司","发布","新产品"], ["体育","比赛","精彩","激烈"]]
nb = MultinomialNB(alpha=1.0)
nb.fit(docs, [0,0,1])
print(nb.predict())  # 输出: [0]

import java.util.*;

public class MultinomialNaiveBayes {
    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 MultinomialNaiveBayes(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[]> wordFreq = new HashMap<>();
        Map<Integer, Integer> totalWords = new HashMap<>();
        for (int label : classDocCount.keySet()) {
            wordFreq.put(label, new int[vocabSize]);
            totalWords.put(label, 0);
        }

        for (int i = 0; i < docs.size(); i++) {
            int label = labels.get(i);
            for (String word : docs.get(i)) {
                if (vocab.containsKey(word)) {
                    int wIdx = vocab.get(word);
                    wordFreq.get(label)[wIdx]++;
                    totalWords.put(label, totalWords.get(label) + 1);
                }
            }
        }

        // 先验概率
        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 totalWordCount = totalWords.get(label);
            for (int i = 0; i < vocabSize; i++) {
                prob[i] = (wordFreq.get(label)[i] + alpha) / (totalWordCount + alpha * vocabSize);
            }
            condProb.put(label, prob);
        }
    }

    public int predict(List<String> doc) {
        Map<Integer, Double> scores = new HashMap<>();
        for (int label : priors.keySet()) {
            double logScore = Math.log(priors.get(label));
            for (String word : doc) {
                if (vocab.containsKey(word)) {
                    int wIdx = vocab.get(word);
                    logScore += Math.log(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("体育", "比赛", "精彩", "激烈")
        );
        List<Integer> labels = Arrays.asList(0, 0, 1);

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

        List<String> testDoc = Arrays.asList("人工智能", "比赛");
        int prediction = nb.predict(testDoc);
        System.out.println("预测结果: " + (prediction == 0 ? "科技" : "体育"));
        // 输出: 科技
    }
}