【大数据】机器学习-----------贝叶斯分类器

1. 贝叶斯决策论

贝叶斯决策论的核心是基于贝叶斯定理来计算后验概率 (P(c|x))，根据贝叶斯定理：

其中：

• (P(c|x)) 是后验概率，即在特征 (x) 出现的情况下，样本属于类别 (c) 的概率。
• (P(x|c)) 是类条件概率，即类别 (c) 中出现特征 (x) 的概率。
• (P©) 是类先验概率，即类别 © 的先验概率。
• (P(x)) 是特征 (x) 的先验概率。

2. 极大似然估计 (MLE)

假设样本

是独立同分布的，对于参数为 (\theta) 的概率分布

，极大似然估计是寻找一个 (\theta) 使得似然函数最大。

通常为了计算方便，对似然函数取对数得到对数似然函数：

3. 朴素贝叶斯分类器

假设特征 (x=(x_1, x_2, \cdots, x_d)) 相互独立，朴素贝叶斯分类器计算后验概率：

(P(c|x)=\frac{P©\prod_{i = 1}^{d}P(x_i|c)}{P(x)})

通常使用最大后验概率 (MAP) 来预测类别：

(y=\arg\max_{c}P©\prod_{i = 1}^{d}P(x_i|c))

4. 半朴素贝叶斯分类器

在朴素贝叶斯的基础上，假设部分特征之间存在依赖关系，常见的有SPODE（Super-Parent ODE）方法，假设每个特征最多依赖一个父特征 (x_j)，则：

**

**

5. 贝叶斯网

贝叶斯网是一个有向无环图 (DAG)，其中节点表示随机变量，边表示变量之间的依赖关系，联合概率分布可以表示为：

6. EM 算法 (Expectation-Maximization)

对于含有隐变量 (Z) 的模型，目标是最大化似然函数 (L(\theta)=\sum_{i = 1}^{n}\log\sum_{z}P(x_i,z|\theta))。

EM 算法分为两步：

• E 步：计算期望

• 

• M 步：更新参数

代码示例

朴素贝叶斯分类器（使用 Python 和 scikit-learn）

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score

# 加载鸢尾花数据集
iris = datasets.load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建朴素贝叶斯分类器
nb_classifier = GaussianNB()
nb_classifier.fit(X_train, y_train)

# 预测
y_pred = nb_classifier.predict(X_test)

# 计算准确率
print("Accuracy:", accuracy_score(y_test, y_pred))

代码解释：

• datasets.load_iris()：加载鸢尾花数据集。
• train_test_split：将数据集划分为训练集和测试集。
• GaussianNB()：创建高斯朴素贝叶斯分类器，假设特征服从高斯分布。
• nb_classifier.fit(X_train, y_train)：使用训练集训练分类器。
• y_pred = nb_classifier.predict(X_test)：使用测试集进行预测。
• accuracy_score(y_test, y_pred)：计算预测的准确率。

手动实现朴素贝叶斯分类器

import numpy as np


class NaiveBayes:
    def fit(self, X, y):
        n_samples, n_features = X.shape
        self.classes = np.unique(y)
        n_classes = len(self.classes)

        # 计算先验概率 P(c)
        self.priors = np.zeros(n_classes)
        self.mean = np.zeros((n_classes, n_features))
        self.var = np.zeros((n_classes, n_features))
        for idx, c in enumerate(self.classes):
            X_c = X[y == c]
            self.priors[idx] = len(X_c) / n_samples
            self.mean[idx] = X_c.mean(axis=0)
            self.var[idx] = X_c.var(axis=0)

    def predict(self, X):
        y_pred = []
        for x in X:
            posteriors = []
            for idx, c in enumerate(self.classes):
                prior = np.log(self.priors[idx])
                posterior = np.sum(np.log(self._pdf(idx, x)))
                posterior = prior + posterior
                posteriors.append(posterior)
            y_pred.append(self.classes[np.argmax(posteriors)])
        return np.array(y_pred)

    def _pdf(self, class_idx, x):
        mean = self.mean[class_idx]
        var = self.var[class_idx]
        numerator = np.exp(-((x - mean) ** 2) / (2 * var))
        denominator = np.sqrt(2 * np.pi * var)
        return numerator / denominator


# 示例使用
X = np.array([[1, 2], [2, 3], [3, 4], [6, 7], [7, 8], [8, 9]])
y = np.array([0, 0, 0, 1, 1, 1])
nb = NaiveBayes()
nb.fit(X, y)
print(nb.predict(np.array([[2, 2], [7, 7]])))

代码解释：

• fit 方法：
  • 计算每个类别的先验概率 (P©)。
  • 计算每个类别下每个特征的均值和方差，用于计算 (P(x_i|c)) 假设为高斯分布。
• predict 方法：
  • 计算每个类别的后验概率 (P(c|x)) 的对数，使用对数是为了避免数值下溢。
  • 选择后验概率最大的类别作为预测结果。
• _pdf 方法：
  • 计算高斯分布的概率密度函数。

EM 算法代码示例

import numpy as np


def em_algorithm(X, n_components, max_iter=100, tol=1e-4):
    n_samples, n_features = X.shape
    # 初始化参数
    pi = np.ones(n_components) / n_components
    means = np.random.randn(n_components, n_features)
    covs = np.array([np.eye(n_features)] * n_components)
    responsibilities = np.zeros((n_samples, n_components))

    for iteration in range(max_iter):
        # E 步
        for k in range(n_components):
            responsibilities[:, k] = pi[k] * multivariate_gaussian(X, means[k], covs[k])
        responsibilities /= responsibilities.sum(axis=1, keepdims=True)

        # M 步
        Nk = responsibilities.sum(axis=0)
        pi = Nk / n_samples
        for k in range(n_components):
            means[k] = (responsibilities[:, k].dot(X)) / Nk[k]
            diff = X - means[k]
            covs[k] = (responsibilities[:, k] * diff.T).dot(diff) / Nk[k]

        # 计算似然函数
        likelihood = np.sum(np.log(responsibilities.dot(pi)))
        if iteration > 0 and np.abs(likelihood - prev_likelihood) < tol:
            break
        prev_likelihood = likelihood

    return pi, means, covs


def multivariate_gaussian(X, mean, cov):
    n = X.shape[1]
    diff = X - mean
    inv_cov = np.linalg.inv(cov)
    det_cov = np.linalg.det(cov)
    exponent = -0.5 * np.sum(diff @ inv_cov * diff, axis=1)
    return (1 / np.sqrt((2 * np.pi) ** n * det_cov)) * np.exp(exponent)


# 示例使用
X = np.random.randn(100, 2)
pi, means, covs = em_algorithm(X, 2)
print("Pi:", pi)
print("Means:", means)
print("Covariances:", covs)

代码解释：

• em_algorithm 函数：
  • 初始化参数 (\pi)（混合系数）、(\mu)（均值）和 (\Sigma)（协方差矩阵）。
  • E 步：计算每个样本属于每个组件的责任（responsibility）。
  • M 步：更新参数。
  • 计算似然函数并检查收敛。
• multivariate_gaussian 函数：计算多元高斯分布的概率密度函数。