数据预处理简单介绍，并给出具体的代码示例

深度学习数据预处理简单介绍

深度学习的数据预处理包括以下几个方面：

1. 数据读取和加载：将数据从存储介质中读取到内存中，用于后续的处理和训练。
2. 数据清洗和去噪：对数据进行处理，修复缺失值和错误，去除噪声和异常值等。
3. 数据归一化和缩放：对数据进行归一化和缩放，使得数据具有相同的范围和分布，以提高模型的训练效果。
4. 数据变换和映射：对数据进行特征提取、降维和变换，以减少数据的维度和提取有用的特征。
5. 数据增强和扩展：通过对数据进行旋转、裁剪、翻转、加噪声等操作，增加数据的数量和多样性，提高模型的泛化能力和鲁棒性。
6. 数据划分和验证：将原始数据集划分为训练集、验证集和测试集，用于模型的训练、调优和评估。
7. 数据保存和加载：将数据和模型保存到磁盘或云存储，用于后续的部署和应用。

在每个方面，具体的处理方法和技术都有很多种，需要根据具体的问题和数据特征进行选取和应用。

在深度学习中，数据预处理是非常关键的一个步骤。本教程将介绍一些数据预处理的基础技巧，包括数据清洗、归一化、平衡数据集等。

数据清洗

数据清洗是指删除或纠正数据集中的错误或不完整的数据。数据清洗可以有效地避免噪声的影响，提高模型的准确性。

常见的数据清洗方法包括：

• 删除缺失数据：删除数据中包含缺失值的行或列。
• 数据平滑：平滑噪声的方法包括滤波和移动平均。
• 去重：删除数据集中的重复数据。
• 异常检测：检测并删除异常数据。
• 缺失值填充：增加一些缺失值
• 重复值删除：去掉一些重复数据，和去重类似
• 数据类型转换：把数据转换为不同的类型

1. 删除缺失数据

在数据中有时会存在缺失的情况，比如某一行或某一列中某些数据没有被记录，这些缺失值可能会对后续处理产生负面影响。因此，我们需要将这些缺失数据清除掉。

import pandas as pd

# 读取csv文件
df = pd.read_csv('data.csv')

# 删除包含缺失值的行或列
df = df.dropna(axis=0, subset=['col1', 'col2'])
1
2
3
4
5
6
7

在这段代码中，我们使用 Pandas 库中的 read_csv 函数来读取 csv 文件，然后使用 dropna 函数删除包含缺失值的行或列，其中 axis=0 参数表示删除行， subset=['col1', 'col2'] 参数表示对列 ‘col1’ 和 ‘col2’ 中含有缺失值的行进行删除。

2. 数据平滑

在一些数据中可能会存在噪声，而噪声会影响模型的表现，因此需要对数据进行平滑处理，以减少噪声的影响。

import numpy as np
from scipy.ndimage.filters import gaussian_filter

# 生成带噪声的数据
data = np.random.uniform(low=0.0, high=1.0, size=(100,))
noise = np.random.normal(loc=0, scale=0.1, size=(100,))
data_with_noise = data + noise

# 进行高斯滤波
data_smooth = gaussian_filter(data_with_noise, sigma=3)
1
2
3
4
5
6
7
8
9
10

首先，我们使用 Numpy 库中的 np.random 模块生成一个随机的数据集，并添加了一些噪声。然后使用 Scipy 库中的 gaussian_filter 函数对数据进行高斯滤波，其中 sigma=3 表示设定高斯核的标准差为 3。

3. 去重

在某些数据集中，可能会包含一些重复的数据，这些重复数据会对模型的准确性产生负面影响，因此需要将这些重复的数据删除。

# 生成带重复数据的数据集
data = [1, 2, 2, 3, 4, 4, 4, 5]

# 使用 Pandas 库去重
unique_data = pd.DataFrame(data, columns=['col1']).drop_duplicates()
1
2
3
4
5

这段代码中，我们首先生成了一个包含重复数据的数据集，然后使用 Pandas 库中的 drop_duplicates 函数对数据集进行去重，其中 columns=['col1'] 表示以列 ‘col1’ 作为唯一标识，如果该列中有重复数据，则将其删除。

4. 异常检测

检测异常数据的方法有很多种，常见的方法包括箱线图、z-score等，这里根据数据集的特点和具体的需求进行适当选择。

import numpy as np
# 生成带异常数据的数据集
data = [1, 2, 3, 4, 100]

# 使用 z-score 进行异常检测
mean_value = np.mean(data)
std_value = np.std(data)
threshold = 2.0
outliers = []
for x in data:
    if abs(x - mean_value) > threshold * std_value:
        outliers.append(x)
