机器学习实践（上）：从数据处理到模型优化，掌握关键代码技巧(可收藏随时拿来用)_机器学习代码能力

引言：在当今信息爆炸的时代，机器学习成为了数据科学领域最重要的技术之一。然而，对于初学者来说，面对庞大的数据和复杂的算法，往往会感到无从下手。本文旨在为大家提供一个全面的机器学习实用代码汇总，涵盖了数据导入、数据预处理、特征选择、模型搭建及优化等关键步骤。通过学习本文，你将能够掌握从数据处理到模型优化的关键代码技巧，为解决实际问题提供有力支持。无论你是初学者还是有一定经验的数据科学家，本文都将帮助你更轻松地进行机器学习实践，实现数据驱动的决策和创新。让我们一起开启机器学习之旅吧！废话不多说，直接上代码拿来使用。

零、随机种子的设定

为了能更好的复现代码结果，我们很有必要使用随机种子。以下是我尽可能的考虑多种库下的情况。

import random
import numpy as np
import pandas as pd
import torch
import sklearn 
import tensorflow as tf 

random_seed = 3220822
# 设置随机数种子
torch.manual_seed(random_seed)
# 设置随机数种子
np.random.seed(random_seed)
# 设置全局随机数种子
random.seed(random_seed)
# 设置随机数种子
tf.random.set_seed(random_seed)
# 设置随机数种子
sklearn.utils.check_random_state(random_seed)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

一、数据读取

数据的读取方式有多种，最终我们可以转化为numpy和pandas形式储存，方便后续的模型建立。

1.1 读取库的安装

# 需要用到的三个库
pip install pandas
pip install numpy
pip install openpyxl
1
2
3
4

1.2 库的使用

import pandas as pd

# 1、CSV文件读取
path=r"data.csv"   # 获取CSV数据文件的绝对路径(相对路径)
data = pd.read_csv(path)

# 2、 xlsx文件读取
data = pd.read_excel(path)
1
2
3
4
5
6
7
8

pd.read_excel('data.xlsx') 和 df = pd.read_csv('data.csv') 这两个函数在读取不同文件格式（Excel 和 CSV）时有一些共同的参数。下面是这些共同参数的详细解释：

1. filepath_or_buffer：指定要读取的文件路径或 URL。可以使用文件的绝对路径或相对路径，也可以是一个 URL 地址。
2. header：指定是否将文件的第一行视为列名。默认值为 infer，表示自动推断列名。如果设置为 None，则不将任何行作为列名。
3. index_col：指定作为行索引的列。可以传递列名或列索引的整数值。默认为 None，表示不使用任何列作为行索引。
4. usecols：指定要读取的列。可以传递一个列表或字符串。如果是列表，可以指定具体的列名；如果是字符串，可以使用逗号分隔的列名。
5. dtype：指定每列的数据类型。可以传递一个字典，其中键为列名，值为数据类型。
6. parse_dates：指定需要解析为日期时间类型的列。可以传递一个列表或字典。如果是列表，可以指定需要解析的列名；如果是字典，可以指定需要解析的列名及其对应的日期格式。
7. na_values：指定需要替换为 NaN 的缺失值。可以传递一个列表或字典。列表中的元素是需要替换的值；字典中的键是列名，值是需要替换的值。
8. skiprows：指定要跳过的行数。可以传递一个整数来表示要跳过的行数，或者是一个由行索引组成的列表来指定要跳过的特定行。
9. nrows：指定要读取的行数。可以传递一个整数来表示要读取的行数。
10. skip_blank_lines：指定是否跳过空白行。默认为 True，表示跳过空白行。

1.3 txt文本读取

# 1、逐行读取文本文件
file_path = 'data.txt'  # 文本文件路径

with open(file_path, 'r') as file:
    for line in file:
        print(line)
1
2
3
4
5
6

在上述示例中，我们首先指定了文本文件的路径 file_path。然后使用 open() 函数打开文件，并指定模式为 ‘r’（只读模式）。通过 with 语句，可以确保在处理完成后自动关闭文件。然后，使用 for 循环逐行读取文件内容，并打印每行。

# 2、读取整个文本文件内容
file_path = 'data.txt'  # 文本文件路径
with open(file_path, 'r') as file:
    content = file.read()
print(content)
1
2
3
4
5

在上述示例中，我们使用 read() 方法将整个文本文件内容读取到变量 content 中。然后，我们打印 content，显示文件的全部内容。

二、数据处理

在获取数据之后，通常需要进行一系列的数据处理步骤以准备数据进行分析或建模。以下是一些常见的数据处理步骤：

1. 数据清洗（Data Cleaning）：检查和处理数据中的缺失值、异常值或错误数据。这可能涉及到填充缺失值、删除重复数据、纠正错误数据等。

2. 数据转换（Data Transformation）：对数据进行转换，使其适应特定的分析需求或算法。例如，对数值型数据进行标准化或归一化，对类别型数据进行编码（如独热编码），对文本数据进行分词或向量化等。

3. 特征选择（Feature Selection）：从原始数据中选择最相关或最有用的特征，以降低维度和提高模型的效果。可以使用统计方法（如方差阈值、卡方检验）或机器学习方法（如基于模型的特征选择）来进行特征选择。

4. 特征工程（Feature Engineering）：根据领域知识或数据理解，创建新的特征以增强模型的表现。这可以包括生成交互特征、多项式特征、时间序列特征等。

