基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型
6 G" |4 F3 ^+ V+ X
决策树模型
目录
人工智能第五次实验报告 1
" U0 V9 p; z( v; a6 T6 y决策树模型 1
0 A0 R1 e+ C1 |2 {$ i  r一 、问题背景 1
1.1 监督学习简介 1
' f0 i5 q! K% J! {- D" U* \1.2 决策树简介 1
" }# M8 C! m, l& t/ j' k1 `( N二 、程序说明 3
1 y8 ^, Z3 ?. G7 [" w. h2.1 数据载入 3
! \' K% n' K" k2 r- k  m2.2 功能函数 3
2.3 决策树模型 4
3 J5 {) y* r4 ]& u三 、程序测试 5
$ u5 l& Q; j4 u1 {" D7 C! \' ^3.1 数据集说明 5
3.2 决策树生成和测试 6
% H( U3 W0 m$ ~$ }' A# `1 X0 F3.3 学习曲线评估算法精度 7
. F8 l. F# b0 p3 B8 n+ I四 、实验总结 8
( `/ _6 x# K. H1 l/ E6 T附 录 - 程序代码 8
一 、问题背景
* w" Z) b* J% z4 h1.1监督学习简介
, K! @1 q% f1 l, M2 e机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
" W+ Z+ i1 m4 w3 L# L' w1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
7 I- y% |4 N- Y5 i9 ^& Q
# R! r" S7 \+ y$ d7 g: zimport numpy as np
- o6 z! j! _3 M0 ?, k2 @from matplotlib import pyplot as plt
/ p2 M8 |$ c" \: y, h, H1 Hfrom math import log
2 i+ T6 @  A5 f% H0 yimport pandas as pd
import pydotplus as pdp
% {7 I1 b! s( ], i9 H
7 N- F" G# L; s9 w+ W1 r"""
1 P  A- s  _% w1 ~8 ~/ M6 _19335286 郑有为
人工智能作业 - 实现ID3决策树
"""

nonce = 0  # 用来给节点一个全局ID
8 v/ g$ o" |" E; gcolor_i = 0
$ [1 C4 w( Y  N  l( v2 {* D+ g# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
color_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
8 _  k# z9 z* j  I& A5 {" H
" z; d3 R5 G+ e$ w. f% N# 载入汽车数据, 判断顾客要不要买
9 h8 m( T" u, P' M# r2 pclass load_car:
    # 在表格中,最后一列是分类结果
) S  U# x8 Q- p" L6 I    # feature_names: 属性名列表
" p8 R5 E* P+ R, E% K! \    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
; I) C& f; T$ ?- x) w    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
        labels = df.columns.values
0 C8 u4 k* z# @4 J. c# O        data_array = np.array(df[1:])
7 \& l' `% u5 I5 P$ {1 H2 ]1 v( ^        self.feature_names = labels[0:-1]
        self.target_names = labels[-1]
        self.data = data_array[0:,0:-1]
; J  J9 u( U9 }; a+ P( m        self.target = data_array[0:,-1]

- c# }' [4 z( E0 ]# 载入蘑菇数据, 鉴别蘑菇是否有毒
' s. {& o0 M* S  f/ F& Dclass load_mushroom:
( p: t( F' i2 c) V9 X. y    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
6 }" S+ c8 y+ b# b2 C    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
1 T/ U2 V- d8 q6 a7 `# o2 p    def __init__(self):
        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
        data_array = np.array(df)
        labels = ["edible/poisonous", "cap-shape", "cap-surface", "cap-color", "bruises", "odor", "gill-attachment",
) |6 X* C7 _+ ~( L0 n                  "gill-spacing", "gill-size", "gill-color", "stalk-shape", "stalk-root", "stalk-surface-above-ring",
7 o" C0 E1 [2 v, j8 v3 Y                  "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"]
        self.feature_names = labels[1:]
1 k/ b* n. K' o6 H8 v8 c        self.target_names = labels[0]
8 y8 I! n. y; n6 B4 c        self.data = data_array[0:,1:]
- Q! L" Z, d5 ^0 p& J        self.target = data_array[0:,0]

8 b5 j8 r1 M8 T3 x& D# 创建一个临时的子数据集, 在划分测试集和训练集时使用
6 n0 f. B, }) Xclass new_dataset:
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
- I: M( N: S5 ~) V% K6 l- D' j7 g8 i; i    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
        self.feature_names = f_n
% T0 ]) H: A/ u* I8 n$ t3 f& t        self.target_names = t_n
        self.data = d
0 h) F$ {5 z4 X7 f6 C/ e; G        self.target = t
) Y0 }) ?. F, B+ `% O5 X
& L; l; g" t" h* n+ J9 n# O# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
3 A% y* M: D& T#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
& `. c2 g* _% E  e# target: 分类结果的列表, return: 信息熵
& C7 h, ^: \! o( h+ }3 h6 ddef get_h(target):
    target_count = {}
    for i in range(len(target)):
        label = target
2 [) q& _5 D. {6 i8 B2 v" v        if label not in target_count.keys():
            target_count[label] = 1.0
/ Z) P* p' ?) d        else:
- X5 d& V+ R( v( l$ [            target_count[label] += 1.0
3 k0 Z$ g. F  F6 n) h0 d    h = 0.0
3 r- W2 o& m, v    for k in target_count:
        p = target_count[k] / len(target)
8 J, `# y: c9 C' h        h -= p * log(p, 2)
    return h
( Q) U8 u5 X  k* b! V9 _
* p2 v+ N+ @( M$ s7 r8 Q# {5 N+ h# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
; {7 Q: T- h6 ^8 X( Y, f( x# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
$ V9 R! T2 M6 Q9 `def get_subset(dataset, feature_name, feature_value):
    sub_data = []
4 [$ E& `9 ^. g    sub_target = []
  R. w2 _& p4 F! R- X7 @& F    f_index = -1
( P. p1 K$ `2 L7 t0 Y1 I3 x    for i in range(len(dataset.feature_names)):
        if dataset.feature_names == feature_name:
, u. V4 \, q% q            f_index = i
            break

    for i in range(len(dataset.data)):
        if dataset.data[f_index] == feature_value:
            l = list(dataset.data[:f_index])
4 y. R4 C/ }) o            l.extend(dataset.data[f_index+1:])
5 o& i7 ]* `0 r: I  {            sub_data.append(l)
3 k% X/ q! z4 |            sub_target.append(dataset.target)

    sub_feature_names = list(dataset.feature_names[:f_index])
    sub_feature_names.extend(dataset.feature_names[f_index+1:])
    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)
' n0 t# u( m: F5 v
' C& }4 v1 s) `# 寻找并返回信息收益最大的属性划分
; `$ w, R1 g0 _* Y& o1 D2 K, l# 信息收益值划分该数据集前后的熵减
9 w  g: ~: N, `8 h- z0 ]; _) _: ?# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
def best_spilt(dataset):

! L  i7 M% \5 ?    base_h = get_h(dataset.target)
    best_gain = 0.0
) C' X* }! a" }    best_feature = None
5 e* y5 `8 W! v    for i in range(len(dataset.feature_names)):
        feature_range = []
        for j in range(len(dataset.data)):
5 f7 V7 m/ h0 N. d' a% {            if dataset.data[j] not in feature_range:
1 J. G# F2 ?+ |8 s, I                feature_range.append(dataset.data[j])

        spilt_h = 0.0
        for feature_value in feature_range:
8 T7 @/ v9 {0 V# L6 ~) l            subset = get_subset(dataset, dataset.feature_names, feature_value)
            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)
- t$ _! U# b% p& N
, g+ R/ h0 t9 C; }+ h- w        if best_gain <= base_h - spilt_h:
            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names

6 i4 q( {# t+ z    return best_feature

# 返回数据集中一个数据最可能的标签
  m8 J9 E4 x/ S: \2 ^6 y  g; a; Rdef vote_most(dataset):
    target_range = {}
! W! U. X3 w) B4 g% t    best_target = None
9 K7 y& P" `1 ?% S' V    best_vote = 0

& v$ S6 |, I3 E6 t- h    for t in dataset.target:
        if t not in target_range.keys():
" b: T- \2 i0 q* k7 Z2 X5 Y1 `& M            target_range[t] = 1
        else:
            target_range[t] += 1
& V/ C0 [* T6 V( }% I9 Y/ w
  W& ?1 {- j/ v- ^1 Q    for t in target_range.keys():
( r: z# z0 G( {        if target_range[t] > best_vote:
6 h$ V+ A% q$ u- D            best_vote = target_range[t]
7 ~4 n' Z, }2 h! d3 o  T& V            best_target = t
* ^5 y/ C! u2 q  r! X2 B. R2 N
    return best_target
3 Q4 e+ K/ {  W
# 返回测试的正确率
# predict_result: 预测标签列表, target_result: 实际标签列表
def accuracy_rate(predict_result, target_result):
6 w7 i5 s! ?( k3 E    # print("Predict Result: ", predict_result)
8 q: N$ H: ~' k& H# f3 _- F- x    # print("Target Result:  ", target_result)
    accuracy_score = 0
    for i in range(len(predict_result)):
1 b( \% A1 g: E1 v+ ~3 @) c1 I" |        if predict_result == target_result:
6 Z3 {& R  C5 h3 m) D) Z6 P8 J, n& C- |            accuracy_score += 1
    return accuracy_score / len(predict_result)

8 P* [& T4 V0 F# 决策树的节点结构
& r. P6 ~9 S9 v4 ^7 }% G# nclass dt_node:
2 k$ w4 i# Y/ e, ~
0 j" D& \; ^0 \" c0 ?" |    def __init__(self, content, is_leaf=False, parent=None):
0 b' y1 x. p4 ]/ L6 a7 O        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
$ X" _6 m7 E! S' ^& D: u" _        nonce += 1
" w  \) R6 w8 Q& G- i& H        self.feature_name = None
+ N  u5 J$ R6 e+ _        self.target_value = None
        self.vote_most = None # 记录当前节点最可能的标签
& B$ L( [( k+ t' T; A        if not is_leaf:
            self.feature_name = content # 非叶子节点的属性名
        else:
            self.target_value = content # 叶子节点的标签

        self.parent = parent
- [3 \4 Z8 r1 r1 h, c/ Z        self.child = {} # 以当前节点的属性对应的属性值作为键值

# 决策树模型
class dt_tree:
8 M3 G, G, }0 V
    def __init__(self):
        self.tree = None # 决策树的根节点
        self.map_str = """
& V. m% Y& M1 l. Q2 s6 a            digraph demo{
) I  \1 x" g9 h' S2 x3 ?            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
2 t" W- a# c1 n1 J6 Y/ |4 l            edge [fontname="Microsoft YaHei"];
            """ # 用于作图: pydotplus 格式的树图生成代码结构
' Z( l- O/ E1 {        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值
! [3 D( b! H* s$ i. [( J0 T9 @! M
4 @  C* `, m2 u4 v* @7 @1 n) V    # 训练模型, train_set: 训练集
    def fit(self, train_set):
$ D, u( |8 T' |1 E, k  E
" ~1 Q  L4 n  g+ I9 P        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
            return None

$ o/ a; x" R# }/ C" A4 n        target_all_same = True
        for i in train_set.target:
            if i != train_set.target[0]:
                target_all_same = False
) @# @7 J2 U! |' |% N& _) D0 y                break

        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
( v* l% h: }2 ^1 _            node = dt_node(train_set.target[0], is_leaf=True)
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
9 N# s: w. t) z' a& D                self.tree = node
* ^$ \1 N1 ~8 U& b" a/ S
. g4 x( J, ]' {# T4 x            # 用于作图, 更新 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"
( W# C, \# t1 V1 J7 ]+ ?6 {
7 g& L% u0 ]- z9 V3 A6 g) d% Y            return node
* a6 l# K2 p: Q        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
2 A& G% `; s5 q3 ~, x4 R6 j            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
9 {% d) u2 X0 r, K4 Z                self.color_dir[vote_most(train_set)] = color_set[0]
! T1 p5 R+ Z/ {                self.tree = node

            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
: H" ^  v; e5 a4 c1 g            node_content = "标签：" + str(node.target_value)
9 z+ G- K0 G5 m! j; h$ C$ Q. R            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"

& t! _3 k& Y) r5 x! m            return node
        else: # 普通情况, 构建一个内容为属性的非叶子节点
            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
; k$ r7 Q+ n$ h/ ?' ^# h4 i            best_feature_index = -1
0 a; n9 g0 C) t; L2 `& ], J" _            for i in range(len(train_set.feature_names)):
                if train_set.feature_names == best_feature:
                    best_feature_index = i
5 b8 [+ {$ i+ U# N                    break
; A  p9 F* o9 U
7 `( r1 Y+ B( {; L* ^3 i            node = dt_node(best_feature)
+ X# P+ m& x4 `3 y6 I1 d" f            node.vote_most = vote_most(train_set)
            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
. i' R3 n; h6 Z4 r6 G# i                self.tree = node
5 |0 {  ]* ]% d8 y8 r# n: N3 ^1 j                # 用于作图, 初始化叶子节点可选颜色
                for i in range(len(train_set.target)):
8 c' z8 z" B! E                    if train_set.target not in self.color_dir:
% G8 z1 C9 k2 w% W8 C4 j                        global color_i
5 [, g6 R) L- v5 R6 p3 A( c$ Q                        self.color_dir[train_set.target] = color_set[color_i]
                        color_i += 1
5 V2 a. Q  Q: a                        color_i %= len(color_set)
( `$ @+ F. X% ~) L# j8 q
            feature_range = [] # 获取该属性出现在数据集中的可选属性值
( F; @  G; L% I5 }1 {, `$ X            for t in train_set.data:
8 m* |( o5 E& ?" l$ G                if t[best_feature_index] not in feature_range:
3 [; n3 f  \' x9 Q0 U* o3 E: A                    feature_range.append(t[best_feature_index])
2 T, N3 a) |5 _3 m* c% A
            # 用于做图, 创建一个内容为属性的非叶子节点
            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)  # 获取每一个子集
/ s# A& c( Y& j$ X9 B. f* _                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
8 I  N. T+ ?1 w5 R                if node.child[feature_value] == None:
                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
1 k7 O0 F- a* J* z6 N                node.child[feature_value].parent = node

6 e! p. J% ?$ ~6 U" Y' H% ~                # 用于做图, 创建当前节点到所有子节点的连线
9 [% W" D  @8 A& U, O6 y% N                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"

$ X9 v, o5 v6 s7 b) X: n            # print("Rest Festure: ", train_set.feature_names)
            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
$ B. Z" p$ W3 y6 s0 g2 Z- d            # for feature_value in feature_range:
: Y2 P6 F7 o1 d# X8 ^  l8 o            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
            return node

    # 测试模型, 对测试集 test_set 进行预测
    def predict(self, test_set):
, y% l' c) r  P8 V( q        test_result = []
+ O' _5 |$ T: b* v' E4 C  P        for test in test_set.data:
- C; d2 W& h( f( |. h% e            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
' @4 |8 `& ?, v5 U# r. b9 r            while node.target_value == None:
2 C, X5 K7 K+ F                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
( r3 G3 m  J& O2 m$ g$ C0 ]                if test[feature_name_index] not in node.child.keys():
                    break
                else:
                    node = node.child[test[feature_name_index]]
/ o  Q, a, V9 z7 w$ ]/ v0 }( @0 E
            if node.target_value == None:
" `9 t4 x7 X3 S$ K2 A  i3 k5 E3 y9 s                test_result.append(node.vote_most)
) e! s% s5 _) N3 d1 c! s% J) f            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
  l7 O& p. H8 y- z1 M                test_result.append(node.target_value)
3 N. A" `6 ~; @0 X$ ]$ @! f, X
        return test_result
( J, _  ?% i( Q5 M
    # 输出树, 生成图片, path: 图片的位置
    def show_tree(self, path="demo.png"):
+ R; K9 |5 y! ~5 V        map = self.map_str + "}"
        print(map)
& U6 x. c; u7 y- z$ @        graph = pdp.graph_from_dot_data(map)
2 H/ j# D3 e3 \  V8 m3 t5 _3 m7 B) u        graph.write_png(path)
9 \0 N0 Y) b# j4 k# T$ B4 e6 D
# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
# P# D$ x( G; x, R, v3 k    c = dataset
- g# w* m- r6 V# f    r = range(5, len(c.data) - 1, interval)
: M" e) a3 F7 r" S9 O# K    rates = []
. D7 k$ _" N* J, @    for train_num in r:
        print(train_num)
- f" q* N% ^1 Z        train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
! ]* z2 L& z9 b" n+ c, W        test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
2 B8 F0 G- O1 q, O3 N! }7 W        dt = dt_tree()
        dt.fit(train_set)
        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))
0 |5 p7 q2 Q3 K6 F& g
# p4 f2 G- U) q5 V3 s0 ]    print(rates)
! `, v% q0 A. L1 s+ |+ F    plt.plot(r, rates)
    plt.ylabel(label)
/ x' X; M. p" S& U: ]* e: I/ J    plt.show()

if __name__ == '__main__':

6 g# w# ~  X" ?. E  ?9 I    c = load_car()  # 载入汽车数据集
    # c = load_mushroom()  # 载入蘑菇数据集
7 }* [/ ?' E) v    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
1 X( q; s# ^" Y6 a- 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:])

    dt = dt_tree()  # 初始化决策树模型
5 a. r( `  q# x0 T4 ?3 a    dt.fit(train_set)  # 训练
    dt.show_tree("../image/demo.png") # 输出决策树图片
    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)
5 m3 `& }  ~! m' K


1
  E& R5 o( e$ w- m2
: N- ~2 c" h) P# L2 ^3 [- q3
1 x/ p1 H5 B8 I, N) M4
, R; Z/ H$ X) m" S( g" B9 b8 H5
6
% r/ c" I3 R7 y% }# m" r( m7
8
9
10
11
* q1 U- ~* j# P- h+ R12
$ i' ~2 [- Q1 K5 F13
14
6 p% A: g5 {  G* k9 X( ~5 z. \15
16
5 D/ f; z6 J6 b" _- d9 r17
18
19
20
; Y- a4 f$ ^3 E3 `21
% Q+ `1 }" x/ U22
23
6 d. i. d* }+ \$ s24
- n! N, l) a1 g0 u) b25
6 W0 h% Z) d/ K2 v26
/ c2 `. w' ]+ ~1 f& t2 s' f27
28
  E" V+ |5 J: Q: r" n$ z29
% a3 S/ r% B6 D) h. ?+ x30
31
32
33
34
- R  o- |& _$ n- A  c4 `$ r, K/ y: {35
36
! O# l# q* C$ `3 E: O37
6 [) B. B& i" G1 I6 X) E2 N38
39
" S! P+ W, C; L9 t: q40
41
: m% p0 j: R' [/ g) U42
, m6 k1 B# }1 B" V" ?" B2 E2 i2 C8 a7 \43
44
45
46
4 K& Y& N% u# f7 r+ G2 }1 I47
48
49
: q; |  `) K& o50
51
5 P/ b/ A$ L# Q- R0 m' g52
53
' P  A3 Q" P" l* j. _+ o54
55
56
57
9 O2 I  D# B/ \& ~4 _58
, y! l; }8 C$ x' K4 g6 y8 n$ o59
60
61
62
63
& G3 X: t# L0 B& m64
6 V8 Z: j+ f! _) k$ ]65
66
2 j  T7 T/ R$ S2 ~- Q. z) {5 f67
* Z( J$ g+ ~1 ], A; N8 X& o. Z68
69
7 l' f5 c7 K/ l; S+ G70
! Z( Q& K6 ]+ v! Z71
72
73
74
/ z3 ]& |$ F. @( M75
0 u# X8 {* {" e& F76
0 s9 u+ c* t: A4 }/ p77
0 \/ k7 y3 a0 r5 \2 r$ ], M78
79
80
81
- k% V- S3 u( q$ z8 {2 n+ v) j82
6 s0 P5 X! R( @8 P0 G5 B2 X' U8 e83
84
85
9 a+ e6 y9 o" t86
87
5 H1 Z. t* H7 ]$ ^: I* o/ G88
89
90
91
92
93
94
95
% {' u' F  H9 Y+ U" a8 E96
( Z0 ]8 P2 p6 U2 v! x3 b& F97
98
6 R* l3 R/ ~  s! Q- c% _, r9 y, e99
100
; D5 E9 @6 f1 g0 A" A$ v101
/ \9 h; V! ^) Q8 d102
103
104
105
106
3 s. K$ F8 V+ a( {- l$ M) o7 A107
2 x+ `1 ]$ y& t+ p- A- r0 M( m( w108
9 R1 g8 d0 d+ {6 c' M109
; f7 @) x7 A. h& |110
111
+ A/ p2 d( U: m. J5 ]; V  b112
1 b, Z$ K) N6 P+ B' c9 }113
114
115
& [* k: {9 E4 G* T5 S! b116
; d3 Z' [$ n  o! l7 i117
; `7 Q+ m3 ?- S5 k118
119
( r3 Y4 o+ K& d$ b0 t- @5 y( k$ k120
( B. V8 h: A3 k  T/ Y& o! P121
" D6 f6 K. @+ }4 g122
123
124
125
+ H# y2 E9 v6 c! ]1 G126
7 ?, n4 d& U) v0 B127
128
129
130
131
1 J. S* G( F2 c: y% M132
" o$ U( J! X5 ]0 V133
134
6 E. v! q* V, T* }- N& b135
136
137
. t) U! `) \6 p8 e3 U0 I138
  N7 F. m" s3 S- f% O/ W139
' y1 J( `" H5 Q0 U7 R140
/ ^/ n0 D! Z# ~/ Z1 g) l  I( f141
, W& U8 H( p: c7 s- R# ~! R; [, b142
" b& W8 j) P2 ^' r5 E/ h5 h143
% g! J+ n! w* p3 D% J" Y144
145
: |) N. A9 q8 m7 K, Y% u: Z146
147
148
149
' d! W1 J8 O( ~# l. X5 T150
151
9 ~8 E, x4 m( d. M152
153
9 P* I. ^& |' @  {3 r154
155
156
6 h6 R8 o# M  Y1 P4 p0 R157
158
159
160
5 }4 e" d# j3 r161
  {: P0 J% N, X8 m; U162
163
164
165
6 X) X" t/ v6 U( X166
167
/ z, V1 p/ R9 _, F8 P4 Y  u168
5 K  E+ v5 F* C2 r4 l# |169
170
171
% m1 R5 a2 R1 t( Q172
% S; b% L/ i4 i$ S& S& L: f2 Y. X173
* u2 [; v$ \) r6 j2 I9 N4 f174
# v$ t) Z5 x6 `175
6 [3 Q7 s: k" ]% v4 b8 L176
177
178
179
180
181
# T" |  y6 I) ~# H$ G182
183
184
185
186
  x2 u5 ]  R, w# t% y0 z7 c187
188
189
2 r/ r  ^* q* L) V190
191
' C0 H8 @, E- V  y. i4 Y& y0 _192
# M5 |" b, h9 i3 N1 L, l9 `9 Y1 ^193
6 G  M+ w) r% w, }4 x, T194
195
" C7 v' C$ z# b. M3 H7 a196
197
! [/ t( z( j8 C2 t7 K198
199
4 _; A$ T; d" z200
# K3 B: K' ]" t: ~( c8 C201
202
) W2 W4 b3 }0 h- A$ [# w203
- K3 W! e0 ^3 H5 v  d7 D" K204
205
( N" d( A; y1 t5 L8 |1 p9 z206
207
208
209
& m9 N, o5 F$ L. A0 C0 d' G210
211
212
213
) @9 W/ |$ ~# u4 ?' _# j3 w214
+ i; s( ~& @3 p$ B% c9 o215
* j9 U: i5 K/ j* N' f- g! B1 ^4 ~" N216
217
218
& t$ z, q$ R0 c( f219
220
221
222
223
224
225
6 P& X9 g3 S  c6 q226
227
( [  Z* B* F1 {9 q228
. R1 \7 k$ q, E5 i3 j229
230
: u6 K0 f  g. b* U9 I! M, r6 A231
, \3 V4 O$ X! _' f9 L232
& p0 G5 b9 Z2 ~% ~3 R0 Z  `, v& N1 s233
234
+ K" c9 X5 c' }& z0 n- C235
236
. w% V8 d$ \' u$ P( o5 e237
238
" N" S$ y5 q5 h8 I) K* g& p5 `" e" Q; A239
240
241
* F0 [/ b" M" v242
6 g; p2 x: R$ P7 o4 D1 `6 @243
244
245
246
" O' O$ G" V' }1 T; |247
8 }6 N1 L) }# v9 {+ l  i/ V6 D4 y! ^7 S248
249
/ w& {3 U1 Y% U1 n3 U250
: o# b2 t) |5 v251
% E0 A0 T8 r; o4 z5 y252
253
' Y6 y/ T/ Q8 v' ]1 A  _254
1 n4 b# D+ r5 S) a" Z, n255
) h- Z1 E0 I" \* h0 u+ i256
257
. Q& V" V0 {2 ^! W* K258
( T2 T# o# ~* e; U2 b259
260
261
) H5 U, d: A4 E% P262
9 E$ A- {  W- u1 P& z$ }+ Z263
: O# q1 |) z5 t' o264
265
266
$ E. A9 d, W. ^, V) A% b  R; W: I267
268
2 W2 C  v2 ^7 `$ d269
* i) q( `# k$ {3 k8 C  J270
271
' b, o' ^. I. m+ G4 I272
6 |( ~. l# A* C3 g273
274
$ a# Z! y1 N# H" e  {3 G. n275
) C) s' S9 a" _; w+ L3 e  i( {$ I9 ~276
  g# b5 V" T) @: C277
" }4 j: o, Q- r: X278
279
0 {; v( O/ E. Z- r+ ^! g: G4 b  c280
281
282
2 W, e" H% b$ q. E283
284
2 h- I# H: q% B7 g& D3 y285
/ j+ T. u9 D8 R8 N6 O  R286
287
288
289
4 R4 F6 \6 I8 t$ ]1 W290
291
292
; i3 ?( k5 W2 J0 L293
! B6 X* p) k9 n% L. V- ^8 ?294
295
0 M; h' v7 T3 G) ]296
4 [# L2 ~; p+ H/ Q297
! A! g+ y. |, d2 k  W- R298
4 ]+ L& V' b  V( b299
) U4 ?( K9 S, g+ l( j: S6 J# q300
301
302
303
1 y1 m7 z4 x8 }( u1 o6 R304
305
306
307
0 c6 D5 I; `8 q# ]# D; x. ^308
309
310
" [5 \/ J$ E, R8 {: S1 s311
312
313
314
315
316
317
318
$ I  a4 l2 ^3 l9 Y; B) d319
$ G  b  X* [% X; o$ y+ ], Q, X9 Q6 Z320
321
322
8 o9 ]3 ?* G6 e6 I/ A323
" V$ M6 f; F& z  ~324
325
: o0 c7 O1 `$ y9 s  }, q326
327
328
! z6 [2 |6 D4 G0 t7 ~, c: w329
330
: V& L- P; h; U! A% o- ?331
0 _- U- T$ {# b1 H' \7 k4 L

2 t. L# C) O1 j$ ?5 p( K6 ]

- ]5 x, E7 r7 V& p- J' N( C% Y
" Q: K& M3 F" @" q9 Z
+ S$ E% n7 C+ M7 Y; C- C1 q9 X

9 c( J1 F$ A# `& K

5 R! @2 N3 K4 m' w* d

————————————————
: P: V, p0 r0 [% L5 ]: }版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242