K 近邻算法（一）

为什么学习KNN算法

KNN是监督学习分类算法，主要解决现实生活中分类问题。

（1）首先准备数据，可以是视频、音频、文本、图片等等

（2）抽取所需要的一些列特征，形成特征向量

（3）将这些特征向量连同标记一并送入机器学习算法中，训练出一个预测模型。

（4）采用同样的特征提取方法作用于新数据，得到用于测试的特征向量。

（5）使用预测模型对这些待测的特征向量进行预测并得到结果。

K近邻是机器学习算法中理论最简单，最好理解的算法，虽然算法简单，但效果也不错。

算法的思想：通过K个最近的已知分类的样本来判断未知样本的类别

• 图像识别：KNN可以用于图像分类任务，例如人脸识别、车牌识别等。在图像识别领域，KNN通过计算测试图像与训练集中图像的相似度来进行分类。
• 文本分类：在文本分类方面，KNN算法可以应用于垃圾邮件过滤、情感分析等领域。通过对文本数据的特征提取和距离计算，KNN能够对新文本进行有效的分类。
• 回归预测：虽然KNN更常用于分类问题，但它也可以用于解决回归问题。在回归任务中，KNN通过找到最近的K个邻居，并根据它们的值来预测连续的输出变量。
• 医疗诊断：KNN算法可以辅助医生进行疾病的诊断。通过比较患者的临床数据与历史病例数据，KNN有助于识别疾病的模式和趋势。
• 金融风控：在金融领域，KNN可用于信用评分和欺诈检测。通过分析客户的交易行为和信用历史，KNN可以帮助金融机构评估风险。
• 推荐系统：KNN还可以用于构建推荐系统，通过分析用户的历史行为和其他用户的行为模式，为用户推荐商品或服务。

Sklearn API

鸢尾花Iris Dataset数据集是机器学习领域经典数据集，鸢尾花数据集包含了150条鸢尾花信息，每50条取自三个鸢尾花中之一：Versicolour、Setosa和Virginica。

from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
 
if __name__ == '__main__':
      
    iris = load_iris() 
 
    # 数据标准化
    transformer = StandardScaler()
    x_ = transformer.fit_transform(iris.data) 
 
    # 模型训练
    estimator = KNeighborsClassifier(n_neighbors=3) # Knn中的K值
    estimator.fit(x_, iris.target) # 调用fit方法 传入特征和目标进行模型训练
 
    result = estimator.predict(x_) 
    print(result)

数据集划分

为了能够评估模型的泛化能力，可以通过实验测试对学习器的泛化能力进行评估，进而做出选择。因此需要使用一个测试集来测试学习器对新样本的判别能力。（2比8）

留出法：将数据集划分成两个互斥的集合：训练集，测试集。

交叉验证：将数据集划分为训练集，验证集，测试集 (验证集用于参数调整)。

留出法:

from sklearn.model_selection import train_test_split
from sklearn.model_selection import StratifiedShuffleSplit
from sklearn.model_selection import ShuffleSplit
from collections import Counter
from sklearn.datasets import load_iris
 
 
def test1():
 
    # 载数据集
    x, y = load_iris(return_X_y=True)
    print('原始类别比例:', Counter(y))
 
    # 留出法(随机分割)
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
    print('随机类别分割:', Counter(y_train), Counter(y_test))
 
    # 留出法(分层分割)
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, stratify=y)
    print('分层类别分割:', Counter(y_train), Counter(y_test))
 
 
def test2():
 
    
    x, y = load_iris(return_X_y=True)
    print('原始类别比例:', Counter(y))
    print('*' * 40)
 
    # 多次划分(随机分割)
    spliter = ShuffleSplit(n_splits=5, test_size=0.2, random_state=0)
    for train, test in spliter.split(x, y):
        print('随机多次分割:', Counter(y[test]))
 
    print('*' * 40)
 
    # 多次划分(分层分割)
    spliter = StratifiedShuffleSplit(n_splits=5, test_size=0.2, random_state=0)
    for train, test in spliter.split(x, y):
        print('分层多次分割:', Counter(y[test]))
 
 