1
2
3
4
5
6
7
8
9
10
11
12

这段代码中，我们首先生成了一个包含异常数据的数据集，然后使用 z-score 进行异常检测，将均值加减两倍标准差之外的数据都视为异常数据，并将其放入列表 outliers 中。

5. 缺失值填充

在数据中，有时候可能会有一些缺失值，这会影响到数据的计算和分析，因此需要进行缺失值填充。

import pandas as pd

# 生成带缺失值的数据集
data = {'name': ['A', 'B', 'C', 'D'], 'age': [20, None, 22, 24], 'gender': ['M', 'F', None, 'F']}
df = pd.DataFrame(data)

# 使用均值填充缺失值
df = df.fillna(df.mean())
1
2
3
4
5
6
7
8

这段代码中，我们首先生成了一个带缺失值的数据集，然后使用 Pandas 库中的 fillna 函数对缺失值进行填充，其中 df.mean() 表示使用列的均值来填充缺失值。

6. 重复值删除

在数据集中，有时可能会有一些完全相同的数据记录，这些记录对数据分析不会产生太大的影响，并且删除这些记录可以为后续的分析提供更准确的数据。

import pandas as pd

# 生成带重复值的数据集
data = {'name': ['A', 'B', 'B', 'C', 'C'], 'age': [20, 22, 22, 24, 24], 'gender': ['M', 'F', 'F', 'F', 'F']}
df = pd.DataFrame(data)

# 使用唯一值筛选器删除重复值
df = df.drop_duplicates()
1
2
3
4
5
6
7
8

这段代码中，我们首先生成了一个带重复值的数据集，然后使用 Pandas 库中的 drop_duplicates 函数对数据集进行去重，保留第一次出现的记录，同时删除后续的记录。

7. 数据类型转换

在深度学习中，很多时候需要对数据类型进行转换，如将字符串类型转换成整型或浮点型数据。

import pandas as pd

# 生成带字符串类型的数据集
data = {'name': ['A', 'B', 'C', 'D'], 'age': ['20', '22', '24', '26']}
df = pd.DataFrame(data)

# 将字符串类型转换为整型
df['age'] = df['age'].astype(int)
1
2
3
4
5
6
7
8

这段代码中，我们首先生成了一个带字符串类型的数据集，然后使用 Pandas 库中的 astype 函数将 ‘age’ 列的数据类型转换成整型。我们还可以使用 float、str 等其他类型，具体根据需要进行选择。

小结

数据清洗是深度学习中十分重要的步骤，本文介绍了数据清洗常用的操作，包括删除缺失数据、数据平滑、去重、异常检测、缺失值填充、重复值删除以及数据类型转换，并提供了相应的 Python 代码。在实践中，我们可以根据具体数据集的特点和需求选择相应的方法来进行数据清洗。

归一化

在深度学习中，归一化（Normalization）是一项常见的数据预处理步骤，它的目的是将输入数据的范围缩放到一个相对较小的范围内，这有助于增加模型的稳定性和准确性。在归一化后，数据的分布就会更加接近于标准分布，更符合模型的假设，同时避免了一些特征过大或过小导致的问题。

常见的归一化方法包括：

• 最小-最大归一化：将数据缩放到给定的区间内，通常是[0,1]或[-1,1]。
• z-score归一化：将数据缩放为均值为0，标准方差为1的正态分布。

最小-最大归一化

最小-最大归一化方法是将数据线性缩放到一个给定的范围之内，通常是[0, 1]或[-1, 1]。具体来说，通过以下公式将数据缩放到指定区间：
$$x^{\prime }=\frac{x-x_{min}}{x_{max}-x_{min}}$$

其中$x$是原始数据，$x_{min}$和分$x_{max}$别是数据的最小值和最大值，$x^{\prime }$是归一化后的数据。

最小-最大归一化的实现代码如下：

def min_max_normalization(data):
    """最大-最小归一化"""
    return (data - np.min(data)) / (np.max(data) - np.min(data))

data = np.array([1, 2, 3, 4, 5])
print("原始数据：", data)
print("最大-最小归一化后：", min_max_normalization(data))
1
2
3
4
5
6
7

输出结果为：

原始数据： [1 2 3 4 5]
最大-最小归一化后： [0.   0.25 0.5  0.75 1.  ]
1
2

可以看到，在使用最大-最小归一化后，数据被缩放到[0,1][0,1]的范围内。

z-score归一化

z-score归一化方法是将数据缩放为均值为0，标准差为1的分布，类似于一个标准正态分布。具体来说，通过以下公式将数据转换为z-score：
$$x^{\prime }=\frac{x-\mu }{\sigma }$$
其中$x$是原始数据，$\mu$是数据的均值，$\sigma$是数据的标准差，$x’$是归一化后的数据。

