机器学习day02

机器学习day2

KNN算法

KNN算法简介

1.KNN

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

1.1K-近邻算法

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

Snipaste_2024-06-18_20-19-50

1.2KNN算法

解决问题：分类问题、回归问题
算法思想：若一个样本在特征空间中的 k 个最相似的样本大多数属于某一个类别，则该样本也属于这个类别
相似性：欧氏距离

分类流程

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

回归流程

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

1.3K值选择

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

1.4总结

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

KNN算法API介绍

# - *- 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特征预处理

数据归一化

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

数据标准化

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

案例：归一化处理

#!/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()

案例：数据标准化

#!/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算法对鸢尾花分类

实现流程：

获取数据集
数据基本处理
数据集预处理-数据标准化
机器学习(模型训练)
模型评估
模型预测

#!/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)}')

posted @ 2024-06-18 20:38 叱咤月海鱼鱼猫阅读(48) 评论(0) 收藏举报

刷新页面返回顶部

叱咤月海鱼鱼猫