0
0

机器学习3-特征工程个人笔记

特征缩放

主要导包

  1. from sklearn import preprocessing

创建numpy二维数组进行后续特征类操作：

  1. import numpy as np
  3. arr = np.array([[1., -1., 2.], [3., 1., -2.], [2., 1., 1.]])

一、标准差标准化

函数语法格式:

  1. preprocessing.StandardScaler(copy=True, with_mean=True, with_std=True)

参数解析：

  1.     copy:默认True，若为False则表示在原数据上进行操作。
  3.     with_mean:默认为True，若为False则表示将公式里的均值设为0。
  5.     with_std:默认为True，若为False则表示将公式里的std值设为1。

StandardScaler的四个属性：

scale_每个特征对应的数据缩放比例mean_每个特征的均值var_每个特征的方差n_samples_seen_每个特征处理的样本数

详细实现代码：

  1. # 原数据
  2. print(arr)
  3. # 定义规则StandardScaler并获取该规则所需的参数fit
  4. std = preprocessing.StandardScaler().fit(arr)
  5. # 输出每一列的均值
  6. print(std.mean_)
  7. # 输出每个特征的样本数
  8. print(std.n_samples_seen_)
  9. # 输出标准化后的数据
  10. print(std.transform(arr))
  12. #####
  13. [[ 1. -1.  2.]
  14.  [ 3.  1. -2.]
  15.  [ 2.  1.  1.]]
  16. #####
  17. [2.         0.33333333 0.33333333]
  18. #####
  19. 3
  20. #####
  21. [[-1.22474487 -1.41421356  0.98058068]
  22.  [ 1.22474487  0.70710678 -1.37281295]
  23.  [ 0.          0.70710678  0.39223227]]

  • fit()

    1.   一个适配的过程，sklearn中封装的各种方法都需要这个过程的结果来进行下一步操作，得到要训练数据集的一些属性参数，如均值、方差、最值。

  • transform()

    1.   通过调用的函数规则对原数据进行转换，以fit()为前提。

  • fit_stansform()

    1.   fit()和transform()方法的结合，先fit再transform。

二、离差标准化（最小值最大值归一化）

  1.     将训练集中的特征数值缩放到固定区间内(默认0-1)，容易受噪声值影响。

函数语法格式:

  1. preprocessing.MinMaxScaler(copy=True, feature_range=(0, 1))

参数解析：

  1.     feature_range:默认(0, 1)，指定缩放的区间。

MinMaxScaler的五个属性：

min_每个特征的最小调整scale_ 每个特征数据的缩放比例data_min_每个特征最小值data_max_每个特征最大值data_range_每个特征范围

详细实现代码：

  1. std1 = preprocessing.MinMaxScaler().fit(arr)
  2. # 输出每个特征列的最大值
  3. print(std1.data_max_)
  4. # 输出标准化后数据
  5. print(std1.transform(arr))
  7. #####
  8. [3. 1. 2.]
  9. #####
  10. [[0.   0.   1.  ]
  11.  [1.   1.   0.  ]
  12.  [0.5  1.   0.75]]

三、正则归一化

函数语法格式：

  1. preprocessing.Normalizer(norm="l2", copy=True)

参数解析：

  1.     norm:默认为l2，表示对每个特征的每个元素都除以该样本的L1或L2范数。

详细实现代码：

  1. std2 = preprocessing.Normalizer().fit(arr)
  2. print(std2.transform(arr))
  4. #####
  5. [[ 0.40824829 -0.40824829  0.81649658]
  6.  [ 0.80178373  0.26726124 -0.53452248]
  7.  [ 0.81649658  0.40824829  0.40824829]]

四、二值化处理

  1.     设置一个阈值，将所有大于阈值特征值转换为1，所有小于等于阈值的特征值转换为0。

函数语法格式：

  1. preprocessing.Binarizer(threshold=0.0, copy=True)

参数解析：

  1.     threshold:默认0.0，设置阈值。

详细实现代码：

  1. std3 = preprocessing.Binarizer().fit(arr)
  2. print(std3.transform(arr))
  4. #####
  5. [[1. 0. 1.]
  6.  [1. 1. 0.]
  7.  [1. 1. 1.]]

五、独热编码

  1.     独热编码即One-Hot编码，类似于哑变量编码。

函数语法格式：

  1. preprocessing.OneHotEnconder()

