基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

决策树模型
. X* O# e7 C$ K3 P目录
人工智能第五次实验报告 1
决策树模型 1
: {# {+ g* Z* Z9 c# I( N一 、问题背景 1
: r; a' c4 Q1 F) ], D" j. R3 |1.1 监督学习简介 1
. v- F' X" l- N, `/ k7 Y# [3 `1.2 决策树简介 1
二 、程序说明 3
2.1 数据载入 3
2.2 功能函数 3
2.3 决策树模型 4
* w# I' p% A  v6 Q三 、程序测试 5
3.1 数据集说明 5
7 W( ^8 S! H) b3.2 决策树生成和测试 6
7 O# v7 o+ D7 N3 A- Q3.3 学习曲线评估算法精度 7
' G& K  I9 x6 y8 i7 D  k四 、实验总结 8
- i$ O; T, `( X附 录 - 程序代码 8
/ S* m/ N( i. `& ~7 ~/ n一 、问题背景
1.1监督学习简介
; [0 t. l8 n! S6 p( f/ q机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
+ a) z4 X% s/ _4 h) z) }7 B常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。

import numpy as np
* S/ x4 d# o( b0 h  ^+ ~" e) Efrom matplotlib import pyplot as plt
& B( Y8 d! O6 |5 G- ^- vfrom math import log
$ j4 F# j/ ]5 Yimport pandas as pd
import pydotplus as pdp
( T% a; i2 ?" {
"""
) {+ r! w/ }$ @' @' n19335286 郑有为
人工智能作业 - 实现ID3决策树
"""
1 A- g$ C2 H$ }: G7 F- V
nonce = 0  # 用来给节点一个全局ID
color_i = 0
1 K* y" H- B% [# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
color_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]

# 载入汽车数据, 判断顾客要不要买
0 n( x  s0 q/ {class load_car:
    # 在表格中,最后一列是分类结果
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
- j. Z3 c' o# q4 q  ?5 B    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
        labels = df.columns.values
        data_array = np.array(df[1:])
- r0 m; g5 ]3 ?5 I        self.feature_names = labels[0:-1]
        self.target_names = labels[-1]
        self.data = data_array[0:,0:-1]
3 M( o2 t0 M& ~  U  Z$ ~        self.target = data_array[0:,-1]
/ I2 O9 ]6 o' q8 Z) A- k& _
# 载入蘑菇数据, 鉴别蘑菇是否有毒
class load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
5 u  [+ p) c) f0 i' q) m    # feature_names: 属性名列表
" q/ ~  G: C4 d9 b    # target_names: 标签(分类)名
/ x# e: d' \9 ~) ^2 c+ Y1 m    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
& K) F2 d5 X1 @    def __init__(self):
1 k; s, e# |: ^6 T8 @: N1 V1 P        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
/ f4 K- n/ B0 ^' o        data_array = np.array(df)
        labels = ["edible/poisonous", "cap-shape", "cap-surface", "cap-color", "bruises", "odor", "gill-attachment",
                  "gill-spacing", "gill-size", "gill-color", "stalk-shape", "stalk-root", "stalk-surface-above-ring",
                  "stalk-surface-below-ring", "stalk-color-above-ring", "stalk-color-below-ring",
+ o8 Q; H9 M7 k0 X% H$ ~                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
: w# t- \9 i7 L9 o8 D& M        self.feature_names = labels[1:]
        self.target_names = labels[0]
        self.data = data_array[0:,1:]
6 ]/ l' z- A2 o3 y8 s2 J7 f9 H        self.target = data_array[0:,0]

: b6 q3 F1 M9 @; P4 L- K7 T# 创建一个临时的子数据集, 在划分测试集和训练集时使用
4 ~5 g0 |) e; k- }# V7 W8 M# Yclass new_dataset:
1 S5 }) G: E( e7 _* c' e    # feature_names: 属性名列表
    # target_names: 标签(分类)名
9 n& X) \5 Q, p" j& F9 h; @    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
! `; p" W# r) @' i1 ?$ o    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
/ }) O* f2 {6 `; p  \5 ~% I# M        self.feature_names = f_n
        self.target_names = t_n
        self.data = d