5. 数据集平衡（Data Balancing）：处理不均衡数据集的问题，以确保对于分类或回归任务，各类别样本的比例合理。可以使用欠采样、过采样等方法来平衡数据集。

6. 数据集合并（Data Integration）：将来自不同数据源的数据进行合并，以建立更完整和综合的数据集。这可能涉及到表的连接、合并或拼接操作。

7. 数据降维（Dimensionality Reduction）：数据降维是减少数据集维度的过程，旨在去除冗余特征、提高计算效率、减少存储空间、避免维度灾难以及改善模型表现。

8. 数据集划分（Data Splitting）：将数据集划分为训练集、验证集和测试集。训练集用于模型训练，验证集用于调参和模型选择，测试集用于评估模型的性能。
   在这里我们一步步给出相关代码

2.1 数据清洗（Data Cleaning）

2.1.1 统计缺失值

import pandas as pd
import numpy as np

# 创建包含缺失值的 DataFrame 示例
data = {'A': [1, 2, None, 4, 5],
        'B': ['a', 'b', None, 'd', 'e'],
        'C': ['x', None, 'z', None, 'w']}
df = pd.DataFrame(data)
print("原始 DataFrame:")
print(df)

print("\n")
# 检查列中的缺失值数量
missing_values = df.isnull().sum()
print(missing_values)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.1.2 删除缺失值

# 删除包含缺失值的行
df_cleaned = df.dropna(axis=0)
print(df_cleaned)

# 删除包含缺失值的列（适用于缺失占比过大情形下）
df_cleaned2 = df.dropna(axis=1)
print(df_cleaned2)
1
2
3
4
5
6
7

2.1.3 填充缺失值

# 使用均值填充缺失值
df_filled = df.fillna(df.mean())
print("\n使用均值填充缺失值后的 DataFrame:")
print(df_filled)

# 使用众数填充缺失值
df_filled = df.fillna(df.mode().iloc[0])
print("\n使用众数填充缺失值后的 DataFrame:")
print(df_filled)
1
2
3
4
5
6
7
8
9

2.1.4 使用3σ原则剔除异常值

import pandas as pd
import numpy as np

# 创建包含异常值的 DataFrame 示例
data = {'A': [11,11,11,12,12,12,13,13,13,14,14,14,14,13,13,13,12,12,12,11,11,11,-9999999],
        'B': [101,101,101,102,102,102,103,103,103,104,104,104,104,103,103,103,102,102,102,101,101,101,-9999999]}
df = pd.DataFrame(data)
print("原始 DataFrame:")
print(df)
print("\n")

# 使用3σ原则剔除异常值
mean = df.mean()  # 每列的均值
std = df.std()    # 每列的方差
threshold = 3
df_cleaned = df[(df - mean).abs() < threshold * std]
df_cleaned = df_cleaned.dropna()  # 剔除包含缺失值的行
print("\n使用3σ原则剔除异常值后的 DataFrame:")
print(df_cleaned)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在这个示例中，我们首先计算了每列的均值 (mean) 和标准差 (std)。然后，我们根据3σ原则，筛选出与均值差距超过3倍标准差的数据点，并将它们剔除。为了剔除包含缺失值的行，我们使用了 dropna() 方法。在这个例子中，异常值-9999999被正确地剔除了。

2.2 数据转换（Data Transformation）

2.2.1 标准化（Normalization）

标准化是一种常见的数据转换方法，旨在将数值型数据缩放到相同的范围，以消除不同特征之间的量纲差异。常用的标准化方法包括Z-score标准化和最小-最大标准化。

import pandas as pd
from sklearn.preprocessing import StandardScaler, MinMaxScaler

# 创建包含数值型数据的DataFrame示例
data = {'A': [10, 20, 30, 40, 50],
        'B': [2, 4, 6, 8, 10]}
df = pd.DataFrame(data)
print("原始 DataFrame:")
print(df)

# 使用Z-score标准化
scaler = StandardScaler()
df_normalized = pd.DataFrame(scaler.fit_transform(df), columns=df.columns)
print("\nZ-score标准化后的 DataFrame:")
print(df_normalized)

# 使用最小-最大标准化
min_max_scaler = MinMaxScaler()
df_normalized_minmax = pd.DataFrame(min_max_scaler.fit_transform(df), columns=df.columns)
print("\n最小-最大标准化后的 DataFrame:")
print(df_normalized_minmax)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2.2.2 编码（Encoding）

编码用于将类别型数据转换为适用于机器学习算法的数值型数据。常用的编码方法包括独热编码和标签编码。

import pandas as pd
from sklearn.preprocessing import OneHotEncoder, LabelEncoder

# 创建包含类别型数据的DataFrame示例
data = {'A': ['红', '蓝', '绿', '绿', '红'],
        'B': ['大', '小', '中', '大', '中']}
df = pd.DataFrame(data)
print("原始 DataFrame:")
print(df)

# 使用独热编码
encoder = OneHotEncoder(sparse=False)
df_encoded = pd.DataFrame(encoder.fit_transform(df), columns=encoder.get_feature_names_out())
print("\n独热编码后的 DataFrame:")
print(df_encoded)

