关于机器学习:机器学习朴素贝叶斯

45次阅读

共计 2115 个字符，预计需要花费 6 分钟才能阅读完成。

前言

奢侈贝叶斯是一种基于贝叶斯定理的分类算法，属于生成式模型的领域。它的根本思维是基于贝叶斯定理和特色独立性假如。它假如每个特色之间互相独立，因而名称为“奢侈”。
在奢侈贝叶斯分类中，咱们假如给定数据点属于某个类别，能够通过对该类别中各个特色的条件概率进行乘积计算，以计算该数据点属于该类别的概率。最终，抉择概率最大的类别作为该数据点的预测类别。

公式

贝叶斯定理：贝叶斯定理通知咱们如何计算某个事件产生的概率，即：

$P(A|B) = P(B|A) * P(A) / P(B)$

其中，P(A|B) 示意事件 A 在事件 B 产生的状况下产生的概率；P(B|A) 示意事件 B 在事件 A 产生的状况下发生的概率；P(A) 示意事件 A 产生的概率；P(B) 示意事件 B 产生的概率

2. 特色独立性假如：奢侈贝叶斯假如特色之间是独立的，即：

$P(x1, x2, …, xn | y) = P(x1 | y) * P(x2 | y) * … * P(xn | y)$

其中，xi 示意第 i 个特色，y 示意分类后果。

极大似然预计：奢侈贝叶斯应用极大似然预计来确定特色与分类后果之间的关系，即：

$P(y | x1, x2, …, xn) = P(x1, x2, …, xn | y) * P(y) / P(x1, x2, …, xn)$

其中，P(y | x1, x2, …, xn) 示意给定特色 x1, x2, …, xn 时分类后果 y 的概率；P(y) 示意分类后果 y 的先验概率；P(x1, x2, …, xn) 示意特色 x1, x2, …, xn 的先验概率。

实现流程

数据预处理：对数据进行荡涤、格式化等解决，确保数据的可用性和有效性。
特色抽取：从原始数据中抽取出无效的特色，用于后续的模型训练。
计算先验概率：计算出每一个分类后果的先验概率，即该分类后果在样本中呈现的频率。
计算条件概率：对于每一个特色，计算出该特色在各个分类后果中呈现的条件概率。
计算后验概率：应用贝叶斯定理计算出后验概率，即在已知特色的状况下，每一个分类后果的概率。
预测分类后果：选取后验概率最大的分类后果作为最终的预测后果。

代码

import numpy as np
from collections import Counter

class NaiveBayes:
    def __init__(self):
        # 定义类的属性，初始化为 None
        self.X = None
        self.y = None
        self.classes = None
        self.priors = None
        self.cond_probs = None

    def fit(self, X, y):
        # 存储训练数据
        self.X = X
        self.y = y
        # 获取分类类别
        self.classes = np.unique(y)
        # 计算先验概率
        self.priors = self._compute_priors()
        # 计算条件概率
        self.cond_probs = self._compute_cond_probs()

    def _compute_priors(self):
        # 统计每个类别的样本数量
        classes_counts = Counter(self.y)
        # 计算总样本数量
        total_count = len(self.y)
        # 计算每个类别的先验概率
        priors = {c: count / total_count for c, count in classes_counts.items()}
        return priors

    def _compute_cond_probs(self):
        # 计算特色数量
        n_features = self.X.shape[1]
        cond_probs = {}
        # 计算每个类别的条件概率
        for c in self.classes:
            # 获取每个类别的样本
            X_c = self.X[self.y == c]
            # 计算每个特色的均值和标准差
            means = np.mean(X_c, axis=0)
            stds = np.std(X_c, axis=0)
            # 将均值和标准差存储在字典中
            cond_probs = (means, stds)
        return cond_probs

    def predict(self, X):
        y_pred = []
        # 遍历所有的预测样本
        for x in X:
            scores = []
            # 遍历所有的类别
            for c, (mean, std) in self.cond_probs.items():
                # 计算每个特色在该类别下的概率密度值
                prob = np.exp(-0.5 * ((x - mean) / std) ** 2) / (np.sqrt(2 * np.pi) * std)
                # 计算概率密度值的乘积
                prob = np.prod(prob)
                # 乘上该类别的先验概率
                prob *= self.priors
                scores.append(prob)
            # 预测该样本的类别
            y_pred.append(self.classes[np.argmax(scores)])
        return np.array(y_pred)