【深度学习】实验03 特征处理-Toy模板网

这篇具有很好参考价值的文章主要介绍了【深度学习】实验03 特征处理。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

特征处理

标准化、归一化和正则化是常见的数据处理方法，用于在机器学习和统计模型中对数据进行预处理和特征转换。它们具有不同的目的和方法。

1.归一化

归一化是机器学习中一个非常重要的数据预处理方法，它通过对数据进行缩放和转换，使得数据能够在计算时更加准确、更加稳定，从而提高机器学习算法的性能和效果。归一化可以分为线性归一化和非线性归一化两种方法。

（1）线性归一化，也称为min-max缩放，是将数据按比例缩放到给定的值范围内。它通过将原始数据 $x$ 进行转换，使得 $x_{i}$ 被转换为 $[0, 1]$ 范围内的值，转换公式如下：
$\frac{x - x_{min}}{x_{max}-x_{min}}$
其中， $x_{min}$ 和 $x_{max}$ 分别是数据集中的最小值和最大值。这种方法常用于数据的连续特征变量，例如图像处理中的灰度值处理。

（2）非线性归一化则可以分为Z-score标准化和正则化两种方法：

Z-score标准化，也称为零均值标准化，是将数据按比例缩放并平移，使得数据符合正态分布。它通过将原始数据 $x$ 进行转换，使得 $x_{i}$ 被转换为均值为0、标准差为1的正态分布，转换公式如下：
$\frac{x - \mu}{\sigma}$
其中， $\mu$ 和 $\sigma$ 分别是数据集中的均值和标准差。这种方法常用于数据的连续特征变量，例如金融领域中的股票价格。
正则化，也称为L1和L2正则化，是通过对数据进行缩放和约束，使得数据的各个特征具有相近的重要性。它通过将原始数据 $x$ 进行转换，使得 $x_{i}$ 被转换为在单位范数下的值，转换公式如下：
$L1: ||x'||_{1} = 1, L2: ||x'||_{2} = 1$
其中， $x'||_{1}$ 和 $x'||_{2}$ 分别是数据集中的L1和L2范数。这种方法常用于文本分类中的TF-IDF特征权重计算中。

归一化的主要目的是使得不同特征之间具有可比性，从而可以更加准确地进行模型训练和预测。归一化还可以防止机器学习算法因各种原因而发生数值溢出、数值不稳定、精度误差等问题，从而提高模型的泛化能力和准确率。因此，在进行机器学习任务时，归一化的操作应该被充分考虑。

# 导入归一化库
from sklearn.preprocessing import MinMaxScaler
import numpy as np

data = np.random.uniform(0, 100, 10)[:, np.newaxis]
mm = MinMaxScaler()
mm_data = mm.fit_transform(data)
origin_data = mm.inverse_transform(mm_data)
print('data is ',data)
print('after Min Max ',mm_data)
print('origin data is ',origin_data)

   data is  [[67.74476271]
    [10.2077285 ]
    [27.34037799]
    [24.72236105]
    [68.67245127]
    [91.11026437]
    [51.92345696]
    [92.05191865]
    [16.9495692 ]
    [94.18851495]]
   after Min Max  [[0.6851214 ]
    [0.        ]
    [0.20400678]
    [0.17283278]
    [0.69616784]
    [0.96334578]
    [0.49672943]
    [0.97455851]
    [0.08027837]
    [1.        ]]
   origin data is  [[67.74476271]
    [10.2077285 ]
    [27.34037799]
    [24.72236105]
    [68.67245127]
    [91.11026437]
    [51.92345696]
    [92.05191865]
    [16.9495692 ]
    [94.18851495]]

2.标准化

标准化，也称为中心化处理，是机器学习中常用的一种预处理方法，其主要目的是将原始数据转换为均值为0、方差为1的标准正态分布。标准化主要应用于数据预处理、特征选择和模型建立等各个环节，可以提高算法的性能和效果。下面我们从基本概念和实现过程等方面来介绍标准化的相关内容。

基本概念

标准化是一种将不同尺度和量级的数据转换为相同尺度和量级的数据的方法。其主要目的是将数据按照一定规律进行缩放，从而使得数据在进行机器学习算法时具有相同的权重和比重。标准化的常用方法有Z-score标准化和小数定标标准化两种方法。

Z-score标准化：将原始数据减去平均值再除以标准差，使得数据转化为均值为0、标准差为1的标准正态分布。Z-score标准化常用于线性回归等机器学习算法中。

