sklearn学习

介绍：scaler：换算的意思

1. 归一化MinMaxScaler()

归一化的意思是将一堆数，如果比较离散，为了让数据更适合模型训练，将离散的数据压缩到0到1之间，以方便模型更高效优质的学习，而对数据的预处理

例如：[-100,3,50,800,10900]在这组数据中最小的是-100，最大是10900,这样的数太分散，如果压缩到0到1，则更方便神经网络学习

压缩数据的公式：

x 是原始特征值。
min( x ) 是特征的最⼩值。
max( x ) 是特征的最⼤值。
x' 是缩放后的特征值。

使用numpy对数据进行压缩：

import numpy as np

data = np.array([[11, 3, -10], [21, -30, 1], [100, 3, 12]])
maxitem = np.max(data, axis=0)
minitem = np.min(data, axis=0)
print(maxitem, minitem)
rangeitem = maxitem - minitem

rangeitem[rangeitem == 0] = 1
result = (data-minitem)/rangeitem
print(result)

解释：

这个是使用numpy对数据进行压缩，使用以上的公式

这里rangeitem[rangeitem == 0] = 1的解释：

rangeitem == 0会得到一个bool类型的数组[False False False]，这样就构成了布尔索引，当为true也就是max和min相同时，为了确保分母不为0，则将其分母变为1

用sklearn来归一化：

import numpy as np
from sklearn.preprocessing import MinMaxScaler
print("方式一")
data = np.array([[11, 3, -10], [21, -30, 1], [100, 3, 12]])
scaler = MinMaxScaler()
scaler.fit(data)
print(scaler.data_min_,scaler.data_max_)
result1 = scaler.transform(data)
print(result1)
print("方式二")
#将data数组归一化，先调用构造函数创造归一化对象，然后使用fit合适求出min和max，再使用transform将使用min和max对数据进行归一化
result2 = MinMaxScaler().fit_transform(data)
print(result2)

解释：MinMaxScaler()是使用构造方法创建一个归一化器scaler

scaler.fit(数据)是对数据进行计算出最大最小特征值，scaler.transfrom(数据)是对数据使用最大最小值进行计算得出归一化的结果。

也可以简写：MinMaxScaler().fit_transform(data)

2. 标准化StandardScaler

就是将一堆数据，压缩为一个服从正太分布的数据，以方便后期神经网络学习，也就是对数据进行预处理

话不多说上代码：

from sklearn.preprocessing import StandardScaler

data = [[-1, 2], [-0.5, 6], [0, 10], [1, 18]]
print("方式一")
scaler = StandardScaler()
scaler.fit(data)
#获取均值和方差
print(scaler.mean_,scaler.var_)
#使用均值和方差对data数据进行标准化处理
result = scaler.transform(data)

print(result)
#将标准化的结果反向求出原始数据
inv_res = scaler.inverse_transform(result)
print(inv_res)

print("方式二")
scaler1 = StandardScaler()
result1 = scaler1.fit_transform(data)
inv_res1 = scaler1.inverse_transform(result1)
print(inv_res1)

解释：StandardScaler()是获取标准化器对象scaler，有属性mean_均值，和var_方差

scaler.fit_transform(数据)意思是对数据进行标准化处理

scaler1.inverse_transform(result1)意思是对标准化后的数据进行反向求出原始数据

3. 缺失值处理SimpleImputer

这个SimpleImputer不是在sklearn.preprocessing包下的，而是sklearn.impute包下的

机器学习或数据挖掘中，常常会有重要的字段缺失值很多，但⼜不能舍弃字段的情况。因此，数据

预处理中⾮常重要的⼀项就是处理缺失值。

from sklearn.impute import SimpleImputer
import pandas as pd
df = pd.read_csv("titanic_train.csv")
age = df.loc[:,"Age"].values.reshape(-1,1)
print(age[:20])
print("===================")
age_median = SimpleImputer(strategy="median").fit_transform(age)
print(age_median[:20])
df.loc[:,"Age"]=age_median

解释，用panda读取csv数据，然后使用df.loc标签索引，0轴索引全部，1轴索引标签为Age的，让后使用.values将pandas结果的数据age列转化为np的数组，然后reshape变为以列为主的二维数据

SimpleImputer()是缺失值补全工具对象创建方法，然后照样使用.fit_transform(age)对age列进行缺失值补全，至于按照什么模式填补，则看SimpleImputer中传的strategy的参数，有平均值，中值填补等

4. Sklearn 中的三种编码工具详解

4.1 LabelEncoder

功能：将单一特征的分类数据转换为整数形式。

