基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

决策树模型
目录
' {) ^; f2 Y! j! V. @# t+ f人工智能第五次实验报告 1
6 u$ R/ e& P, y决策树模型 1
一 、问题背景 1
! v* k/ Q3 a7 K9 ?1.1 监督学习简介 1
& H% x7 q8 N' V2 k. U$ r% a7 d0 g1.2 决策树简介 1
( Q7 p2 w! o/ F! A7 Z5 q二 、程序说明 3
( p+ U1 V/ ]6 G2.1 数据载入 3
2.2 功能函数 3
+ h) H( y" K/ ]- u. B+ `$ G; t2.3 决策树模型 4
, t. ?" a' L7 b" w+ \  ~5 [$ ~6 l三 、程序测试 5
3.1 数据集说明 5
% n5 y! a* P$ B; f3.2 决策树生成和测试 6
; {% E' l+ p/ ]; C, m/ ~9 M3.3 学习曲线评估算法精度 7
四 、实验总结 8
附 录 - 程序代码 8
一 、问题背景
# T# E; N1 h6 D9 F" \7 o1.1监督学习简介
! N; k" ]0 _" b/ D机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
# ^# t- M& d9 D. q$ N+ v6 }" Z监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
, ~! ~% m6 G9 o$ k. e# J1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
! u/ F% C, p; m8 |
- H$ q. I8 r3 p& G* Timport numpy as np
( m' ?9 g7 C! L* d- H# Qfrom matplotlib import pyplot as plt
7 O, t: L5 o* [* Rfrom math import log
' ?: \# i; G! C1 U( ~( iimport pandas as pd
- I1 u5 O3 h, h9 B/ simport pydotplus as pdp

"""
% J, v0 |/ i4 {2 y9 q0 V19335286 郑有为
. F: ]; A% A7 R% N人工智能作业 - 实现ID3决策树
: `1 c2 ~, y, m) d0 S9 p+ F"""
5 |: J3 a& ^2 Y' _- W
2 n7 w+ T% W) m8 r4 gnonce = 0  # 用来给节点一个全局ID
# b) t$ t6 W7 c7 ^: b* ycolor_i = 0
8 o( \# r) c( }7 N! p# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
color_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]

* {0 Q4 g( |! Z2 t3 \( N# 载入汽车数据, 判断顾客要不要买
2 H7 L% u( R0 s* h# f+ l* ^) Rclass load_car:
" M# E) }  M! v9 P    # 在表格中,最后一列是分类结果
2 h, P  @) L2 a$ D* T% p- t    # feature_names: 属性名列表
) U  r! x( h+ r5 \/ H6 U8 v2 J    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
) E7 T5 y2 g" ^0 Y2 e/ U    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
1 ^6 a( ^( p) h1 g1 q! l        labels = df.columns.values
3 K3 _, ^' n. [- P, F        data_array = np.array(df[1:])
        self.feature_names = labels[0:-1]
1 w1 L/ n# q, e& S) F0 x        self.target_names = labels[-1]
/ `8 w" [% ?2 r, s5 W) M# n0 k        self.data = data_array[0:,0:-1]
/ D- L; _1 M& q! d! r4 L        self.target = data_array[0:,-1]
- B+ G1 O; P6 Z
+ Y" \: K; i, @! J. [& D. w# 载入蘑菇数据, 鉴别蘑菇是否有毒
/ i. m& N! A" ]  _# P$ j: ~class load_mushroom:
2 O- W; E1 [) ]    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
    # feature_names: 属性名列表
* h2 l& U: b4 b: j5 E6 D: _    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
. k9 Z. \5 ~) V4 i; ?; T    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
        data_array = np.array(df)
, ^- i4 E0 s; d; q" a: n  B0 E        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",
! L1 J2 M& J* W                  "stalk-surface-below-ring", "stalk-color-above-ring", "stalk-color-below-ring",
4 R5 V( o7 E. E- s                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
6 X- F, k2 [# O! U( p        self.feature_names = labels[1:]
: ~" G, e. S. e# c1 W& i, _, q        self.target_names = labels[0]
; Z  n% e- P" d, n& C        self.data = data_array[0:,1:]
        self.target = data_array[0:,0]

# 创建一个临时的子数据集, 在划分测试集和训练集时使用
$ O6 c, H( R# f, I" Uclass new_dataset:
; W  t2 s; k% `    # feature_names: 属性名列表
- N0 H7 V; R+ G" z! Q  M    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
; ^3 {5 P& k( p4 R  K    def __init__(self, f_n, t_n, d, t):
& Y) d% D! k7 I6 _, f        self.feature_names = f_n
* Q) R; A' ?+ l( _  T        self.target_names = t_n
* _$ Z1 Y! x2 d, t# m        self.data = d
        self.target = t
( `6 ^+ v+ L! y2 n
, p, r6 V) ~3 w2 f/ M# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
6 F9 j9 I+ a4 e7 @# target: 分类结果的列表, return: 信息熵
def get_h(target):
) l" N  T. c# G' K- G, z    target_count = {}
    for i in range(len(target)):
* w+ @: |5 \4 h2 c# z5 m) Y        label = target
        if label not in target_count.keys():
            target_count[label] = 1.0
        else:
1 f/ J. N, {2 W  {5 p6 p            target_count[label] += 1.0
    h = 0.0
    for k in target_count:
        p = target_count[k] / len(target)
1 o$ ^/ G: d9 c8 [5 W. F        h -= p * log(p, 2)
    return h
: }0 G' w" r. Y7 X. v* t3 _
) K  d0 x- W! }4 c5 Z# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
+ Z1 I" G- m- ?: m, {' a# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
/ q9 b# V2 h6 hdef get_subset(dataset, feature_name, feature_value):
: a' S6 q% m& L9 W1 F" B" @    sub_data = []
    sub_target = []
0 r# E! L; w$ L( _. H$ F    f_index = -1
9 Y* C7 h4 A/ m- ^    for i in range(len(dataset.feature_names)):
$ B7 x. D. `6 O        if dataset.feature_names == feature_name:
$ H2 h- i0 h; `, l3 c# a2 s            f_index = i
/ v- y$ \( N# ?" Y5 j! Y/ U            break

9 d' O, S& f6 u1 |% T2 h5 S    for i in range(len(dataset.data)):
. [, Q8 ?% ]2 P' T        if dataset.data[f_index] == feature_value:
            l = list(dataset.data[:f_index])
            l.extend(dataset.data[f_index+1:])
            sub_data.append(l)
. ~+ [1 E  C6 \6 F# P            sub_target.append(dataset.target)

  y9 e  o( i5 ?/ s; k% V    sub_feature_names = list(dataset.feature_names[:f_index])
& r) i* w5 t: T/ P( B5 D    sub_feature_names.extend(dataset.feature_names[f_index+1:])
$ O+ n8 P  D5 j) z) r    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)
7 h3 u" n. h7 Z( ^
, ?1 ^3 d* |3 _# 寻找并返回信息收益最大的属性划分
  O: I3 M8 m# e  v3 Q& p% x2 m# 信息收益值划分该数据集前后的熵减
# g% K1 ?( a) N- ~: @* G  W# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
0 S, P8 u. t4 I" ^. {/ B/ e6 ^def best_spilt(dataset):
% ]+ h' g9 R$ j4 s
    base_h = get_h(dataset.target)
' Y  P3 d% _3 Y- M( J4 u" P- @& w& [    best_gain = 0.0
    best_feature = None
4 P: L  C$ a* D0 }9 }    for i in range(len(dataset.feature_names)):
) V$ K, S1 S- ]; J3 c* ~, H) y        feature_range = []
        for j in range(len(dataset.data)):
            if dataset.data[j] not in feature_range:
                feature_range.append(dataset.data[j])

7 P* K5 f6 F  _9 \6 v0 _        spilt_h = 0.0
        for feature_value in feature_range:
/ M. w5 o( @, U! @3 C/ s; M/ h! S. W            subset = get_subset(dataset, dataset.feature_names, feature_value)
* ?7 j" l$ W) F- I( H4 n; J            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)
* v; p" Y$ Z& j; T# r. j/ L
5 d1 l2 m, |" a7 t  }) O$ N  l        if best_gain <= base_h - spilt_h:
            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names

    return best_feature

# 返回数据集中一个数据最可能的标签
6 f; l# X' v7 X) q& d4 V  gdef vote_most(dataset):
2 F4 ?+ d% t# g    target_range = {}
& Y! U- R7 M2 R3 \% j    best_target = None
+ y3 a( i9 f9 q, Q$ W    best_vote = 0
% Z7 J4 P& `, L7 {' _1 d  J
4 x! b& v( {, s  [0 _) k( K4 v+ L    for t in dataset.target:
+ c" ?, o4 f! O. S8 r        if t not in target_range.keys():
# S) }2 F5 c! g) T+ S            target_range[t] = 1
        else:
  S6 T& l" N2 G) ?1 D            target_range[t] += 1
; f3 o# J1 Y& f6 a
/ z5 f; ~8 ^( V+ l. H; [7 a    for t in target_range.keys():
/ [; X6 V9 \) T3 U        if target_range[t] > best_vote:
            best_vote = target_range[t]
            best_target = t

- L% `; u9 J  j9 e    return best_target

# 返回测试的正确率
# predict_result: 预测标签列表, target_result: 实际标签列表
7 E8 [. ?. T6 l& E/ Vdef accuracy_rate(predict_result, target_result):
    # print("Predict Result: ", predict_result)
5 r, E' b3 V. A    # print("Target Result:  ", target_result)
2 p& I1 u- Q) B+ l    accuracy_score = 0
+ Y* o" [2 T5 L3 {, x: M    for i in range(len(predict_result)):
  j7 D' D- S. F9 k1 p$ l1 a" M        if predict_result == target_result:
            accuracy_score += 1
$ u/ R9 H; V7 M2 y) J    return accuracy_score / len(predict_result)
4 }1 ~' r( L* m1 J: c2 `( R) R
% q  p! I8 A! N" P1 H# 决策树的节点结构
class dt_node:
. _% `' |6 u- L# V/ t* s
, ?& _( _% x# W3 m# b' @0 q    def __init__(self, content, is_leaf=False, parent=None):
5 j' A$ o' o8 l6 l3 h        global nonce
" O2 V7 b& c+ `" G/ m8 E        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
  c0 j2 X1 y7 B) b! O  X        nonce += 1
" p( R! G' Y/ T. L        self.feature_name = None
        self.target_value = None
        self.vote_most = None # 记录当前节点最可能的标签
        if not is_leaf:
4 a7 X; h5 T2 {4 A! W            self.feature_name = content # 非叶子节点的属性名
# Q: G* B8 g1 h3 g/ D/ U) |" @        else:
, z; t- m- U; f" u            self.target_value = content # 叶子节点的标签

        self.parent = parent
        self.child = {} # 以当前节点的属性对应的属性值作为键值
% m& Z9 G3 l+ u7 q7 ]7 Q% s
# 决策树模型
% g6 l, r2 l* f) nclass dt_tree:

    def __init__(self):
1 R- K4 L; ]6 @5 ]# {; X        self.tree = None # 决策树的根节点
: K, G8 O5 }$ _% o9 [        self.map_str = """
            digraph demo{
            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
            edge [fontname="Microsoft YaHei"];
3 ^" _* w6 {5 |            """ # 用于作图: pydotplus 格式的树图生成代码结构
        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值

    # 训练模型, train_set: 训练集
- b; P# k# ?1 [; q' B/ ~    def fit(self, train_set):
! k5 h: u3 \6 A' [* |" ]/ t. K
: {/ f1 t0 m  D, x3 Q7 K        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
            return None
4 Y; J' }, e6 p
        target_all_same = True
# @3 r& ]! ?% W4 t5 a" n" b        for i in train_set.target:
            if i != train_set.target[0]:
                target_all_same = False
2 H4 _4 A% y' s8 \                break
& K' h! @' @! x
, F0 N2 N8 G/ J* x& p, d2 e        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
            node = dt_node(train_set.target[0], is_leaf=True)
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
+ v& p) t) G  K/ i                self.tree = node
; y; E& [  q, m) K$ @
5 z! }7 T& M2 H+ `: o" R( j            # 用于作图, 更新 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"
* N+ n) f2 x: A5 l, F$ P! ?
0 B; Z+ X8 s8 P9 v% {. a            return node
; D, t2 q" O0 U        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
( [* T5 X- z. M0 s7 @; ], h" k            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
& J  E, z) {8 q                self.color_dir[vote_most(train_set)] = color_set[0]
                self.tree = node

' T; H6 y( `- y' Y            # 用于作图, 更新 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
/ h& C* {* \5 `, P6 ]3 _- V% h8 k        else: # 普通情况, 构建一个内容为属性的非叶子节点
! |. o  o' y! u/ l( @5 z, R            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
            best_feature_index = -1
) d+ o2 b4 |; T# j5 c            for i in range(len(train_set.feature_names)):
                if train_set.feature_names == best_feature:
                    best_feature_index = i
                    break
4 L1 C8 _! Q0 x: U  @+ _" x
, T3 w  [3 Y, J/ I7 z+ A: ^9 c            node = dt_node(best_feature)
            node.vote_most = vote_most(train_set)
            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
: e. I; K, G2 p3 J                self.tree = node
: R2 l' H$ l& e4 M                # 用于作图, 初始化叶子节点可选颜色
3 D( B4 H8 Z1 i3 X. T+ G                for i in range(len(train_set.target)):
                    if train_set.target not in self.color_dir:
( X3 v5 P% N; z  |& [  h                        global color_i
  P# o! K, v, I3 W" I                        self.color_dir[train_set.target] = color_set[color_i]
4 N) H. L3 A; m6 e4 @6 A5 I                        color_i += 1
* I& _% J5 M4 Z- N* I                        color_i %= len(color_set)

            feature_range = [] # 获取该属性出现在数据集中的可选属性值
& M5 u0 v8 z1 h3 _) [/ {0 h- [            for t in train_set.data:
8 D/ L7 q$ ?) q- ^4 l! `$ V                if t[best_feature_index] not in feature_range:
                    feature_range.append(t[best_feature_index])

            # 用于做图, 创建一个内容为属性的非叶子节点
) W# X% r5 w0 V' A. N$ G            node_content = "属性：" + node.feature_name
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
# R9 [* G- r8 y2 D$ `9 f
" H" ~  n, I6 `            for feature_value in feature_range:
1 O, O" d' V9 a                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
                if node.child[feature_value] == None:
                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
                node.child[feature_value].parent = node

                # 用于做图, 创建当前节点到所有子节点的连线
1 F+ ?# w9 q! k5 _' V                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"

            # print("Rest Festure: ", train_set.feature_names)
            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
  a9 w( V! ^4 ?5 L4 {4 P            # for feature_value in feature_range:
            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
            return node
; V3 U- v/ g9 s% c, k
    # 测试模型, 对测试集 test_set 进行预测
( s2 f! I8 F, z- A1 s    def predict(self, test_set):
        test_result = []
( S: w2 g2 o# z* }) \        for test in test_set.data:
# G" X# b& f5 D+ \& i1 N, X            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
9 L) }: P  D2 m+ h4 G8 Q! o' T            while node.target_value == None:
                feature_name_index = -1
                for i in range(len(test_set.feature_names)):
7 W! \- U9 \8 \5 e! r) o                    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]]
" y) {& J' g% V; Q' n
% F3 }9 R' D4 {  W/ O% H. w            if node.target_value == None:
& r. x" }. f- F/ k  e( _8 I' a                test_result.append(node.vote_most)
            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
                test_result.append(node.target_value)

$ ]/ S% ^8 i* R. l, _( r        return test_result
6 i0 W: h8 i: t9 r3 e
& B* q6 }/ K5 o: v$ u: }0 B" N    # 输出树, 生成图片, path: 图片的位置
: a6 @4 \# r8 T: t" I    def show_tree(self, path="demo.png"):
8 V" `4 b1 E. ~- `! G2 m        map = self.map_str + "}"
, O' ^2 W2 E# J* z# q* ~7 M9 `        print(map)
) q7 g2 M: u6 v, {  c/ Y        graph = pdp.graph_from_dot_data(map)
        graph.write_png(path)
% s3 m/ j6 }5 p$ m1 \
$ h3 N% ?9 {6 B. t8 N3 R" w& N# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
5 E3 ]) o, n" ^  o& G& \: H! I0 C. @def incremental_train_scale_test(dataset, label, interval=1):
9 B: N* Y  b+ @3 ?. G+ m3 \$ M$ m2 n; i. C    c = dataset
; ]4 y( B0 |1 E2 k: _    r = range(5, len(c.data) - 1, interval)
9 l, G5 R7 c. @6 n* G$ g# o& ~4 }2 @    rates = []
4 d0 ^' z! T5 U4 ^6 Z( d# i, f( \( v/ ?    for train_num in r:
. Y' @) x7 _6 S/ A$ l        print(train_num)
+ }8 K$ e4 k' p        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 d5 L; p9 G4 u) A5 i! Z/ K5 q( L. }        dt = dt_tree()
# b1 E# o6 o" S' ^        dt.fit(train_set)
        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))
- v2 x. u- O: N8 k  ^, [7 S
    print(rates)
- P5 o4 i5 P/ U1 ^% D    plt.plot(r, rates)
" K: J8 ]$ Y- v! a$ N' U/ f; Q/ h" d0 s    plt.ylabel(label)
    plt.show()
5 v3 \# z; F1 j
if __name__ == '__main__':

% K" Y: _9 L( g4 }1 b9 t  j    c = load_car()  # 载入汽车数据集
' D# U/ w4 G' h( F& j6 a    # c = load_mushroom()  # 载入蘑菇数据集
2 s# I  T- `" V, ~# \    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
" Q! ^7 P" _& O, x$ ^    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:])
3 A3 x1 i8 }5 A' V& i  i2 z
    dt = dt_tree()  # 初始化决策树模型
    dt.fit(train_set)  # 训练
    dt.show_tree("../image/demo.png") # 输出决策树图片
+ n; \) X8 C: ^: ^! R    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧

    # incremental_train_scale_test(load_car(), "car")
    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)


