基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

决策树模型
7 ?- j' X/ }+ j! h目录
人工智能第五次实验报告 1
6 x5 L! W7 J2 N+ Y1 o决策树模型 1
: B: I2 n0 d1 G8 f* m8 l5 a; K6 s一 、问题背景 1
0 d& {1 s: I2 {/ _% ]1.1 监督学习简介 1
1.2 决策树简介 1
二 、程序说明 3
2.1 数据载入 3
2.2 功能函数 3
- Q* D2 n+ F5 i" n& h2.3 决策树模型 4
# E$ v0 P, a4 B( A3 c2 r( l三 、程序测试 5
3.1 数据集说明 5
3.2 决策树生成和测试 6
% m; X) J0 _8 `! \4 w3.3 学习曲线评估算法精度 7
4 w5 V, {  u# m5 |/ D6 ^四 、实验总结 8
附 录 - 程序代码 8
一 、问题背景
1.1监督学习简介
! Y+ v" n; }1 f3 K机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
3 V6 N& ]# |; g! q0 W: ~1.2决策树简介
8 e5 Y$ ~7 K. i2 S% W9 |决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
/ l$ i6 Q4 C; i, i  A0 O决策树的组成
* z0 O6 b5 P& A& h9 }决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
/ {; ]. v- t. Q) D: H7 h
. B% t" H' A% p, C" N9 oimport numpy as np
from matplotlib import pyplot as plt
from math import log
9 M# `: v' ]/ c/ B2 c. g9 fimport pandas as pd
* I' p. P* H0 s& limport pydotplus as pdp

"""
) W: d( X* }5 i8 b19335286 郑有为
人工智能作业 - 实现ID3决策树
1 t3 K* r! M9 K"""

) E8 Z: t2 v4 V0 x0 _# b4 b( S- @2 xnonce = 0  # 用来给节点一个全局ID
0 }$ s' r' F+ S' p( e! F/ jcolor_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
color_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
% N5 w: g% s! t# w
# 载入汽车数据, 判断顾客要不要买
2 [- G& E7 Z, H2 m! S+ u7 ]0 y! Eclass load_car:
    # 在表格中,最后一列是分类结果
" ~9 K  k8 Y+ e( j    # feature_names: 属性名列表
% }. a- I* {* A    # target_names: 标签(分类)名
  i" |' P- L  O4 ~8 Z5 ^    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
# Y( \/ [; j: ?$ g- }8 _8 G" c8 {    def __init__(self):
- B' U/ c' o6 z5 b! r/ h0 s        df = pd.read_csv('../dataset/car/car_train.csv')
0 _, B, m: J9 M$ ^8 i        labels = df.columns.values
  X' E; x# C% A/ U1 s        data_array = np.array(df[1:])
& Q9 H! T8 _  b: w6 v        self.feature_names = labels[0:-1]
- I; g; i" J, f6 }1 p+ ?) y        self.target_names = labels[-1]
7 i; ?6 Y2 [: ]+ G        self.data = data_array[0:,0:-1]
        self.target = data_array[0:,-1]
+ s1 `$ Z+ f4 R" Z* X) w
# 载入蘑菇数据, 鉴别蘑菇是否有毒
# b4 ?* p3 P8 f. [class load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
7 {2 Z4 X7 ]2 |2 z. `    def __init__(self):
3 @3 F' ^- U$ N# {: y5 J6 W! n7 l        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
* p  }; \# ^$ u# ]        data_array = np.array(df)
+ E3 [$ A' {( `0 N0 w        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",
! z0 \2 h  R8 c: ]. N! B) a* a                  "stalk-surface-below-ring", "stalk-color-above-ring", "stalk-color-below-ring",
  h+ r" u6 o+ i5 u) J1 _2 m/ }7 |                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
        self.feature_names = labels[1:]
- X6 X* f+ {$ u9 ]+ N        self.target_names = labels[0]
/ a6 M* ?+ U# }: y        self.data = data_array[0:,1:]
        self.target = data_array[0:,0]
