机器学习基础系列——朴素贝叶斯

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB

# 生成数据
np.random.seed(42)
X, y = make_classification(n_samples=200, n_features=2, n_informative=2,
                           n_redundant=0, n_clusters_per_class=1, random_state=42)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 训练高斯朴素贝叶斯
gnb = GaussianNB()
gnb.fit(X_train, y_train)

print(f"训练准确率: {gnb.score(X_train, y_train):.4f}")
print(f"测试准确率: {gnb.score(X_test, y_test):.4f}")

# 可视化决策边界
xx, yy = np.meshgrid(np.linspace(X[:, 0].min()-1, X[:, 0].max()+1, 100),
                     np.linspace(X[:, 1].min()-1, X[:, 1].max()+1, 100))
Z = gnb.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]
Z = Z.reshape(xx.shape)

plt.figure(figsize=(10, 8))
plt.contourf(xx, yy, Z, levels=np.linspace(0, 1, 11), cmap='RdYlBu_r', alpha=0.8)
plt.colorbar(label='P(y=1)')
plt.scatter(X[y==0, 0], X[y==0, 1], c='blue', edgecolors='k', label='Class 0')
plt.scatter(X[y==1, 0], X[y==1, 1], c='red', edgecolors='k', label='Class 1')
plt.contour(xx, yy, Z, levels=[0.5], colors='k', linewidths=2)
plt.title('高斯朴素贝叶斯决策边界')
plt.legend()
plt.show()

# 查看学习到的参数
print(f"\n类别先验: {gnb.class_prior_}")
print(f"各类别均值:\n{gnb.theta_}")
print(f"各类别方差:\n{gnb.var_}")

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

# 文本分类示例
texts = [
    "I love this movie",
    "This movie is great", 
    "Best film ever",
    "I hate this movie",
    "Terrible film",
    "Worst movie ever",
    "Really bad movie",
    "Amazing story and acting"
]
labels = [1, 1, 1, 0, 0, 0, 0, 1]  # 1=positive, 0=negative

# 文本向量化
vectorizer = CountVectorizer()
X_text = vectorizer.fit_transform(texts)

print(f"词汇表: {vectorizer.get_feature_names_out()}")
print(f"特征矩阵:\n{X_text.toarray()}")

# 训练多项式朴素贝叶斯
mnb = MultinomialNB(alpha=1.0)  # 拉普拉斯平滑
mnb.fit(X_text, labels)

# 预测新文本
new_texts = ["I love this great movie", "This is terrible"]
X_new = vectorizer.transform(new_texts)
predictions = mnb.predict(X_new)
probas = mnb.predict_proba(X_new)

for text, pred, proba in zip(new_texts, predictions, probas):
    sentiment = "Positive" if pred == 1 else "Negative"
    print(f"'{text}' -> {sentiment} (P={proba[pred]:.3f})")

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

# 二值化文本特征
vectorizer_binary = CountVectorizer(binary=True)
X_binary = vectorizer_binary.fit_transform(texts)

bnb = BernoulliNB()
bnb.fit(X_binary, labels)

X_new_binary = vectorizer_binary.transform(new_texts)
predictions = bnb.predict(X_new_binary)

for text, pred in zip(new_texts, predictions):
    sentiment = "Positive" if pred == 1 else "Negative"
    print(f"'{text}' -> {sentiment}")

class GaussianNBScratch:
    def __init__(self):
        self.classes = None
        self.mean = {}
        self.var = {}
        self.prior = {}
    
    def fit(self, X, y):
        self.classes = np.unique(y)
        n_samples = len(y)
        
        for c in self.classes:
            X_c = X[y == c]
            self.mean[c] = np.mean(X_c, axis=0)
            self.var[c] = np.var(X_c, axis=0)
            self.prior[c] = len(X_c) / n_samples
        
        return self
    
    def _gaussian_likelihood(self, x, mean, var):
        """计算高斯概率密度"""
        eps = 1e-10  # 避免除零
        coef = 1 / np.sqrt(2 * np.pi * (var + eps))
        exponent = np.exp(-(x - mean) ** 2 / (2 * (var + eps)))
        return coef * exponent
    
    def _predict_single(self, x):
        """预测单个样本"""
        posteriors = []
        
        for c in self.classes:
            prior = np.log(self.prior[c])
            likelihood = np.sum(np.log(
                self._gaussian_likelihood(x, self.mean[c], self.var[c])
            ))
            posterior = prior + likelihood
            posteriors.append(posterior)
        
        return self.classes[np.argmax(posteriors)]
    
    def predict(self, X):
        return np.array([self._predict_single(x) for x in X])
    
    def predict_proba(self, X):
        """计算预测概率"""
        probas = []
        
        for x in X:
            log_posteriors = []
            for c in self.classes:
                prior = np.log(self.prior[c])
                likelihood = np.sum(np.log(
                    self._gaussian_likelihood(x, self.mean[c], self.var[c])
                ))
                log_posteriors.append(prior + likelihood)
            
            # 使用log-sum-exp技巧避免数值问题
            max_log = np.max(log_posteriors)
            posteriors = np.exp(log_posteriors - max_log)
            posteriors = posteriors / np.sum(posteriors)
            probas.append(posteriors)
        
        return np.array(probas)
    
    def score(self, X, y):
        return np.mean(self.predict(X) == y)