# 使用标签编码
label_encoder = LabelEncoder()
df_encoded_label = df.apply(label_encoder.fit_transform)
print("\n标签编码后的 DataFrame:")
print(df_encoded_label)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2.2.3 文本向量化（Text Vectorization）

文本向量化是将文本数据转换为数值型数据的过程。常见的文本向量化方法包括词袋模型和TF-IDF模型。

from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer

# 创建包含文本数据的DataFrame示例
data = {'text': ['我 爱 中国', '中国 拥有 众多 历史 名胜', '我 喜欢 吃 中国 菜']}
df = pd.DataFrame(data)
print("原始 DataFrame:")
print(df)

# 使用词袋模型进行文本向量化
vectorizer = CountVectorizer()
df_vectorized = pd.DataFrame(vectorizer.fit_transform(df['text']).toarray(), columns=vectorizer.get_feature_names_out())
print("\n词袋模型向量化后的 DataFrame:")
print(df_vectorized)

# 使用TF-IDF模型进行文本向量化
tfidf_vectorizer = TfidfVectorizer()
df_tfidf = pd.DataFrame(tfidf_vectorizer.fit_transform(df['text']).toarray(), columns=tfidf_vectorizer.get_feature_names_out())
print("\nTF-IDF模型向量化后的 DataFrame:")
print(df_tfidf)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.3 特征选择（Feature Selection）

当涉及到特征选择时，Python中有多个库和方法可供选择。以下是使用几种常见的特征选择方法的示例。

2.3.1 方差阈值法（Variance Threshold Method）

方差阈值法用于检测具有低方差的特征并将其删除。这种方法适用于大多数特征都有相似方差的情况。在sklearn库中，可以使用VarianceThreshold类来实现方差阈值特征选择。

from sklearn.feature_selection import VarianceThreshold

data = pd.read_csv(r"IRIS.csv")
print(data.head()) # 输出数据的前几行查看
X = data[['Sepal.Length', 'Sepal.Width', 'Petal.Length','Petal.Width']]# 选取所有的特征列
y = data["Species"] # 选取因变量（也就是要预测的目标变量）
# 创建VarianceThreshold对象，设置方差阈值
selector = VarianceThreshold(threshold=0.2)

# 使用fit_transform方法选择特征
new_features = selector.fit_transform(X)

# 输出选择的特征
selected_features = X.columns[selector.get_support()]
print("Selected Features:", selected_features)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.3.2 单变量特征选择（Univariate Feature Selection）

from sklearn.feature_selection import VarianceThreshold, SelectKBest, f_classif

#基于统计方法的单变量特征选择
selector = SelectKBest(score_func=f_classif, k=2)
X_univariate = selector.fit_transform(X, y)

# 打印使用单变量特征选择后的特征维度
print("单变量特征选择后的特征维度:", X_univariate.shape[1])
1
2
3
4
5
6
7
8

基于统计方法的单变量特征选择则使用统计检验方法来计算每个特征与目标变量之间的关联程度，选择最相关的特征。在示例代码中，我们使用F值作为评分函数，并选择k个最好的特征（k=2）。通过SelectKBest(score_func=f_classif, k=2)来实现特征选择，同样使用fit_transform方法得到经过特征选择后的数据集X_univariate。

最后，使用shape[1]打印特征选择后的数据集的特征维度，可以观察到经过特征选择后的结果。

2.3.3 基于模型的特征选择（Model-based Feature Selection）

基于模型的特征选择方法通过训练一个机器学习模型并使用模型的特征重要性或系数来选择最相关的特征。这个示例使用随机森林模型来进行特征选择。

from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectFromModel

# 创建随机森林分类器作为模型
model = RandomForestClassifier()

# 使用SelectFromModel选择特征，设置阈值为"median"
selector = SelectFromModel(model, threshold="median")

# 使用fit_transform方法选择特征
new_features = selector.fit_transform(X, y)

# 输出选择的特征
selected_features = X.columns[selector.get_support()]
print("Selected Features:", selected_features)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.3.4 基于模糊粗糙集的属性约简（特征选择）

这是笔者在研一期间的研究方向，有兴趣的读者可以去我的专栏：模糊粗糙集
获取相关的代码（可直接调用使用）。
若是同研究方向的同学，也可私聊互相讨论。

2.4 特征工程（Feature Engineering）

2.4.1 生成交互特征（Interaction Features）

交互特征是通过将不同特征之间的乘积或其他数学操作组合在一起创建的新特征。以鸢尾花数据集中，我们可以将花萼长度（sepal length）和花瓣宽度（petal width）相乘创建一个交互特征。

import pandas as pd

# 生成交互特征: 花萼长度与花瓣宽度的乘积
data['interaction_feature'] = data['Sepal.Length'] * data['Petal.Width']

# 查看新特征
print(data.head())
1
2
3
4
5
6
7

2.4.2 多项式特征（Polynomial Features）

多项式特征通过对原始特征进行多项式扩展来创建新的特征。在鸢尾花数据集中，我们可以使用PolynomialFeatures类来生成原始特征的高阶多项式特征。

from sklearn.preprocessing import PolynomialFeatures

# 创建PolynomialFeatures对象，设置多项式阶数为2
poly_features = PolynomialFeatures(degree=2)

# 生成多项式特征
X_poly = poly_features.fit_transform(X)

# 将生成的多项式特征转换为DataFrame
df_poly = pd.DataFrame(X_poly, columns=poly_features.get_feature_names_out())

