用于分类和回归的非监督学习方法，通过简单的决策规则（if-else）预测目标

优缺点

• 思想简单，可视乎表达，易理解，可以处理多分类问题
• 可能会过拟合，此时需要剪枝、采用设置最小样本数目或树的深度
• 基于启发式算法，节点采用贪婪算法（局部最优），不能保证全局最优，可以随机抽取样本，训练多个树
• 过于复杂的概念，无法表达

决策树 CART

CART: classifcation and regression tree

irsi数据集构建分类决策树

from sklearn.datasets import load_iris
from sklearn import tree

#加载iris数据集
iris = load_iris()
clf = tree.DecisionTreeClassifier()
clf = clf.fit(iris.data, iris.target)
import pydotplus
dot_data = tree.export_graphviz(clf, out_file=None)
#dot_data = tree.export_graphviz(clf, out_file=None,
                              feature_names=iris.feature_names,
                              class_names=iris.target_names,
                              filled=True, rounded=True,
                              special_characters=True)
graph = pydotplus.graph_from_dot_data(dot_data)
#导出决策树
graph.write_pdf(“iris.pdf”)
#Image(graph.create_png())

sklearn example

import numpy as np
import matplotlib.pyplot as plt

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
Parameters
n_classes = 3
plot_colors = “ryb”
plot_step = 0.02
Load data
iris = load_iris()
for pairidx, pair in enumerate([[0, 1], [0, 2], [0, 3],
                                [1, 2], [1, 3], [2, 3]]):
    # We only take the two corresponding features
    X = iris.data[:, pair]
    y = iris.target
# Train
clf = DecisionTreeClassifier().fit(X, y)

Plot the decision boundary
plt.subplot(2, 3, pairidx + 1)
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, plot_step),
                     np.arange(y_min, y_max, plot_step))
plt.tight_layout(h_pad=0.5, w_pad=0.5, pad=2.5)
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
cs = plt.contourf(xx, yy, Z, cmap=plt.cm.RdYlBu)
plt.xlabel(iris.feature_names[pair[0]])
plt.ylabel(iris.feature_names[pair[1]])
Plot the training points
for i, color in zip(range(n_classes), plot_colors):
    idx = np.where(y == i)
    plt.scatter(X[idx, 0], X[idx, 1], c=color, label=iris.target_names[i],
                cmap=plt.cm.RdYlBu, edgecolor=’black’, s=15)

plt.suptitle(“Decision surface of a decision tree using paired features”)
plt.legend(loc=’lower right’, borderpad=0, handletextpad=0)
plt.axis(“tight”)
plt.show()

链接：https://scikit-learn.org/stable/auto_examples/tree/plot_iris.html#sphx-glr-auto-examples-tree-plot-iris-py

决策树回归

max_depth：图的深度，值太大会导致过拟合

# Import the necessary modules and libraries
import numpy as np
from sklearn.tree import DecisionTreeRegressor
import matplotlib.pyplot as plt

Create a random dataset
rng = np.random.RandomState(1)
X = np.sort(5 * rng.rand(80, 1), axis=0)
y = np.sin(X).ravel() #学习sin曲线
y[::5] += 3 * (0.5 - rng.rand(16)) #干扰值
Fit regression model
regr_1 = DecisionTreeRegressor(max_depth=2)
regr_2 = DecisionTreeRegressor(max_depth=5)
regr_1.fit(X, y)
regr_2.fit(X, y)
Predict
X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]
y_1 = regr_1.predict(X_test)
y_2 = regr_2.predict(X_test)
Plot the results
plt.figure()
plt.scatter(X, y, s=20, edgecolor=”black”,
            c=”darkorange”, label=”data”)
plt.plot(X_test, y_1, color=”cornflowerblue”,
         label=”max_depth=2”, linewidth=2)
plt.plot(X_test, y_2, color=”yellowgreen”, label=”max_depth=5”, linewidth=2)
plt.xlabel(“data”)
plt.ylabel(“target”)
plt.title(“Decision Tree Regression”)
plt.legend()
plt.show()

链接：https://scikit-learn.org/stable/auto_examples/tree/plot_tree_regression.html#sphx-glr-auto-examples-tree-plot-tree-regression-py