* w9 Y' K" V( c
1
, V0 E, A, E) m9 R2
3 K% z4 }9 q$ [; U' Q" I" ?, u" g3
  B4 s% R6 H* P& r: k: Z& i4
! ^: I  s# l3 \6 b( D; c: F5
6
0 z0 \$ v8 R3 m6 g: z& E  |# s- `7
8
9
10
7 |6 H2 ^" N/ X" n5 X/ h# E; B11
12
2 t( W: ^3 m: r+ `13
6 h& M$ E# j+ @% K+ b14
15
16
17
18
19
20
21
22
' [# Z2 v& u. B" O* O! w7 o23
24
& q7 m/ `; z, |) W25
  |. {3 g! Q0 |4 o9 J26
- F; n6 N5 g0 O. [( d5 g- H8 @' ^27
28
( E8 t. u2 J' t& G, s$ m29
: n0 o6 z' O+ ^" ]1 _3 v5 _30
31
32
33
, P% T& U- z# f0 W& R8 z34
- K$ E8 b) u2 Q3 q/ I1 k$ _35
36
37
38
5 o/ q0 M- w% y+ G39
40
) @+ z2 ~7 j5 L7 p5 H( V+ \41
, b: Z, |: u, F7 F% G7 p42
43
, A9 m% w) M3 Y- ~8 e$ `# i2 q! a* m44
' z" u$ E0 [3 J* Z& i45
) P& u# M. ?) T/ h46
  D: d3 I/ ^, t7 E, t$ _47
2 f9 D# i8 ?; \1 H) R+ G5 K48
1 h3 J! o1 w9 c! @' `49
50
51
( c. j; P7 i" W/ I$ M/ o9 H52
; z4 U( u0 t- j- _8 @" `( p1 X53
4 b0 K, O/ Q5 O3 {0 W54
55
. r( n7 H- f" y+ I7 w( J+ ?, Z0 C56
57
58
59
60
61
, l' x4 x( [5 b* H6 K+ P62
' N4 P9 o0 Z. }# V; P) B) R" {63
64
65
66
" V; |. \; ~8 o67
68
69
+ j' t! u* Q! b6 |, I- ~70
71
* u6 U8 W0 X0 T. {( D72
73
74
7 w1 F0 {: n& d* p8 T75
76
9 N3 I: Z+ p4 @! J( H77
9 T8 M+ }- c0 U- ^* b78
: f: C( v  ^7 J6 X/ c79
80
81
$ ?2 g# }* L) h% i* G82
3 L7 b4 N# \# y; E4 ~/ \  t83
84
9 q. h" v. F7 V+ ?85
& Z! S2 N& R% m86
0 }5 l+ i' x3 V0 L3 _; K. a87
; u6 P1 n: n! K" B+ u; p88
89
90
* K6 b4 _- }$ M# ?* \9 \91
! D& L3 ]4 L$ O% I; ~92
93
( Z1 W2 T5 q8 a( [' c94
5 W8 A& w8 s; I+ Z95
5 h, [+ k# m; q- j& ~0 d) `4 |. t96
/ Z+ ~5 u4 X) d& X' {; G4 J97
98
99
100
3 c3 }+ t. @. o' [1 S/ F# C; E' F' C101
102
103
9 H6 I3 @; J! p: C* B9 {104
105
106
/ M5 S" z6 N$ F9 y  Z9 P107
108
109
1 a# R$ X" `2 ^) Q110
111
& d  n% H2 `4 s112
, q8 T/ u( ^+ t/ j( k113
114
- p& w2 c4 ?% F7 j115
2 p& @* e* _$ v- X' G9 H& [4 W116
% A) `# Z" P6 X4 p117
: y% u  W& h' j2 d# G118
119
: F9 P. E& c: d3 M0 w1 u" n7 S120
$ j- @2 [7 m+ |; @5 k121
122
$ C; @) Q" J+ X5 b- B123
2 d. ]) I- B# D( X! X* ^124
125
+ B- n/ s$ f1 E7 N3 y; V- H126
1 Q2 a# x; ^6 d2 n) W3 E8 d/ m127
4 a7 |0 g) D8 a. e128
129
6 R: y, s' L3 V/ \& T130
131
132
) k$ j) ?) T1 l( y/ g2 D133
& L( n5 d& }6 K8 w5 h9 N134
4 ~! X7 p3 J$ P135
& |4 U' J. b7 z) p  R136
137
" C9 \/ |6 j6 J) ^- Z, A( H138
139
1 v5 C" z5 `1 z5 @1 t5 {7 @140
141
3 t' p) A# h, e142
143
144
* H3 y6 H$ f- H( e5 E9 K9 d& d& t$ R145
146
147
148
' z3 T( z* R* M" L8 }+ J# {; O+ h149
+ V1 A% \7 e9 {/ G7 ~8 Q# t150
  a$ F% a& {! x  h' m7 D( U151
152
153
5 G1 z. ^' @8 o* n4 Z# k, n$ B154
' H/ J8 C: N# R0 z155
156
; k7 X! Z1 k9 J0 @" e157
1 E  {' w. w, M: @( A6 ?- C' ]; Q% I158
159
160
161
162
163
* j5 N: l# G: e- s) j3 f164
7 Q$ K) N; S0 E165
; d  z9 R" I  i. H7 }166
) a) ~9 U# ?- ?+ _, O$ K" {* |. U2 ?167
168
169
+ ^: E! ^* [3 n  V170
171
172
173
' b5 l7 j3 V7 S2 j; W2 E174
8 D' ^: p  T: r. z175
; @! V( n) N/ V176
177
178
  |  s! g; _& h$ M# x7 i179
# k  y! R( {9 n6 M0 O180
5 G/ B& c0 J2 @5 X5 o$ [) o181
182
183
4 z/ [, H# V* e, N$ @5 l184
185
186
187
188
189
190
& o" Q" M! \/ O7 O191
192
0 F  j2 k4 ]# }/ W0 H  b  w* _193
194
195
196
197
198
+ u( e5 ^, ^/ E/ B199
200
201
1 d4 G0 l) Q+ h202
203
8 m  a2 O7 Z- h  E! K  B" K) `204
205
4 H& U1 [# r9 p206
% W  H/ C' T( i- q1 @- T8 {1 Y207
/ r  O2 @0 Y8 `# S5 Z208
" J1 j0 [. ?1 A% p) C; [6 k! N209
210
1 h; F: l- G  u+ l211
212
3 c% I& N8 \) D; ]3 L- ~$ ~213
! D- a6 m' G% @: Y( P214
# ?' z" e1 e0 Q( q, g2 W215
& q1 v$ s' T' n216
; ~( l7 u2 N$ w4 S+ }217
  R2 v: ?2 b( a; ^218
# u1 E' v& H3 a6 t% Z0 U! z9 c219
220
; |6 E* x8 p$ T* q221
222
6 N9 |  ]# t: A0 \6 J( ?223
224
225
226
227
) K0 C; }: }/ z0 ~2 j228
229
230
231
232
233
234
' d+ Y4 M) d5 U% w9 q" t6 X  Z7 U- M235
236
237
238
239
240
241
242
0 C+ o; k) u3 A: v4 \. }243
244
245
) s" ~$ @6 P  r$ z# r246
  z8 ^" K3 J' d( ]; s/ ~/ i247
' n" c7 K0 `! h' z6 X248
249
3 d4 R. L, m- S( Z! c; ?250
7 o! q" F0 K- \3 {/ F' r7 ?251
252
8 ?5 B5 g% h! D- t9 Q; R253
254
+ w# L( ]9 H1 A% `+ _$ `7 V$ p255
256
257
$ t' W; ~+ e& B+ X- g3 ?: q% {258
259
- g/ o. b; d- u+ i! U3 T260
5 v) F: f4 T' {: B& n" Z261
- T3 o/ o( i( y9 p, |6 s6 Q$ n7 d262
263
# d( S# t9 Q) {/ ]; N/ c0 z0 q264
265
266
267
6 i- |9 i6 a' {  A; r" {  w9 [268
& o) Z3 c) V* v* H0 h) B7 w- ^269
" p% R+ ?: [( j/ s& d% a5 b270
271
272
273
274
0 L& z9 e, l' d* E: ^275
, j/ q, C8 B& y& a276
, i9 N  \, B( \9 l0 \) y% E277
" h4 @& W# D( g- D278
. e; F1 k7 }3 n# N279
280
( ~. s, G7 Y# ?0 J, m. e7 S281
6 X$ \0 \8 [+ @; q: z282
283
* X% o! p3 C6 z# a' u% v284
2 {- |2 Q) f2 D1 S6 u) L& n285
4 i" g& I, Q# G  g' @3 z$ x* L286
287
288
289
290
% Q/ P# n* [0 K/ k3 d0 d7 T8 F291
292
293
294
; J3 s% Z0 V1 K% c  O  E! d% j: e295
9 o& I+ H5 W( @# u" `( B. F$ e296
297
' z8 R7 B1 u# ^; m298
6 l! L8 |9 f. U$ _& d299
8 p! m! F# }! Y  k- @; K300
6 ^7 S* B. S; ^7 P1 L301
302
303
304
305
306
1 n  |  x# [5 T* ~+ O307
, ]8 ?! E0 g3 x( N  C- L308
! H6 O, e$ ?0 M. f9 @309
310
311
6 y3 \9 P: |* c- F8 G312
313
314
315
316
4 o& i6 P! s' @4 p317
318
, U# Y' z$ }! y  ~9 g# J: w$ F319
) s. r  o  @3 H7 P4 Z320
321
322
" M% z0 s* G1 {5 A323
324
; u, o5 c0 ~" r. X9 d325
) v' \' Z3 K' \+ |* }326
4 |: A! z) D) S327
9 ?( a* q# m: [1 ^. }5 t328
329
330
331



0 f% V- l. b' R: _& V4 ?
! N( J/ w  v2 H0 l
/ f9 b0 K8 W0 K! }% a. o! l5 O2 X
. O9 T+ S9 E1 c& p1 Q% R
* }2 F1 O5 Q, P: ~: s


1 l: z" t$ i/ p3 k& I

' A4 t4 t4 u9 F3 f* k————————————————
+ K$ Y: a; L- J版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
5 |! b/ k5 o. v! }$ f, p原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242
0 }& f, z4 ?4 ]& P2 J! d, r- _