# 查看新特征
print(df_poly)
1
2
3
4
5
6
7
8
9
10
11
12
13

2.4.3 时间序列特征（Time Series Features）

如果你的数据集中包含时间序列信息，你可以创建一些基于时间的特征来捕捉时间的趋势和周期性。在鸢尾花数据集中没有时间序列信息，但假设你有一个带有时间戳的数据集，你可以使用datetime库中的函数来生成时间序列特征。

import datetime

# 假设你的数据集中有一个"timestamp"列，包含时间戳信息
df['timestamp'] = pd.to_datetime(df['timestamp'])

# 提取时间特征
df['year'] = df['timestamp'].dt.year
df['month'] = df['timestamp'].dt.month
df['day'] = df['timestamp'].dt.day
df['hour'] = df['timestamp'].dt.hour

# 查看新特征
print(df.head())
1
2
3
4
5
6
7
8
9
10
11
12
13

通过生成交互特征、多项式特征和时间序列特征等，你可以利用领域知识或数据理解来创建新的特征，从而提高模型的性能。这些示例仅为特征工程的一小部分，实际上还有许多其他技术和方法可供探索和尝试。根据具体的问题和数据集，你可以选择适合的特征工程方法来优化模型的表现。

2.5 数据集平衡（Data Balancing）

处理不均衡数据集的问题可以使用欠采样（Undersampling）和过采样（Oversampling）等方法来平衡各类别样本的比例。然后，根据具体情况选择以下的欠采样或过采样方法进行处理。

首先，安装imbalanced-learn库

pip install imbalanced-learn
1

假设正在处理一个二分类任务的不均衡数据集，其中正例的数量远远少于负例。希望通过欠采样和过采样等方法来平衡数据集，确保各类别样本的比例合理。

import numpy as np
from sklearn.datasets import make_classification
from imblearn.over_sampling import RandomOverSampler
from imblearn.under_sampling import RandomUnderSampler

# 生成不均衡数据集
#     其中X.shape=(1000,100)即1000个样本量，每个样本量有100个特征
X, y = make_classification(n_samples=1000, weights=[0.9, 0.1], random_state=3220822,n_features=100)

# 打印原始数据集中各类别样本数量
print("原始数据集中各类别样本数量：")
print("类别 0 的样本数量：", np.sum(y == 0))
print("类别 1 的样本数量：", np.sum(y == 1))

# 使用过采样方法平衡数据集
ros = RandomOverSampler(sampling_strategy=0.5)
X_resampled, y_resampled = ros.fit_resample(X, y)

# 打印过采样后数据集中各类别样本数量
print("\n过采样后数据集中各类别样本数量：")
print("类别 0 的样本数量：", np.sum(y_resampled == 0))
print("类别 1 的样本数量：", np.sum(y_resampled == 1))

# 使用欠采样方法平衡数据集
rus = RandomUnderSampler(sampling_strategy=0.5)
X_resampled, y_resampled = rus.fit_resample(X, y)

# 打印欠采样后数据集中各类别样本数量
print("\n欠采样后数据集中各类别样本数量：")
print("类别 0 的样本数量：", np.sum(y_resampled == 0))
print("类别 1 的样本数量：", np.sum(y_resampled == 1))
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

通过打印原始数据集和处理后数据集中各类别样本的数量，可以观察到数据集平衡后各类别样本数量的变化。你可以根据实际情况选择适合的采样方法对数据集进行处理，使各类别样本的比例合理。并根据数据集的特点和需求进行调整。其中我们获取的X_resampled, y_resampled便是我们的新的数据集，可以拿去进行建立模型。

2.6 数据集合并（Data Integration）

import pandas as pd

# 创建学生信息数据集
student_data = pd.DataFrame({
    '学号': ['001', '002', '003', '004'],
    '姓名': ['张三', '李四', '王五', '赵六'],
    '年龄': [18, 19, 20, 18],
    '性别': ['男', '女', '男', '女']
})

# 创建学生成绩数据集
score_data = pd.DataFrame({
    '学号': ['001', '002', '004', '005'],
    '科目': ['数学', '英语', '数学', '英语'],
    '分数': [80, 85, 90, 95]
})

# 创建课程信息数据集
course_data = pd.DataFrame({
    '科目': ['数学', '英语', '物理', '化学'],
    '学分': [4, 3, 3, 2]
})

# 行合并数据集
merged_data_rows = pd.concat([student_data, score_data, course_data])

# 列合并数据集
merged_data_columns = pd.concat([student_data, score_data, course_data], axis=1)

# 表连接操作
merged_data_join = pd.merge(student_data, score_data, on='学号', how='left')

# 打印行合并后的数据集
print("行合并后的数据集：")
print(merged_data_rows)

# 打印列合并后的数据集
print("\n列合并后的数据集：")
print(merged_data_columns)

# 打印表连接后的数据集
print("\n表连接后的数据集：")
print(merged_data_join)
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
39
40
41
42
43

2.7 数据降维（Dimensionality Reduction）

数据降维是减少数据集维度的过程，旨在去除冗余特征、提高计算效率、减少存储空间、避免维度灾难以及改善模型表现。下面详细介绍几种常用的数据降维方法：