多输出问题

import numpy as np
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeRegressor

Create a random dataset
rng = np.random.RandomState(1)
X = np.sort(200 * rng.rand(100, 1) - 100, axis=0)
y = np.array([np.pi * np.sin(X).ravel(), np.pi * np.cos(X).ravel()]).T #输出X正弦 余弦
y[::5, :] += (0.5 - rng.rand(20, 2)) #干扰
Fit regression model
regr_1 = DecisionTreeRegressor(max_depth=2)
regr_2 = DecisionTreeRegressor(max_depth=5)
regr_3 = DecisionTreeRegressor(max_depth=8)
regr_1.fit(X, y)
regr_2.fit(X, y)
regr_3.fit(X, y)
Predict
X_test = np.arange(-100.0, 100.0, 0.01)[:, np.newaxis]
y_1 = regr_1.predict(X_test)
y_2 = regr_2.predict(X_test)
y_3 = regr_3.predict(X_test)
Plot the results
plt.figure()
s = 25
plt.scatter(y[:, 0], y[:, 1], c=”navy”, s=s,
            edgecolor=”black”, label=”data”)
plt.scatter(y_1[:, 0], y_1[:, 1], c=”cornflowerblue”, s=s,
            edgecolor=”black”, label=”max_depth=2”)
plt.scatter(y_2[:, 0], y_2[:, 1], c=”red”, s=s,
            edgecolor=”black”, label=”max_depth=5”)
plt.scatter(y_3[:, 0], y_3[:, 1], c=”orange”, s=s,
            edgecolor=”black”, label=”max_depth=8”)
plt.xlim([-6, 6])
plt.ylim([-6, 6])
plt.xlabel(“target 1”)
plt.ylabel(“target 2”)
plt.title(“Multi-output Decision Tree Regression”)
plt.legend(loc=”best”)
plt.show()

链接：https://scikit-learn.org/stable/auto_examples/tree/plot_tree_regression_multioutput.html#sphx-glr-auto-examples-tree-plot-tree-regression-multioutput-py

不确定性程度的物理量

自封闭系统的运动向均匀分布—熵总是增加的

信息熵（Entropy）是一种用于衡量随机变量不确定性的度量。在信息论中，熵表示一个随机变量的不确定性或信息量。对于分类问题，熵越高，表示随机变量的不确定性越大，即数据分布越均匀。

信息熵的计算公式如下：

[ H(X) = -\sum_{i=1}^{n} P(x_i) \cdot \log_2(P(x_i)) ]

其中，( n ) 是类别数，( P(x_i) ) 是随机变量 ( X ) 取值为 ( x_i ) 的概率。

以下是一个使用Python实现信息熵计算的示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import numpy as np

def entropy(probabilities):
    # 避免概率为0时取对数导致无限大
    epsilon = 1e-15
    probabilities = np.clip(probabilities, epsilon, 1 - epsilon)
    entropy = -np.sum(probabilities * np.log2(probabilities))
    return entropy

# 示例概率分布
probabilities = np.array([0.2, 0.3, 0.5])

# 计算信息熵
entropy_value = entropy(probabilities)
print("Entropy:", entropy_value)

在上述代码中，我们定义了一个entropy函数，接受概率分布作为输入，并计算信息熵。为了避免取对数时出现无限大，我们使用了一个小的epsilon值进行裁剪。然后，通过对概率分布与对数化后的概率分布进行元素级相乘，最后取负数并求和，得到信息熵值。

信息熵可以用于决策树等算法中，用于选择合适的特征进行数据分割，从而达到更好的分类效果。

联合熵

条件熵

信息增益

ID3

信息增益率

C4.5

gini系数

CART

互信息

交叉验证（Cross-Validation）是一种评估机器学习模型性能的方法，通过将数据集分成训练集和验证集来进行多次训练和测试。它有助于更准确地估计模型在未见过数据上的性能，并避免对单一验证集的过度拟合。