( |3 d) k5 P0 z$ L, [  c! b0 u$ C
4 P7 H/ v' r1 t& {) k" F5 F# 创建一个临时的子数据集, 在划分测试集和训练集时使用
class new_dataset:
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
. I7 h  I  _  Z- l& c        self.feature_names = f_n
        self.target_names = t_n
        self.data = d
3 f  R( _' y6 l( c+ i1 V# ?        self.target = t

5 u+ F- \; X. G! A: e0 N# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
) R+ d, j. i, @; L8 x) d, A#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
, R6 R' L* s! @6 Y# target: 分类结果的列表, return: 信息熵
! I3 y# J) I- O& C- Z7 e+ Xdef get_h(target):
    target_count = {}
    for i in range(len(target)):
# D5 N" f- [3 O0 L# g7 b; I        label = target
( @9 y* x2 x  O        if label not in target_count.keys():
            target_count[label] = 1.0
        else:
' U2 R3 k" t, b& \6 a            target_count[label] += 1.0
4 \& S% o  t6 l9 r  j2 s6 ?' C% g    h = 0.0
- _  D* ], Z  w4 j    for k in target_count:
        p = target_count[k] / len(target)
9 q6 M, K% N9 A" \0 z/ y* E        h -= p * log(p, 2)
; K/ E6 a1 ^: |3 }) m9 B$ C    return h

' L4 `! R$ R$ S- u; N5 V- p+ M# K# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
9 a* G. \3 r8 Z, c- [& m  wdef get_subset(dataset, feature_name, feature_value):
    sub_data = []
    sub_target = []
    f_index = -1
; m$ h+ |# G# X* a/ O    for i in range(len(dataset.feature_names)):
        if dataset.feature_names == feature_name:
            f_index = i
8 h, N0 _0 z( c; @            break
) }& I9 i7 T: U4 S7 X8 [6 v, I
    for i in range(len(dataset.data)):
$ j. F$ ?, O& D: \) M1 a7 i        if dataset.data[f_index] == feature_value:
2 y/ ~# o! y3 m. J            l = list(dataset.data[:f_index])
            l.extend(dataset.data[f_index+1:])
            sub_data.append(l)
            sub_target.append(dataset.target)
- N3 u; V, a: t+ k) g# i  I
    sub_feature_names = list(dataset.feature_names[:f_index])
6 f3 \/ _0 f! S8 E% w$ S    sub_feature_names.extend(dataset.feature_names[f_index+1:])
    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)
; ~, d: U7 ~9 |: Q* y7 R
! w# T7 T* D* X3 Z: o+ f' w# 寻找并返回信息收益最大的属性划分
$ e+ S" {  z: j. b2 m" f# 信息收益值划分该数据集前后的熵减
# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
1 v! x$ S8 R  a2 u; j! e* edef best_spilt(dataset):

    base_h = get_h(dataset.target)
; R5 d  H% m5 P1 Q$ t) ^7 }6 U    best_gain = 0.0
, E0 |6 P3 z4 ?. y( e' z    best_feature = None
) k) Q8 d7 C9 |! `9 i& s# g+ t# Q% w    for i in range(len(dataset.feature_names)):
- P- K& z. u+ h9 p! }        feature_range = []
6 T7 w+ [* d" J& E8 O        for j in range(len(dataset.data)):
5 p7 H% ^- u7 y+ \2 ]5 S            if dataset.data[j] not in feature_range:
                feature_range.append(dataset.data[j])
0 ?2 H, z; n  ^; e7 \
        spilt_h = 0.0
( u  o$ N6 `7 v' b7 N& f3 Z        for feature_value in feature_range:
            subset = get_subset(dataset, dataset.feature_names, feature_value)
