【Python】scikit-learn 数据预处理总结

数据预处理常见方法和步骤

数据预处理是数据准备阶段的一个重要环节，主要目的是将原始数据转换成适合机器学习模型使用的格式，同时处理数据中的缺失值、异常值、重复值、不一致性等问题。数据预处理可以显著提高机器学习模型的性能和准确度。

以下是一些常见的数据预处理步骤：

1. 缺失值处理：

   • 删除含有缺失值的记录。
   • 用某个统计值（如均值、中位数、众数）填充缺失值。
   • 使用算法（如K-近邻、决策树等）预测缺失值。

2. 异常值检测与处理：

   • 使用统计方法（如Z-score、IQR法则）检测异常值。
   • 根据业务需求决定是删除、替换或保留异常值。

3. 数据标准化/归一化：

   • 标准化（Z-score标准化）：将数据转换为均值为0，标准差为1的分布。
   • 归一化（Min-Max归一化）：将数据缩放到[0,1]或[-1,1]的范围内。

4. 编码分类变量：

   • 独热编码（One-Hot Encoding）：将分类变量转换为二进制列。
   • 标签编码（Label Encoding）：将分类变量转换为整数。
   • 顺序编码（Ordinal Encoding）：针对有序的分类变量，将其转换为整数，保留顺序信息。

5. 特征选择和降维：

   • 使用统计测试、模型权重等方法选择重要的特征。
   • 使用PCA、t-SNE等方法进行降维，减少特征的复杂性。

6. 数据变换：

   • 对数变换、Box-Cox变换等，用于稳定方差或使数据更接近正态分布。
   • 多项式特征生成，用于捕捉非线性关系。

7. 数据划分：

   • 将数据集划分为训练集、验证集和测试集，以评估模型的性能和泛化能力。

8. 处理不平衡数据：

   • 过采样少数类（如SMOTE算法）。
   • 欠采样多数类。
   • 使用合成样本技术或代价敏感学习来处理不平衡问题。

9. 文本数据预处理：

   • 去除停用词、标点符号和特殊字符。
   • 词干提取（stemming）或词形还原（lemmatization）。
   • 文本向量化，如词袋模型、TF-IDF等。

10. 时间序列数据预处理：

    • 日期和时间特征的提取，如年、月、日、小时等。
    • 时间序列的平稳化处理，如差分、对数变换等。
    • 季节性分解、趋势分解等。

数据预处理的具体步骤应根据数据集的特性、业务需求和所选模型的要求来确定。预处理后的数据应能更好地反映潜在的数据结构和模式，从而提高机器学习模型的预测性能。

示例：数据预处理简单代码

当然，以下是一个简单的数据预处理示例代码，使用Python的Pandas库来处理一个假设的数据集。这个示例将涵盖一些基本的数据预处理步骤，如缺失值处理、数据标准化和编码分类变量。

import pandas as pd
from sklearn.preprocessing import StandardScaler, OneHotEncoder
import numpy as np

# 假设我们有一个包含缺失值、数值特征和分类特征的DataFrame
data = {
    'Age': [25, np.nan, 35, 45, 55],
    'Salary': [50000, 60000, np.nan, 80000, 90000],
    'Gender': ['Male', 'Female', 'Male', 'Male', 'Female'],
    'MaritalStatus': ['Married', 'Single', 'Married', 'Single', 'Married']
}

df = pd.DataFrame(data)

# 处理缺失值：使用均值填充
df['Age'].fillna(df['Age'].mean(), inplace=True)
df['Salary'].fillna(df['Salary'].mean(), inplace=True)

# 数据标准化：对Age和Salary进行标准化
scaler = StandardScaler()
df[['Age', 'Salary']] = scaler.fit_transform(df[['Age', 'Salary']])

# 编码分类变量：使用独热编码处理Gender和MaritalStatus
encoder = OneHotEncoder(sparse=False)
encoded_gender = encoder.fit_transform(df[['Gender']])
encoded_marital = encoder.fit_transform(df[['MaritalStatus']])