常见的交叉验证方法包括K折交叉验证和留一交叉验证。其中，K折交叉验证将数据集分成K个子集，依次将每个子集作为验证集，其余作为训练集，重复K次；留一交叉验证是K折交叉验证的特例，其中K等于数据集大小。交叉验证的结果通常是各次验证的平均性能。

以下是一个使用Python实现K折交叉验证的示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
from sklearn.svm import SVC

# 加载鸢尾花数据集
iris = load_iris()
X, y = iris.data, iris.target

# 创建SVM分类器
svm_model = SVC(kernel='linear', C=1.0, random_state=42)

# 进行5折交叉验证
scores = cross_val_score(svm_model, X, y, cv=5)  # cv参数指定折数

print("Cross-Validation Scores:", scores)
print("Mean Score:", scores.mean())

在上述代码中，我们使用load_iris函数加载鸢尾花数据集，并创建了一个线性SVM分类器。然后，使用cross_val_score函数进行5折交叉验证，得到每次验证的性能分数。最后，我们打印出各次分数和平均分数。

通过交叉验证，可以更准确地估计模型的性能，并对模型进行调参。

交叉熵（Cross-Entropy）是一种常用的损失函数，用于衡量实际概率分布与预测概率分布之间的差异。在分类问题中，交叉熵可以用于衡量模型预测结果与真实标签之间的距离，从而进行模型的优化。

以下是一个使用Python实现交叉熵计算的示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import numpy as np

def cross_entropy(y_true, y_pred):
    epsilon = 1e-15  # 用于避免取对数时出现无限大
    y_pred = np.clip(y_pred, epsilon, 1 - epsilon)  # 对预测结果进行裁剪
    ce = -np.sum(y_true * np.log(y_pred))
    return ce

# 真实标签和预测概率分布
y_true = np.array([0, 1, 0, 0])
y_pred = np.array([0.1, 0.6, 0.2, 0.1])

# 计算交叉熵
ce = cross_entropy(y_true, y_pred)
print("Cross-Entropy:", ce)

在上述代码中，我们定义了一个cross_entropy函数，接受真实标签和预测概率分布作为输入，并计算交叉熵。为了避免取对数时出现无限大，我们使用了一个小的epsilon值进行裁剪。然后，通过对真实标签与对数化后的预测概率分布进行元素级相乘，最后对结果取负数并求和，得到交叉熵值。

请注意，上述代码示例只是一个简单的交叉熵计算实现。在实际应用中，您可能需要处理更多情况，例如多类别问题、批量计算等。在深度学习中，交叉熵常作为损失函数，在优化过程中用于衡量预测结果与真实标签之间的误差。

分类

• 基于字典、词库匹配
• 基于词频度统计
• 基于知识理解

字典、词库匹配

中文复杂、丰富，词典、词库匹配无法有效处理大规模文本分词处理

1. 逐词遍历法：全字典遍历一遍，效率低，不适用于大系统
2. 机械分词法

最大正向匹配法

假定词典词最大长度为i,被处理文档的当前字串中的前i个字作为匹配字段，匹配成功，则切分出来，匹配失败，则i-1，继续匹配，若成功则i+1，知道文档处理完成

逆向最大匹配法

文档逆序处理，通过逆序词典匹配，汉语中偏正结构较多，若从后向前匹配，可以适当提高精确度，逆向最大匹配法比正向最大匹配法的误差要小

最少切分法

使每一句中切出的词数最小

双向匹配法

将正向最大匹配法与逆向最大匹配法组合，如果两种分词方法得到的匹配结果相同，则认为分词正确，否则，按最小集处理

词频统计

考虑到相邻字词关系、词频、共现信息，有较好的实用性

全切分和基于词的频度统计的分词方法

基于词的频度统计的分词方法是一种全切分方法

全切分要求获得输入序列的所有可接受的切分形式，而部分切分只取得一种或几种可接受的切分形式，由于部分切分忽略了可能的其他切分形式，所以建立在部分切分基础上的分词方法不管采取何种歧义纠正策略，都可能会遗漏正确的切分，造成分词错误或失败。而建立在全切分基础上的分词方法，由于全切分取得了所有可能的切分形式，因而从根本上避免了可能切分形式的遗漏，克服了部分切分方法的缺陷。

问题：

