基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

. v! i- k$ a+ R* B决策树模型
目录
人工智能第五次实验报告 1
决策树模型 1
  m# m* `4 z7 V. A一 、问题背景 1
1.1 监督学习简介 1
1.2 决策树简介 1
二 、程序说明 3
1 P5 ^' \" N0 ?8 n$ R- |( Z  v2.1 数据载入 3
6 W2 f4 Y% ~7 q" y  ^9 q2.2 功能函数 3
0 M' [5 O% [2 ]% q" O9 I2.3 决策树模型 4
三 、程序测试 5
3.1 数据集说明 5
3.2 决策树生成和测试 6
! S. d2 z; ~8 |5 d* h" S0 R, q3.3 学习曲线评估算法精度 7
四 、实验总结 8
9 u& U$ d' J' g& m" \附 录 - 程序代码 8
$ ?! r, K; O# p- b2 n9 x% c4 J# D一 、问题背景
1 B4 U! X- R" o6 L! Y1.1监督学习简介
( J" @7 \( Y& J机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
6 [1 g6 `; ]7 o8 J1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
) k1 p8 x0 u- ?: s% ]5 m3 U# ?决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。

1 e+ A7 x) U/ ^+ c% ^# ]8 l9 Dimport numpy as np
from matplotlib import pyplot as plt
1 {2 ?) g9 ^, U4 {9 [) e; Zfrom math import log
import pandas as pd
import pydotplus as pdp
1 c+ Z6 D$ ]) h4 g8 R
"""
19335286 郑有为
人工智能作业 - 实现ID3决策树
4 T4 x1 G9 q8 |; _& B) B; Y1 l/ R"""

% f9 j) o3 H1 c5 S' g* q# {0 unonce = 0  # 用来给节点一个全局ID
  M1 O2 P; j" ^' T3 f% |color_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
; i: T  F' K5 Z; K- i! T. `, t5 ucolor_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
6 c* D2 U: T4 s( s* `! T' p
# 载入汽车数据, 判断顾客要不要买
! P! z( ~9 z2 f5 b9 E- F8 zclass load_car:
4 ~2 o" z6 d+ t- B2 e7 n( I    # 在表格中,最后一列是分类结果
4 l* r6 c8 D) `" [& J, f3 H    # feature_names: 属性名列表
6 {+ `& x( C1 ~7 t/ M    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
5 q, w7 w/ ]( E+ L; E7 S5 [2 w    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
% T7 L$ \6 @/ \6 i' C  n# W        labels = df.columns.values
% x' l' o8 k3 R# U; H# E        data_array = np.array(df[1:])
) [: Z& }- k! g7 U( J( i        self.feature_names = labels[0:-1]
        self.target_names = labels[-1]
! C& v  W+ P/ f4 j* w, n9 L        self.data = data_array[0:,0:-1]
        self.target = data_array[0:,-1]

# 载入蘑菇数据, 鉴别蘑菇是否有毒
class load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
, j+ V) r  u8 C' [% q; G    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
' k8 p& N3 }) M. J" Z( ?/ v    # target: 目标分类值列表
& X7 ^2 _# j6 J: a2 |+ E! f    def __init__(self):
: S) s  \  e$ k+ ]* I, ~6 r  C        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
! ~! }" r1 S8 K1 r        data_array = np.array(df)
        labels = ["edible/poisonous", "cap-shape", "cap-surface", "cap-color", "bruises", "odor", "gill-attachment",
% ?1 ]! z! s9 L% R% T                  "gill-spacing", "gill-size", "gill-color", "stalk-shape", "stalk-root", "stalk-surface-above-ring",
4 k$ ^* Y4 ?7 Q8 Q9 V9 ]" B                  "stalk-surface-below-ring", "stalk-color-above-ring", "stalk-color-below-ring",
                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
8 h4 J1 K, B5 u; I/ Z7 _$ [) X9 v        self.feature_names = labels[1:]
        self.target_names = labels[0]
        self.data = data_array[0:,1:]
: M! o; Q) B$ S8 L4 ~8 t0 }        self.target = data_array[0:,0]

7 q0 e# Z) S# D* m. \# 创建一个临时的子数据集, 在划分测试集和训练集时使用
class new_dataset:
    # feature_names: 属性名列表
) C! V. N# h7 ~- Q. m1 q" T/ z    # target_names: 标签(分类)名
; p5 k. L) L3 D    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
1 w0 p$ ~: y: [% _# n* }( E    # target: 目标分类值列表
" P& n5 d- {& Y) W' A- \: w' [    def __init__(self, f_n, t_n, d, t):
        self.feature_names = f_n
        self.target_names = t_n
) e" n9 W$ |7 K/ h8 Z0 L& K% u        self.data = d
        self.target = t

# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
: S" d5 O9 G& k7 n#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
0 T! e  N6 ]0 D& T  x5 K5 t7 y# target: 分类结果的列表, return: 信息熵
def get_h(target):
    target_count = {}
- F. [1 E3 K  ^3 `+ o8 |: x    for i in range(len(target)):
! V# e8 o+ k- ~  i/ q* V        label = target
$ {: f  W, i' r+ W; \) j6 m        if label not in target_count.keys():
6 I, U2 ^0 t* p$ D" }' Z) q8 {3 z; a            target_count[label] = 1.0
2 A2 A% _, ?- J, |5 H: H/ v        else:
            target_count[label] += 1.0
' n' F; ^, g  _3 b8 R4 Y/ W    h = 0.0
- R7 \- d$ {4 l* K. }    for k in target_count:
4 _# o+ w# `2 V6 u1 v4 u; V; H        p = target_count[k] / len(target)
0 H' T3 q8 [/ `4 l, k1 C- H        h -= p * log(p, 2)
4 q& q! ]$ N2 V2 I0 h    return h

# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
: m. D! `* H9 \def get_subset(dataset, feature_name, feature_value):
! U( H' V. {- Y4 f: Y/ ~- S$ U    sub_data = []
1 Y# U, O/ Z! R) Z$ T5 k/ S( ], E    sub_target = []
9 Z) Q' D- ^# v3 n( |    f_index = -1
8 V- w) w+ N& N; ^. K    for i in range(len(dataset.feature_names)):
        if dataset.feature_names == feature_name:
            f_index = i
            break

! ~- ~6 k/ f% d' R' F- F9 }2 \8 c    for i in range(len(dataset.data)):
        if dataset.data[f_index] == feature_value:
" h) f3 N- N) |            l = list(dataset.data[:f_index])
            l.extend(dataset.data[f_index+1:])
            sub_data.append(l)
" V- m! _8 }% Q3 z; I! S( {6 k            sub_target.append(dataset.target)
6 _- x: D* {" s" M: u
& n- {" n: @% n0 i! R    sub_feature_names = list(dataset.feature_names[:f_index])
7 ~6 \) O% ^& D" ^" L" T1 @    sub_feature_names.extend(dataset.feature_names[f_index+1:])
  `6 z: D" S5 `) {. D7 l    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)

# 寻找并返回信息收益最大的属性划分
8 f* d7 I1 ?" m. K$ E- |4 ~# 信息收益值划分该数据集前后的熵减
' U1 W6 Z) V" B4 d7 Q# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
# q& n0 w; W) {9 M9 ^& bdef best_spilt(dataset):

    base_h = get_h(dataset.target)
    best_gain = 0.0
    best_feature = None
  n( {, E2 N; e1 W( C- q9 E- ~    for i in range(len(dataset.feature_names)):
& @" a6 f7 B, `$ R3 g. S- o. v# Y0 V        feature_range = []
! b: u" U1 X# [        for j in range(len(dataset.data)):
2 |: m7 l2 H9 y- g8 {            if dataset.data[j] not in feature_range:
6 W  K: Y+ G+ Z/ K* w                feature_range.append(dataset.data[j])
- w- @  C4 G6 v% B' X
        spilt_h = 0.0
        for feature_value in feature_range:
            subset = get_subset(dataset, dataset.feature_names, feature_value)
- w9 ^- E# V% u/ v* e6 ]            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)

        if best_gain <= base_h - spilt_h:
            best_gain = base_h - spilt_h
+ e1 u) n+ F4 l2 E1 @6 `/ e            best_feature = dataset.feature_names

    return best_feature
! S& D0 a4 @" {8 r4 m8 Q
  U7 m# L1 [3 _/ l4 A( ~* j  F# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
% t4 `0 H, {( L1 @+ I% _    target_range = {}
) B) A5 U- f- d. e* h' y    best_target = None
    best_vote = 0

+ s! C: F& C3 Y9 L8 N4 v- a# W1 f    for t in dataset.target:
        if t not in target_range.keys():
( `" V: H+ \, Z; i- i            target_range[t] = 1
        else:
# P! W0 v( M. `( p6 u- I- X3 [            target_range[t] += 1
  ~) X7 ?' r( R! o, L
    for t in target_range.keys():
" y6 L' g+ D; Z3 ]. Y; H        if target_range[t] > best_vote:
$ E" A5 p% t" x: F& Y            best_vote = target_range[t]
            best_target = t
3 n2 w0 y* f2 S8 |. O
8 e2 I6 v, E$ R, i0 B; `    return best_target
+ c6 M  g9 H% o+ k/ I7 `" |- g
# 返回测试的正确率
# predict_result: 预测标签列表, target_result: 实际标签列表
' C. d+ t8 g* h, Fdef accuracy_rate(predict_result, target_result):
    # print("Predict Result: ", predict_result)
    # print("Target Result:  ", target_result)
9 m% p- P: R" {$ B* J; ?    accuracy_score = 0
3 @# U0 O5 ?3 X5 W    for i in range(len(predict_result)):
+ ~, n/ s8 O5 `: _6 @$ X        if predict_result == target_result:
, ^  o) I+ O1 `            accuracy_score += 1
; T  }" K" b# |5 ]* v    return accuracy_score / len(predict_result)
& C8 {% J' \0 F8 J* z9 y
' e5 j( _; S1 }4 P# 决策树的节点结构
: R# r0 P' a7 B/ d/ g9 qclass dt_node:

    def __init__(self, content, is_leaf=False, parent=None):
        global nonce
' T) o/ V1 W, I+ K$ ~; I        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
        nonce += 1
! J3 h1 _9 {# J7 A& `        self.feature_name = None
        self.target_value = None
" g' ~& }, _2 a! X1 v" p3 z! ^3 M. [        self.vote_most = None # 记录当前节点最可能的标签
+ h: N& n: K6 j/ O/ Z, k        if not is_leaf:
8 g% \6 G) S8 K" W0 `            self.feature_name = content # 非叶子节点的属性名
3 r1 u; ]& u- V( _" k        else:
            self.target_value = content # 叶子节点的标签
. N1 M$ b3 P( z, f
        self.parent = parent
; c2 K2 i' ?1 Q7 v$ o        self.child = {} # 以当前节点的属性对应的属性值作为键值
8 b; m& W) i# |7 p5 R& M3 K
  t3 o  P5 {: T$ b/ P' H: s# 决策树模型
class dt_tree:
; k* K; D8 s! E8 Q# x# X
8 V/ j  [' U( E' A4 a. I; j9 B5 @    def __init__(self):
        self.tree = None # 决策树的根节点
- ]4 j6 t' A6 ]$ g5 v* R! p: {- o, h        self.map_str = """
            digraph demo{
            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
% g  [! i! t* m+ o            edge [fontname="Microsoft YaHei"];
+ h- [7 P) K" y            """ # 用于作图: pydotplus 格式的树图生成代码结构
        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值
( j+ z' y1 e2 |, v4 n
    # 训练模型, train_set: 训练集
    def fit(self, train_set):
& R  v$ H9 k# u" o9 {
0 F7 g0 \$ C# r1 V" y! n        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
            return None
( U4 a5 ?, {( C$ b9 y1 t
: E+ }, E$ q/ h0 I        target_all_same = True
8 L# V- \" ?1 y# a2 R2 m, `. D        for i in train_set.target:
            if i != train_set.target[0]:
                target_all_same = False
5 |3 R, B( p' Y" Z* Y4 W5 a                break
( X$ P0 p3 @' j  d. t, ~
8 g* c6 ?( b, T$ \8 a4 a7 ]        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
$ C$ N8 O- C/ F, d  ^6 e8 X; J            node = dt_node(train_set.target[0], is_leaf=True)
8 b& C) i) c4 w9 R1 `            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
) L$ k3 e" K- b! R* t6 J% J& z                self.tree = node

  E! n: W0 T7 U# {% A4 _8 q            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
$ |# U  z& \9 U' t            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"

% z  K' F2 y- k4 ], d* W* x. O* \            return node
        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
, x( k8 P+ }& q- o2 q            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
- u9 Z9 \2 c! W, O9 P            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
7 q! L. o# j0 ^  B                self.color_dir[vote_most(train_set)] = color_set[0]
$ U9 v" Y0 N4 F' Y                self.tree = node

5 I5 m2 s) j& ^: q% i2 Y6 N            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
3 \, O$ o! \& C; T$ I( T            node_content = "标签：" + str(node.target_value)
$ C( T. B6 O. w) p5 Q; F  g            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"

            return node
        else: # 普通情况, 构建一个内容为属性的非叶子节点
            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
# i- J  x) z7 u% i9 k
            node = dt_node(best_feature)
            node.vote_most = vote_most(train_set)
( Y$ p0 N: h: h* o            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
                self.tree = node
- k& g$ G) t* |( B                # 用于作图, 初始化叶子节点可选颜色
" K4 e5 l: k  E: q" N  W$ ^                for i in range(len(train_set.target)):
                    if train_set.target not in self.color_dir:
7 {1 R9 G7 G& ?6 e5 I! e                        global color_i
. l. [  ^+ o# a% X4 ?. w( H                        self.color_dir[train_set.target] = color_set[color_i]
                        color_i += 1
                        color_i %= len(color_set)

            feature_range = [] # 获取该属性出现在数据集中的可选属性值
            for t in train_set.data:
! P4 W* K4 e5 S                if t[best_feature_index] not in feature_range:
                    feature_range.append(t[best_feature_index])

: ]2 F1 t+ [0 J" x- R. c: C            # 用于做图, 创建一个内容为属性的非叶子节点
& W  m( P) F9 {5 g  C3 |+ }3 X            node_content = "属性：" + node.feature_name
! L! Y( C4 W+ L/ b$ G            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
- I0 P2 R/ }5 m( l3 T! ]; e
            for feature_value in feature_range:
, i* ^) e; J( ^! Z" y  x8 W                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
  N0 v2 V0 _  C& u3 Y: l                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
3 U+ r/ _) l$ l; U4 Z1 r                if node.child[feature_value] == None:
                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
/ \$ m' ^& y% T9 L# J# p, c                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
                node.child[feature_value].parent = node

: `3 S  x4 z5 U4 J! p* c0 S                # 用于做图, 创建当前节点到所有子节点的连线
; q  i5 O) }- ~( {5 G                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"
' ~: a/ L( f  E: y/ J% H2 w# d& t
            # print("Rest Festure: ", train_set.feature_names)
            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
            # for feature_value in feature_range:
            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
2 T2 o4 w& x# z1 P/ B. `& L            return node

    # 测试模型, 对测试集 test_set 进行预测
    def predict(self, test_set):
% W, I! j& A: j* h  s* |5 w        test_result = []
" k  d/ e5 h2 [: V  Z        for test in test_set.data:
            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
7 z" Z4 ^! V. J6 ~6 P- X5 O            while node.target_value == None:
                feature_name_index = -1
4 w8 H' @1 l8 d) Q2 B# p                for i in range(len(test_set.feature_names)):
                    if test_set.feature_names == node.feature_name:
) q" t+ b0 e7 u- I0 ^                        feature_name_index = i
7 T0 {. c8 c5 `# p8 M2 ^2 j1 M                        break
; a9 Z# z' K" r4 _                if test[feature_name_index] not in node.child.keys():
: K) o/ _& h$ ^1 A5 [2 s+ f                    break
- j2 C3 o% \- c9 ]* h9 }                else:
  n" d( K/ t3 d% k: C0 x                    node = node.child[test[feature_name_index]]
2 x2 R& R0 O8 t1 [
            if node.target_value == None:
" T0 w% ?3 q  X" T; Q3 c7 u1 X* o                test_result.append(node.vote_most)
            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
                test_result.append(node.target_value)

        return test_result

    # 输出树, 生成图片, path: 图片的位置
: d4 B+ ^# T4 f! }    def show_tree(self, path="demo.png"):
+ O( m' N1 B& l9 j9 h0 B) `        map = self.map_str + "}"
        print(map)
, p* W* Y  ^5 @5 ]* y; y        graph = pdp.graph_from_dot_data(map)
        graph.write_png(path)
" i6 ^, q1 D& {7 k' t
# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
# a) U. Y2 j9 D* a8 w    c = dataset
. L) ~: o. [! R; f    r = range(5, len(c.data) - 1, interval)
    rates = []
1 Q8 m5 y! O) `6 z    for train_num in r:
# }# g) K. S! u* O7 h        print(train_num)
        train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
* l* r5 H7 s9 g  D" @9 A- G6 ?        test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
! \' \, K/ I6 d+ P: r, S* y0 _        dt = dt_tree()
# W  _1 [+ o& X  }! n# ?        dt.fit(train_set)
- ?7 ?% f. H) w; W% q3 [        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))

    print(rates)
2 O! A% ~: J% I& Y* t+ }    plt.plot(r, rates)
3 i! |6 w, V' X9 X# v1 x3 _    plt.ylabel(label)
    plt.show()
7 m1 k7 b( L# j" a8 N4 W  F. m
if __name__ == '__main__':
* w4 n6 [0 w- |" k# Q
    c = load_car()  # 载入汽车数据集
    # c = load_mushroom()  # 载入蘑菇数据集
    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
    train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
# p0 ^, v( _, H" w$ L: o2 o. \    test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])

2 S2 w( k) f, a. [( g    dt = dt_tree()  # 初始化决策树模型
    dt.fit(train_set)  # 训练
    dt.show_tree("../image/demo.png") # 输出决策树图片
    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧
8 i5 V. o& i, o
3 I/ D/ u; I8 ]" }# J    # incremental_train_scale_test(load_car(), "car")
    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)

, c' m8 u2 d! k* z1 {
  d8 W4 W9 I. Y: L- r8 ?9 M
1
2
3
' `; z& R* V4 [2 |2 _. E6 _4
5
6
0 ~) U" k6 T( a8 }# Z" p# F% ?0 c7
% n& f- j7 s4 O$ ~% N& n, [6 ~8
9
10
9 ]; R5 p! [0 M# i8 {  g0 V11
7 M8 D" e5 b4 R. U$ J8 J12
5 |/ Z# e5 L) P  |0 p- t; t13
6 K8 L* F0 w2 N  ~# q0 R14
15
7 y" [. h. U$ }: Q. L, m* F16
8 _5 Q. {: z' u- s. Y9 H5 j8 g17
% J2 ~+ H* W, \9 H. X18
4 y3 \7 d" e$ `$ w4 L19
20
: x& K5 H/ E6 N. |21
22
9 I$ `; {7 _' Z  }! R8 c7 M, ~23
24
25
8 ?: T; U( E, S0 a1 m26
27
/ ?  @1 A& S% x$ Z' c. m28
29
30
6 I% B( r9 \; V+ f9 h! Z  e- n7 U31
32
33
" k: N/ H2 ^1 S8 h  W34
) {) y- E* l$ O3 W7 {5 x35
& F, \/ F0 Q* O7 @: E, F: A  o36
37
/ W" ~+ {9 Y! ^: ?8 R38
39
40
41
42
7 Y: B7 Z. {, g8 @43
8 k5 D9 ]1 N! ]( b44
45
; \/ t' B1 ?1 k) ~! X# m* C46
47
2 k# l. G- T9 D" J2 X48
& |+ U: t: G/ Z4 J; b49
* q! |$ B& ]1 y* K50
51
( K. e; c0 j0 v9 Z! r52
53
" ^+ m3 Y& Z9 {6 S54
55
56
57
4 W  w. _; }7 H& v' L6 m/ n58
59
60
61
62
63
, B  H4 Z- d4 L64
5 z$ J5 a2 k0 `# O9 `65
- H3 B& S0 R, G7 a2 J  f8 p66
7 O" d! x& P% Y67
# `, H: y% d5 ~; r( Q* H68
2 |4 O9 u" s; F  {" h2 i8 {: k69
70
" ]+ e4 n0 Q4 K+ @) \71
72
73
7 T$ d0 u* a" X) C' q( |74
75
2 |( i9 X7 A7 o0 k7 {+ T' }76
' O$ t* I, |$ @0 F7 m+ c' ]77
5 w1 y, w5 O* v. M78
7 U  N$ P0 S8 s, T; e9 c79
* c. }$ [: V5 R1 u80
$ i& Y: a3 x( r81
82
4 o: v' W7 W* x1 D83
$ F$ A! E) f: P5 M; h84
3 O- J$ f. ^$ P7 C- O' Z, G8 s# p0 S85
86
) i, u$ Y) h- g' F- _9 y  K87
0 K$ J' ^2 v" V% h& ~* G" u88
7 O7 z& E! O1 e  f89
90
91
92
93
# B' J. R4 Q# J- ?& H% @94
5 x2 M$ L8 u0 j' ~, f9 R! P95
96
+ q9 l* y5 r/ r% R$ W97
3 R+ {9 M. ?0 H) g( a98
1 j" z; q2 K4 c# t4 v99
100
101
3 a7 M9 {1 G/ T; Z7 i102
103
104
105
' J$ w$ G# u7 V' l! b+ G0 M& r106
+ P% O8 I" c0 X9 }107
3 @' D, k( N( H0 W- i108
+ ?; y: K* c  q+ @, N) n109
110
111
112
& o8 g' Z; n: q$ G% v" `113
114
$ ?4 D% d* w. K% [/ w115
0 [# j! Q& N. c8 @; n+ o/ D# i116
117
118
2 E! x, n) F/ A7 ^% C119
( V; R8 P7 e7 b& \# `" W7 w120
$ m3 u+ d# n  q* E3 _. e121
122
123
124
125
7 A8 Q7 a" R8 k( _0 ^5 r% ?126
9 i1 u# b/ j$ V127
128
129
, I$ I0 W& Z  i+ h2 \130
131
& m7 K; d  T2 M$ J  W132
) D  c7 g+ Y: H0 A+ Q  g: d133
134
135
136
3 r' g2 M4 u8 P* R, O4 u# p, M137
138
139
140
141
) \( V+ L2 z9 j4 N" r( X) C% R. @142
9 @3 u1 B! ]* |7 K2 ^; f" P) ~143
% u! I# B5 \& r144
! t4 n2 E, r) s2 w$ M% \0 R145
146
0 G6 Z7 n2 W) k8 K147
$ ]  h8 K$ ~8 a5 q* U148
, F# t2 Y6 ~  f% F149
. H2 r( M* n4 t9 V) I: y150
151
152
/ n# r( s9 b) o# h0 y: Z  h$ u$ @, Z153
% r- X* @) j5 e154
5 u$ o( {8 m% k. [% G155
156
157
; `( ^7 G9 j! t- Q3 x0 T158
  t8 L6 B3 v, Y4 n159
3 g0 H( c6 o* m4 Q, ]$ J160
/ k7 s8 m# H2 G$ Q161
% k' _' d6 P4 O2 b; b. o2 M$ I162
163
2 e! k! X, F2 h- I% b1 ~: O164
* F, Z, L7 k4 N) S165
3 y! [# K9 b7 Q# ^166
) z( V' e, H/ ?5 E$ H167
168
169
1 v& d6 L( }& p( A6 m8 O170
9 Q$ n# c# |# G5 r, w+ ]171
% g/ y- G! z8 L172
173
174
# k$ C' w, j6 _% g4 t: r* i175
176
177
& s: i! h( t: i& b178
179
180
181
182
183
' u2 B  |- R7 e8 F1 I6 j; M! h184
4 q& F5 H! D; u) D' W185
* G) t8 V1 s7 P5 s( z186
187
188
* t0 V& m, k7 a5 K189
  ^( [4 t6 r7 o' I- k" J190
191
9 o6 w2 Z" I7 ]- k0 E) j- A% T192
193
; Q7 a7 b3 @) D1 _, y- Z( }194
195
196
197
: y1 K! ^/ F3 {& A- M198
199
" A  E3 z6 ]2 ]* s8 e8 K8 Y200
/ l6 \6 b8 x& B- a, u" l5 G( k201
202
203
204
205
/ i) j- p0 s5 ~# Y) E4 q206
( _0 o# G. n$ w% V9 ?  }, P207
% q# a9 @0 R5 w# I208
6 M; q. m( q! x$ g2 f) y* G209
210
% A: {" P4 {2 @# u6 x211
% ]1 F9 K/ @6 Y0 J- i/ |212
6 O5 d) }) A8 H( F( T213
214
215
216
2 I) Q1 X# E, }217
218
' @) D8 L; z8 T) ~/ X$ P: R1 v/ R219
2 B+ Q" N8 l- Q, _* [2 B  R220
4 q5 N/ Z7 w7 `$ K* x221
222
4 o, W/ F9 N/ Y223
0 j3 i1 X8 x4 A/ R- x224
225
226
( k8 s0 I4 v' w! h- ?3 X0 e227
: N4 K1 v- i* \3 ^  }' i228
3 M! T* m1 w$ O/ m229
230
- x4 K6 B% y- x- k3 P1 `- E( A231
* G8 J8 h, e% M: f* K232
233
234
235
. P$ a) Z  b; |" C' N5 r% x5 t236
5 S: H9 l$ {( Q/ j8 W- e237
238
239
240
8 n' l% w: R& Y/ t  R5 o4 _) `, ?241
242
5 Z) ?7 n* [8 d, N  |: W4 R$ _( C243
244
245
- b( X7 E1 C0 Z4 {246
247
248
249
" F, y, O. v& v8 J! P$ H250
4 l" ~+ ?# i/ s5 Y  W0 S7 `5 u251
252
253
254
255
256
257
& m# E6 N; F) B7 L2 N, E258
259
; C5 J; b% F% v. z+ Y+ r260
261
  I. h4 R4 L! O1 M262
8 q. x( g4 G# b: n6 z263
& T" s) B" ]8 n6 e- ?) E264
265
' j) p* E  T  k266
5 J# |) B' U3 [& t! g4 C9 N267
* K; w2 r, ^$ j9 T2 c, Q268
( l. m! X* e- W1 P3 Y8 G4 S. {269
270
271
+ K% A* N. o+ a" ~272
) E0 a6 A0 N" Q( P9 r  k2 K% A( L273
6 z$ C1 F3 d: _0 A274
) X8 G9 f4 z( h0 ]9 o275
7 G5 }  i  ?! G/ u" v( E276
2 a$ C& f2 q$ g, o$ k277
278
9 g$ c9 U  `) v279
280
) i% z% p/ f1 |" D9 p( b$ q281
2 C" Y5 K8 U* l% z7 T282
- E& {. `5 P; T% |' ]# {283
284
285
286
287
) {. P  u, J! [" _% v288
4 M; m2 N: O' F! W+ L289
6 P1 Q6 |3 A  q2 R7 J/ F+ c$ h; Z) H290
% P/ e3 o& n1 f0 F291
292
293
/ J. e& _4 C7 u; H# b' I2 @3 M294
4 C: X& O4 y2 T0 L9 H295
) y! P6 i3 T; J! n/ z7 Q296
297
4 Z) f( l4 t# f2 a4 D. v298
299
300
' n0 O$ i8 ~' |/ ^6 i; P& r# _301
302
4 |" F, c# H8 m) x9 U303
304
305
306
  ?% M6 U% F5 a0 V307
308
309
" E9 x/ w; I  \3 H310
311
312
313
  }( q, D4 \  m4 j& R  w314
315
316
317
318
9 v$ J) |& d  d& T1 k9 Y319
320
321
322
& W8 J5 ?' F5 W3 J, k% v323
2 o( d( t- x  q/ Q324
$ j& N: d& Z8 }325
326
7 z/ s! n& _* v- S0 V: G, k327
328
) S; I6 Y' U5 f) R5 l2 l329
- q, h2 p4 t( U! ]" y330
6 v* a; V) K) T7 Z331

/ }' w8 C( o1 \% t  B5 Y# W4 `+ l
( J* Q* i& z! l& [# x$ O0 t




) |: f$ m$ r. D, U5 d* o
; L* _% H& Q3 ?1 }! H" r" X# g



————————————————
* h0 |# q% _0 `# E9 }版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
# L+ K5 b5 Z0 e/ k2 z( }* O原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242
1 x! k$ F% |# T$ a6 K" ]  B
$ X1 h; [8 T9 n( `/ b