# 将编码后的数据转换为DataFrame并添加到原始DataFrame中
df_gender = pd.DataFrame(encoded_gender, columns=[f"Gender_{str(i)}" for i in range(encoded_gender.shape[1])])
df_marital = pd.DataFrame(encoded_marital, columns=[f"MaritalStatus_{str(i)}" for i in range(encoded_marital.shape[1])])

# 删除原始的分类列
df.drop(['Gender', 'MaritalStatus'], axis=1, inplace=True)

# 合并编码后的数据列
df = pd.concat([df, df_gender, df_marital], axis=1)

print(df)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

在这个示例中，我们首先创建了一个包含数值特征（Age, Salary）和分类特征（Gender, MaritalStatus）的假设数据集，并且这个数据集中包含了一些缺失值。然后，我们按照以下步骤进行了数据预处理：

1. 使用均值填充了缺失值。
2. 使用StandardScaler对数值特征进行了标准化。
3. 使用OneHotEncoder对分类特征进行了独热编码。
4. 删除了原始的分类列，并将编码后的列添加到了DataFrame中。

请注意，这个示例是为了展示数据预处理的基本步骤，实际应用中可能需要根据数据的特性和业务需求进行相应的调整。

主要步骤详解

1、使用统计方法（如Z-score、IQR法则）检测异常值。

在数据分析中，异常值检测是一个重要步骤，因为它可以帮助我们识别出那些可能由于数据录入错误、测量误差或其他异常原因而产生的不合理数据点。这些异常值可能会对数据分析结果产生负面影响，因此识别并处理它们是很重要的。

以下是两种常用的统计方法来检测异常值：

1. Z-score 方法：
   Z-score 是一个测量值相对于整个数据集的均值和标准差的距离。对于给定的数据点 (x)，其 Z-score 可以通过以下公式计算：
   [ Z = \frac{x - \mu}{\sigma} ]
   其中，(\mu) 是数据的均值，(\sigma) 是数据的标准差。

   通常，如果某个数据点的 Z-score 的绝对值大于 3（或根据具体情境选择其他阈值，如 2 或 3.5），则可以将该数据点视为异常值。

import numpy as np
from scipy import stats

# 示例数据
data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 20])  # 最后一个值是异常值

# 计算Z-score
z_scores = np.abs(stats.zscore(data))
print("z_scores:",z_scores)
# [1.07349008 0.87831007 0.68313005 0.48795004 0.29277002 0.09759001
#  0.09759001 0.29277002 0.48795004 2.6349302 ]

# 设定阈值，通常使用2.5作为标准，但可以根据实际情况调整
threshold = 2.5

# 检测异常值
outliers = np.where(z_scores > threshold)

print("异常值的索引:", outliers)
# (array([], dtype=int64),)
print("异常值:", data[outliers])
# [20]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2. IQR 法则（四分位距法则）：
   IQR 是第三四分位数（Q3）与第一四分位数（Q1）之差，用于测量数据的离散程度。IQR 法则定义了一个范围，该范围由 Q1 - 1.5 * IQR 和 Q3 + 1.5 * IQR 界定。任何落在这个范围之外的数据点都可以被视为异常值。

   具体来说，IQR 的计算公式为：
   [ IQR = Q3 - Q1 ]
   异常值的检测范围为：
   [ \text{下限} = Q1 - 1.5 \times IQR ]
   [ \text{上限} = Q3 + 1.5 \times IQR ]

import numpy as np

# 示例数据
data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 50])  # 最后一个值是异常值

# 计算四分位数和IQR
Q1 = np.percentile(data, 25)
Q3 = np.percentile(data, 75)
IQR = Q3 - Q1
# 设定IQR法则的阈值
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
print(f'lower_bound:{lower_bound}, upper_bound:{upper_bound}')
# lower_bound:-3.5, upper_bound:14.5

# 检测异常值
outliers = np.where((data < lower_bound) | (data > upper_bound))

print("异常值的索引:", outliers)
# (array([9], dtype=int64),)
print("异常值:", data[outliers])
# [50]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

使用这两种方法时，需要注意以下几点：