1. 全切分算法只是能获得正确分词的前提，因为全切分不具有歧义检测功能，最终分词结果的正确性和完全性依赖于独立的歧义处理方法，如果评测有误，也会造成错误的结果。

2. 全切分的切分结果个数随句子长度的增长呈指数增长，一方面将导致庞大的无用数据充斥于存储数据库；另一方面当句长达到一定长度后，由于切分形式过多,造成分词效率严重下降。

解决方案：

基于词的频度统计的分词方法：

这是一种全切分方法。它不依靠词典,而是将文章中任意两个字同时出现的频率进行统计,次数越高的就可能是一个词。它首先切分出与词表匹配的所有可能的词,运用统计语言模型和决策算法决定最优的切分结果。它的优点在于可以发现所有的切分歧义并且容易将新词提取出来。

基于知识理解

基于句法、语法分析，并结合语义分析，通过对上下文内容所提供信息的分析对词进行定界，它通常包括三个部分：分词子系统、句法语义子系统、总控部分。在总控部分的协调下，分词子系统可以获得有关词、句子等的句法和语义信息来对分词歧义进行判断。这类方法试图让机器具有人类的理解能力，需要使用大量的语言知识和信息。由于汉语语言知识的笼统、复杂性，难以将各种语言信息组织成机器可直接读取的形式。因此目前基于知识的分词系统还处在试验阶段。

并行分词方法

并行分词方法：这种分词方法借助于一个含有分词词库的管道进行 ,比较匹配过程是分步进行的 ,每一步可以对进入管道中的词同时与词库中相应的词进行比较 ,由于同时有多个词进行比较匹配 ,因而分词速度可以大幅度提高。这种方法涉及到多级内码理论和管道的词典数据结构。（详细算法可以参考吴胜远的《并行分词方法的研究》。）

在Python中，有许多库可以用于中文分词，其中最常用的是jieba库。以下是一个使用jieba库进行中文分词的示例代码：

首先，确保已安装 jieba 库，可以通过以下命令安装：

1

pip install jieba

接下来，使用下面的代码示例：

1
2
3
4
5
6
7
8
9
10

import jieba

# 输入文本
text = "今天天气不错，适合出去玩。"

# 使用jieba分词
seg_list = jieba.cut(text, cut_all=False)  # cut_all=False表示精确模式分词
seg_result = " ".join(seg_list)

print("分词结果:", seg_result)

在上述代码中，我们使用了jieba.cut函数对输入文本进行中文分词。设置cut_all=False表示使用精确模式进行分词。然后，将分词结果用空格连接起来并打印出来。

jieba库支持更多的分词模式、自定义词典、停用词过滤等功能，以及支持并行分词，适用于不同的应用场景。在实际应用中，您可以根据需求对分词结果进行后续处理，比如进行文本分析、情感分析等。

XGBoost（eXtreme Gradient Boosting）是一种梯度提升树算法，被广泛应用于机器学习竞赛和实际项目中。它在GBDT的基础上进行了改进，引入了正则化项、并行处理、稀疏数据优化等特性，以提高模型的性能和泛化能力。

以下是一个使用Python的xgboost库实现XGBoost的示例代码：

首先，确保已安装 xgboost 库，可以通过以下命令安装：

1

pip install xgboost

接下来，使用下面的代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import xgboost as xgb
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 加载鸢尾花数据集
iris = load_iris()
X, y = iris.data, iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 构建XGBoost分类器
xgb_model = xgb.XGBClassifier(objective='multi:softmax', num_class=3, random_state=42)

# 训练模型
xgb_model.fit(X_train, y_train)

# 在测试集上进行预测
y_pred = xgb_model.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print("XGBoost Accuracy:", accuracy)

在上述代码中，我们使用了load_iris函数加载鸢尾花数据集，并将数据集划分为训练集和测试集。然后，我们创建了一个XGBoost分类器（XGBClassifier），并使用fit方法训练模型。接着，我们在测试集上进行预测并计算准确率。

XGBoost有很多参数可以调整，包括树的深度、学习率、子样本比例、正则化项等。您可以根据实际问题进行调参，以达到更好的性能。请注意，XGBoost还支持回归问题，以及对稀疏数据和缺失值的处理。