1. 主成分分析（Principal Component Analysis, PCA）：PCA是一种常用的无监督降维方法。它通过线性变换将原始特征投影到一个新的坐标系中，使得新坐标轴上的方差尽可能大，并且不同坐标轴之间尽可能不相关。通过保留主成分分析中的前k个主成分，可以实现数据降维。

2. t-SNE（t-Distributed Stochastic Neighbor Embedding）：t-SNE是一种非线性降维方法，常用于可视化高维数据。它在保持样本点之间的局部相似性的同时，试图捕捉原始数据的全局结构。t-SNE通常用于探索数据集中的聚类和类别之间的关系。

3. 线性判别分析（Linear Discriminant Analysis, LDA）：LDA是一种有监督降维方法。它将样本投影到低维空间，使得同类样本尽可能靠近，不同类样本尽可能分开。LDA在分类任务中经常用于降低维度，并且具有一定的分类能力。

4. 特征选择法：特征选择方法通过选择与目标变量相关性高的特征，剔除与目标变量关联性较低的特征，从而实现降维。常用的特征选择方法包括方差选择法、单变量特征选择、基于模型的特征选择等（本文中的2.3）。

5. 奇异值分解（Singular Value Decomposition, SVD）：SVD是一种常用的矩阵分解技术，可以用于降维。通过对数据矩阵进行奇异值分解，可以得到特征值、特征向量和奇异值矩阵，从而实现数据降维。

6. 非负矩阵分解（Non-negative Matrix Factorization, NMF）：NMF是一种非负矩阵分解技术，常用于非负数据的降维。它将原始数据矩阵分解为非负的两个低秩矩阵，从而实现数据降维。

这些方法各有特点，适用于不同的数据集和问题。在实际应用中，需要根据数据集特点和任务要求选择合适的降维方法，并评估降维后数据的信息保留程度。同时，也可以结合多种降维方法进行组合使用，以获得更好的降维效果。

2.7.1 PCA（主成分分析）

首先，我们需要导入所需的库和数据集。在这个示例中，我们将使用sklearn库来实现降维方法，同时使用make_classification生成想要的数据集形式作为案例。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA

# 生成不数据集
#     其中X.shape=(1000,100)即1000个样本量，每个样本量有100个特征
X, y = make_classification(n_samples=1000, weights=[0.5, 0.5], random_state=3220822,n_features=100)

# 使用PCA进行降维
#     并且降维至n_components=2维度
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

# 绘制PCA降维后的散点图
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y)
plt.xlabel('PC1')
plt.ylabel('PC2')
plt.title('PCA Dimensionality Reduction')
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2.7.2 t-SNE（t-Distributed Stochastic Neighbor Embedding）

from sklearn.manifold import TSNE
# 使用t-SNE进行降维
tsne = TSNE(n_components=2)
X_tsne = tsne.fit_transform(X)

# 绘制t-SNE降维后的散点图
plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y)
plt.xlabel('t-SNE Dimension 1')
plt.ylabel('t-SNE Dimension 2')
plt.title('t-SNE Dimensionality Reduction')
plt.show()
1
2
3
4
5
6
7
8
9
10
11

使用t-SNE进行降维。同样地，我们将把数据降到2维，并绘制散点图进行可视化。

2.7.3 LDA（线性判别分析）

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

n = 5
# 其中X.shape=(1000,100)即1000个样本量，每个样本量有100个特征
# n_classes=n,表明该数据集共有n类
X, y = make_classification(n_samples=1000, random_state=3220822,n_features=100,n_classes=n,n_informative=n)

# 使用LDA进行降维
lda = LinearDiscriminantAnalysis(n_components=2)
X_lda = lda.fit_transform(X, y)

# 绘制LDA降维后的散点图
plt.scatter(X_lda[:, 0], X_lda[:, 1], c=y)
plt.xlabel('LDA Dimension 1')
plt.ylabel('LDA Dimension 2')
plt.title('LDA Dimensionality Reduction')
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

注意：
LDA算法中，降维的维度数量 n_components 不能超过样本特征数目或者类别数目减去1。这是因为在LDA中，投影到低维空间的维度数量不能超过样本的维度数量或者类别的数量减去1。

因此，确保指定的 n_components 参数小于等于 min(n_features, n_classes - 1)，其中 n_features 是样本的特征数目，n_classes 是类别的数目减去1。

2.8 数据集划分(Data splitting)

对数据进行了一系列的清洗、转换等操作后，为我们的模型建立提供有效的数据集。但仍需要切割数据集为3部分：训练集、验证集和测试集。

from sklearn.model_selection import train_test_split

# 假设你的特征数据保存在X中，标签保存在y中
# X和y是NumPy数组或Pandas DataFrame类型（在此代码块中，X,y是2.3.1出现的鸢尾花数据集）

# 首先将数据集划分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=3220822)

# 再将训练集进一步划分为训练集和验证集
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.2, random_state=3220822)

# 查看各个数据集的样本数量
print("训练集样本数量：", X_train.shape[0])
print("验证集样本数量：", X_val.shape[0])
print("测试集样本数量：", X_test.shape[0])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

三、模型建立–回归模型（实现常见七大类16种）

当涉及到数据分析和预测问题时，回归模型是一种强大的工具。回归模型通过观察变量之间的关系，帮助我们理解和预测数值型目标变量。在这个多样化的回归模型家族中，各种算法根据其特定的属性和表现被归为不同的类别。