详细实现代码：

  1. import pandas as pd
  3. # 创建一个DataFrame对象
  4. std4 = pd.DataFrame({'城市':['上海', '深圳', '广州', '重庆']}, index=[1, 2, 3, 4])
  5. print(std4)
  6. # 哑变量编码
  7. print(pd.get_dummies(std4))
  8. # 独热编码
  9. std4['城市'] = preprocessing.LabelEncoder().fit_transform(std4['城市'])
  10. print(std4)
  11. # 格式转换
  12. print(preprocessing.OneHotEncoder().fit_transform(std4))
  13. print(preprocessing.OneHotEncoder().fit_transform(std4).toarray())
  15. #####
  16.    城市
  17. 1  上海
  18. 2  深圳
  19. 3  广州
  20. 4  重庆
  21. #####哑变量
  22.    城市_上海  城市_广州  城市_深圳  城市_重庆
  23. 1      1      0      0      0
  24. 2      0      0      1      0
  25. 3      0      1      0      0
  26. 4      0      0      0      1
  27. #####对应哑变量编码之后的索引值
  28.    城市
  29. 1   0
  30. 2   2
  31. 3   1
  32. 4   3
  33. #####输出有值的行列值
  34.   (0, 0)    1.0
  35.   (1, 2)    1.0
  36.   (2, 1)    1.0
  37.   (3, 3)    1.0
  38. #####转换为数组列表
  39. [[1. 0. 0. 0.]
  40.  [0. 0. 1. 0.]
  41.  [0. 1. 0. 0.]
  42.  [0. 0. 0. 1.]]

特征降维

  1.     两个角度理解降维
  • 数据角度：减少数据列数
  • 空间角度：将高维度映射到低维度

主要导包

  1. from sklearn import decomposition

一、PCA（主要成分分析）

  1.     将n维特征映射到m维上（m<n），其中m维称特征为主成分，并非直接去除其他n-m维特征得到的，PCA为无监督学习。

语法格式：

  1. decomposition.PCA(n_components=None, copy=True, whiten=False, svd_solver='auto')

参数解析：

n_components：指定主成分的维度数量。

whiten：白化，默认False，是否让每个特征都具有相同的方差。

svd_solver：svd策略，默认auto，可选auto、full、arpack、randomized。

主要属性：

components_降维后各主成分方向，并按方差值大小排序explained_variance_降维后各主成分的方差值explained_variance_ratio_降维后各主成分方差值占比singular_values_最大奇异值

详细代码：

  1. # 使用sklearn内置数据集，鸢尾花数据集
  2. from sklearn import datasets
  3. iris = datasets.load_iris()
  4. # 获取数据特征值
  5. x = iris.data
  6. # 获取数据目标值
  7. y = iris.target
  8. print(x)
  9. print(y)
  11. #####
  12. [[5.1 3.5 1.4 0.2]
  13.  [4.9 3.  1.4 0.2]
  14.  [4.7 3.2 1.3 0.2]
  15.  [4.6 3.1 1.5 0.2]
  16.  [5.  3.6 1.4 0.2]
  17.  [5.4 3.9 1.7 0.4]
  18. [...]...]
  19. #####
  20.  [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  21.  0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
  22.  1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2
  23.  2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
  24.  2 2]
  1.     可以看到鸢尾花的数据集是四维数据，分别代表花瓣的长度宽度、花萼的长度宽度，使用PCA将特征值降维到二维，具体如下：
  1. # 定义PCA降维规则
  2. pca = decomposition.PCA(n_components=2)
  3. # 将规则实现到特征值上
  4. pca_x = pca.fit_transform(x)
  5. print(pca_x)
  7. #####
  8. [[-2.68412563  0.31939725]
  9.  [-2.71414169 -0.17700123]
  10.  [-2.88899057 -0.14494943]
  11.  [-2.74534286 -0.31829898]
  12.  [-2.72871654  0.32675451]
  13.  [-2.28085963  0.74133045]
  14. [...]...]

二、ICA（独立成分分析）

  1.     从多变量统计数据中找到隐含的因素，常用于还原混淆信号中的不同源信号。