参考: [博客 xgboost原理]( https://www.cnblogs.com/zhouxiaohui888/p/6008368.html “xgboost”）

参考: github xgboost学习

在特征空间上找到最佳的分离超平面使得训练集上正负样本间隔最大

用来解决二分类问题的有监督学习算法

引入了核方法之后SVM也可以用来解决非线性问题

类型

• 硬间隔支持向量机（线性可分支持向量机）：当训练数据线性可分时，可通过硬间隔最大化学得一个线性可分支持向量机。
• 软间隔支持向量机：当训练数据近似线性可分时，可通过软间隔最大化学得一个线性支持向量机。
• 非线性支持向量机：当训练数据线性不可分时，可通过核方法以及软间隔最大化学得一个非线性支持向量机。

支持向量机（Support Vector Machine，SVM）是一种常用的机器学习算法，主要用于分类和回归问题。SVM的核心思想是通过找到一个超平面（或者更一般地说，一个线性决策边界），将不同类别的数据点尽可能分开，同时最大化支持向量与超平面的距离（即间隔）。在分类问题中，SVM的目标是找到一个最优的超平面，使得不同类别的数据点都尽可能远离这个超平面。

以下是一个使用Python和scikit-learn库实现SVM的示例代码：

首先，确保已安装 scikit-learn 库，可以通过以下命令安装：

1

pip install scikit-learn

接下来，使用下面的代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

# 加载鸢尾花数据集
iris = datasets.load_iris()
X, y = iris.data, iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建SVM分类器
svm_model = SVC(kernel='linear', C=1.0, random_state=42)

# 训练模型
svm_model.fit(X_train, y_train)

# 在测试集上进行预测
y_pred = svm_model.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print("SVM Accuracy:", accuracy)

在上述代码中，我们使用了datasets.load_iris函数加载鸢尾花数据集，并将数据集划分为训练集和测试集。然后，我们创建了一个线性SVM分类器（SVC），使用fit方法训练模型。接着，我们在测试集上进行预测并计算准确率。

您可以通过调整参数（例如核函数、惩罚参数C等）来进一步优化SVM模型的性能。注意，SVM算法不仅适用于二元分类问题，还可以扩展到多类别分类和回归问题。

参考: svm

Softmax回归是一种用于多类别分类的线性模型。它在输出层使用了Softmax函数，将线性组合的原始分数转化为类别的概率分布，从而进行多类别分类。Softmax回归常用于机器学习中的分类任务，尤其是在神经网络中作为输出层来处理多类别分类问题。

以下是一个使用Python和TensorFlow库实现Softmax回归的简单示例代码：

首先，确保已安装 tensorflow 库，可以通过以下命令安装：

1

pip install tensorflow

接下来，使用下面的代码示例：

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

import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score

# 加载鸢尾花数据集
iris = load_iris()
X, y = iris.data, iris.target

# 数据预处理
scaler = StandardScaler()
X = scaler.fit_transform(X)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 构建Softmax回归模型
model = tf.keras.models.Sequential([
    tf.keras.layers.Input(shape=(4,)),  # 输入层
    tf.keras.layers.Dense(3, activation='softmax')  # 输出层，3个类别
])

# 编译模型
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# 训练模型
model.fit(X_train, y_train, epochs=100, batch_size=16, verbose=1)

# 在测试集上进行预测
y_pred = model.predict(X_test)
y_pred_classes = y_pred.argmax(axis=1)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred_classes)
print("Accuracy:", accuracy)

在上述代码中，我们使用load_iris函数加载鸢尾花数据集，并进行数据预处理。然后，我们构建了一个包含输入层和输出层的Softmax回归模型。通过compile方法来指定优化器和损失函数。接着，使用fit方法来训练模型。最后，我们在测试集上进行预测并计算准确率。

请注意，这只是一个简单的Softmax回归实现示例。在实际应用中，您可能需要考虑更复杂的模型结构、超参数调整以及更多的优化。