我们使用一个随机的数据集，预处理时使用z-score归一化：

def z_score_normalization(data):
    """z-score归一化"""
    mean = np.mean(data)
    std = np.std(data)
    return (data - mean) / std

np.random.seed(1)
data = np.random.randn(5)
print("原始数据：", data)
print("z-score归一化后：", z_score_normalization(data))
1
2
3
4
5
6
7
8
9
10

输出结果为：

原始数据： [ 1.62434536 -0.61175641 -0.52817175 -1.07296862  0.86540763]
z-score归一化后： [ 1.11627197 -0.3168376  -0.2550353  -0.88956586  0.34516678]
1
2

可以看到，在使用z-score归一化后，原始数据被转换为均值为0，标准差为1的分布。

小数定标标准化

小数定标标准化（Decimal Scaling）是一种简单的归一化方法，它把值都放大或缩小成某个基数的整数次幂，通常取10的整数次幂。这种方法在计算机内部实现比较容易，因为只需要向左或向右移动小数点即可。
$$x^{\prime }=\frac{x}{10^k}$$
其中$x$是原始数据，$k$是要移动的幂次。

我们使用一个含有较大值的数据集，预处理时使用小数定标标准化：

import numpy as np

def decimal_scaling(data, k):
    """小数定标标准化"""
    return data / (10 ** k)

data = np.array([1000, 2000, 3000, 4000, 5000])
print("原始数据：", data)
print("小数定标标准化后：", decimal_scaling(data, 3))
1
2
3
4
5
6
7
8
9

输出结果为：

原始数据： [1000 2000 3000 4000 5000]
小数定标标准化后： [1. 2. 3. 4. 5.]
1
2

可以看到，在使用小数定标标准化后，原始数据矩阵中的每个值都被缩小了103103倍。

范围缩放法

范围缩放法（Scaling）是一种将原始数据缩放到特定区间的常用手段，常见的应用是将数据缩放到一个为实现指定功能而设置的特定取值范围内。
$$x^{\prime }=\frac{x-x_{min}}{a}$$
其中x是原始数据，$x_{min}$是数据的最小值，a是数据的范围。

我们使用一个含有不同范围的数据集，预处理时使用范围缩放法：

def scaling(data, x_min, x_max, a):
    """范围缩放法"""
    return (data - x_min) / a

data = np.array([1, 2, 3, 4, 5])
print("原始数据：", data)
print("范围缩放法后：", scaling(data, np.min(data), np.max(data), 2))
1
2
3
4
5
6
7

输出结果为：

原始数据： [1 2 3 4 5]
范围缩放法后： [0.   0.25 0.5  0.75 1.  ]
1
2

可以看到，在使用范围缩放法后，数据被缩放到[0,2][0,2]的范围内。

Sigmoid归一化

我们使用一个随机的数据集，预处理时使用Sigmoid归一化：

def sigmoid_normalization(data):
    """Sigmoid归一化"""
    return 1 / (1 + np.exp(-data))

np.random.seed(1)
data = np.random.randn(5)
print("原始数据：", data)
print("Sigmoid归一化后：", sigmoid_normalization(data))
1
2
3
4
5
6
7
8

输出结果为：

原始数据： [ 1.62434536 -0.61175641 -0.52817175 -1.07296862  0.86540763]
Sigmoid归一化后： [0.83540418 0.35010885 0.37144016 0.25415724 0.70419688]
1
2

可以看到，在使用Sigmoid归一化后，原始数据矩阵中的每个值都被转化到[0,1][0,1]的区间内。

Tanh归一化

我们使用一个随机的数据集，预处理时使用Tanh归一化：

def tanh_normalization(data):
    """Tanh归一化"""
    return np.tanh(data)

np.random.seed(1)
data = np.random.randn(5)
print("原始数据：", data)
print("Tanh归一化后：", tanh_normalization(data))
1
2
3
4
5
6
7
8

输出结果为：

原始数据： [ 1.62434536 -0.61175641 -0.52817175 -1.07296862  0.86540763]
Tanh归一化后： [ 0.9255347  -0.54185332 -0.47922714 -0.79410112  0.69529199]
1
2

可以看到，在使用Tanh归一化后，原始数据被转换为[−1,1][−1,1]的区间内。

小结

归一化是深度学习中一个重要的预处理步骤，它可以将数据的范围缩放到一个合适的区间内，提高模型的稳定性和准确性。本文介绍了几种归一化，并提供了实现代码。在选择归一化的方法时，需要根据具体的情况进行选择。

