实现knn 朴素贝叶斯 决策算法

KNN（K-Nearest Neighbors）算法是一种基于实例的学习方法，它的基本思想是在训练数据集中找到与测试数据最相似的 k 个数据，然后根据它们的类别进行预测。具体实现步骤如下：

1. 计算测试数据与每个训练数据之间的距离（可以使用欧氏距离、曼哈顿距离等）；

2. 对距离进行排序，选取距离最近的 k 个训练数据；

3. 统计这 k 个训练数据中最多的类别，作为预测结果。

下面是一个简单的 Python 实现：

import numpy as np

class KNN:
    def __init__(self, k=3):
        self.k = k

    def fit(self, X, y):
        self.X_train = X
        self.y_train = y

    def predict(self, X):
        predictions = []

        for i in range(len(X)):
            distances = np.sqrt(np.sum(np.square(self.X_train - X[i,:]), axis=1))
            k_nearest = np.argsort(distances)[:self.k]
            k_nearest_labels = self.y_train[k_nearest]
            most_common = np.argmax(np.bincount(k_nearest_labels))
            predictions.append(most_common)

        return predictions

朴素贝叶斯（Naive Bayes）算法是一种基于概率统计的分类算法，它的基本思想是根据贝叶斯定理计算出样本属于每个类别的概率，然后选择概率最大的类别作为预测结果。具体实现步骤如下：

1. 计算每个类别的先验概率，即在训练数据集中，每个类别出现的概率；

2. 计算每个特征在各个类别下的条件概率，即在给定某个类别的情况下，某个特征出现的概率；

3. 对于一个测试样本，计算它属于每个类别的后验概率，即在给定某个类别的情况下，该样本属于该类别的概率，然后选择后验概率最大的类别作为预测结果。

下面是一个简单的 Python 实现：

from collections import Counter
import numpy as np

class NaiveBayes:
    def fit(self, X, y):
        self.X_train = X
        self.y_train = y
        self.classes = np.unique(y)
        self.parameters = []

        for i, c in enumerate(self.classes):
            X_c = X[y == c]
            self.parameters.append([])
            for j in range(X.shape[1]):
                col = X_c[:, j]
                mean = np.mean(col)
                std = np.std(col)
                self.parameters[i].append({'mean': mean, 'std': std})

    def _calculate_likelihood(self, mean, std, x):
        exponent = np.exp(-((x - mean) ** 2 / (2 * std ** 2)))
        return np.log(exponent / (np.sqrt(2 * np.pi) * std))

    def _calculate_prior(self, c):
        samples = self.y_train.shape[0]
        class_samples = np.sum(self.y_train == c)
        return class_samples / samples

    def _classify(self, sample):
        posteriors = []

        for i, c in enumerate(self.classes):
            prior = self._calculate_prior(c)
            posterior = np.log(prior)

            for j, param in enumerate(self.parameters[i]):
                mean = param['mean']
                std = param['std']
                x = sample[j]
                likelihood = self._calculate_likelihood(mean, std, x)
                posterior += likelihood

            posteriors.append(posterior)

        return self.classes[np.argmax(posteriors)]

    def predict(self, X):
        predictions = []

        for sample in X:
            predictions.append(self._classify(sample))

        return predictions

以上是 KNN 和朴素贝叶斯的基本实现，实际应用中可能需要对算法进行改进和优化。