1. 线性回归类别：包括经典的线性回归以及一些正则化的变体（如Lasso回归、Ridge回归和Elastic Net回归）。这些模型基于线性关系假设，适用于数据中存在线性关系的情况。

2. 决策树回归类别：包括决策树回归本身以及随机森林回归、Adaboost回归、梯度增强随机森林回归和ExtraTree回归等。这些模型将数据划分为树状结构，通过树上的分支和叶节点来进行预测。

3. 支持向量机回归类别：包含支持向量机回归算法，它通过将数据映射到高维空间，并在该空间中寻找最佳的超平面来进行回归预测。

4. 最近邻回归类别：只包含了K近邻回归模型，该模型通过寻找最接近目标样本的K个最近邻来进行回归预测。

5. Boosting回归类别：包括Adaboost回归和梯度增强随机森林回归等算法，它们利用集成学习的思想，在一系列弱学习器的基础上构建出更强大的回归模型。

6. Bagging回归类别：包含了随机森林回归和Bagging回归两种算法，这些模型通过构建多个基学习器，并对它们的预测结果进行平均来进行回归预测。

7. Xgboost回归类别：则是指Xgboost回归算法，它是一种梯度提升决策树的变体，兼具高效性和准确性。

8. 最后，还有一些其他回归模型类别，如Bayesian回归、Huber回归、主成分回归（PCR）、偏最小二乘回归（PLSR）和多层感知机回归（MLP）。这些模型根据不同的统计方法或神经网络结构提供了不同的回归功能。

在下文中将会实现前七大类共计16种回归模型，希望读者能够了解不同回归模型的优劣势，并根据具体问题的需求选择适合的模型。

3.1 线性回归类别

• 线性回归
• Lasso回归
• Ridge回归
• Elastic Net回归

# 导入所需库
import numpy as np
from sklearn.linear_model import LinearRegression, Lasso, Ridge, ElasticNet

# 创建样本数据
X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
y = np.array([3, 4, 5, 6])

# 线性回归
linear_reg = LinearRegression()
linear_reg.fit(X, y)                    # 训练模型 
linear_pred = linear_reg.predict(X)     # 模型预测
print("Linear Regression Coefficients:", linear_reg.coef_)
print("Linear Regression Intercept:", linear_reg.intercept_)
print("Linear Regression Predictions:", linear_pred)

# Lasso回归
lasso_reg = Lasso(alpha=0.1)
lasso_reg.fit(X, y)
lasso_pred = lasso_reg.predict(X)
print("Lasso Regression Coefficients:", lasso_reg.coef_)
print("Lasso Regression Intercept:", lasso_reg.intercept_)
print("Lasso Regression Predictions:", lasso_pred)

# Ridge回归
ridge_reg = Ridge(alpha=0.5)
ridge_reg.fit(X, y)
ridge_pred = ridge_reg.predict(X)
print("Ridge Regression Coefficients:", ridge_reg.coef_)
print("Ridge Regression Intercept:", ridge_reg.intercept_)
print("Ridge Regression Predictions:", ridge_pred)

# Elastic Net回归
elastic_net = ElasticNet(alpha=0.1, l1_ratio=0.5)
elastic_net.fit(X, y)
elastic_pred = elastic_net.predict(X)
print("Elastic Net Regression Coefficients:", elastic_net.coef_)
print("Elastic Net Regression Intercept:", elastic_net.intercept_)
print("Elastic Net Regression Predictions:", elastic_pred)
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
39

这是一个简单的回归问题示例。我们使用一个2维特征矩阵 X 和一个目标变量向量 y 来训练和预测。每个模型都根据给定的数据进行拟合，并计算出相应的系数、截距和预测值。

3.2 决策树回归类别

• 决策树回归
• 随机森林回归
• Adaboost回归
• 梯度增强随机森林回归
• ExtraTree回归

# 导入所需库
import numpy as np
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, AdaBoostRegressor, GradientBoostingRegressor, ExtraTreesRegressor

# 创建样本数据
X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
y = np.array([3.1, 4.2, 5.3, 6.4])

# 决策树回归
dt_reg = DecisionTreeRegressor()
dt_reg.fit(X, y)
dt_pred = dt_reg.predict(X)
print("Decision Tree Predictions:", dt_pred)

# 随机森林回归
rf_reg = RandomForestRegressor(n_estimators=100)
rf_reg.fit(X, y)
rf_pred = rf_reg.predict(X)
print("Random Forest Predictions:", rf_pred)

# Adaboost回归
ada_reg = AdaBoostRegressor(DecisionTreeRegressor(), n_estimators=100)
ada_reg.fit(X, y)
ada_pred = ada_reg.predict(X)
print("AdaBoost Predictions:", ada_pred)

# 梯度增强随机森林回归
gb_reg = GradientBoostingRegressor(n_estimators=100)
gb_reg.fit(X, y)
gb_pred = gb_reg.predict(X)
print("Gradient Boosting Predictions:", gb_pred)

# ExtraTree回归
et_reg = ExtraTreesRegressor(n_estimators=100)
et_reg.fit(X, y)
et_pred = et_reg.predict(X)
print("ExtraTree Predictions:", et_pred)
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

在这个示例中，我们使用一个2维特征矩阵 X 和一个目标变量向量 y 来训练和预测。每个模型都根据给定的数据进行拟合，并计算出相应的预测值。