代码实操：

  1.     全部导包：
  1. import numpy as np
  2. # 用于生成信号
  3. from scipy import signal
  4. # 通过pca对ica进行比较
  5. from sklearn.decomposition import PCA
  6. from sklearn.decomposition import FastICA
  7. # 作图，直观展示
  8. import matplotlib.pyplot as plt
  1.     ICA还原已混淆信号操作，首先创建混淆信号：
  1. # 设置随机种子，使得随机数固定生成
  2. np.random.seed(0)
  3. # 生成0到8之间数量为2000的等差数列
  4. time = np.linspace(0, 8, 2000)
  5. # 生成3种源信号
  6. waft1 = np.sin(2 * time)  # 正弦信号
  7. waft2 = np.sign(np.sin(3 * time))  # 方波信号
  8. waft3 = signal.sawtooth(2 * np.pi * time)  # 锯齿信号
  9. print('正弦信号为：\n', waft1, '\n',
  10.       '方波信号为：\n', waft2, '\n',
  11.       '锯齿信号为：\n', waft3)
  13. # 生成混淆信号
  14. waft = np.c_[waft1, waft2, waft3]
  15. waft += 0.2 * np.random.normal(size=waft.shape)  # 增加噪声
  16. waft /= waft.std(axis=0)  # 数据标准化
  17. arr = np.array([[1, 1, 1], [0.5, 2, 1.0], [1.5, 1.0, 2.0]])  # 混淆矩阵
  18. mix_waft = np.dot(waft, arr.T)  # 生成的混淆信号
  19. print('混淆信号为：\n', mix_waft)
  21. #####
  22. 正弦信号为：
  23.  [ 0.          0.00800392  0.01600732 ... -0.27253687 -0.28022907
  24.  -0.28790332] 
  25.  方波信号为：
  26.  [ 0.  1.  1. ... -1. -1. -1.] 
  27.  锯齿信号为：
  28.  [-1.       -0.991996 -0.983992 ...  0.983992  0.991996 -1.      ]
  29. 混淆信号为：
  30.  [[-0.74486315 -0.91401507 -1.81570038]
  31.  [ 0.03932519  1.06492993 -1.58715033]
  32.  [-0.40766041  0.39786915 -1.90998106]
  33.  ...
  34.  [ 0.23856791 -0.28486909  1.38619226]
  35.  [-0.00653213 -0.99317023  1.48134842]
  36.  [-3.00301507 -3.62816891 -4.8258685 ]]
  1.     对mix_waft混淆信号进行降维操作：
  1. # 创建ica规则
  2. ica = FastICA(n_components=3).fit(mix_waft)
  4. # 使用ICA还原信号
  5. waft_ica = ica.transform(mix_waft)
  6. # 使用PCA还原信号
  7. waft_pca = PCA(n_components=3).fit_transform(mix_waft)
  8. # 绘制结果
  9. plt.figure(figsize=[12, 6])  # 设置画布大小
  10. # 设置中文字体格式
  11. plt.rcParams['font.sans-serif'] = 'SimHei'
  12. # 设置正负号正常显示
  13. plt.rcParams['axes.unicode_minus'] = False
  14. models = [mix_waft, waft, waft_ica, waft_pca]
  15. names = ['混淆信号',
  16.          '实际源信号',
  17.          'ICA复原信号',
  18.          'PCA复原信号']
  19. colors = ['red', 'steelblue', 'orange']
  20. for i, (model, name) in enumerate(zip(models, names), 1):
  21.     # 创建子图
  22.     plt.subplot(4, 1, i)
  23.     # 设置标题，对应上面定义过的names
  24.     plt.title(name)
  25.     # 设置三个信号在图形中的数据值和颜色
  26.     for sig, color in zip(model.T, colors):
  27.         plt.plot(sig, color=color)
  28. # 设置每个子图之间的边距
  29. plt.subplots_adjust(0.09, 0.04, 0.94, 0.94, 0.26, 0.46)
  30. # 展示
  31. plt.show()

  1.      可以看出，对于复原信号来说，ICA复原的信号比PCA复原的信号更明显更接近实际数据。

三、LDA

  1.     LDA是一种监督学习的降维技术，主要功能是将高维度数据在低维度上进行投影展示，其中同一类别的各数据投影点较近，不同类别的数据投影点中心之间距离尽可能大。LDA可用于降维，也可用于分类。

LDA与PCA的区别

  1.     LDA和PCA都是将多维数据降为低维数据，但PCA的降维不容易区分数据属于哪个类别，即不做分类调整，而LDA则会将不同类别的数据以他们的中心点做分类处理，更容易区分类别之间的差异。

代码实现：

  1. import matplotlib.pyplot as plt
  2. from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
  3. from sklearn import decomposition
  4. from sklearn import datasets
  6. iris = datasets.load_iris()
  7. x = iris.data
  8. y = iris.target
  9. # 构建并训练lda和pca模型，获取到降维结果
  10. x_lda = LinearDiscriminantAnalysis(n_components=2).fit_transform(x, y)
  11. x_pca = decomposition.PCA(n_components=2).fit_transform(x)
  12. # 创建画布
  13. plt.figure()
  14. # 图表正常显示
  15. plt.rcParams['font.sans-serif'] = 'SimHei'
  16. plt.rcParams['axes.unicode_minus'] = False
  17. # 设置每个特征在图形展示的颜色
  18. colors = ['r', 'g', 'b']
  19. # 设置图形形状
  20. markers = ['*', '.', 'd']
  21. # 绘制PCA散点图
  22. for color, i, marker in zip(colors, [0, 1, 2], markers):
  23.     plt.scatter(x_pca[y == i, 0], x_pca[y == i, 1], color=color, marker=marker)
  24. plt.title('PCA结果展示')
  25. plt.show()
  26. # 绘制LDA散点图
  27. plt.figure()
  28. for color, i, marker in zip(colors, [0, 1, 2], markers):
  29.     plt.scatter(x_lda[y == i, 0], x_lda[y == i, 1], color=color, marker=marker)
  30. plt.title('LDA结果展示')
  31. plt.show()

标签： python 开发语言 机器学习
本文转载自: https://blog.csdn.net/Jun_257/article/details/125022260
版权归原作者 落系 所有， 如有侵权，请联系我们删除。
登录后发布评论

“机器学习3-特征工程个人笔记”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？