( T" u0 o0 T- m( D2 E  a            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
            best_feature = dataset.feature_names
4 [4 v& F: P& C/ ]& i! `; m
    return best_feature
7 m5 t4 Y* F" l9 [; P5 g4 N
# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
    target_range = {}
    best_target = None
    best_vote = 0

0 z( V" ?  C& ?- o, F    for t in dataset.target:
* C; e. D" T# \" S2 h        if t not in target_range.keys():
            target_range[t] = 1
2 j8 g$ b  H+ J2 i# s, _        else:
: ?' {: J: Q! f$ |& N4 W3 F            target_range[t] += 1
9 W9 \  I6 z# v/ B; ^
    for t in target_range.keys():
        if target_range[t] > best_vote:
: v& h. j6 L8 O6 F; V            best_vote = target_range[t]
- p( k7 o7 g3 Q; Y            best_target = t

    return best_target

7 `7 R/ Z9 J* s8 g# 返回测试的正确率
# predict_result: 预测标签列表, target_result: 实际标签列表
def accuracy_rate(predict_result, target_result):
+ B- E: A- g3 \5 W6 c# g+ d    # print("Predict Result: ", predict_result)
5 }3 a" ?) O* ^* z  `& c    # print("Target Result:  ", target_result)
1 t5 j! S  J% A2 Z0 X% N    accuracy_score = 0
    for i in range(len(predict_result)):
2 O& ]- B$ l5 N        if predict_result == target_result:
            accuracy_score += 1
    return accuracy_score / len(predict_result)
# E% D& ]- W! O* ^9 d% c0 x- k2 A
# 决策树的节点结构
% Y" Q' v, ?% G) P- ^class dt_node:
( [* d  p& j, b4 y: J
6 r+ Y4 M1 \2 `: t: n# b2 @* d    def __init__(self, content, is_leaf=False, parent=None):
        global nonce
6 }1 o6 `$ t; o+ U4 |7 o0 K" p( f        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
) ?* W3 n5 S* L        nonce += 1
        self.feature_name = None
        self.target_value = None
        self.vote_most = None # 记录当前节点最可能的标签
5 R" e3 x( p' G. S  x! k' @* o1 x        if not is_leaf:
( D' V* A* |! i9 @: f* z/ z            self.feature_name = content # 非叶子节点的属性名
        else:
            self.target_value = content # 叶子节点的标签

( }' M7 l' U) I* R+ a  j( e; |  b/ J0 ~        self.parent = parent
        self.child = {} # 以当前节点的属性对应的属性值作为键值

# 决策树模型
class dt_tree:
9 f* B/ b  }+ X! |8 l! O* D: }
9 K% F1 Y3 R1 ^1 h6 k    def __init__(self):
: c/ }: `( \. s        self.tree = None # 决策树的根节点
        self.map_str = """
" F2 t. j  z5 i: B            digraph demo{
. _4 F- x" a. q6 Z9 U            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
. W. q% {; n# u" G7 n            edge [fontname="Microsoft YaHei"];
  M2 k2 K" d1 s: q& C7 n3 n% H4 c& ^            """ # 用于作图: pydotplus 格式的树图生成代码结构
        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值
0 U2 h( E6 l9 Z' ^2 U/ `7 I8 Q1 i( K
  }# f( b: {+ Y& k/ B# s" V    # 训练模型, train_set: 训练集
    def fit(self, train_set):

9 M6 h8 C1 v0 \        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
            return None
8 R. P: B  @) T* @# Y( f3 Q
6 @4 I5 f% d- @        target_all_same = True
        for i in train_set.target:
" O8 M% x5 Q3 {            if i != train_set.target[0]:
4 _4 C4 K8 E) t( H/ o! Q                target_all_same = False
                break
# i2 x# s. i* }9 B; h* s0 I
        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
) i% e/ U) {; y* x& q. w1 Z* Y            node = dt_node(train_set.target[0], is_leaf=True)
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.tree = node

: r0 [) X* f1 b' b" r            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
. d, t6 [: R2 R            node_content = "标签：" + str(node.target_value)
% H* O6 I/ P$ }8 B0 y9 O            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
9 b8 f1 T5 V! j) W7 }
            return node
        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
& q% Z9 X1 D( r/ v; T/ i                self.color_dir[vote_most(train_set)] = color_set[0]
9 O' Q" f- l0 G" I) ?                self.tree = node

            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
: }) d* y( I6 A1 _5 W# u0 G            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"

0 r# c" j% H6 P6 W            return node
% _; r9 }1 c; s4 j$ X% j% C! o        else: # 普通情况, 构建一个内容为属性的非叶子节点
* m/ Y! w% e7 I" H. |3 f/ u2 U            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
            best_feature_index = -1