# 测试
gnb_scratch = GaussianNBScratch()
gnb_scratch.fit(X_train, y_train)

print(f"自实现 - 训练准确率: {gnb_scratch.score(X_train, y_train):.4f}")
print(f"自实现 - 测试准确率: {gnb_scratch.score(X_test, y_test):.4f}")

# 与sklearn对比
print(f"sklearn - 测试准确率: {gnb.score(X_test, y_test):.4f}")

# 平滑参数影响
alphas = [0.01, 0.1, 1.0, 10.0]

print("不同平滑参数的影响:")
for alpha in alphas:
    mnb = MultinomialNB(alpha=alpha)
    mnb.fit(X_text, labels)
    
    # 使用交叉验证（数据太少只能用留一法）
    from sklearn.model_selection import cross_val_score
    # 由于数据太少，这里直接看训练准确率
    acc = mnb.score(X_text, labels)
    print(f"alpha={alpha:5.2f}: 准确率={acc:.4f}")

from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics import classification_report, confusion_matrix
import seaborn as sns

# 加载数据（选择4个类别）
categories = ['alt.atheism', 'soc.religion.christian', 'comp.graphics', 'sci.med']

train_data = fetch_20newsgroups(subset='train', categories=categories, 
                                 shuffle=True, random_state=42)
test_data = fetch_20newsgroups(subset='test', categories=categories,
                                shuffle=True, random_state=42)

print(f"训练样本数: {len(train_data.data)}")
print(f"测试样本数: {len(test_data.data)}")
print(f"类别: {train_data.target_names}")

# TF-IDF特征
tfidf = TfidfVectorizer(max_features=5000, stop_words='english')
X_train_tfidf = tfidf.fit_transform(train_data.data)
X_test_tfidf = tfidf.transform(test_data.data)

# 训练朴素贝叶斯
mnb_news = MultinomialNB(alpha=0.1)
mnb_news.fit(X_train_tfidf, train_data.target)

# 评估
y_pred = mnb_news.predict(X_test_tfidf)

print(f"\n测试准确率: {mnb_news.score(X_test_tfidf, test_data.target):.4f}")
print("\n分类报告:")
print(classification_report(test_data.target, y_pred, target_names=train_data.target_names))

# 混淆矩阵
plt.figure(figsize=(10, 8))
cm = confusion_matrix(test_data.target, y_pred)
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=train_data.target_names,
            yticklabels=train_data.target_names)
plt.xlabel('预测')
plt.ylabel('实际')
plt.title('新闻分类混淆矩阵')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# 查看各类别的重要特征
feature_names = np.array(tfidf.get_feature_names_out())

print("\n各类别Top 10特征:")
for i, category in enumerate(train_data.target_names):
    top_features = np.argsort(mnb_news.feature_log_prob_[i])[-10:]
    print(f"\n{category}:")
    print(", ".join(feature_names[top_features]))

# 简单的垃圾邮件分类示例
spam_data = [
    ("Free money now!!!", 1),
    ("Win a lottery today", 1),
    ("Cheap medicine available", 1),
    ("You have won $1000000", 1),
    ("Meeting at 3pm tomorrow", 0),
    ("Project report attached", 0),
    ("Can you review this document?", 0),
    ("Team lunch on Friday", 0),
    ("Buy now, limited offer!", 1),
    ("Conference call reminder", 0),
    ("Get rich quick scheme", 1),
    ("Quarterly review meeting", 0),
]

texts, labels = zip(*spam_data)
labels = np.array(labels)

# 向量化
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(texts)

# 训练
mnb_spam = MultinomialNB()
mnb_spam.fit(X, labels)

# 预测新邮件
new_emails = [
    "Free lottery tickets for you!",
    "Please review the attached report",
    "Cheap pills available now"
]

X_new = vectorizer.transform(new_emails)
predictions = mnb_spam.predict(X_new)
probas = mnb_spam.predict_proba(X_new)

print("垃圾邮件检测:")
for email, pred, proba in zip(new_emails, predictions, probas):
    label = "垃圾邮件" if pred == 1 else "正常邮件"
    confidence = proba[pred]
    print(f"  '{email[:30]}...' -> {label} (置信度: {confidence:.3f})")

from sklearn.linear_model import LogisticRegression
from sklearn.svm import LinearSVC
from sklearn.ensemble import RandomForestClassifier
import time

# 使用20newsgroups数据比较
classifiers = {
    'Naive Bayes': MultinomialNB(alpha=0.1),
    'Logistic Regression': LogisticRegression(max_iter=1000),
    'Linear SVM': LinearSVC(),
    'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42)
}

results = []
for name, clf in classifiers.items():
    start = time.time()
    clf.fit(X_train_tfidf, train_data.target)
    train_time = time.time() - start
    
    start = time.time()
    accuracy = clf.score(X_test_tfidf, test_data.target)
    pred_time = time.time() - start
    
    results.append({
        'Classifier': name,
        'Accuracy': accuracy,
        'Train Time': train_time,
        'Predict Time': pred_time
    })
    print(f"{name}: Acc={accuracy:.4f}, Train={train_time:.3f}s, Predict={pred_time:.3f}s")

# 结果表格
import pandas as pd
pd.DataFrame(results).set_index('Classifier')