* j# ~( u- i5 @  q        self.target = t
. S) d0 F0 Z0 Y' `: j2 C
# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
( Q+ v8 O! o  s8 e/ u: t! @#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
, J! G0 j$ O- i; O# target: 分类结果的列表, return: 信息熵
% K0 z+ M2 n$ j& Ydef get_h(target):
    target_count = {}
    for i in range(len(target)):
        label = target
        if label not in target_count.keys():
            target_count[label] = 1.0
: e1 D0 a# }; M9 z. L; A1 o/ x        else:
+ v) D- b& x' A$ M6 v            target_count[label] += 1.0
    h = 0.0
    for k in target_count:
        p = target_count[k] / len(target)
9 @6 z8 g" ^9 ^2 K: t/ {2 a0 X        h -= p * log(p, 2)
    return h

, c( [% o* A7 D8 ?2 \# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
4 w$ M- q6 D5 e8 g: E# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
def get_subset(dataset, feature_name, feature_value):
    sub_data = []
1 F, f) ^4 d& |3 W    sub_target = []
    f_index = -1
    for i in range(len(dataset.feature_names)):
! I1 E( J9 k" F2 j2 f* n        if dataset.feature_names == feature_name:
' n  G! D* B9 \3 O4 S            f_index = i
9 p. l2 s5 K* e, |# @. c            break

( Y% @6 x' [4 C4 s    for i in range(len(dataset.data)):
3 b7 W* A2 Y9 r8 F; {- a        if dataset.data[f_index] == feature_value:
            l = list(dataset.data[:f_index])
! ^5 a& C; A  H, P, O& F            l.extend(dataset.data[f_index+1:])
            sub_data.append(l)
            sub_target.append(dataset.target)
" h! \6 O: L& K
9 f! W9 I3 f) i: i6 E. Y    sub_feature_names = list(dataset.feature_names[:f_index])
( p- T1 C! C+ A# K    sub_feature_names.extend(dataset.feature_names[f_index+1:])
0 z# e- V8 u) R0 A( Q    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)

# 寻找并返回信息收益最大的属性划分
. h" f! w, b+ ^& f  Z& N# 信息收益值划分该数据集前后的熵减
- w! _' [5 U- L# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
; d+ }2 r! a3 Y  U9 d: Q' ~5 Kdef best_spilt(dataset):

: v3 J; W2 x5 Y: o3 m: P, Y* o    base_h = get_h(dataset.target)
/ u/ V3 |; A7 W6 G( z: O& i# L    best_gain = 0.0
+ e+ Q1 k% }2 q    best_feature = None
    for i in range(len(dataset.feature_names)):
        feature_range = []
        for j in range(len(dataset.data)):
* U9 Z, R" V% a" Q5 l) B            if dataset.data[j] not in feature_range:
                feature_range.append(dataset.data[j])
5 a6 q" w; d+ u0 h; J& a! s
/ c8 a- }; l1 m' u7 t! K( u9 v# }        spilt_h = 0.0
        for feature_value in feature_range:
            subset = get_subset(dataset, dataset.feature_names, feature_value)
- L  Y; r; s. A            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)
& D" `( W9 H. t$ j
. o! r- @/ Z2 [& @% g        if best_gain <= base_h - spilt_h:
! q1 G/ W* _  C9 [$ I            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names
% c$ R, p$ D! y: r4 W0 ]4 D
    return best_feature

% ?* ^7 J% w1 M6 s( R" [$ J7 }# 返回数据集中一个数据最可能的标签
  U8 c$ _4 b. y5 mdef vote_most(dataset):
    target_range = {}
5 t. |8 k0 O/ c; \' T* ^" @    best_target = None
    best_vote = 0

    for t in dataset.target:
        if t not in target_range.keys():
            target_range[t] = 1
        else:
( a7 i& C# {( K( C            target_range[t] += 1

    for t in target_range.keys():
0 X% u- m/ E1 y( q  _1 `        if target_range[t] > best_vote:
            best_vote = target_range[t]
            best_target = t

    return best_target

. W; \0 ?2 f( }/ q% f# 返回测试的正确率
# predict_result: 预测标签列表, target_result: 实际标签列表
- b! a6 A" D! d/ Jdef accuracy_rate(predict_result, target_result):
% I0 x  v# X1 O3 L/ E) [( U- H    # print("Predict Result: ", predict_result)
    # print("Target Result:  ", target_result)
    accuracy_score = 0
    for i in range(len(predict_result)):
) g$ s+ r1 I# c2 H; Z        if predict_result == target_result:
            accuracy_score += 1
    return accuracy_score / len(predict_result)

# 决策树的节点结构
0 E  S3 Q( I3 D8 ^class dt_node:
  N* [7 u! o+ }
    def __init__(self, content, is_leaf=False, parent=None):
1 `1 K% }- G9 b) A& `        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
        nonce += 1
% C( j2 i% m1 B        self.feature_name = None
        self.target_value = None
        self.vote_most = None # 记录当前节点最可能的标签
# w- K, S( V" j( Q7 G7 s        if not is_leaf:
            self.feature_name = content # 非叶子节点的属性名
        else:
. O' N9 }5 R2 Y: t1 q            self.target_value = content # 叶子节点的标签
3 r8 h6 o+ ^  ]* V- h# W/ r  ?2 [" m
        self.parent = parent
0 t4 u' v. G1 a6 r5 W        self.child = {} # 以当前节点的属性对应的属性值作为键值
% p; q( y* B6 v
# 决策树模型
7 B* [+ H" k8 C  j9 eclass dt_tree:
! M: U$ r* J! }. R& E! R) ~
    def __init__(self):
        self.tree = None # 决策树的根节点
2 B2 K! c+ j/ j' Y; v; h        self.map_str = """
! Y: ~7 }* ~3 L6 I4 H1 r' Z            digraph demo{
* ?8 [9 m. g! G% V& H* ]6 F            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
            edge [fontname="Microsoft YaHei"];
* K$ n% b% i5 i% ?! q" @            """ # 用于作图: pydotplus 格式的树图生成代码结构
( S1 H; P# w/ N* `  ]        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值
% [3 X' j% W9 w6 ]
    # 训练模型, train_set: 训练集
4 \& y1 w. n0 R! c1 E8 B    def fit(self, train_set):
5 J9 w7 g* Z& p& @
+ ]; g3 n4 E+ ~7 `5 x1 C6 |3 a        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
            return None
- C) ]& i! d1 P2 M# q4 u% j
: e; V# b# j4 ~7 T1 A        target_all_same = True
        for i in train_set.target:
9 s5 H0 X7 D5 Q, ]- y            if i != train_set.target[0]:
                target_all_same = False
) h# F( q! a2 k; B                break

& {2 z5 r/ x: m( K) |) N        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
            node = dt_node(train_set.target[0], is_leaf=True)
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.tree = node
) q. m( }7 [9 {5 ]4 v- ^3 G
            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            node_content = "标签：" + str(node.target_value)
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"

            return node
        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
& a4 L! e1 S: A; M            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
( x7 |& E( k3 U" |  S, C  x5 I                self.color_dir[vote_most(train_set)] = color_set[0]
                self.tree = node
! V6 D$ S3 q* E
* U1 W" o9 F+ A8 P5 }8 _# u0 N            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            node_content = "标签：" + str(node.target_value)
* Q! K1 W+ Q( V- D2 r% [  s            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"

            return node
$ B' \/ r: j9 j: O9 T9 |1 x: M        else: # 普通情况, 构建一个内容为属性的非叶子节点
! J! ]6 `2 }8 f4 U, `2 Q  x            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
            best_feature_index = -1
            for i in range(len(train_set.feature_names)):
                if train_set.feature_names == best_feature:
                    best_feature_index = i
                    break
9 u) g( k/ u. P; N: x/ f) }: z2 |% L
% t# E8 X0 M) ]( u# X  N            node = dt_node(best_feature)
0 z- X& ]. q& z  \" h: k            node.vote_most = vote_most(train_set)
            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
                self.tree = node
                # 用于作图, 初始化叶子节点可选颜色
# K& W: X  Q  @                for i in range(len(train_set.target)):
* @2 I9 u" M8 F5 D8 F                    if train_set.target not in self.color_dir:
- `/ F3 L/ E$ r+ f( W                        global color_i
                        self.color_dir[train_set.target] = color_set[color_i]
% ?) A$ `( _8 C2 R1 P* }8 {                        color_i += 1
6 G$ O% C3 J4 i- X8 |7 Q2 T                        color_i %= len(color_set)

3 X3 F5 b" ?5 |$ S- v            feature_range = [] # 获取该属性出现在数据集中的可选属性值
" r2 K* y& W' |8 Q3 q' i4 v! h            for t in train_set.data:
& F! _( x. m4 A! d! x3 X  I                if t[best_feature_index] not in feature_range:
                    feature_range.append(t[best_feature_index])

            # 用于做图, 创建一个内容为属性的非叶子节点
/ y: {+ [! Z+ j4 [4 l+ Y            node_content = "属性：" + node.feature_name
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"

            for feature_value in feature_range:
                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
                if node.child[feature_value] == None:
6 ^0 ?& q" b) `6 O( W$ w+ i                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
6 ^5 u% X, l3 c. n- L' l                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
                node.child[feature_value].parent = node

                # 用于做图, 创建当前节点到所有子节点的连线
                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"
% e' d0 u+ f( f+ n
& M8 C9 ~6 ?2 ~1 U- m            # print("Rest Festure: ", train_set.feature_names)
            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
( D9 n) y  e% y2 U            # for feature_value in feature_range:
            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
. A$ F% Q' T$ V" W3 E            return node

3 L+ w* k/ s! w; Q; d. E    # 测试模型, 对测试集 test_set 进行预测
9 h3 `% P/ K% p2 R! y7 W) p' Q    def predict(self, test_set):
        test_result = []
        for test in test_set.data:
            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
8 \! w6 A  U: L5 U            while node.target_value == None:
9 z. ~5 N6 i% c: A7 {% K- A                feature_name_index = -1
                for i in range(len(test_set.feature_names)):
                    if test_set.feature_names == node.feature_name:
                        feature_name_index = i
                        break
                if test[feature_name_index] not in node.child.keys():
                    break
                else:
                    node = node.child[test[feature_name_index]]
9 ]4 C- E/ |& J. P7 e- h4 H, q3 t
' p9 `9 c$ a) n1 |6 J2 N. S            if node.target_value == None:
- {3 n' ^2 h( c  L' J& T! h' n& g' W                test_result.append(node.vote_most)
0 k$ ^/ _) m: X* z            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
& O: g. Q3 N" Q9 t1 s" `& Z0 d- G; m9 a                test_result.append(node.target_value)

1 Q4 P) y+ R& p        return test_result
, S7 i0 l" Z! C& W8 n
8 q+ Z0 s5 h  i7 M. D1 u4 n6 S    # 输出树, 生成图片, path: 图片的位置
    def show_tree(self, path="demo.png"):
        map = self.map_str + "}"
        print(map)
% f' }$ T8 @& g* H+ d, e        graph = pdp.graph_from_dot_data(map)
        graph.write_png(path)

# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
5 I" r3 \  [9 @7 \& `, T- Z8 j    c = dataset
' a% @8 j) p3 H1 I* h$ n" J    r = range(5, len(c.data) - 1, interval)
/ U3 L$ R3 ~5 u5 W: E9 d. E    rates = []
    for train_num in r:
        print(train_num)
        train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
