机器学习day02

机器学习day2

KNN算法#

KNN算法简介#

1.KNN#

• K-近邻算法（K Nearest Neighbor，简称KNN）。比如：根据你的“邻居”来推断出你的类别
• KNN算法思想：如果一个样本在特征空间中的 k 个最相似的样本中的大多数属于某一个类别，则该样本也属于这个类别

1.1K-近邻算法#

• 样本相似性：样本都是属于一个任务数据集的。样本距离越近则越相似。
• 利用K近邻算法预测电影类

1.2KNN算法#

• 解决问题：分类问题、回归问题

• 算法思想：若一个样本在特征空间中的 k 个最相似的样本大多数属于某一个类别，则该样本也属于这个类 别

• 相似性：欧氏距离

  分类流程

1. 计算未知样本到每一个训练样本的距离
2. 将训练样本根据距离大小升序排列
3. 取出距离最近的 K 个训练样本
4. 进行多数表决，统计 K 个样本中哪个类别 的样本个数最多
5. 将未知的样本归属到出现次数最多的类别

回归流程

1. 计算未知样本到每一个训练样本的距离
2. 将训练样本根据距离大小升序排列
3. 取出距离最近的 K 个训练样本
4. 把这个 K 个样本的目标值计算其平均值
5. 作为将未知的样本预测的值

1.3K值选择#

• K值过小：用较小邻域中的训练实例进行预测 容易受到异常点的影响 K值的减小就意味着整体模型变得复杂，容易发生过拟合
• K值过大：用较大邻域中的训练实例进行预测 受到样本均衡的问题 且K值的增大就意味着整体的模型变得简单，欠拟合

1.4总结#

1. KNN概念 K Nearest Neighbor • 一个样本最相似的 k 个样本中的大多数属于某一个类别，则该样本也属于这个类别
2. KNN分类流程
   • 计算未知样本到每一个训练样本的距离
   • 将训练样本根据距离大小升序排列
   • 取出距离最近的 K 个训练样本
   • 进行多数表决，统计 K 个样本中哪个类别的样本个数最多
   • 将未知的样本归属到出现次数最多的类别
3. KNN回归流程
   • 计算未知样本到每一个训练样本的距离
   • 将训练样本根据距离大小升序排列
   • 取出距离最近的 K 个训练样本
   • 把这个 K 个样本的目标值计算其平均值 5.将未知的样本预测的值了
4. K值的选择 • K值过小：过拟合 • K值过大：欠拟合

KNN算法API介绍#

Copy
# - *- coding: utf-8 -*-
"""
-----------------------
    File Name:knn_01
    Author:chizhayuehai
    Date    2024/6/18
------------------------
    Deos TODO K近邻算法演示
    # todo 1.导包
    # todo 2.导数据
    # todo 3.模型实例化
    # todo 4.训练
    # todo 5.预测
    # todo（直接挪上去shift+CTRL+上下键）
    # todo（CTRL+y 光标在那一行删除哪一行）
    # todo (多光标选中，鼠标滚轮或shift+alt+鼠标左键）
 
"""
def dm1_classifier():
    # todo 1.导包
    from sklearn.neighbors import KNeighborsClassifier
    # todo 2.导数据
    x = [[0, 2], [1, 3], [2, 5], [3, 6], [4, 2]]
    y = [0, 0, 0, 1, 1]
 
    # todo 3.模型实例化 (实例化：在编程中创建类的实例或对象的过程。在面向对象的编程语言中，类是一种模板或蓝图，描述了对象的属性和行为。通过实例化，程序可以根据类的定义创建具体的对象，这些对象可以在程序中被使用和操作。）
    estimator = KNeighborsClassifier(n_neighbors=3)
 
    # todo 4.训练 (fit：表示训练）
    estimator.fit(x, y)
 
    # todo 5.预测
    mypre = estimator.predict([[3, 6], [2, 5], [4, 2]])
    print(f'mypre:{mypre}')
    print('mypre:', mypre)
 
def dm2_regressor():
    # todo 1.导包
    from sklearn.neighbors import KNeighborsRegressor
    # todo 2.导数据
    x = [[0, 2], [1, 3], [2, 5], [3, 6], [4, 2]]
    y = [0.1, 0.3, 0.5, 0.7, 0.9]
    # todo 3.模型实例化
    estimator = KNeighborsRegressor(n_neighbors=3)
    # todo 4.训练
    estimator.fit(x, y)
    # todo 5.预测
    mypre = estimator.predict([[3, 6], [2, 5], [3, 4]])
    print(f'mypre:{mypre}')
 