if __name__ == '__main__':
    test1()
    test2()

随机类别分割: Counter({1: 41, 0: 40, 2: 39}) Counter({2: 11, 0: 10, 1: 9})

分层类别分割: Counter({2: 40, 0: 40, 1: 40}) Counter({2: 10, 1: 10, 0: 10})

原始类别比例: Counter({0: 50, 1: 50, 2: 50})

****************************************

随机多次分割: Counter({1: 13, 0: 11, 2: 6})

随机多次分割: Counter({1: 12, 2: 10, 0: 8})

随机多次分割: Counter({1: 11, 0: 10, 2: 9})

随机多次分割: Counter({2: 14, 1: 9, 0: 7})

随机多次分割: Counter({2: 13, 0: 12, 1: 5})

****************************************

分层多次分割: Counter({0: 10, 1: 10, 2: 10})

分层多次分割: Counter({2: 10, 0: 10, 1: 10})

分层多次分割: Counter({0: 10, 1: 10, 2: 10})

分层多次分割: Counter({1: 10, 2: 10, 0: 10})

分层多次分割: Counter({1: 10, 2: 10, 0: 10})

train_test_split 是一个函数，它用于将数据集划分为训练集和测试集。它可以随机地将数据集划分为两个子集，并可以指定划分的比例或数量。这个方法适用于大多数机器学习任务，特别是需要将数据集划分为训练集和测试集的情况。

而 ShuffleSplit 是一个类，它用于生成多个独立的训练/测试数据划分。与 train_test_split 不同，ShuffleSplit 会随机打乱数据集的顺序，然后根据指定的参数进行划分。这个方法适用于交叉验证的场景，特别是在需要多次划分数据集以评估模型性能的情况下。

总结来说，train_test_split 是一个简单的函数，用于将数据集划分为训练集和测试集；而 ShuffleSplit 是一个类，用于生成多个独立的训练/测试数据划分，适用于交叉验证的场景。

交叉验证法

K-Fold交叉验证，将数据随机且均匀地分成k分

• 第一次使用标号为0-8的共9份数据来做训练，而使用标号为9的这一份数据来进行测试，得到一个准确率
• 第二次使用标记为1-9的共9份数据进行训练，而使用标号为0的这份数据进行测试，得到第二个准确率
• 以此类推，每次使用9份数据作为训练，而使用剩下的一份数据进行测试，共进行10次训练，最后模型的准确率为10次准确率的平均值

from sklearn.model_selection import KFold
from sklearn.model_selection import StratifiedKFold
from collections import Counter
from sklearn.datasets import load_iris
 
def test():
 
    
    x, y = load_iris(return_X_y=True)
    print('原始类别比例:', Counter(y))
    print('*' * 40)
 
    #  随机交叉验证
    spliter = KFold(n_splits=5, shuffle=True, random_state=0)
    for train, test in spliter.split(x, y):
        print('随机交叉验证:', Counter(y[test]))
 
    print('*' * 40)
 
    # 分层交叉验证
    spliter = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
    for train, test in spliter.split(x, y):
        print('分层交叉验证:', Counter(y[test]))

随机交叉验证: Counter({1: 13, 0: 11, 2: 6})

随机交叉验证: Counter({2: 15, 1: 10, 0: 5})

随机交叉验证: Counter({0: 10, 1: 10, 2: 10})

随机交叉验证: Counter({0: 14, 2: 10, 1: 6})

随机交叉验证: Counter({1: 11, 0: 10, 2: 9})

****************************************

分层交叉验证: Counter({0: 10, 1: 10, 2: 10})

分层交叉验证: Counter({0: 10, 1: 10, 2: 10})

分层交叉验证: Counter({0: 10, 1: 10, 2: 10})

分层交叉验证: Counter({0: 10, 1: 10, 2: 10})

分层交叉验证: Counter({0: 10, 1: 10, 2: 10})

K 近邻算法（二）+https://developer.aliyun.com/article/1544596?spm=a2c6h.13148508.setting.33.2a1e4f0enzfh9f