python 实现朴素贝叶斯算法

朴素贝叶斯算法是一种基于概率论的分类算法，它的核心思想是通过贝叶斯定理计算后验概率，然后选择具有最大后验概率的类别作为预测结果。

首先，需要统计训练数据中每个类别的先验概率和每个特征在每个类别中的条件概率。然后，对于一个新的样本，利用这些概率计算出属于每个类别的后验概率，并选择具有最大后验概率的类别作为预测结果。

下面是一个简单的示例代码实现朴素贝叶斯算法：

import numpy as np

class NaiveBayes:
    def fit(self, X, y):
        self.classes = np.unique(y)
        self.priors = np.zeros(len(self.classes))
        self.likelihoods = []

        for i, c in enumerate(self.classes):
            X_c = X[y == c]
            self.priors[i] = X_c.shape[0] / X.shape[0]

            likelihood = []
            for j in range(X.shape[1]):
                feature_values = np.unique(X[:, j])
                likelihood_c = np.zeros(len(feature_values))
                for k, v in enumerate(feature_values):
                    likelihood_c[k] = ((X_c[:, j] == v).sum() + 1) / (X_c.shape[0] + len(feature_values))
                likelihood.append(likelihood_c)
            self.likelihoods.append(likelihood)

    def predict(self, X):
        posteriors = np.zeros((len(X), len(self.classes)))

        for i, x in enumerate(X):
            for j, c in enumerate(self.classes):
                likelihoods = self.likelihoods[j]
                prior = self.priors[j]
                posterior = np.log(prior)
                for k, likelihood in enumerate(likelihoods):
                    posterior += np.log(likelihood[np.where(np.unique(X[:, k]) == x[k])[0][0]])
                posteriors[i, j] = posterior

        return self.classes[np.argmax(posteriors, axis=1)]

使用示例：

X = np.array([[1, 'S'], [1, 'M'], [1, 'M'], [1, 'S'], [1, 'S'],
              [2, 'S'], [2, 'M'], [2, 'M'], [2, 'L'], [2, 'L'],
              [3, 'L'], [3, 'M'], [3, 'M'], [3, 'L'], [3, 'L']])
y = np.array([0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0])

model = NaiveBayes()
model.fit(X, y)

X_test = np.array([[2, 'S'], [1, 'M'], [3, 'L']])
y_pred = model.predict(X_test)

print(y_pred)  # 输出：[1 0 0]

这里的示例数据是一个简单的餐厅决策问题，X 是特征矩阵，y 是类别向量。fit() 方法用于训练模型，predict() 方法用于预测新样本的类别。