# \# `# y" D8 F5 K0 t        test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
* s" o7 l- K1 [0 f0 K        dt = dt_tree()
4 E& _" i' b9 N2 _  f( c* \        dt.fit(train_set)
& c& i3 F& y! R( Y2 W1 Y( F        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))
. x, ]1 `$ z' G4 e- V) c. J
    print(rates)
    plt.plot(r, rates)
3 u- v4 G( f. d3 c. Y    plt.ylabel(label)
; T' t. {1 B: S4 m    plt.show()

if __name__ == '__main__':

    c = load_car()  # 载入汽车数据集
! `! B6 l: m( F, k/ V" \    # c = load_mushroom()  # 载入蘑菇数据集
    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
8 a2 S5 p5 N8 y3 P5 f: z0 v    train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
    test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])

2 x# o7 O) r- x* Q: [+ H: d* e    dt = dt_tree()  # 初始化决策树模型
    dt.fit(train_set)  # 训练
+ J) B2 Z8 A$ r' T    dt.show_tree("../image/demo.png") # 输出决策树图片
    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧
7 Y3 h3 k, Y3 F$ K, g2 O' h
1 t7 g" u: z$ X3 L( q    # incremental_train_scale_test(load_car(), "car")
    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)
; r( z, B7 m6 C7 l- r- B# f


1
. ]: }2 z+ M0 O( H; |9 T2
( o1 k1 r; B8 ?+ T- X3
1 D6 @% K$ k% b8 f4
3 \6 k% r6 [- N7 E3 T1 l5
6
9 R9 v7 y+ l1 X5 ^7
8
" w" F/ ?$ O1 X' e2 h9
10
11
' ~8 D" `; \2 ^# Z, h12
" Q" G) A. D" ]13
7 q) B7 W( N, v( X8 j" C5 p14
15
16
4 a8 t) q! l( T6 r7 Z17
$ L! S+ p3 e7 J- B8 l% V18
19
20
  }$ n. w3 ?# x( f21
22
, u. i* _9 B& A1 ^23
% O3 R: o4 m# K. W  ?24
25
! ^7 d: P/ f1 _! c  j4 V26
27
28
4 x6 m% i4 j! C, @, ~" J5 g1 D29
30
31
32
( a; K) ?7 J# ]- z/ J3 B33
34
6 |. p2 e6 g: l7 \( V  |$ D$ X35
9 N5 M: a1 l$ ?1 e: n36
37
38
39
* v( A7 R& M/ @& {9 A40
: X7 H. c* w* k3 q: ?41
42
43
44
1 D7 Y  @3 p( n" E45
46
47
48
49
50
5 S3 R% I/ T) B2 ^% q' {- d, ]51
52
' ]* \! k2 S% }53
9 _' m; U& W$ p% j( k54
55
56
3 H; R% L% u  M* F2 r57
3 e2 L- n5 C: C5 t58
1 a$ m3 U. N1 B59
60
61
, Z/ L2 S1 W  z% s: M0 F1 |8 F' k62
8 `. u. r6 X( |5 t4 G- z) Z& O' ?63
( E; U# q& n& `$ G7 N# `64
65
# z$ W1 Z( Q4 G; F% \66
67
68
9 n% G* G4 z2 O6 T9 L69
70
! l( n" t* V5 P71
8 o7 F2 s  j# V9 X6 ?' Q6 a72
- Y/ a& D5 p$ }; r+ ]$ Z73
74
75
! E4 p( H, b% e) H+ e76
0 W3 O" b$ M! |) P, |77
78
- w1 L  t' S$ k8 I+ c# D79
' Q" ~: e3 S/ m3 X( m) n80
81
% t' u  O; E. p* ?, q82
6 i- s. S* V& i) S/ ]  Y83
6 b. O+ G) c. m2 D84
85
86
- E0 t8 `$ |& F" U87
# t5 ?% n/ Z0 n1 N88
- E) B- ^8 u# R- A" r+ X; Q( G/ D3 @89
90
' d! W  f: w/ E( R" L91
6 H' P. K: U# i92
93
" U1 q0 S- ~/ |6 z! Q, n8 {0 ]94
95
. ^5 N$ C/ ^. ~/ y& p+ M0 K96
97
2 P2 J2 O3 S+ y98
99
' u7 o" `: C+ g# B: z3 p6 |" F100
101
102
' Y6 O. q* ?, O& O* \% B9 A/ q103
104
105
106
107
108
109
6 U: T- v; R( `110
! q# F& w: L; h1 o5 {+ J3 S111
' k$ a* `5 G& h1 g5 f$ V112
113
$ X0 ~/ B6 N0 B$ J3 x114
' ^" j$ b* I% k' u115
116
117
118
9 c9 m* Y  H% h6 V119
$ j; H5 m& G  d1 ^3 u120
121
7 S7 I( a& O8 e9 ?$ l2 [) p122
123
. |, Y1 U4 J, y124
$ O) c5 M! i/ Z" i9 h& F- e4 r0 K6 D125
  P4 t' _( ~/ G" d/ Z7 e0 I7 e$ V126
/ \+ {2 }' |1 D2 {127
5 A" e2 \/ G* F2 T( C128
& f. H, X- F8 x1 E129
130
131
132
7 T% H* G7 ]- s1 c6 e. z133
4 \3 g# n! Z! U- P- H9 f134
" \" S3 W' j4 d; |# f) t; S4 ^135
" }: m, R0 _2 D( n" q. O* Z136
# D+ g% A" y8 S/ d! p! A, T137
7 f: F" ?) l- I! S3 Z; y+ ]: A! ^, {3 t) X138
- J6 S, `' \8 t1 i& Q1 T' k139
140
$ ?) h% R& z2 f% J; m/ u2 g141
142
. W" b2 B6 M! S: Q6 K143
144
145
146
147
* r1 s8 u7 v+ I9 d) h3 S6 `; ]148
5 D0 \" ?* o% o* N149
150
151
152
153
2 \9 S- t# C1 n/ A; B' p154
155
156
157
, g6 L8 j+ L- g' z" f1 q158
, Q3 O  y3 N7 X/ D/ V159
160
161
# x5 s( O5 R" ?. Q8 v162
163
) D9 u7 t5 ]. m5 U164
165
166
0 L* l! G/ [5 ~) v167
& W3 f, ?/ s( i. M( h% c8 h168
169
0 k0 K4 \2 x+ z* I3 Q+ b170
3 b) ?$ n( N0 q* X4 A8 L171
172
, y) l$ b/ @; K+ s. c0 V8 p, {6 N5 m1 F173
174
7 F5 }1 ]) ], \; `175
7 ~$ }+ d; f3 g176
! D3 Y6 G) b8 M. G* t177
178
9 E) U: H4 m& ~( B& n6 H9 }2 l179
180
) b/ A2 v- [2 F; Y" |+ V5 b181
& x, D+ H8 t: s" y182
' s2 D/ u6 \, \183
( ?) Y) V0 m6 B2 o) p0 n5 |184
/ J. @. G. g7 y3 S( ?185
186
187
2 h9 C7 [+ f- ?# Q188
8 f8 a# W9 T4 b' ^* j4 A6 C  J7 A189
190
191
# K6 e1 ]+ c. G# Z- ?+ H* m5 ^192
193
194
195
196
197
3 Z, ?8 {; t, M) K) Z198
; Z  ?# A& h* l199
& E7 I) t# p) N! l% t7 `200
8 i4 x2 c$ n4 @6 j. ^) _1 O" k201
202
- n4 w& j$ P* ?- Z203
204
205
206
207
1 r- V8 K' ^- d, V, q+ z208
209
4 j4 Z. J6 `1 _: b7 @1 \210
211
212
0 N4 B% w' V. _* U( e* L213
214
! S, \+ F- I" F2 q- b5 @9 M- O215
216
217
218
219
. [6 H0 ~5 b4 _' I' x220
6 s3 C) L1 N7 f! n& R1 A- |221
- ?. e& l  |9 d  D5 [& f3 `222
6 h% a- B$ b" \, F. W223
" ]% {7 c/ D  ]/ k( K224
225
( t2 n1 x' j9 z226
* w8 F; t6 j, P5 m' t( X227
228
: r& z; X0 ?, t' Y  v229
8 q9 Q1 ?5 s' w2 D230
231
6 X  B6 c0 M0 ^" X9 M6 N7 Q232
4 s) `1 M1 x, N233
# [% x" ^2 v& d) L) Q$ {  P9 P234
235
' J5 ~6 s9 t( g( y0 V236
237
5 l* y9 F6 W2 }9 p* [8 Q238
239
$ v  v9 [0 S4 s7 S" N240
8 P* i1 d) y* b  |% l, W, ?241
! `  |' j$ K9 R# A; P3 ~$ s& ~' p, h3 S242
243
244
245
/ l: o3 ~) |* R# r+ a5 T' f' H246
0 r8 \  h/ l2 F- {' c( f  n247
248
8 T: l6 ]* s8 [- g249
+ ^6 I! T; F) o$ m. K; x250
2 D% u4 s. B" H+ g251
252
253
254
255
: b, u# I& C# _3 ?7 @. g256
257
  x9 b' f( V7 J258