if __name__ == '__main__':
    dm1_classifier()
    dm2_regressor()

距离度量#

1.1距离度量 distance measure – 常见距离公式#

欧氏距离 Euclidean Distance 直观的距离度量方法， 两个点在空间中的距离一般都是指欧氏距离

曼哈顿距离(Manhattan Distance) 也称为“城市街区距离”(City Block distance)，曼哈顿城市特点：横平竖直

切比雪夫距离 Chebyshev Distance 国际象棋中，国王可以直行、横行、斜行，所以国王走一步可以移动到相邻8个方格中的任意一个。 国王从格子(x1,y1)走到格子(x2,y2)最少需要多少步？这个距离就叫切比雪夫距离。

闵可夫斯基距离 MinkowskiDistance 闵氏距离

• 不是一种新的距离的度量方式。
• 是对多个距离度量公式的概括性的表述
• 两个n维变量a(x11 ,x12, …, x1n) 与 b(x21, x22,…, x2n) 间的闵可夫斯基距离定义为

其中p是一个变参数： 当 p=1 时，就是曼哈顿距离； 当 p=2 时，就是欧氏距离； 当 p→∞ 时，就是切比雪夫距离 根据 p 的不同，闵氏距离可表示某一类种的距离

特征预处理#

1.1为什么要做归一化和标准化#

特征的单位或者大小相差较大，或者某特征的方差相比其他的特征要大出几个数量级，容易影响 （支配）目标结果，使得一些模型（算法）无法学习到其它的特征。

归一化：通过对原始数据进行变换把数据映射到【mi,mx】(默认为[0,1])之间

数据归一化：通过对原始数据进行变换把数据映射到【mi,mx】(默认为[0,1])之间

数据归一化API： 1.sklearn.preprocessing.MinMaxScaler (feature_range=(0,1)… ) feature_range 缩放区间 2. fit_transform(X) 将特征进行归一化缩放

数据标准化：通过对原始数据进行标准化，转换为均值为0标准差为1的标准正态分布的数据

数据标准化API： 1.sklearn.preprocessing. StandardScaler() 2. fit_transform(X) 将特征进行归一化缩放

正态分布是一种概率分布，大自然很多数据符合正态分布 也叫高斯分布，钟形分布。正态分布记作N(μ，σ ) μ决定了其位置，其标准差σ决定了分布的幅度 当μ = 0, σ = 1时的正态分布是标准正态分布

• 方差𝞼𝟐是在概率论和统计方差衡量一组数据时离散程度的度量 其中M为均值 n为数据总数

• 标准差σ是方差开根号

• 正态分布的3σ法则（68-95-99.7 法则）

1.2特征预处理#

1. 数据归一化

• 如果出现异常点，影响了最大值和最小值，那么结果 显然会发生改变
• 应用场景：最大值与最小值非常容易受异常点影响，鲁棒性较差，只适合传统精确小数据场景
• sklearn.preprocessing.MinMaxScaler (feature_range=(0,1)… )

2. 数据标准化