• 选择哪种方法取决于数据的分布和特性。Z-score 方法假设数据近似正态分布，而 IQR 法则对于偏态分布或非正态分布的数据更为稳健。
• 阈值（如 Z-score 的 3 或 IQR 法则的 1.5 倍 IQR）是经验性的，可能需要根据具体情况进行调整。
• 检测到的异常值需要进一步分析，以确定它们是真正的异常还是数据中的有效部分。不是所有超出范围的数值都是错误的，有些可能是合理的极端值。
• 在处理异常值时，应谨慎考虑是否删除或替换它们。有时，异常值可能包含重要信息，不应轻易丢弃。

2、去除停用词、标点符号和特殊字符

在处理文本数据时，去除停用词（如“的”、“是”、“在”等常用词汇）、标点符号和特殊字符是常见的预处理步骤。这些元素通常不包含对文本意义有实质性贡献的信息，而且可能会干扰自然语言处理或机器学习模型的性能。

以下是一个简单的Python示例，展示了如何使用nltk库（自然语言处理工具包）去除文本中的停用词，以及如何使用正则表达式去除标点符号和特殊字符：

import re
import nltk
from nltk.corpus import stopwords

# 确保已经下载了停用词列表
nltk.download('stopwords')

# 获取停用词列表
stop_words = set(stopwords.words('chinese'))  # 假设我们处理的是中文文本

# 定义一个函数去除停用词
def remove_stopwords(text, stop_words):
    return ' '.join([word for word in text.split() if word not in stop_words])

# 定义一个函数去除标点符号和特殊字符
def remove_punctuation_and_special_chars(text):
    # 使用正则表达式替换非字母数字的字符
    return re.sub(r'[^\w\s]', '', text)

# 示例文本
text = "这是。一个示例，文本！里面包含了许多停用词、标点符号和特殊字符。"

# 去除标点符号和特殊字符
cleaned_text = remove_punctuation_and_special_chars(text)

# 去除停用词
cleaned_text = remove_stopwords(cleaned_text, stop_words)