% L3 d5 `0 |: b  X% N: {259
260
: f6 k2 D6 U* N261
262
263
264
265
0 u0 S. j: j) E6 I) \. a2 p266
267
268
" T6 J3 i/ [, K) h! H. b7 Q269
270
271
: o. A8 O0 D$ m0 w, V* p; c6 o0 Q272
0 G2 l7 ]3 M0 O$ F! P2 W273
6 f: C& O' V' ^274
1 x4 a3 @: t2 U" K5 D275
4 ]  v8 a( Y5 H! i276
1 A" q8 c/ q+ @* u0 T1 y  D277
8 W1 W4 ?  H1 c. B: q* t& _278
279
' k9 v. C( m8 D' f+ A280
281
8 s  i2 q, r# |4 o* l2 o" `282
283
1 Y# o* t9 `' {2 K9 x284
* W$ n) }: q0 P( \; ]: ?& _1 O285
286
287
288
289
" |. s  j2 U) \290
+ o) @- X$ m( F0 ^8 D( _, V: B291
292
& Q8 L8 S5 V& r! D293
294
$ B% I9 t% I$ c* m: J8 W6 c295
296
297
298
' p1 S0 y: h- p, z299
300
' r" L% v* R- X9 O301
302
& q; ?  i) A5 U" o  x7 K303
304
305
306
0 U' \/ }, n* A4 u9 v307
2 E5 y/ W( x) u) j0 B% Y% n& D308
5 ~) c1 R# p  I9 n: [; r# n( e309
4 x; H- |7 g8 I# w' g# ]310
311
312
; Z' n  q7 T) e313
314
315
316
317
318
. {. p# j4 c' D, j5 W319
  _8 q& P6 R3 u  g7 i- w7 s9 v320
321
4 Q. V# P& Y- v$ f2 P% k. I322
323
; G4 b  ?2 L. g# J- [5 l2 ?6 y324
325
326
327
( H' k1 S4 e; m7 U  [# M6 f328
329
) t9 I  n& G4 X& \! G9 W330
' y1 K" {8 [( f331
* P  h6 J5 M, N/ ~( G7 d
- w  M, h7 i- ]& W) a1 L' n
/ _; I4 J2 _7 _: I2 }7 d: C8 D
5 I& i( L4 T+ T) k. z: m
  m& E+ F3 u9 x1 l* y! i! X

# D$ |9 S6 w) ?' W

  F( B% n, m) F0 Q" ]+ Y
- A8 S, ~: T+ K+ y. j4 n6 o" F
- v& P) _& |* |* A: `  T+ S! |* }

! H; @- {4 M) p8 `- O! y————————————————
( n: D# c5 }$ I- [( V7 {9 c  z版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
2 _/ _! A! m9 m# G原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242
0 r7 z' V) b6 j" ]9 ~" A1 b: E
8 z+ \. r2 Y9 G* y6 b# `