% k8 l  i+ e; o4 w            for i in range(len(train_set.feature_names)):
0 f8 Y" b- J7 I4 `; p% S0 z                if train_set.feature_names == best_feature:
% V7 r( D: l; N, _' {  I) v  V                    best_feature_index = i
                    break

            node = dt_node(best_feature)
& ~! V, F, p& R) E            node.vote_most = vote_most(train_set)
# c7 J* J7 [+ s  d7 H, Y& v            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
                self.tree = node
                # 用于作图, 初始化叶子节点可选颜色
) F6 C9 t4 R. o- C( n4 \" y                for i in range(len(train_set.target)):
                    if train_set.target not in self.color_dir:
8 e+ r3 e+ b% w4 a. R5 n                        global color_i
                        self.color_dir[train_set.target] = color_set[color_i]
                        color_i += 1
0 G" T; Z9 C& \2 n                        color_i %= len(color_set)
9 S" A0 t5 [, D" P/ r: t4 [
            feature_range = [] # 获取该属性出现在数据集中的可选属性值
            for t in train_set.data:
                if t[best_feature_index] not in feature_range:
                    feature_range.append(t[best_feature_index])
2 {$ @5 o& |# E$ k0 d
            # 用于做图, 创建一个内容为属性的非叶子节点
            node_content = "属性：" + node.feature_name
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"

% i- d4 `- f  k  l8 ~) c            for feature_value in feature_range:
                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
3 }$ B2 t' E% z# k+ G& y( ?                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
& S: s6 ^5 m; D+ d0 c/ v                if node.child[feature_value] == None:
+ C* P' q. t6 q6 Q* N                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
* [8 n- I0 G4 q4 b                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
. I: {5 ~" \. c3 D' ~                node.child[feature_value].parent = node
# o- q5 Z1 a/ W; ?! U8 W" n& r
( _- d# k' m7 ~5 P  M  N                # 用于做图, 创建当前节点到所有子节点的连线
1 I3 {* p9 Y, O; b                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)
& Z6 ?; \6 X) W% W7 U, {# `- O# U& ^4 S            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
7 V9 T% D# G+ d) t) o( ~            # for feature_value in feature_range:
            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
1 C3 E. v* \5 z% C/ p: s9 i            return node
2 Z# n0 B7 k: T- H
" P# f1 I2 l4 G- c# g7 L. N    # 测试模型, 对测试集 test_set 进行预测
. [  L1 W" B! K3 D3 d% ?8 P+ n3 n    def predict(self, test_set):
$ Q& b( l5 H8 z# w# s        test_result = []
        for test in test_set.data:
. p3 ]2 f7 b+ \; J8 b3 P/ c9 T% {- j            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
            while node.target_value == None:
. e! Z8 s* I9 `" n. Z  s# I                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
% a+ y+ `( s, U( d* L: ~1 M                        break
                if test[feature_name_index] not in node.child.keys():
8 ~( f& K4 ^* a! B- F1 M" M% d" A                    break
                else:
; h: ?2 W8 @  r: n                    node = node.child[test[feature_name_index]]

/ q7 R; U) {$ |4 i4 Z  B            if node.target_value == None:
- u0 A& f* y1 o- w% d0 k                test_result.append(node.vote_most)
            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
                test_result.append(node.target_value)

        return test_result

- v0 N3 g3 ~4 G+ u5 u# e    # 输出树, 生成图片, path: 图片的位置
    def show_tree(self, path="demo.png"):
0 s3 V" Z1 N! k: P" V- H# W2 m        map = self.map_str + "}"
& K+ B4 q: H9 y1 |        print(map)
5 Z. x% m8 {% k+ g: |" U/ i! P        graph = pdp.graph_from_dot_data(map)
        graph.write_png(path)

# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
+ r3 ?8 A! H# b5 m4 e& p    c = dataset
    r = range(5, len(c.data) - 1, interval)
    rates = []
    for train_num in r:
: ]6 L8 z4 h, @* u. `! o0 y        print(train_num)
4 R: Y4 g, g" y# K, Q+ S        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:])
* \1 _' u3 x( ]        dt = dt_tree()
        dt.fit(train_set)
! Q2 S% D/ I, `1 u        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))

, b" e8 J5 [1 a$ k5 I: w* _    print(rates)
    plt.plot(r, rates)
    plt.ylabel(label)
    plt.show()
7 d9 Y, Z* F1 B0 M0 h2 u- e1 \
: u' q/ H1 W+ U- mif __name__ == '__main__':
! p( M% Q, j  o( L$ }1 I" s
    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])
4 _+ E& s2 J9 |7 u    test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])

    dt = dt_tree()  # 初始化决策树模型
9 u' w/ z+ |1 T: ~7 M: A    dt.fit(train_set)  # 训练
    dt.show_tree("../image/demo.png") # 输出决策树图片
; R. Z* s* g$ I1 I; [! i    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)



1
2
, o" ]' t$ b" a7 }' y/ L3
4
5
! n. o, A/ [  q1 B9 L1 m6
- R2 O6 W, T- ^& j& y7
8 w; z  ~8 S3 t5 W) L8
) e2 {8 h1 J9 I& G9 j9
10
/ }0 u& }, F- f  C0 W11
+ f# `1 |- E3 M* C3 _12
13
& n: Z+ j% U. M8 P- C  X7 l, N8 y( ^: G14
15
$ }: j  @1 G; F3 A9 J8 _0 R( |16
17
4 H& B0 F" D' c) ^8 B18
3 E9 F$ Q: I7 U& K' B19
20
21
3 n! h9 {9 p5 q22
, K% G! L5 v# u" g7 d4 [9 b; C23
24
4 ?/ |& `1 b) [: r; x25
" T: `0 a1 M+ Q! a8 b( w0 @0 g26
27
# C) R+ d- t, `3 \28
, W7 _2 ^/ V3 w3 S+ p; c29
, R2 t3 K/ j% \. M8 W30
31
32
33
34
35
0 r+ u9 ?8 i* U7 r1 U0 q. |+ k36
/ j2 z7 c1 ^! F$ \37
38
  R5 p  p! X$ f5 g  h39
/ U  [2 u6 K8 t. t- g, P6 s! x40
4 Y, a! a8 N- V, `! m6 U4 t41
42
43
* ]) r' {' U6 v44
45
46
47
. [! @0 }8 I8 N! r4 G48
49
- j) }4 v1 r2 U6 P50
+ {' O- C9 K* a. X, R- O/ K51
8 I& x3 ~& j: O52
( \+ T& B" R; J, J+ P53
54
1 G& z/ i$ Z. [# X6 S55
56
. Y7 U# U9 [1 I6 {1 {$ P& k+ N' F57
0 U! L2 F' s+ x6 t( u58
0 V( X$ f3 _4 B/ [: _8 u59
60
# Q9 I" B( z2 b9 D; s61
62
63
" m( Q! o' `" z4 ?; d9 x: C8 J64
65
0 U1 D! _5 D/ Y( k, @# n1 U66
- R6 w2 e/ @! M+ ~/ `) k67
68
69
70
71
. d2 O: J, G, Z1 \# y72
73
74
+ Z2 g2 C8 G5 ~" @, l) A75
5 g* V! L7 u3 j) D6 y76
77
78
79
80
81
82
: `( U1 Q6 A1 f/ V9 J83
( g7 }  Q2 B4 k84
( D: X4 K$ R$ j. d/ i* k! r85
86
, ?9 i. u& r7 O. D, |87
88
89
9 |: ]" A1 E3 P4 n; m, I1 a, \90
91
/ }) A) n* e/ G! e( d92
# Z9 i. y/ J: T: Y4 N* y% O; V93
$ E* `- R8 \" ]8 s! i# M94
2 l) J  I- z; U6 }" d& A# p95
96
+ S% K) K: _* y+ ]2 C97
* |6 L0 o2 H- k1 P/ r. K4 p( {& y0 K98
99
# R3 u9 ^! j0 b9 j% W9 M( b100
; m5 ^' I# X2 q9 g101
2 M" H2 ?+ n! n" `8 ?" o$ F102
9 a0 D' k, n7 V9 K* B* b4 G; B103
104
' P) w0 k/ `* S0 c: W' V105
' R/ q0 F9 }# F3 q1 M106
. L' `) v; X7 w- W: _7 Q107
108
109
110
7 M) ?- S9 |$ Y& D/ t% ~4 j" ^111
112
113
114
115
* u4 C  z$ [! b: \116
117
6 d# W8 i" D& A3 w. z. E2 x118
119
, x. \+ H* m! i6 n8 P) r120
1 b. _7 F" A. S" X' [. ?5 O1 O121
5 @2 E, M1 q* l6 L* r# E2 M. m+ Y122
$ N6 g! S* [0 `! K+ B8 N5 k1 n  ^7 X123
$ E0 i5 K+ [/ W  s: ^( f/ Y& F124
125
126
& t# x: N; E# I/ J1 U; I) c2 C127
128
129
5 F% h$ r2 K4 g* I6 S" U" ^6 {. I# |0 \130
131
! E. j% g5 L) P" a/ D5 x132
133
134
135
" P  }3 }0 c; R5 R, n0 x136
137
0 ^% B' D+ ^" Z% \; ?+ }; E% p138
139
4 [1 p$ O( l% }  C& Q140
* f- |9 {7 c0 F% j: o* u141
142
8 c) f$ t# H9 s4 e) e% v143
144
+ X; C. I. J$ ]145
146
147
148
# b/ A3 ~5 R, ], W' N. m8 q( n149
" H# U+ M# Z/ Z$ n5 \$ Y% Y150
151
152
! a2 g; n* E# F6 W0 j153
154
155
156
157
4 l1 Y6 Y% Z1 ?# o, W1 m# E158
" G7 X2 R: Q2 o3 Q  ~9 [' M" i159
160
161
162
3 S5 D9 }7 F# G9 S, {+ N163
+ H- u( ]( q2 ?' U% y. _164
165
1 Y5 j' z2 C* \/ u; M/ a" k166
167
2 D. d( P  X8 h. _; ^. T! `( b! P" A( M168
4 E1 X" U) o; k3 m/ u. r169
170
171
172
1 [- t# M; Z( ]  N5 P173
174
175
3 L. r3 U) }' m9 \4 v( a6 ~( Z& p4 G/ i176
% e/ _# ?2 e, }177
6 Q4 w7 b' L( W0 v% y$ I178
+ d/ \3 X+ {' O9 R3 h: {: ?3 K( g179
180
181
182
183
184
185
186
187
. Y: [# Z2 ?! |3 b3 c) j) X$ e188
, a  g* f9 l) I189
; b& v9 g# z9 x, T# D190
191
192
( ]/ G5 f3 b, G4 B% X* `193
194
; g6 n2 \! u9 O1 H9 J: ]( a195
196
2 }! F4 F& R- ~% P* w+ r. P1 h; n197
198
199
200
201
- d# t# C" y% H' l7 F5 v202
4 i$ Q" p0 V+ _4 g9 t$ U8 a% ]203
; n% ^* v: C. v1 V( \! @204
205
206
* X2 b$ ]2 A. o. k+ {3 [207
% i# y" Y8 D0 n. r9 T  c208
9 b1 i. S5 e" v- X4 ?; d209
210
5 S$ W1 v! c8 Q; {/ J! s, ^  ]211
212
) ]6 J1 n+ C. [" P' V213
3 q# z$ K' n5 h  ~+ e214
215
8 A1 F, }- l1 H5 O216
217
1 j  \/ \* z& d# y218
0 r# ?$ O, P. H0 g/ e% W( A219
220
221
- @' F# Q* S1 j3 h  r' |# b* [222
) u/ ^& _' h; R" ?- _7 n/ ^2 n223
224
225
226
227
0 `/ g: y; {4 z" m0 u8 o228
229
  N6 t, U+ M/ Y$ p6 h230
231
232
233
234
235
; W3 g6 y3 C5 U2 A9 M& {236
$ i" O  T) Q# p237
6 @# ~: L, R. F3 H2 H' N0 Y2 `3 g238
239
240
% K7 M2 c4 k- ]# ^* S241
242
243
) T5 M) E" L8 }  u; g1 b3 i7 G244
245
  Y; R6 l/ k/ C246
+ B1 Z2 J* ~- C5 {; @247
0 c7 F! j0 m$ E# E248
, D/ P0 `# r1 q8 ?: U/ a249
9 h; h& Z1 ?3 v4 Y2 c; f- k1 B250
2 O$ K, O. I) w1 Y+ C7 H& `1 N251
252
253
+ _$ h0 m+ e7 c& W$ J254
255
256
257
: v2 z" |" r) @- E  X: ]# n258
  u6 D2 A6 o) Q: K# @0 o259
% O2 N$ N7 G$ k- n( V3 e* O9 h8 O260
261
262
2 g4 _: s2 n  J+ A! Y8 R; S8 v/ [263
5 R8 Z$ m( J0 E, {8 ^264
265
3 v2 b  W  C0 j266
3 E" ~3 g1 ]6 A: G267
268
. M& r% _% E. o4 K" e2 t5 ]" \7 f6 Q269
270
271
272
. _3 y" E! b, e$ ]) M273
274
275
276
277
278
# c2 n% @, x2 V, S. ~! f279
+ z0 c* a: a8 c  U- ~! [! v280
: }" X+ q# W7 a, G. U, S% f281
282
283
284
; E  x0 J) t! m( u" F5 w285
& G* ^2 D, e* O, R3 T286
  X/ _* c/ s$ G4 ~( N1 y# G% J# G! F287
! t8 [' H- {$ }2 Y8 D# ~7 ^288
  l) W  n; b! u! B. F& j$ M289
1 z" x  q0 I5 d: c290
291
( U# N7 N9 T: m! l) A( l292
293
294
' w" X; o7 F# w' a  \+ j- b295
' i7 a! N1 _" ^! j) |0 P/ `296
297
298
299
% ^/ r# J& t5 r7 ?: W/ k300
301
302
# F: ]+ l5 }) U5 B* ^3 R3 o9 U/ q303
304
* g5 E& p' |% i& E# Y305
306
8 j' j& Y, p/ Z, o; s  b: K, c6 F307
* L# E8 e6 a! s( I308
309
6 F0 F2 M$ a+ D' m5 V310
0 B' W) A( V. Z7 G- k0 u4 z) h311
9 J0 N3 s6 Y$ T# a. Z: F  ^312
313
314
( |0 Q2 v8 s* M& G) q; @315
% U" f/ _! P2 t1 y316
317
& C2 l+ c, ~1 H3 O# z318
6 H8 f5 ^7 N5 x: \) U* c1 H319
  t9 \3 V$ w! l: K: r* w5 K320
6 q- P, n4 @% _321
5 I( M; d6 Q. y& {) v7 ]322
323
8 W' g* o: V1 f324
325
2 Q* L- S6 m9 n9 }326
327
328
329
2 ]" Z! N6 Y+ N6 ?9 i) g7 S330
/ ~/ m+ d( l, [% C  y# m# |9 c1 ]331

0 O* s$ O; N9 V
+ f+ L3 E6 P) t  s, r) F

2 P  }0 g5 t% A: h+ X% r  B
6 {7 R6 a1 ^, z* t* p
5 C" l3 U8 ?# j8 V, S' o/ R

3 u: \1 T3 I9 U, p
+ \6 e0 m0 x" o6 K* J" F
" Q/ F- U! m: z1 ^% t7 @% r

& b6 N# N0 C' l. j" E, K————————————————
& i' ^$ N# c) C8 n5 a版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
* D3 L. a7 M' Z7 c# R原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242


+ x0 x% l0 b$ M& t8 w: [3 H1 }