print(cleaned_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

请注意，nltk.corpus.stopwords.words('chinese') 提供的是英文停用词列表。对于中文，你可能需要自己创建一个中文停用词列表或使用现有的中文NLP库（如jieba）来提供中文停用词。

此外，remove_punctuation_and_special_chars 函数使用正则表达式 [^\w\s] 来匹配任何非字母数字和非空白的字符，并将其替换为空字符串。这可以有效地去除标点符号和特殊字符。

如果你处理的是中文文本，正则表达式可能需要根据中文字符的特点进行调整。例如，如果你想去除所有的中文字符以外的符号，你可以使用 [^\u4e00-\u9fa5] 正则表达式来匹配非中文字符。

最后，请注意，停用词的去除并不总是必要的或有益的，这取决于你的具体任务和模型。在某些情况下，停用词可能包含对模型有用的上下文信息。

3、标准化（Z-score标准化）：将数据转换为均值为0，标准差为1的分布

标准化（也称为Z-score标准化或Standard Score）是一种常用的数据预处理技术，其目的是将数据转换为均值为0，标准差为1的分布。这种方法对于许多机器学习算法都很重要，因为它可以帮助算法更好地处理不同尺度的数据，并减少某些特征由于具有较大的数值范围而对结果产生过大的影响。

Z-score标准化的公式如下：

[ z = \frac{x - \mu}{\sigma} ]

其中：

• ( z ) 是标准化后的值。
• ( x ) 是原始数据中的值。
• ( \mu ) 是原始数据的均值。
• ( \sigma ) 是原始数据的标准差。

在Python中，你可以使用scipy.stats库中的zscore函数来进行Z-score标准化，或者手动实现上述公式。以下是一个使用Pandas和NumPy进行Z-score标准化的示例：

import pandas as pd
import numpy as np

# 创建一个简单的DataFrame作为示例数据
data = {'value': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)

# 计算均值和标准差
mean = df['value'].mean()
std = df['value'].std()

# 应用Z-score标准化公式
df['standardized_value'] = (df['value'] - mean) / std

print(df)

import pandas as pd
import numpy as np

# 创建一个简单的DataFrame作为示例数据
data = {'value': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)

# 计算均值和标准差  
mean = df['value'].mean()
std = df['value'].std()

# 应用Z-score标准化公式
df['standardized_value'] = (df['value'] - mean) / std

print(df)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

   value  standardized_value
0     10           -1.264911
1     20           -0.632456
2     30            0.000000
3     40            0.632456
4     50            1.264911
1
2
3
4
5
6

或者使用scipy.stats的zscore函数：

from scipy import stats

# 使用scipy的zscore函数进行标准化
df['zscore_value'] = stats.zscore(df['value'])

print(df)
1
2
3
4
5
6

   value  zscore_value
0     10     -1.414214
1     20     -0.707107
2     30      0.000000
3     40      0.707107
4     50      1.414214
1
2
3
4
5
6

两种方法都会得到相同的结果，即将原始数据转换为均值为0，标准差为1的分布。标准化后的数据可以更好地用于机器学习模型，因为它们具有相同的尺度，这有助于防止某些特征对模型产生过大的影响。

4、归一化（Min-Max归一化）：将数据缩放到[0,1]或[-1,1]的范围内

归一化（Normalization）是另一种常见的数据预处理技术，用于将数据缩放到一个特定的范围内，通常是[0,1]或[-1,1]。Min-Max归一化是一种简单的归一化方法，它通过线性变换将数据值映射到指定的范围。

Min-Max归一化到[0,1]范围

将数据归一化到[0,1]范围的公式如下：

[ x’ = \frac{x - \text{min}}{\text{max} - \text{min}} ]

其中：

• ( x’ ) 是归一化后的值。
• ( x ) 是原始数据中的值。
• ( \text{min} ) 是原始数据中的最小值。
• ( \text{max} ) 是原始数据中的最大值。

Min-Max归一化到[-1,1]范围

将数据归一化到[-1,1]范围的公式稍有不同，如下所示：

[ x’ = 2 \times \frac{x - \text{min}}{\text{max} - \text{min}} - 1 ]

或者使用另一个公式：

[ x’ = \frac{x - (\text{max} + \text{min}) / 2}{(\text{max} - \text{min}) / 2} ]

这两个公式都会将数据映射到[-1,1]范围内。

在Python中，你可以使用NumPy库来轻松实现Min-Max归一化。以下是一个示例代码：

import numpy as np

# 假设这是你的数据集
data = np.array([10, 20, 30, 40, 50])

# 计算最小值和最大值
data_min = np.min(data)
data_max = np.max(data)

# Min-Max归一化到[0,1]范围
normalized_data_01 = (data - data_min) / (data_max - data_min)
print("Normalized to [0,1]:", normalized_data_01)

# Min-Max归一化到[-1,1]范围（使用第一个公式）
normalized_data_11 = 2 * (data - data_min) / (data_max - data_min) - 1
print("Normalized to [-1,1] (formula 1):", normalized_data_11)

# 或者使用第二个公式归一化到[-1,1]范围
normalized_data_11_alt = (data - (data_max + data_min) / 2) / ((data_max - data_min) / 2)
print("Normalized to [-1,1] (formula 2):", normalized_data_11_alt)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Normalized to [0,1]: [0.   0.25 0.5  0.75 1.  ]
Normalized to [-1,1] (formula 1): [-1.  -0.5  0.   0.5  1. ]
Normalized to [-1,1] (formula 2): [-1.  -0.5  0.   0.5  1. ]
1
2
3

这段代码首先计算了数据中的最小值和最大值，然后使用这些值来将数据归一化到[0,1]或[-1,1]的范围。归一化后的数据在机器学习模型中通常表现更好，因为它们都被缩放到了一个共同的范围，这有助于模型训练的稳定性和收敛速度。

5、独热编码（One-Hot Encoding）：将分类变量转换为二进制列。

独热编码（One-Hot Encoding）是一种将分类变量（Categorical Variables）或名义变量（Nominal Variables）转换为机器学习算法易于利用的格式的方法。在数据处理和准备过程中，经常会遇到一些分类特征，例如：颜色（红、绿、蓝）、星期几（周一到周日）、性别（男、女）等。这些分类特征通常不能直接用于机器学习模型，因为它们不是数值型的，而大多数机器学习算法都只能处理数值型数据。

独热编码的基本思想是为每一个分类值创建一个新的二进制列，如果原始数据中的分类值等于该列代表的分类，则该列为1，否则为0。通过这种方式，每个分类值都被表示为一个唯一的二进制向量，这样机器学习模型就能够处理这些分类特征了。

例如，假设有一个特征叫做“颜色”，它有三个可能的取值：红色、绿色和蓝色。通过独热编码，我们可以将这个特征转换为三个二进制列：

• 颜色_红色：如果原始数据中的颜色是红色，则该列为1，否则为0。
• 颜色_绿色：如果原始数据中的颜色是绿色，则该列为1，否则为0。
• 颜色_蓝色：如果原始数据中的颜色是蓝色，则该列为1，否则为0。

在Python中，可以使用pandas库或者scikit-learn库中的OneHotEncoder类来进行独热编码。以下是一个使用pandas进行独热编码的示例：

import pandas as pd

# 假设有一个包含分类变量'颜色'的DataFrame
df = pd.DataFrame({
    '颜色': ['红色', '绿色', '蓝色', '红色', '绿色']
})

# 使用pandas的get_dummies方法进行独热编码
df_onehot = pd.get_dummies(df, columns=['颜色'])

print(df_onehot)
1
2
3
4
5
6
7
8
9
10
11

输出将会是类似这样的DataFrame：

   颜色_红色  颜色_绿色  颜色_蓝色
0       1       0       0
1       0       1       0
2       0       0       1
3       1       0       0
4       0       1       0
1
2
3
4
5
6

在这个例子中，颜色这一列被转换成了三个新的列：颜色_红色、颜色_绿色和颜色_蓝色，分别对应颜色的三个分类值。每一行中，只有一个列的值为1，其余为0，表示原始数据中对应的颜色分类。

6、标签编码（Label Encoding）：将分类变量转换为整数

标签编码（Label Encoding）是一种简单的方法，用于将分类变量（也称为名义变量或类别变量）转换为整数。这种方法通常用于将无序的分类标签（如颜色、星期几的名称、性别的文字表示等）转换为机器学习模型可以处理的数值格式。

在标签编码中，每个唯一的分类标签都会被分配一个唯一的整数。例如，如果有三个分类标签“红”、“绿”和“蓝”，标签编码可能会将它们分别转换为整数0、1和2（或者任何其他的整数映射，关键是保持映射的一致性）。

虽然标签编码可以将分类变量转换为数值，但它有一个重要的限制：它假设了类别之间有一种顺序关系，这在许多情况下是不正确的。例如，在颜色“红”、“绿”和“蓝”之间并没有自然的顺序，但如果使用标签编码，模型可能会错误地解释这些编码后的整数之间存在某种顺序或等级关系。

因此，在使用标签编码时需要特别小心，确保转换后的整数不会被模型误解为具有顺序性。如果分类变量是有序的（比如评分等级“低”、“中”、“高”），那么标签编码是合适的。

在Python中，可以使用sklearn.preprocessing中的LabelEncoder类来进行标签编码。以下是一个示例：

from sklearn.preprocessing import LabelEncoder

# 创建标签编码器
le = LabelEncoder()

# 假设有一个分类变量列表
categories = ['red', 'green', 'blue', 'red', 'green']

# 对分类变量进行标签编码
encoded_categories = le.fit_transform(categories)

print(encoded_categories)
# 输出可能是 [2 1 0 2 1]，具体整数取决于编码器内部的映射

# 可以通过classes_属性查看标签到整数的映射
print(le.classes_)
# 输出 ['blue', 'green', 'red'] 或者其他顺序，这取决于数据中出现的顺序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

请注意，标签编码的结果依赖于标签在数据中出现的顺序，因此不同的数据集或不同的标签顺序可能会导致不同的编码结果。此外，如果测试数据集中出现了训练数据集中未出现的类别，标签编码器将无法正确处理这些新类别，除非对其进行适当的处理（如使用handle_unknown='ignore'参数或预先定义所有可能的类别）。

对于无序的分类变量，通常推荐使用独热编码（One-Hot Encoding）而不是标签编码，以避免引入不必要的顺序关系。

7、顺序编码（Ordinal Encoding）：针对有序的分类变量，将其转换为整数，保留顺序信息

顺序编码（Ordinal Encoding）是一种特定于有序分类变量的编码方法。与标签编码（Label Encoding）类似，顺序编码也是将分类标签转换为整数。然而，与标签编码不同的是，顺序编码专门用于那些具有自然顺序的分类变量，因此转换后的整数不仅代表了不同的类别，还保留了类别之间的顺序关系。

例如，假设我们有一个表示用户满意度的有序分类变量，其类别为“非常不满意”、“不满意”、“一般”、“满意”和“非常满意”。这些类别之间存在一个明确的顺序关系，即“非常不满意” < “不满意” < “一般” < “满意” < “非常满意”。在顺序编码中，我们可以将这些类别按顺序映射为整数，比如映射为0、1、2、3和4。

在Python中，顺序编码可以通过自定义映射或使用现有的数据预处理库来实现。以下是一个简单的Python示例，展示如何手动进行顺序编码：

# 有序分类变量的类别
satisfaction_levels = ["非常不满意", "不满意", "一般", "满意", "非常满意"]

# 自定义顺序编码映射
ordinal_mapping = {level: index for index, level in enumerate(satisfaction_levels)}

print(ordinal_mapping)
# 输出：{'非常不满意': 0, '不满意': 1, '一般': 2, '满意': 3, '非常满意': 4}

# 示例数据
data = ["非常不满意", "满意", "一般", "非常满意", "不满意"]

# 进行顺序编码
encoded_data = [ordinal_mapping[level] for level in data]

print(encoded_data)  # 输出: [0, 3, 2, 4, 1]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个例子中，我们创建了一个从满意度级别到整数的映射，并使用这个映射来转换示例数据。转换后的整数列表encoded_data保留了原始满意度级别的顺序信息。

当使用机器学习模型时，如果分类变量是有序的，并且顺序信息对模型预测很重要，那么使用顺序编码是很有意义的。然而，需要注意的是，如果模型不能很好地处理这种顺序关系（比如某些基于距离的算法），则可能需要考虑其他编码方法，如独热编码。

内置方式

在Python的机器学习库中，并没有直接命名为“顺序编码”的内置功能，因为顺序编码通常是通过简单的映射实现的，不需要复杂的库函数。然而，你可以利用sklearn.preprocessing中的LabelEncoder来实现顺序编码，只要确保你的分类变量是有序的，并且你按照正确的顺序对它们进行编码。

LabelEncoder会将每个唯一的标签分配一个整数，通常是根据标签在数据中出现的顺序。如果你的有序分类变量的顺序与它们在数据中出现的顺序一致，你可以直接使用LabelEncoder。否则，你可能需要先对分类变量进行排序，然后再使用LabelEncoder，或者手动创建一个映射字典来实现顺序编码。

下面是一个使用LabelEncoder进行顺序编码的示例：

from sklearn.preprocessing import LabelEncoder
import numpy as np

# 有序分类变量的类别，按顺序排列
categories = np.array(["低", "中", "高"])

# 创建标签编码器
le = LabelEncoder()

# 对有序分类变量进行编码
encoded_categories = le.fit_transform(categories)

print(encoded_categories)  # 输出: [0 1 2]

# 对于新的数据点，也可以使用相同的编码器进行转换
new_data = np.array(["中", "高", "低"])
encoded_new_data = le.transform(new_data)
print(encoded_new_data)  # 输出: [1 2 0]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在这个例子中，我们首先创建了一个有序的类别数组，然后使用LabelEncoder对其进行编码。由于类别已经是有序的，并且是按照我们想要的顺序出现的，所以编码后的整数保留了原有的顺序信息。

如果你使用的有序分类变量的顺序与它们在数据集中出现的顺序不一致，你需要先对它们进行排序，或者手动指定一个映射关系来确保正确的顺序编码。

请注意，虽然LabelEncoder通常用于标签编码，但只要确保类别的有序性，它同样可以用于实现顺序编码。如果你正在使用的库或框架有特定的顺序编码功能，请查阅相关文档以获取详细信息。不同的库和框架可能有不同的实现方式和命名约定。

参考

• https://scikit-learn.org/