每个类别映射到一个唯一的整数。
适用于单个特征（一维数据）。

特点：

不生成额外的列。
不适合处理无序的分类数据，因为整数编码可能引入错误的顺序关系。

工作原理：

from sklearn.preprocessing import LabelEncoder

data = ['red', 'green', 'blue', 'green']
encoder = LabelEncoder()
encoded = encoder.fit_transform(data)
print(encoded)
# 输出: [2, 1, 0, 1]

映射关系为：

blue -> 0
green -> 1
red -> 2

4.2 OrdinalEncoder

功能：将二维数据中的多个特征的类别映射为整数值。

每个类别映射到一个唯一的整数值。
适用于具有顺序关系的类别数据（如“低、中、高”）。

特点：

用于多特征。
如果类别之间无顺序关系，使用此方法可能导致模型误解类别之间的关系。

工作原理：

from sklearn.preprocessing import OrdinalEncoder

data = [['low'], ['medium'], ['high'], ['medium']]
encoder = OrdinalEncoder()
encoded = encoder.fit_transform(data)
print(encoded)
# 输出: [[1.], [2.], [0.], [2.]]

映射关系为：

high -> 0
low -> 1
medium -> 2

注意：

这里的映射顺序是人为指定的。如果类别本身无序（比如颜色），这种编码可能会引入不正确的顺序信息。

4.3 OneHotEncoder

功能：将类别变量转换为哑变量（独热编码）。

每个类别用一个二进制列表示。
适用于无序的类别数据。

特点：

不引入类别之间的顺序关系。
输出结果可以是稀疏矩阵，节省存储空间。

工作原理：

from sklearn.preprocessing import OneHotEncoder

data = [['red'], ['green'], ['blue'], ['green']]
encoder = OneHotEncoder(sparse=False)
encoded = encoder.fit_transform(data)
print(encoded)

输出为：

[[0. 0. 1.]
 [0. 1. 0.]
 [1. 0. 0.]
 [0. 1. 0.]]

映射关系为：

red   -> [0. 0. 1.]
green -> [0. 1. 0.]
blue  -> [1. 0. 0.]

4.4. 编码方法的选择

编码方法	适用场景	优点	缺点
LabelEncode	一维特征，单个特征有少量类别，无需表示顺序关系。	简单直接，输出紧凑	可能引入虚假顺序
OrdinalEncoder	多个特征，类别本身有顺序关系（如教育程度：小学<中学<大学）。	适合处理有序类别	无法处理无序类别
OneHotEncoder	多个特征，类别之间无顺序关系（如颜色、城市名称）。	避免顺序误解，生成独立的二进制列	高维度类别会导致维数过大，稀疏矩阵占用空间

4.5. 为什么要区分哑变量和整数编码？

整数编码：可能引入类别之间的虚假顺序关系。例如，如果模型看到 Color=[Red, Green, Blue] 编码为 [0, 1, 2]，它可能错误地认为 Green 比 Red 大，而 Blue 比 Green 大。
哑变量（独热编码）：通过创建独立的列避免类别之间的顺序关系，特别适用于非数值型的分类变量。

4.6. 示例对比

from sklearn.preprocessing import LabelEncoder, OneHotEncoder, OrdinalEncoder
import numpy as np

# 数据
data = np.array(['red', 'green', 'blue', 'green', 'red'])

# 1. LabelEncoder
le = LabelEncoder()
label_encoded = le.fit_transform(data)
print("LabelEncoder:", label_encoded)
# 输出: [2 1 0 1 2]

# 2. OrdinalEncoder (适用于二维数据)
oe = OrdinalEncoder()
ordinal_encoded = oe.fit_transform(data.reshape(-1, 1))
print("OrdinalEncoder:", ordinal_encoded)
# 输出: [[2.]
#       [1.]
#       [0.]
#       [1.]
#       [2.]]

# 3. OneHotEncoder
ohe = OneHotEncoder(sparse=False)
one_hot_encoded = ohe.fit_transform(data.reshape(-1, 1))
print("OneHotEncoder:\n", one_hot_encoded)
# 输出:
# [[0. 0. 1.]
#  [0. 1. 0.]
#  [1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]

4.7. 总结

编码和哑变量是处理分类数据的重要工具。
LabelEncoder 和 OrdinalEncoder 将类别转换为整数，适用于少量类别的数据，但需注意顺序问题。
OneHotEncoder 将类别转化为二进制向量，适合无序类别数据。
选择合适的编码方式可以提高模型的准确性和效率。

5. knn分类

KNN (K-Nearest Neighbors)

简介：