平衡数据集

在某些情况下，数据集可能存在类别不平衡的问题，即不同类别的样本数量不同。这会导致模型对数量较少的类别的准确性下降。

常用的平衡数据集方法包括：

• 过采样：在数量较少的类别中增加样本数。
• 欠采样：减少数量较多的类别的样本数。
• 合成数据：合成与数据集相似的数据
• 加权：给不同数据分配不同权重

在深度学习模型的训练过程中，数据集中不同类别的样本数量不一致容易导致模型训练过程中出现偏差，使得模型预测结果不理想。为此，常常需要对数据集进行平衡，使得不同类别的样本数量相当，提高模型预测能力和鲁棒性。主要的数据平衡方法包括：

欠采样（undersampling）

欠采样方法主要用于解决数据集中某些类别的样本相对较多，而其他类别的样本数量较少的情况。欠采样的目标是通过减少多数类别样本数量，使得多数类别和少数类别具有相近的样本数量。

Python示例：

from collections import Counter
from sklearn.datasets import make_classification
from imblearn.under_sampling import RandomUnderSampler

# 生成不均衡的二分类数据
X, y = make_classification(n_samples=10000, n_features=10, n_classes=2, weights=[0.9, 0.1])

# 查看样本数量
print(Counter(y))  # 输出: Counter({0: 8995, 1: 1005})

# 对数据进行欠采样
rus = RandomUnderSampler(random_state=42)
X_resampled, y_resampled = rus.fit_resample(X, y)

# 查看欠采样后的样本数量
print(Counter(y_resampled))  # 输出: Counter({0: 1005, 1: 1005})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

过采样（oversampling）

过采样方法主要用于解决数据集中某些类别的样本相对较少，而其他类别的样本数量较多的情况。过采样的目标是通过增加少数类别样本数量，使得多数类别和少数类别具有相近的样本数量。

Python示例：

from collections import Counter
from sklearn.datasets import make_classification
from imblearn.over_sampling import RandomOverSampler

# 生成不均衡的二分类数据
X, y = make_classification(n_samples=10000, n_features=10, n_classes=2, weights=[0.1, 0.9])

# 查看样本数量
print(Counter(y))  # 输出: Counter({1: 8998, 0: 1002})

# 对数据进行过采样
ros = RandomOverSampler(random_state=42)
X_resampled, y_resampled = ros.fit_resample(X, y)

# 查看过采样后的样本数量
print(Counter(y_resampled))  # 输出: Counter({0: 8998, 1: 8998})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

合成数据（data synthesis）

合成数据方法主要是通过对数据进行人工合成，产生与原始数据集不同但具有相似特征和类别分布的新的合成数据，常用的方法有SMOTE等。

Python示例:

from collections import Counter
from sklearn.datasets import make_classification
from imblearn.over_sampling import SMOTE

# 生成不均衡的二分类数据
X, y = make_classification(n_samples=10000, n_features=10, n_classes=2, weights=[0.1, 0.9])

# 查看样本数量
print(Counter(y))  # 输出: Counter({1: 9007, 0: 993})

# 对数据进行SMOTE合成
smote = SMOTE(random_state=42)
X_resampled, y_resampled = smote.fit_resample(X, y)

# 查看SMOTE合成后的样本数量
print(Counter(y_resampled))  # 输出: Counter({0: 9007, 1: 9007})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

加权（weighted）

加权方法主要是通过对数据样本的权重进行调整，给予少数类别更高的权重，使得在训练模型的过程中，少数类别样本更加受到重视，提高在少数类别上的分类能力。

Python示例：

from collections import Counter
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report

# 生成不均衡的二分类数据
X, y = make_classification(n_samples=10000, n_features=10, n_classes=2, weights=[0.1, 0.9])

# 查看样本数量
print(Counter(y))  # 输出: Counter({1: 8977, 0: 1023})

# 对样本进行加权
sample_weight = [1 if i == 1 else 10 for i in y]

# 建立逻辑回归模型
lr = LogisticRegression(class_weight='balanced', random_state=42, solver='lbfgs')
lr.fit(X, y, sample_weight=sample_weight)

# 输出分类报告
y_pred = lr.predict(X)
print(classification_report(y, y_pred))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

其中，sample_weight参数表示对每个样本赋予的权重，将类别为0的样本权重设置为1，类别为1的样本权重设置为10。class_weight参数传入balanced表示自动平衡类别权重，让模型更关注少数类别的分类精度。

总结

本教程介绍了数据预处理的基础技巧，包括数据清洗、归一化和平衡数据集，并给出了一些处理的代码演示。这些方法可以提高模型的准确性和稳定性，适用于各类深度学习任务。