3.3 支持向量机回归类别

• 支持向量机回归（Support Vector Regression，SVR）

# 导入所需库
import numpy as np
from sklearn.svm import SVR

# 创建样本数据
X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
y = np.array([3, 4, 5, 6])

# 支持向量机回归
svr_reg = SVR(kernel='rbf')
svr_reg.fit(X, y)
svr_pred = svr_reg.predict(X)
print("SVR Predictions:", svr_pred)
1
2
3
4
5
6
7
8
9
10
11
12
13

在支持向量机回归中，核函数是一个重要的参数，用于将输入特征映射到高维空间。在Scikit-learn库的SVR模型中，核函数可以通过kernel参数进行选择，并具有以下几个常用的选项：

1. 线性核函数（Linear Kernel）：线性核函数没有额外的参数，使用线性函数进行特征映射。可以通过设置kernel='linear'来选择线性核函数。

2. 多项式核函数（Polynomial Kernel）：多项式核函数使用多项式函数进行特征映射，并包含两个额外参数：degree和coef0。degree表示多项式的阶数，coef0表示独立项的系数。可以通过设置kernel='poly'来选择多项式核函数，并通过设置degree和coef0参数来调整多项式函数的形状。

3. 径向基核函数（Radial Basis Function，RBF Kernel）：径向基核函数使用高斯函数进行特征映射，并包含一个额外参数gamma。gamma控制了特征映射的影响范围，较小的gamma值会使得特征映射更为广泛，而较大的gamma值会使得特征映射更为局部化。可以通过设置kernel='rbf'来选择径向基核函数，并通过设置gamma参数来调整特征映射的影响范围。

4. sigmoid核函数（Sigmoid Kernel）：sigmoid核函数使用双曲正切函数进行特征映射，并包含两个额外参数：gamma和coef0。gamma控制了特征映射的影响范围，coef0控制了双曲正切函数的斜率。可以通过设置kernel='sigmoid'来选择sigmoid核函数，并通过设置gamma和coef0参数来调整特征映射的形状。

3.4 最近邻回归类别

• K近邻回归

# 导入所需库
import numpy as np
from sklearn.neighbors import KNeighborsRegressor
from sklearn.metrics import mean_squared_error

# 创建样本数据
X_train = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
y_train = np.array([3, 4, 5, 6])
X_test = np.array([[3, 3]])

# K近邻回归
knn_reg = KNeighborsRegressor(n_neighbors=3)
knn_reg.fit(X_train, y_train)
y_pred = knn_reg.predict(X_test)

print("KNN Regression Prediction of X_test:", y_pred)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

我们使用已有的数据进行训练，我们选择了 n_neighbors=3 来找出最近的3个近邻点来进行回归。最后，我们使用X_tes作为测试样本进行预测，并通过打印 y_pred 输出预测的值。

请注意，以上只是一个简单的示例，实际使用时可能需要更多的特征和更大规模的数据集来提高预测效果。同时，根据具体问题的不同，还可以调整K近邻回归中的其他参数。

3.5 Boosting回归类别

• Adaboost回归
• 梯度增强随机森林回归

# 导入所需库
import numpy as np
from sklearn.ensemble import AdaBoostRegressor
from sklearn.metrics import mean_squared_error

# 创建样本数据
X_train = np.array([[1,100], [2,250], [3,600], [4,500], [5,700]])
y_train = np.array([2.2, 3.4, 4.5, 5.7, 6.9])
X_test = np.array([[6,800]])

# Adaboost回归
ada_reg = AdaBoostRegressor(n_estimators=50)
ada_reg.fit(X_train, y_train)
Ada_pred = ada_reg.predict(X_test)

print("Adaboost Regression Prediction:", Ada_pred)



# 梯度增强随机森林回归
gb_reg = GradientBoostingRegressor(n_estimators=100)
gb_reg.fit(X_train, y_train)
Gb_pred = gb_reg.predict(X_test)

print("Gradient Boosting Regression Prediction:", Gb_pred)
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

在这个示例中，我们使用一个单特征数据矩阵 X_train 和对应的目标变量向量 y_train 进行训练。然后，我们使用一个新的测试样本 X_test 进行预测。

在Adaboost回归模型中我们选择了 n_estimators=50，表示Adaboost回归模型中包含50个弱学习器（默认为决策树回归器）。可以根据具体情况调整这个参数。

在梯度增强随机森林回归模型中我们选择了 n_estimators=100，表示梯度增强随机森林回归模型中包含100棵决策树。可以根据具体情况调整这个参数。

3.6 Bagging回归类别

• 随机森林回归
• Bagging回归

# 导入所需库
import numpy as np
from sklearn.ensemble import BaggingRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor


# 创建样本数据
X_train = np.array([[1,100], [2,250], [3,600], [4,500], [5,700]])
y_train = np.array([2.2, 3.4, 4.5, 5.7, 6.9])
X_test = np.array([[6,800]])

# 随机森林回归
rf_reg = RandomForestRegressor(n_estimators=100)
rf_reg.fit(X_train, y_train)
rf_pred = rf_reg.predict(X_test)
print("Random Forest Regression Prediction:", rf_pred)