ResNet（Residual Network）是一个深度卷积神经网络架构，由Kaiming He等人在2015年提出。它通过使用残差块（Residual Block）来解决深层网络的退化问题，允许在训练更深的神经网络时仍然能够获得更好的性能。

ResNet引入了”跳跃连接”或”残差连接”的概念，即通过将前一层的输出直接添加到后续层的输出中，以便网络能够学习残差（剩余部分）。这种结构有助于避免梯度消失和梯度爆炸问题，使网络更容易优化。ResNet的核心思想是：通过层与层之间的直接捷径，网络可以学习原始输入和残差之间的映射，从而更轻松地适应更深的层次。

深度网络的退化问题至少说明深度网络不容易训练。但是我们考虑这样一个事实：现在你有一个浅层网络，你想通过向上堆积新层来建立深层网络，一个极端情况是这些增加的层什么也不学习，仅仅复制浅层网络的特征，即这样新层是恒等映射（Identity mapping）。在这种情况下，深层网络应该至少和浅层网络性能一样，也不应该出现退化现象。好吧，你不得不承认肯定是目前的训练方法有问题，才使得深层网络很难去找到一个好的参数。

这个有趣的假设让何博士灵感爆发，他提出了残差学习来解决退化问题。对于一个堆积层结构（几层堆积而成）当输入为时其学习到的特征记为，现在我们希望其可以学习到残差，这样其实原始的学习特征是。之所以这样是因为残差学习相比原始特征直接学习更容易。当残差为0时，此时堆积层仅仅做了恒等映射，至少网络性能不会下降，实际上残差不会为0，这也会使得堆积层在输入特征基础上学习到新的特征，从而拥有更好的性能。残差学习的结构如图4所示。这有点类似与电路中的“短路”，所以是一种短路连接（shortcutconnection）。

以下是一个使用Python和TensorFlow库实现ResNet的简化版本的示例代码：

首先，确保已安装 tensorflow 库，可以通过以下命令安装：

1

pip install tensorflow

接下来，使用下面的代码示例：

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
44
45
46

import tensorflow as tf
from tensorflow.keras.layers import Input, Conv2D, BatchNormalization, ReLU, Add, GlobalAveragePooling2D, Dense
from tensorflow.keras.models import Model

def residual_block(x, filters, kernel_size=3, stride=1):
    shortcut = x
    # 第一个卷积层
    x = Conv2D(filters, kernel_size, strides=stride, padding='same')(x)
    x = BatchNormalization()(x)
    x = ReLU()(x)
    # 第二个卷积层
    x = Conv2D(filters, kernel_size, strides=1, padding='same')(x)
    x = BatchNormalization()(x)
    # 添加残差连接
    if stride != 1 or shortcut.shape[-1] != filters:
        shortcut = Conv2D(filters, kernel_size=1, strides=stride, padding='valid')(shortcut)
        shortcut = BatchNormalization()(shortcut)
    x = Add()([x, shortcut])
    x = ReLU()(x)
    return x

def build_resnet(input_shape, num_classes, num_blocks_list):
    input_layer = Input(shape=input_shape)
    x = Conv2D(64, 7, strides=2, padding='same')(input_layer)
    x = BatchNormalization()(x)
    x = ReLU()(x)
    x = tf.keras.layers.MaxPooling2D(pool_size=3, strides=2, padding='same')(x)

    for num_blocks in num_blocks_list:
        for _ in range(num_blocks):
            x = residual_block(x, 64)
    
    x = GlobalAveragePooling2D()(x)
    x = Dense(num_classes, activation='softmax')(x)
    
    model = Model(inputs=input_layer, outputs=x)
    return model

# 构建ResNet模型
input_shape = (224, 224, 3)  # 输入图像大小
num_classes = 1000  # 分类类别数
num_blocks_list = [2, 2, 2, 2]  # 每个stage的残差块数量
resnet_model = build_resnet(input_shape, num_classes, num_blocks_list)

# 打印模型结构
resnet_model.summary()

在上述代码中，我们定义了一个residual_block函数来实现残差块的构建，然后使用build_resnet函数来构建简化版本的ResNet模型。通过设置不同的num_blocks_list，可以调整每个stage中的残差块数量。最终，我们打印出ResNet模型的结构概要。