KNN 是一种 监督学习 算法，主要用于分类和回归问题。它的基本思想是：给定一个新的数据点，查找在特征空间中最接近（最近）的 K 个数据点，然后通过这些数据点的标签来预测新数据点的标签。

工作原理：

选择 K 值：首先选择一个正整数 K，即最近邻的数量。
计算距离：对于每一个待分类的数据点，计算它与所有训练数据点的距离。常用的距离度量方式包括欧氏距离、曼哈顿距离等。
选取 K 个最近邻：根据计算得到的距离，找到 K 个距离最近的训练数据点。
分类：对于分类任务，通过 K 个邻居的标签进行投票，选票最多的类别作为该点的预测标签。
- 回归任务：对于回归任务，取这 K 个邻居的平均值作为预测值。

优点：

简单且直观，易于理解和实现。
非参数化算法，不需要假设数据的分布。
可以用于多类别分类。

缺点：

计算量大，尤其在数据量大的时候，因为每次预测都要计算与所有训练数据点的距离。
对于高维数据，KNN 的表现会变差（维度灾难），因为高维空间中数据点之间的距离差异变得不明显。
对噪声敏感，异常值可能会影响最终的分类结果。

应用场景：

推荐系统（例如电影推荐）。
图像识别、语音识别。
基于相似度的分类任务。

import matplotlib.pyplot as plt
import numpy as np
from sklearn.neighbors import KNeighborsClassifier

# 定义样本特征数据和对应的标签
X = np.array([[1, 2], [2, 3], [3, 1], [2, 4], [6, 5], [7, 8], [8, 6], [6, 7], [7, 9], [8, 8]])
labels = np.array([0, 0, 0, 0, 1, 1, 1, 1, 1, 1])

# 定义一个新的特征数据
X_new = np.array([[3, 5]])

# 绘制类别为0的数据，红色点
plt.scatter(X[labels == 0, 0], X[labels == 0, 1], color="red", label="Class 0")

# 绘制类别为1的数据，蓝色点
plt.scatter(X[labels == 1, 0], X[labels == 1, 1], color="blue", marker="o", label="Class 1")

# 绘制新的特征数据，绿色加号
plt.scatter(X_new[0, 0], X_new[0, 1], color="green", marker="+", label="New Point")

# 创建KNeighborsClassifier分类器对象
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X, labels)  # 使用样本的特征和标签训Lor
new_label = knn.predict(X_new)  # 预测新数据

# 绘制图例和标题
plt.legend()
plt.title("KNN Visualization")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")

# 显示图像
plt.show()

6. kmeans分类

简介：

KMeans 是一种 无监督学习 聚类算法，用于将数据集分成若干个簇（clusters）。算法试图根据数据点之间的相似性将数据划分成 K 个簇。每个簇由其簇中心（质心）代表，算法通过最小化数据点到质心的距离来寻找最佳的簇划分。

工作原理：

选择 K 值：指定需要聚类的簇的数量 K。
初始化质心：随机选择 K 个数据点作为初始簇中心（质心）。
分配数据点：将每个数据点分配到距离最近的簇中心，形成 K 个簇。
更新质心：计算每个簇中所有数据点的平均值，并将其作为新的簇中心。
迭代：重复步骤 3 和 4，直到簇中心不再变化，或者变化非常小，表明聚类已经收敛。

优点：

算法简单且高效，适合大规模数据。
结果易于理解，可以通过质心直观地表示每个簇。
适用于球形簇数据。

缺点：

需要指定 K 值，即簇的数量，通常需要通过实验来确定。
对初始簇中心敏感，可能会陷入局部最优解。可以通过多次运行并选择最佳结果来缓解这一问题。
对离群点（噪声）敏感，离群点可能影响簇的划分。
不适用于非球形簇，或者簇大小差异过大的情况。

应用场景：

客户细分（例如根据消费习惯将用户分组）。
图像压缩（通过聚类色彩进行压缩）。
数据降维和特征学习。


import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans

# 生成数据
X, y = make_blobs(n_samples=200, centers=5, random_state=0)
print(X,y)
# 绘制原始数据点
plt.scatter(X[:, 0], X[:, 1], c=y)  # 使用y作为颜色标识

# 创建KMeans聚类模型
kmeans = KMeans(n_clusters=10, random_state=3)
kmeans.fit(X)

# 获取KMeans聚类结果的标签
y_kmeans = kmeans.predict(X)
print(y_kmeans)
# 绘制聚类后的数据点
plt.scatter(X[:, 0], X[:, 1], c=y_kmeans)  # 根据聚类结果给每个点上色

plt.show()