# Bagging回归
bag_reg = BaggingRegressor(base_estimator=DecisionTreeRegressor(), n_estimators=100)
bag_reg.fit(X_train, y_train)
bag_pred = bag_reg.predict(X_test)
print("Bagging Regression Prediction:", bag_pred)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

在随机森林回归模型中我们选择了 n_estimators=100，表示随机森林回归模型中包含100棵决策树。可以根据具体情况调整这个参数。

在Bagging回归模型中我们选择了 n_estimators=100，表示Bagging回归模型中包含100个基本估计器（决策树回归器）。可以根据具体情况调整这个参数。

3.7 Xgboost回归类别

• Xgboost回归
  该模型的实现并不是在sklearn中导入的，而是需要单独的进行安装

pip install xgboost
1

# 导入所需库
import numpy as np
import xgboost as xgb
from sklearn.metrics import mean_squared_error

# 创建样本数据
X_train = np.array([[1,100], [2,250], [3,600], [4,500], [5,700]])
y_train = np.array([2.2, 3.4, 4.5, 5.7, 6.9])
X_test = np.array([[6,800]])

# XGBoost回归
xgb_reg = xgb.XGBRegressor(objective='reg:squarederror')
xgb_reg.fit(X_train, y_train)
y_pred = xgb_reg.predict(X_test)

print("XGBoost Regression Prediction:", y_pred)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

XGBoost回归是一种基于决策树的集成学习算法，并具有许多可调参数。下面是一些常用的XGBoost回归参数，以及它们的解释：

1. n_estimators（默认值：100）：表示要构建的弱学习器（决策树）的数量。
2. learning_rate（默认值：0.1）：控制每个弱学习器的权重缩放，用于减少每棵树的贡献。较小的学习率通常需要更多的弱学习器来达到更好的性能。
3. max_depth（默认值：6）：决策树的最大深度。较大的值可以使模型更复杂，容易过拟合。
4. subsample（默认值：1）：用于训练每个决策树的样本的比例。较小的值可以防止过拟合。
5. colsample_bytree（默认值：1）：用于训练每个决策树的特征的比例。较小的值可以增加模型的多样性。
6. gamma（默认值：0）：用于控制决策树分裂的阈值。较大的值可以使模型更保守。
7. reg_alpha（默认值：0）和 reg_lambda（默认值：1）：用于控制决策树的正则化项（L1和L2正则化）。它们可以帮助减少模型的复杂性。
8. objective（默认值：reg:squarederror）：定义要优化的损失函数。对于回归问题，通常使用 reg:squarederror（平方损失函数）。

以上只是一些常见的参数，XGBoost还有其他参数可供调整以优化模型性能。根据具体问题的特点和数据集的规模，可以根据需要进行调整。可以通过查阅XGBoost的文档了解更多参数及其详细解释。

四、回归模型的评估

评价回归模型的优劣可以使用多个指标和方法。下面是一些常用的评价指标：

1. 均方误差（Mean Squared Error，MSE）：计算真实值与预测值之间的平方差的平均值，用于衡量预测值与真实值的离散程度。较小的MSE值表示模型的拟合效果较好。

2. 均方根误差（Root Mean Squared Error，RMSE）：将MSE的平均值进行开平方，即MSE的平方根。RMSE与原始数据的单位相同，并且在计算中对异常值更敏感。

3. 平均绝对误差（Mean Absolute Error，MAE）：计算真实值与预测值之间的绝对差的平均值，用于衡量预测值与真实值之间的平均差异。与MSE相比，MAE更加鲁棒，不受异常值的影响。

4. 决定系数（Coefficient of Determination，R^2）：衡量模型对因变量变异的解释能力。取值范围为0到1，越接近1表示模型的拟合能力越好，越接近0表示模型的拟合能力较差。

5. 相对绝对误差（Relative Absolute Error，RAE）：计算模型预测误差与真实标签之比的平均值，用于比较模型准确性。较小的RAE值表示模型的拟合效果较好。

6. 相对平方误差（Relative Squared Error，RSE）：计算模型预测误差与真实标签平方之比的平均值，用于评估模型的准确性。较小的RSE值表示模型的拟合效果较好。

除了上述指标之外，还可以使用可视化方法来评估模型的优劣，如绘制预测值与真实值的散点图、残差图以及学习曲线等。需要根据具体问题和数据集的特点选择适合的评价指标，综合考虑多个指标来评估回归模型的优劣。

from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

# 假设真实值为y_true，预测值为y_pred

# 计算均方误差（MSE）
mse = mean_squared_error(y_true, y_pred)
print("Mean Squared Error (MSE):", mse)

# 计算均方根误差（RMSE）
rmse = mean_squared_error(y_true, y_pred, squared=False)
print("Root Mean Squared Error (RMSE):", rmse)

# 计算平均绝对误差（MAE）
mae = mean_absolute_error(y_true, y_pred)
print("Mean Absolute Error (MAE):", mae)

# 计算决定系数（R^2）
r2 = r2_score(y_true, y_pred)
print("Coefficient of Determination (R^2):", r2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

请确保在使用以上代码之前，已经导入了sklearn.metrics模块，并且将真实值y_true和预测值y_pred替换为实际的数据。并且在实际应用中，读者可以需要根据自己的需求自行选择适当的评价指标，并灵活运用其他的评价方法。例如，可以通过绘制图表等方式来可视化评估结果，以更直观地判断回归模型的优劣。