小数定标标准化：将原始数据除以10的幂次方，使得数据转化为以小数形式表示的值。小数定标标准化常用于神经网络等机器学习算法中。

标准化的实现过程

标准化的实现过程可以基本分为以下几个步骤：

（1）计算样本的均值和标准差：

对于给定的原始数据集，首先需要计算样本的均值和标准差。均值可以通过以下公式计算：

$\mu = \frac{\sum_{i=1}^{n}x_{i}}{n}$

其中， $n$ 表示样本数量， $x_{i}$ 表示第 $i$ 个样本的取值。标准差可以通过以下公式计算：

$\sigma = \sqrt{\frac{\sum_{i=1}^{n}(x_{i}-\mu)^{2}}{n}}$

（2）进行标准化处理：

在计算出样本的均值和标准差后，就可以对原始数据进行标准化处理了。Z-score标准化可以通过以下公式计算：

$\frac{x-\mu}{\sigma}$

其中， $x$ 表示原始数据， $\mu$ 表示样本均值， $\sigma$ 表示样本标准差。小数定标标准化可以通过以下公式计算：

$\frac{x}{10^{k}}$

其中， $x^{'}$ 表示标准化后的数据， $k$ 表示需要除以的幂次方数。

总结

标准化是机器学习中一种重要的预处理技术，它可以将不同尺度和量级的数据转换为相同尺度和量级的数据，从而提高算法的泛化能力和准确率。标准化方法主要包括Z-score标准化和小数定标标准化两种方法，通过计算样本的均值和标准差，并进行相应的转换操作，可以将原始数据转化为均值为0、标准差为1的标准正态分布。因此，在进行机器学习算法时，标准化的操作应该被充分考虑。

# 导入标准化库
from sklearn.preprocessing import StandardScaler

from matplotlib import gridspec
import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings("ignore")

# 随机生成0到100的整数，100行2列
data = np.random.randint(0, 100, (100, 2))
data

   array([[ 7, 84],
          [43, 81],
          [22, 84],
          [ 7, 61],
          [51, 74],
          [95, 94],
          [80, 92],
          [58, 35],
          [88, 15],
          [61, 42],
          [75, 95],
          [87, 64],
          [18, 77],
          [13, 60],
          [18, 51],
          [61, 12],
          [32, 11],
          [ 6, 77],
          [85, 44],
          [87, 10],
          [84, 10],
          [ 1, 28],
          [76, 87],
          [61,  0],
          [ 9, 25],
          [83, 75],
          [ 7, 60],
          [80, 73],
          [62, 58],
          [71, 84],
          [78,  6],
          [92, 54],
          [92, 50],
          [28, 57],
          [73, 80],
          [97, 86],
          [84, 78],
          [ 9, 29],
          [90, 64],
          [ 8, 32],
          [98, 62],
          [45, 93],
          [73, 72],
          [97, 11],
          [21, 66],
          [32,  9],
          [65, 59],
          [30, 36],
          [19, 37],
          [75, 43],
          [90, 55],
          [53,  8],
          [73, 25],
          [73, 82],
          [84, 76],
          [49, 97],
          [29, 64],
          [69, 37],
          [72, 90],
          [10, 87],
          [19, 70],
          [49, 53],
          [56, 24],
          [61, 16],
          [58, 23],
          [28, 31],
          [37, 49],
          [67, 25],
          [31, 99],
          [38, 84],
          [55, 53],
          [27, 89],
          [83, 50],
          [73, 86],
          [67, 11],
          [61, 72],
          [17, 88],
          [82, 67],
          [56, 51],
          [18, 59],
          [73, 44],
          [ 8, 86],
          [ 6, 20],
          [32, 12],
          [15,  4],
          [91, 17],
          [21, 78],
          [67, 63],
          [12, 32],
          [45, 76],
          [41, 29],
          [75, 64],
          [75, 19],
          [ 1, 76],
          [17, 18],
          [13, 47],
          [80, 48],
          [88, 76],
          [29, 63],
          [21, 95]])

# 标准化
ss = StandardScaler()
std_data = ss.fit_transform(data)
std_data

   array([[-1.50234381,  1.09430096],
          [-0.28120186,  0.98577525],
          [-0.99353466,  1.09430096],
          [-1.50234381,  0.26227048],
          [-0.00983698,  0.73254858],
          [ 1.48266985,  1.45605335],
          [ 0.97386071,  1.38370287],
          [ 0.22760729, -0.67828572],
          [ 1.24522559, -1.40179049],
          [ 0.32936912, -0.42505905],
          [ 0.80425766,  1.49222858],
          [ 1.21130498,  0.37079619],
          [-1.1292171 ,  0.84107429],
          [-1.29882015,  0.22609524],
          [-1.1292171 , -0.09948191],
          [ 0.32936912, -1.5103162 ],
          [-0.65432856, -1.54649144],
          [-1.53626442,  0.84107429],
          [ 1.14346376, -0.35270857],
          [ 1.21130498, -1.58266668],
          [ 1.10954315, -1.58266668],
          [-1.70586747, -0.93151239],
          [ 0.83817827,  1.20282668],
          [ 0.32936912, -1.94441906],
          [-1.43450259, -1.0400381 ],
          [ 1.07562254,  0.76872382],
          [-1.50234381,  0.22609524],
          [ 0.97386071,  0.69637334],
          [ 0.36328973,  0.15374476],
          [ 0.66857522,  1.09430096],
          [ 0.90601949, -1.72736763],
          [ 1.38090802,  0.00904381],
          [ 1.38090802, -0.13565714],
          [-0.790011  ,  0.11756952],
          [ 0.73641644,  0.94960001],
          [ 1.55051107,  1.16665144],
          [ 1.10954315,  0.87724953],
          [-1.43450259, -0.89533715],
          [ 1.3130668 ,  0.37079619],
          [-1.4684232 , -0.78681143],
          [ 1.58443168,  0.29844572],
          [-0.21336064,  1.41987811],
          [ 0.73641644,  0.6601981 ],
          [ 1.55051107, -1.54649144],
          [-1.02745527,  0.44314667],
          [-0.65432856, -1.61884192],
          [ 0.46505156,  0.18992   ],
          [-0.72216978, -0.64211048],
          [-1.09529649, -0.60593524],
          [ 0.80425766, -0.38888381],
          [ 1.3130668 ,  0.04521905],
          [ 0.05800424, -1.65501716],
          [ 0.73641644, -1.0400381 ],
          [ 0.73641644,  1.02195048],
          [ 1.10954315,  0.80489905],
          [-0.0776782 ,  1.56457906],
          [-0.75609039,  0.37079619],
          [ 0.600734  , -0.60593524],
          [ 0.70249583,  1.31135239],
          [-1.40058198,  1.20282668],
          [-1.09529649,  0.58784762],
          [-0.0776782 , -0.02713143],
          [ 0.15976607, -1.07621334],
          [ 0.32936912, -1.36561525],
          [ 0.22760729, -1.11238858],
          [-0.790011  , -0.82298667],
          [-0.48472551, -0.17183238],
          [ 0.53289278, -1.0400381 ],
          [-0.68824917,  1.63692954],
          [-0.4508049 ,  1.09430096],
          [ 0.12584546, -0.02713143],
          [-0.82393161,  1.27517715],
          [ 1.07562254, -0.13565714],
          [ 0.73641644,  1.16665144],
          [ 0.53289278, -1.54649144],
          [ 0.32936912,  0.6601981 ],
          [-1.16313771,  1.23900191],
          [ 1.04170193,  0.47932191],
          [ 0.15976607, -0.09948191],
          [-1.1292171 ,  0.18992   ],
          [ 0.73641644, -0.35270857],
          [-1.4684232 ,  1.16665144],
          [-1.53626442, -1.2209143 ],
          [-0.65432856, -1.5103162 ],
          [-1.23097893, -1.79971811],
          [ 1.34698741, -1.32944001],
          [-1.02745527,  0.87724953],
          [ 0.53289278,  0.33462096],
          [-1.33274076, -0.78681143],
          [-0.21336064,  0.80489905],
          [-0.34904307, -0.89533715],
          [ 0.80425766,  0.37079619],
          [ 0.80425766, -1.25708953],
          [-1.70586747,  0.80489905],
          [-1.16313771, -1.29326477],
          [-1.29882015, -0.24418286],
          [ 0.97386071, -0.20800762],
          [ 1.24522559,  0.80489905],
          [-0.75609039,  0.33462096],
          [-1.02745527,  1.49222858]])

# 作图
gs = gridspec.GridSpec(5,5)
fig = plt.figure()
ax1 = fig.add_subplot(gs[0:2, 1:4])
ax2 = fig.add_subplot(gs[3:5, 1:4])
 
ax1.scatter(data[:, 0], data[:, 1])
ax2.scatter(std_data[:, 0], std_data[:, 1])
 
plt.show()

【深度学习】实验03 特征处理,《深度学习》,python,深度学习,开发语言

3.正则化

正则化是一个用于防止机器学习模型过度拟合的技术，即防止模型过度适应训练数据，而无法泛化到新数据。正则化的目的是通过对模型参数引入一定的惩罚来降低模型复杂度，从而提高模型的泛化能力。在正则化中，L1和L2正则化是两种最常见的方法。

L1正则化，也称为Lasso正则化，是通过向代价函数添加权重的绝对值之和来实现的。这可以将模型权重推向零，从而通过稀疏化来减少模型的复杂性。 L1正则化可以用于特征选择，即从原始特征集中选择最具预测能力的特征。在L1正则化中，较小的特征权重被迫归零，因此不会对预测结果产生贡献。这种方法优点是可以减少特征数量，但同时会导致一些特征的丧失。在代码中，我们可以使用sklearn库中的Normalizer来实现L1正则化。
L2正则化，也称为岭回归，是通过向代价函数添加权重的平方和来实现的。这会导致权重值逐渐缩小，但不会归零。这种正则化方法在训练数据中有很多噪声时表现非常好，它能够减少模型过度适应的情况，提高模型的泛化性能。在代码中，我们可以使用sklearn库中的normalize来实现L2正则化。

区别：

L1和L2正则化的主要区别在于在向代价函数添加权重的方式上。L1使用绝对值，而L2使用平方。从直观上看，L1正则化会导致稀疏矩阵，而L2正则化不会。这意味着，L1通常会选择特征并将其余特征设为零，而L2则会平均选择所有特征。此外，L2对异常值的影响相对较小，而L1可能会将异常值视为噪声并将其从模型中剔除。在选择适当的正则化方法时，需要根据实际情况选择合适的方法，以实现更好的泛化性能。文章来源地址https://www.toymoban.com/news/detail-677006.html

# 导入L1正则化库
from sklearn.preprocessing import Normalizer

# 导入L2正则化库
from sklearn.preprocessing import normalize

X = [[1, -1, 2],
     [2, 0, 0],
     [0, 1, -1]]

normalizerl1 = Normalizer(norm='l1')
l1 = normalizerl1.fit_transform(X)
print('l1:', l1)

l2 = normalize(X, norm='l2')
print('l2:', l2)

l1: [[ 0.25 -0.25  0.5 ]
 [ 1.    0.    0.  ]
 [ 0.    0.5  -0.5 ]]
l2: [[ 0.40824829 -0.40824829  0.81649658]
 [ 1.          0.          0.        ]
 [ 0.          0.70710678 -0.70710678]]

附：系列文章

序号	文章目录	直达链接
1	波士顿房价预测	https://want595.blog.csdn.net/article/details/132181950
2	鸢尾花数据集分析	https://want595.blog.csdn.net/article/details/132182057
3	特征处理	https://want595.blog.csdn.net/article/details/132182165
4	交叉验证	https://want595.blog.csdn.net/article/details/132182238
5	构造神经网络示例	https://want595.blog.csdn.net/article/details/132182341
6	使用TensorFlow完成线性回归	https://want595.blog.csdn.net/article/details/132182417
7	使用TensorFlow完成逻辑回归	https://want595.blog.csdn.net/article/details/132182496
8	TensorBoard案例	https://want595.blog.csdn.net/article/details/132182584
9	使用Keras完成线性回归	https://want595.blog.csdn.net/article/details/132182723
10	使用Keras完成逻辑回归	https://want595.blog.csdn.net/article/details/132182795
11	使用Keras预训练模型完成猫狗识别	https://want595.blog.csdn.net/article/details/132243928
12	使用PyTorch训练模型	https://want595.blog.csdn.net/article/details/132243989
13	使用Dropout抑制过拟合	https://want595.blog.csdn.net/article/details/132244111
14	使用CNN完成MNIST手写体识别(TensorFlow)	https://want595.blog.csdn.net/article/details/132244499
15	使用CNN完成MNIST手写体识别(Keras)	https://want595.blog.csdn.net/article/details/132244552
16	使用CNN完成MNIST手写体识别(PyTorch)	https://want595.blog.csdn.net/article/details/132244641
17	使用GAN生成手写数字样本	https://want595.blog.csdn.net/article/details/132244764
18	自然语言处理	https://want595.blog.csdn.net/article/details/132276591