• 如果出现异常点，由于具有一定数据量，少量的异 常点对于平均值的影响并不大
• 应用场景：适合现代嘈杂大数据场景。(以后就是 用你了）
• sklearn.preprocessing.StandardScaler( )

案例：归一化处理#

Copy
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
'''
----------------------------------
@Project ：pythonclass 
@File    ：MinMaxScaler_02.py
@IDE     ：PyCharm 
@Author  ：chizhayuehaiyuyumao
@Date    ：2024/6/18 15:24 
----------------------------------
    Deos TODO 数据归一化
    # todo 1.导包
    # todo 2.造数据
    # todo 3.实例化对象
    # todo 4.对数据进行归一化
----------------------------------
'''
def dmo1_minmaxscaler():
    # todo 1.导包
    from sklearn.preprocessing import MinMaxScaler
    import numpy as np
 
    # todo 2.造数据
    data = np.array([[1, 2, 3],
                     [4, 5, 6],
                     [7, 8, 9]])
    # todo 3.实例化对象
    scaler = MinMaxScaler()
    # todo 4.对数据进行归一化
    data_scaled = scaler.fit_transform(data)
    print(f'data_scaled{data_scaled}')
 
if __name__ == '__main__':
    dmo1_minmaxscaler()

案例：数据标准化#

Copy
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
'''
----------------------------------
@Project ：pythonclass 
@File    ：StandardScaler_03.py
@IDE     ：PyCharm 
@Author  ：chizhayuehaiyuyumao
@Date    ：2024/6/18 15:28 
----------------------------------
    Deos TODO 数据标准化
    # todo 1.导包
    # todo 2.造数据
    # todo 3.实例化对象（标准化）
    # todo 4.对数据进行标准化
----------------------------------
'''
# todo 1.导包
from sklearn.preprocessing import StandardScaler
 
# todo 2.造数据
x = [[-1, 2], [-0.5, 6], [0, 10], [1, 18]]
# todo 3.实例化对象（标准化）
ss = StandardScaler()
# todo 4.对数据进行标准化
x_new = ss.fit_transform(x)
print(f'标准化前的数据：\n{x}')
print(f'标准化后的数据：\n{ss.fit_transform(x_new)}')
print(f'均值：{ss.mean_}')
print(f'方差：{ss.var_}')

案例：利用KNN算法对鸢尾花分类#

实现流程：

1. 获取数据集
2. 数据基本处理
3. 数据集预处理-数据标准化
4. 机器学习(模型训练)
5. 模型评估
6. 模型预测

Copy
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
'''
----------------------------------
@Project ：pythonclass 
@File    ：knn_iris_04.py
@IDE     ：PyCharm 
@Author  ：chizhayuehaiyuyumao
@Date    ：2024/6/18 15:56 
----------------------------------
    Deos TODO knn处理鸢尾花案例
    # todo 1.导包
    # todo 2.加载数据集
    # todo 3.数据展示
    # todo 4.数据基本处理
    # todo 5.实例化模型
    # todo 6.模型训练
    # todo 7.评估
    # todo 8.预测
----------------------------------
'''
# todo 1.导包
from sklearn.metrics import accuracy_score
from sklearn.neighbors import KNeighborsClassifier  # 导入knn分类算法
from sklearn.datasets import load_iris  # 导入鸢尾花数据集
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
 
# todo 2.加载数据集
iris_data = load_iris()
print(iris_data.DESCR)
 
print(f'数据集-->\n{iris_data.feature_names}\n{iris_data.data[:10]}')
# iris_data.feature_names:特征值名称 iris_data.data:特征值数据 ：10从头到10行
print(f'数据集-->\n{iris_data.target_names}\n{iris_data.target[:10]}')
# todo 3.数据展示
def demo1_iris_data():
    iris_df = pd.DataFrame(iris_data['data'], columns=iris_data.feature_names)
    # 两种方式都行⬆
    # iris_df['target'] = iris_data['target']
    iris_df['target'] = iris_data.target
    print(f'转化为DF格式的数据：\n{iris_df}')
    # 指定横纵轴,指定纵轴
    col1 = 'sepal length (cm)'
    col2 = 'petal width (cm)'
 
    # 作图
    # sns.lmplot(x=col1, y=col2, data=iris_df, hue='target', fit_reg=False)
    # plt.xlabel(f'{col1}')
    # plt.ylabel(f'{col2}')
    # plt.title('iris')
    # plt.show()
    feature_names = iris_data.feature_names
    # print(f'特征值名称：{feature_names}')
    for i in range(len(feature_names)):
        for j in range(i + 1, len(feature_names)):
            col1 = feature_names[i]
            col2 = feature_names[j]
            sns.lmplot(x=col1, y=col2, data=iris_df, hue='target', fit_reg=False)
            plt.xlabel(f'{col1}')
            plt.ylabel(f'{col2}')
            plt.title('iris')
            plt.show()
 
 
# todo 4.数据基本处理
x = iris_data.data
y = iris_data.target
# todo 4.1划分数据集
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=22)
# random_state=22 : 随机数种子（为了不影响结果不同）
# print(f'数据集总量：{len(x)}')
# print(f'训练数据集数量：{len(x_train)}')
# print(f'测试集数据集数量：{len(x_test)}')
 
# todo 4.2 数据预处理(标准化)
scaler = StandardScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)  # 为什么不用fit 是因为可以直接使用已经拟合好的函数
 
# todo 5.实例化模型
knn = KNeighborsClassifier(n_neighbors=5)
# todo 6.模型训练
knn.fit(x_train, y_train)
# todo 7.评估
y_pre = knn.predict(x_test)
score = accuracy_score(y_pre, y_test)
print(f'模型准确率：{score}')
# print(f'模型准确率：{knn.score(x_test, y_test)}')
# todo 8.预测
mydata = [[5.1, 3.5, 1.4, 0.2],
          [4.6, 3.1, 1.5, 0.2]]
mydata = scaler.transform(mydata)
mydata = knn.predict(mydata)
print(f'预测结果：{mydata}')
# print(f'预测结果：{knn.predict(x_test)}')