朴素贝叶斯：概率分类器的原理与应用

import numpy as np
from scipy.stats import norm

class GaussianNaiveBayes:
    """从零实现高斯朴素贝叶斯分类器"""
    
    def fit(self, X, y):
        """训练：计算每个类别的均值、方差和先验概率"""
        self.classes = np.unique(y)
        self.params = {}
        
        for c in self.classes:
            X_c = X[y == c]
            self.params[c] = {
                'mean': np.mean(X_c, axis=0),
                'var': np.var(X_c, axis=0),
                'prior': len(X_c) / len(X)
            }
    
    def _likelihood(self, x, c):
        """计算 P(x|c)，使用高斯概率密度"""
        p = self.params[c]
        return np.prod(
            norm.pdf(x, loc=p['mean'], scale=np.sqrt(p['var']))
        )
    
    def predict(self, X):
        predictions = []
        for x in X:
            posteriors = []
            for c in self.classes:
                log_prior = np.log(self.params[c]['prior'])
                log_likelihood = np.log(self._likelihood(x, c) + 1e-9)
                posteriors.append(log_prior + log_likelihood)
            predictions.append(self.classes[np.argmax(posteriors)])
        return np.array(predictions)

# 测试
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(n_samples=1000, n_features=10, 
                           n_classes=2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

gnb = GaussianNaiveBayes()
gnb.fit(X_train, y_train)
accuracy = np.mean(gnb.predict(X_test) == y_test)
print(f"自定义高斯朴素贝叶斯准确率: {accuracy:.4f}")

# scikit-learn 三种朴素贝叶斯对比
from sklearn.naive_bayes import GaussianNB, MultinomialNB, BernoulliNB
from sklearn.metrics import accuracy_score, classification_report
from sklearn.feature_extraction.text import CountVectorizer

# 1. 高斯朴素贝叶斯（连续数据）
from sklearn.datasets import load_iris
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2)
gnb = GaussianNB()
gnb.fit(X_train, y_train)
print(f"高斯NB (Iris): {accuracy_score(y_test, gnb.predict(X_test)):.4f}")

# 2. 多项式朴素贝叶斯（文本分类）
docs = [
    "这部电影太棒了，强烈推荐",
    "剧情无聊，浪费时间",
    "演员表演精彩，值得一看",
    "毫无新意，非常失望",
    "视觉效果震撼，故事感人",
    "剧本太差，演员也不行"
]
labels = [1, 0, 1, 0, 1, 0]  # 1=正面, 0=负面

vectorizer = CountVectorizer()
X = vectorizer.fit_transform(docs)
mnb = MultinomialNB(alpha=1.0)
mnb.fit(X, labels)

test_docs = ["精彩绝伦的电影", "剧情太差了"]
X_test = vectorizer.transform(test_docs)
preds = mnb.predict(X_test)
print(f"多项式NB 预测: {preds}")  # 预期: [1, 0]

# 3. 伯努利朴素贝叶斯（二元特征）
bnb = BernoulliNB(alpha=1.0)
bnb.fit(X, labels)
preds_b = bnb.predict(X_test)
print(f"伯努利NB 预测: {preds_b}")

# 朴素贝叶斯特征重要性分析
import numpy as np
from sklearn.naive_bayes import MultinomialNB

def feature_importance_nb(model, feature_names, class_idx=0):
    """分析朴素贝叶斯模型中每个特征对特定类别的贡献"""
    # log P(xi|y) + log P(y)
    log_probs = model.feature_log_prob_[class_idx]
    
    # 按贡献排序
    indices = np.argsort(log_probs)[::-1]
    
    print(f"类别 '{model.classes_[class_idx]}' 的前 10 个重要特征:")
    for i in range(min(10, len(indices))):
        idx = indices[i]
        print(f"  {feature_names[idx]:20s}: log_prob = {log_probs[idx]:.4f}")

# 示例：文本分类特征分析
from sklearn.feature_extraction.text import CountVectorizer

docs = [
    "优秀 精彩 推荐 好看 满意 喜欢 完美 好评",
    "差劲 无聊 失望 垃圾 差评 投诉 退货 愤怒",
    "优秀 满意 推荐 精美 好评 喜欢",
    "差劲 投诉 退货 愤怒 失望",
]
labels = [1, 1, 1, 0]  # 1=正面, 0=负面

vectorizer = CountVectorizer()
X = vectorizer.fit_transform(docs)
mnb = MultinomialNB()
mnb.fit(X, labels)

feature_names = vectorizer.get_feature_names_out()
feature_importance_nb(mnb, feature_names, class_idx=1)

# TAN (Tree Augmented Naive Bayes) 简化实现
import numpy as np
from scipy.stats import norm
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

def conditional_mutual_info(X, y, i, j):
    """计算两个特征在给定类别下的条件互信息"""
    classes = np.unique(y)
    cmi = 0.0
    for c in classes:
        mask = y == c
        xi = X[mask, i]
        xj = X[mask, j]
        # 简化：假设连续特征，使用直方图估计
        hist_ij, _, _ = np.histogram2d(xi, xj, bins=10)
        hist_ij = hist_ij / hist_ij.sum() + 1e-10
        
        p_i = hist_ij.sum(axis=1)
        p_j = hist_ij.sum(axis=0)
        
        cmi += (mask.sum() / len(y)) * np.sum(
            hist_ij * np.log(hist_ij / (p_i[:, None] * p_j[None, :]))
        )
    return cmi

def build_tan_tree(X, y):
    """构建 TAN 的最大权值生成树"""
    n_features = X.shape[1]
    mi_matrix = np.zeros((n_features, n_features))
    for i in range(n_features):
        for j in range(i + 1, n_features):
            mi = conditional_mutual_info(X, y, i, j)
            mi_matrix[i, j] = mi
            mi_matrix[j, i] = mi
    
    # 贪心最大边构建生成树
    edges = []
    visited = set([0])
    remaining = set(range(1, n_features))
    
    while remaining:
        best_weight = -1
        best_edge = None
        for v in visited:
            for u in remaining:
                if mi_matrix[v, u] > best_weight:
                    best_weight = mi_matrix[v, u]
                    best_edge = (v, u)
        if best_edge:
            edges.append(best_edge)
            visited.add(best_edge[1])
            remaining.remove(best_edge[1])
    
    return edges

# 测试 TAN
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42)

tan_tree = build_tan_tree(X_train, y_train)
print("TAN 树结构（特征依赖边）:")
for parent, child in tan_tree:
    print(f"  特征 {parent} -> 特征 {child}")