基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型
% `4 W& Z$ b0 y* I
决策树模型
目录
# x. u0 g0 t6 y. H& w* w5 `人工智能第五次实验报告 1
7 V  p5 x" \( @% q. b0 [6 T; t决策树模型 1
一 、问题背景 1
$ \$ f: @) ?2 i- k1.1 监督学习简介 1
- T9 n/ _! b1 h3 k3 E1.2 决策树简介 1
二 、程序说明 3
# c1 Y7 t/ b. S2.1 数据载入 3
2.2 功能函数 3
9 r4 @* E) w) S( t9 I8 L2.3 决策树模型 4
三 、程序测试 5
3.1 数据集说明 5
3.2 决策树生成和测试 6
3.3 学习曲线评估算法精度 7
7 D# v' E0 q8 }2 S  x  K- o2 H四 、实验总结 8
* a- A, ?" V% C8 m4 B+ u0 P附 录 - 程序代码 8
一 、问题背景
1.1监督学习简介
机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
- d/ M  a. H2 R% n' }常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
% T2 Y/ k, g( W' ]8 |0 u/ s1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
- J5 `: ~, P3 _) z+ c决策树的组成
7 G4 S+ G1 c9 u. t' U决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。

( d) t1 e; l2 e7 rimport numpy as np
6 I( `* q  g2 n1 b5 t/ Pfrom matplotlib import pyplot as plt
from math import log
import pandas as pd
import pydotplus as pdp

5 E) V% e* W9 z3 Z7 T% x8 l0 U"""
3 ]  p8 R+ ?: g9 m19335286 郑有为
8 ?! m) L. @, T* l6 |3 Q# z人工智能作业 - 实现ID3决策树
"""
8 C  u5 c9 D) y
nonce = 0  # 用来给节点一个全局ID
color_i = 0
, p% c, S" |* Y) ]* J# g. M- J' }# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
$ j% F4 G5 w5 d, g& _: f2 Ycolor_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
( s8 u1 X' M; I* D6 ]
4 l: `6 g$ E4 e# 载入汽车数据, 判断顾客要不要买
class load_car:
& U0 S/ f4 ^) h2 [0 G9 O    # 在表格中,最后一列是分类结果
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
7 L. D, k$ R+ I# i  g% t    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
: _8 t  B6 P% R* y# w+ `8 E        labels = df.columns.values
% t( H; x7 p" w5 T        data_array = np.array(df[1:])
        self.feature_names = labels[0:-1]
4 I2 f& |0 G3 ^        self.target_names = labels[-1]
) P& m1 Z/ r2 {( c        self.data = data_array[0:,0:-1]
        self.target = data_array[0:,-1]
- D  T. B- x5 b$ _
# 载入蘑菇数据, 鉴别蘑菇是否有毒
4 q8 v* M7 h% Oclass load_mushroom:
1 B% T! ~! w' m    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
1 z" J# F* h. j    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
) p: ]$ o  M& v* M3 t    def __init__(self):
        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
7 n9 z1 U% ]" o; b) [4 s        data_array = np.array(df)
7 E- v8 x& u% m( [        labels = ["edible/poisonous", "cap-shape", "cap-surface", "cap-color", "bruises", "odor", "gill-attachment",
( K! i2 d- F, K2 S" ^* l1 X                  "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",
% _5 t5 e- k* `6 P) \                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
        self.feature_names = labels[1:]
/ h& @8 O. x) U3 g; L! W, X        self.target_names = labels[0]
        self.data = data_array[0:,1:]
1 \' ]: v& K9 }/ Q/ R) K; ~        self.target = data_array[0:,0]

# 创建一个临时的子数据集, 在划分测试集和训练集时使用
class new_dataset:
" @, @" N( g8 x( ?1 Y, G; [+ Z8 s7 L    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
5 ^( h% V: t; K: [. O) F    # target: 目标分类值列表
. ~2 Q: i8 A$ F! O, \; T    def __init__(self, f_n, t_n, d, t):
& Y2 \! _# p, J. y, L8 l        self.feature_names = f_n
        self.target_names = t_n
        self.data = d
4 p, Z$ A% _1 K# \4 ]- ~        self.target = t

4 \- @& q  x0 h) E& O8 W  i) _# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
1 P  P5 |3 y2 O4 s- F7 V" p#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
# target: 分类结果的列表, return: 信息熵
def get_h(target):
5 B8 a; h! M2 R9 T& M8 D    target_count = {}
/ z; @9 z: J8 w% f. E: I    for i in range(len(target)):
! {2 Q% ], _$ |6 _; ^4 ]( l        label = target
        if label not in target_count.keys():
$ j# {/ Y  q$ d9 a            target_count[label] = 1.0
        else:
8 P5 R. L% s, J' Z2 `2 G            target_count[label] += 1.0
1 u9 N7 o& w  }: m: z. c; d    h = 0.0
    for k in target_count:
) Z& Z4 h& Z" W) s3 g' J# f        p = target_count[k] / len(target)
        h -= p * log(p, 2)
    return h
6 |% W. i% P- }
( W1 [# @- e/ y' P# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
$ l9 }' l$ V2 S" O& L7 M  h# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
0 z4 t/ {) s5 d3 g) idef get_subset(dataset, feature_name, feature_value):
    sub_data = []
    sub_target = []
, k; n& h* E6 F4 h  D5 H8 l  F    f_index = -1
    for i in range(len(dataset.feature_names)):
( x5 p( D2 F* P) n. x8 `        if dataset.feature_names == feature_name:
            f_index = i
            break

    for i in range(len(dataset.data)):
0 w0 k8 }2 Q+ ~: O  s5 F, h        if dataset.data[f_index] == feature_value:
            l = list(dataset.data[:f_index])
            l.extend(dataset.data[f_index+1:])
            sub_data.append(l)
            sub_target.append(dataset.target)
6 J) K6 O, ?( D% x: ~
, U+ T; s/ h  I1 |    sub_feature_names = list(dataset.feature_names[:f_index])
, E8 N+ {6 S4 y( a) d3 [& z    sub_feature_names.extend(dataset.feature_names[f_index+1:])
    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)
: \; u, [8 q$ e7 `5 x( W' g) P/ q. V
# 寻找并返回信息收益最大的属性划分
0 K: h' F! F( I! a4 t# 信息收益值划分该数据集前后的熵减
# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
def best_spilt(dataset):
" s+ b6 {  N9 n* A, m; J! z8 P! U
    base_h = get_h(dataset.target)
; D. w0 m" `9 s# a* W* I) T    best_gain = 0.0
8 P1 }. g( H+ [    best_feature = None
    for i in range(len(dataset.feature_names)):
- C0 W' A- }. k        feature_range = []
- l" C/ L4 O1 a3 u        for j in range(len(dataset.data)):
            if dataset.data[j] not in feature_range:
  N1 L9 [/ t; ?1 e                feature_range.append(dataset.data[j])
5 ?5 r% r/ A- o( Q# N  @
        spilt_h = 0.0
        for feature_value in feature_range:
            subset = get_subset(dataset, dataset.feature_names, feature_value)
6 t8 s# P* z4 G  x% E0 v( d            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)
2 D+ Y. p4 Z3 D& b6 K
        if best_gain <= base_h - spilt_h:
% I* W8 _/ Z" Q+ @            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names
$ Q, M* |5 G$ n' G4 J( P
    return best_feature

# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
" f7 h) |: j/ C; s* ~9 R' f5 J  }    target_range = {}
    best_target = None
# m, U% E' Q+ O" E8 p3 V    best_vote = 0
" ~# b" a7 h! j7 O
    for t in dataset.target:
/ f4 _, i3 \: k  C        if t not in target_range.keys():
8 V7 s' Y- `, Y/ G            target_range[t] = 1
        else:
, l& h) [( M% P8 V" M! _            target_range[t] += 1

. q9 \6 W7 O& s* o0 T    for t in target_range.keys():
6 X, K9 x  ^( I5 g* ]. X. B6 h# |        if target_range[t] > best_vote:
            best_vote = target_range[t]
            best_target = t

0 n% l; s+ ]+ v2 v; S2 K8 }    return best_target

# 返回测试的正确率
) ~- R2 v' z9 n4 U" q# predict_result: 预测标签列表, target_result: 实际标签列表
$ x& {4 C% Q* p; y1 \def accuracy_rate(predict_result, target_result):
    # print("Predict Result: ", predict_result)
" ?) O1 o. g; z" y/ B    # print("Target Result:  ", target_result)
    accuracy_score = 0
6 v& m5 _; {0 I5 w1 V0 n& i8 r) n& w    for i in range(len(predict_result)):
( g* H; P# E# J        if predict_result == target_result:
; h2 O: y4 V0 n2 u0 j            accuracy_score += 1
    return accuracy_score / len(predict_result)

; o$ f% R. b9 ?3 C# 决策树的节点结构
* }* ^' S: u4 z8 E) C: ~2 t1 qclass dt_node:

# O, L8 Q1 C# q8 f    def __init__(self, content, is_leaf=False, parent=None):
        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
        nonce += 1
        self.feature_name = None
2 y. j) m' R: N$ q2 X        self.target_value = None
        self.vote_most = None # 记录当前节点最可能的标签
        if not is_leaf:
/ f# ^/ o! c' h( [! k            self.feature_name = content # 非叶子节点的属性名
6 [2 f5 Z+ q) c' H7 N# B1 j4 q        else:
, I) p! j; g  ?. a, {  E            self.target_value = content # 叶子节点的标签

        self.parent = parent
        self.child = {} # 以当前节点的属性对应的属性值作为键值

- |9 w# k0 }% t! X) x# 决策树模型
class dt_tree:
. p6 w; m; w4 A4 R
    def __init__(self):
        self.tree = None # 决策树的根节点
        self.map_str = """
1 Z' ], h9 v3 x5 e0 m: A$ S/ t            digraph demo{
) Z0 _; j; F# J& ]; Y            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
3 b* {" h5 q1 J& A! u9 D8 i            edge [fontname="Microsoft YaHei"];
            """ # 用于作图: pydotplus 格式的树图生成代码结构
        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值

; s2 Q4 w% n: C( \& ^$ S    # 训练模型, train_set: 训练集
    def fit(self, train_set):

) R* R$ p! y4 C8 K% G; V* ^% o        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
+ q. O( @( N* v7 Y: n. T            return None

( l( l* K2 S' N* I$ L6 Q        target_all_same = True
5 A0 T, f, O- o6 e/ E  }; Q        for i in train_set.target:
/ v/ V8 `6 f9 D  H            if i != train_set.target[0]:
                target_all_same = False
                break

        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
% W/ ~. X, M) G5 |% J+ G            node = dt_node(train_set.target[0], is_leaf=True)
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
8 u3 P0 x1 |0 i$ |                self.tree = node

: B" X6 S5 L! V% H) P7 @            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
- }! ~8 H1 F2 M, O) j& t- B: [            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"
2 [: d- F/ h* J9 @" H9 H+ X& X
/ u, t( X1 o5 k# [8 j5 s( O            return node
/ ?* U* H( X  s& {% }3 F        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.color_dir[vote_most(train_set)] = color_set[0]
/ V7 p7 y  I) z7 U& W, m- q8 i                self.tree = node

" T. d% g' k& f" T0 A: m7 Z            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            node_content = "标签：" + str(node.target_value)
4 \2 ?: {3 S* H7 S            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"

" B* v; h# [! U5 l9 X/ q3 G            return node
/ `" x9 R* ^" U; O5 U' A/ @        else: # 普通情况, 构建一个内容为属性的非叶子节点
            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
            best_feature_index = -1
1 y, U7 w( X+ ?6 Y) a$ [3 q9 p' `            for i in range(len(train_set.feature_names)):
! `7 b0 o$ w- k8 [0 e                if train_set.feature_names == best_feature:
                    best_feature_index = i
                    break

  A) |% E( n0 A* X, L9 j$ t            node = dt_node(best_feature)
2 P1 k( J+ a- o5 l) V9 \0 V            node.vote_most = vote_most(train_set)
            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
7 N$ K/ f' \7 `" V7 [, H: ?                self.tree = node
                # 用于作图, 初始化叶子节点可选颜色
1 x# N. k, g$ s2 N; i, I$ M                for i in range(len(train_set.target)):
                    if train_set.target not in self.color_dir:
                        global color_i
" K+ A" l6 n1 K2 X6 P                        self.color_dir[train_set.target] = color_set[color_i]
                        color_i += 1
                        color_i %= len(color_set)

" _) [4 h$ g$ c+ d' Q) q            feature_range = [] # 获取该属性出现在数据集中的可选属性值
            for t in train_set.data:
( Q) g- a, `2 s# a6 }, J                if t[best_feature_index] not in feature_range:
: Z- T, Q- u+ E* Q& D& E1 O                    feature_range.append(t[best_feature_index])
; K: _+ |( M$ \# j/ X: \
            # 用于做图, 创建一个内容为属性的非叶子节点
) N- Y1 ]: o7 I  x) P0 @( D9 c            node_content = "属性：" + node.feature_name
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
! w- o# m! b: x- m
) t) ^! I; c- R3 t; j5 {: f            for feature_value in feature_range:
$ s  x0 ~( \7 x                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
                if node.child[feature_value] == None:
) S6 R6 h* ?' Z+ m                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
                node.child[feature_value].parent = node
6 T1 J7 C4 S  M6 O' m, V, U: Z4 {
, _9 D1 z1 W9 r; x                # 用于做图, 创建当前节点到所有子节点的连线
5 X% n/ d; [, U" Q! r4 p                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)
, ^3 u( O' y5 B' l% a0 A* B/ ?) |1 H            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
7 U2 G- C% }# w& ]3 I            # for feature_value in feature_range:
! n& f3 ~& k$ \& M            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
# ~* J) j" I" g: U1 r; @            return node
" v0 e6 @2 p# L( w% H
  A; y+ P* w2 @' C. p    # 测试模型, 对测试集 test_set 进行预测
7 S' Q, P8 O0 m    def predict(self, test_set):
8 }; x% q/ g, M  I        test_result = []
# c) V$ l. E- l" }8 R        for test in test_set.data:
            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
            while node.target_value == None:
                feature_name_index = -1
! q+ t' e* U2 v" _                for i in range(len(test_set.feature_names)):
+ a8 f: l) u: @9 ^                    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]]

, R7 m' s  R+ b            if node.target_value == None:
                test_result.append(node.vote_most)
, ^) \  J* m9 d8 N) r            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
                test_result.append(node.target_value)
4 O/ U5 [! q2 D) p
7 t, R' k5 V% p3 G* P        return test_result

0 d& N( ~7 ~$ E4 E    # 输出树, 生成图片, path: 图片的位置
0 v: V$ f& d' c# C- J    def show_tree(self, path="demo.png"):
        map = self.map_str + "}"
        print(map)
' @- M8 c* ]+ e        graph = pdp.graph_from_dot_data(map)
5 p" Z( a9 d% ^4 f# V+ P; B        graph.write_png(path)

4 J: B# p3 l: f4 j; c, s* S# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
    c = dataset
    r = range(5, len(c.data) - 1, interval)
    rates = []
8 j1 |! `) I: h4 c# }! ]# B( d) u    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])
$ W4 r) Y+ g( s1 u; H2 R        test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
# K, \  y5 R4 l- z4 |$ N        dt = dt_tree()
& Y+ p" r- h& ?  j1 H9 S  y        dt.fit(train_set)
        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))

    print(rates)
    plt.plot(r, rates)
    plt.ylabel(label)
: M; k) d% R, n3 O9 e% y4 C0 }    plt.show()

3 I4 ~) K/ q7 Oif __name__ == '__main__':
, }7 f3 y8 g2 v
% u8 Q6 b& m/ F, h* y$ m    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])
5 J7 ]) N5 m9 h* G- V7 L$ y3 d' ~    test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
* H8 B' n' P2 b: `
- _* E: z- |+ v9 f' f/ B$ v5 _" L    dt = dt_tree()  # 初始化决策树模型
5 L1 N) P2 v8 S" ?6 N* e    dt.fit(train_set)  # 训练
    dt.show_tree("../image/demo.png") # 输出决策树图片
    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧
$ y* _! g- `7 m
8 j: Y  q1 i4 f- w  r" T3 M  r    # incremental_train_scale_test(load_car(), "car")
8 k  z; i# e+ ~; a+ W    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)
7 l  a4 K, e6 P5 b- n0 E
& D; I8 K; O: Y1 S
' l, z4 I& I8 G+ R& H- {  K7 z
1
2
3 h) P7 }& r- l* V; O, j3
2 S- k* l4 v* [! L" R5 R4
& \  {. k" ^5 f# [8 Q& |! [5 f5
6
# t- p6 J  M! }5 g3 R7
8
9
10
1 {9 k$ K  J2 A! u  e" y5 y* j11
12
13
" d  d7 K" l6 r14
/ w) u4 K/ \' ?! V2 s, |0 {15
3 d! p. s- {# i) ]16
* h! \# t# I2 K6 a5 r' a- t7 H+ I( [17
$ ~1 L9 }3 D( {4 Q8 A7 @) D9 l18
19
" ~5 Z# i% h+ m7 j) |5 m20
21
0 d6 F( k2 K- g22
23
9 J' k. c' W. \* b% \, S0 r24
- u& F2 V( C# [0 B: C25
26
- [  X+ G; s* ~" S/ q  q( }27
28
29
3 T0 e0 S: }4 J* r+ U30
31
1 v3 |  p4 l8 _3 ~32
33
% H) Z; X  d3 S8 n34
35
) W; F* v8 k; s9 D3 I# A36
37
38
2 h( ^7 N( X; J/ _0 {5 W9 _39
# ^! m! m# ]4 {; |5 H4 t; _40
% o6 W$ a3 M3 f9 h: t0 R$ i41
42
, j* R; I- z0 h" q; P. e" J43
- Z- P0 M* w5 y44
8 ^3 `* a5 f+ J; f$ [7 v7 Q+ z45
1 a" i. d- _7 j3 E. P46
/ y) ^. g7 p" N3 U7 k1 h$ A* j' U47
48
. n1 C: Z+ m; K+ D: {* p49
50
51
6 p7 x  S1 B: h* f7 j52
) w  s) x& V. X6 H53
; q& _. k2 L9 F54
55
56
9 F' B6 p( s% K. m% Q3 a+ f57
58
59
60
61
; U% h7 m- {3 u  e& o7 }62
63
64
65
66
67
- f; k4 s4 Z, G68
69
70
71
8 ^) Y3 m4 X$ o; N( X' e72
73
74
9 ]3 J- f9 a8 b  F) W& ^( l75
76
) \7 }( W; Y( x7 b77
78
: `" U( ], X+ Z79
- O8 |$ C- V3 o3 ~80
1 e* {. ?, v1 u' E# T81
82
$ v% _4 }' t5 a3 g83
84
85
( |& }: Z) M* h: B! s3 ^" }# c86
0 O" Q( Z3 ?4 X0 O! C87
88
89
90
4 j) \1 e' J7 v91
$ l0 {% Q8 h; f2 |92
93
# B' B! r$ s: P$ ], b94
95
1 D7 t3 X- [9 q( h96
97
: b9 ]$ t! `6 X/ Z2 |98
99
100
, v' U5 @- d# P4 w: [; `7 g0 i101
102
103
- V" @# x& Y8 n3 V5 J* R104
- O3 C& C7 `% h105
106
: R5 ~. b7 f3 E. ^107
108
; r4 ~7 S" b3 E# T' [- i109
+ D! l1 ], J* B2 ~! x! P6 k110
111
8 [) O6 t7 r, Z. o& z112
113
114
115
: T0 u5 ]. X1 n3 e) L6 }! I' w116
117
4 @; L+ @6 h7 |3 J: P' G/ P4 w; }118
( [9 T5 K1 |/ @( |& N$ W  W2 M3 J119
120
1 m+ x( ]8 ~2 d$ M- K121
122
123
124
7 O3 R- l5 e! Q125
126
127
& e8 f/ A, y% H3 P3 U128
: X# s( Y2 A( e* s+ Y$ N129
130
131
' }9 \) z  `, r% x$ d3 ?132
133
134
135
136
137
138
! ^8 l/ ^! u4 F2 [( A139
2 C9 D& B" [2 p8 N; T140
) M" e7 G/ J& w4 p141
9 i; {2 p/ K7 D( B5 r  m6 ~142
% k4 W1 O# U: I: ]9 L143
1 l* g; N& Q/ M$ v3 C: v144
' d, w( r9 i. A: F7 C145
146
; c0 B; W# L1 D) G+ z* A3 a) U2 {147
: ~( e" `9 E9 m8 M' q( D148
* l& W! `1 j& q/ ^% Y+ e  e149
" C" k! S- F; h! S+ n3 z4 I4 c150
/ p0 `  h+ H5 A4 n, u* C151
" Q4 L* W$ I5 k( f152
# \( Y, [" [0 `2 c  L1 e( O153
4 Y( O) H6 G% H+ ]+ u1 a/ L, c3 t154
, Y# n2 j8 n. [9 i4 A155
( q& l: h4 V, H156
157
158
( x" }9 [& o! y: r! }; J6 j159
2 D8 Z- {/ f. _2 O) P4 r, f9 }160
6 l: K) a! w* Y' r. X161
162
5 O0 U' n" f; |/ `/ e! \163
164
1 ?& X7 T3 s/ K+ N" ?5 c165
$ t$ `7 E0 r7 F/ i7 H0 u$ d166
167
168
+ _: C( a0 _; ^# m- Z) W169
170
$ m" v' [  M3 i9 ]+ r% w171
172
173
174
175
176
177
- X$ g- e" o+ C4 m$ r& A178
179
# n' n' C* ?% W, q7 s" V180
181
# ~3 r+ Z: V1 Q2 C* r0 N182
183
# b+ D' i' v/ r5 ?) I& k6 c& k184
  b6 Z7 O% W! g185
186
187
188
189
190
191
$ l1 {- K" s5 f4 r' v192
193
6 Z" t. F( f) }( s. C: |194
1 H# R1 y* j& z, }195
196
' _/ \, }9 Q! \' g197
198
. `, c- x6 ^9 |+ J, \199
200
0 i2 w+ f& H8 Y+ B# E) j0 Z# {201
202
3 u% \: S7 H/ B$ R203
204
205
. V* }4 {( [4 N, G206
207
" D# x& C# \; T& Z0 v" g5 c# r8 Y208
209
210
211
212
213
" u* r# E( V- M7 N# ~214
% i7 X' Y3 j& h6 T215
# u$ t& C  Q8 w, w216
" |3 a" F( V+ X9 u217
* ?4 T0 _! P( f* _; ]218
. h" D4 n$ D2 Y; X219
220
6 g% l7 a5 K; `3 s" w221
222
' e4 k; {! ^- K" y, _223
224
# `* o  O# x- ]; s7 G225
226
. z) F7 a# C1 [" Y: _5 ~: c& H% X227
228
229
230
231
7 _4 T& v( |8 l4 ?6 c6 r232
2 s- r: g" X& S( A9 _- Q8 }233
7 n* N" ^! W- g: F7 B, U234
6 b0 q' f3 y2 [0 U235
- R: |! I. g" M  {8 T236
237
+ Q" q  @( p' z3 e7 l4 h238
' m! @9 q) o8 D  ?; c9 U7 N7 C, K239
240
241
4 D* b; }  E0 l' q242
243
2 W& C( G7 r# Y. p! o0 ]244
245
246
247
248
249
250
2 J$ M7 y" z" L) C. h251
252
. J! \* @  \% n) e4 v$ S: ?253
. l3 X# ^( a4 K  L' ^  \254
255
256
257
) f/ ?3 k# A8 j# _* ~, r$ `. _258
) b% n1 v, A2 d8 a6 `4 [0 L% _259
260
7 z# f& v, [/ p& V) D/ [261
, b/ L/ x0 l( ~5 I262
% Q9 z) ~7 ?/ E9 O% X263
  w8 z  H% S, {$ \# E7 t264
265
7 R4 ~, I1 f4 N/ a) H9 Q266
267
7 n) ~# g% Q0 L7 A268
269
270
( ^2 V. H1 A- ?- n: _271
2 U/ A0 |: a5 d$ Y: ]5 g  H3 V7 ?272
4 g- U* c& v: U- U1 R- d273
# M1 H3 m( E9 G7 A* B7 M+ V274
275
9 J6 Q7 r8 P2 m* I- t4 `5 q276
277
278
, j4 K3 G5 S. F  }279
280
; V1 y8 z- A! e( Q! a: d5 i281
282
: [$ v, d& h( }: _* X283
284
285
286
287
! H& D2 ?) |) \288
289
5 B2 B9 v1 b& }; u' ~4 H290
291
292
1 e# Z* o# m$ R- N7 v/ Z% @/ p& ^293
294
295
% m" F. t7 R  g296
297
# c& m9 N8 T- K+ ^7 V1 P. Y298
4 i! o0 u4 h% y; h; l299
300
301
302
303
1 v& `' V6 D9 G" e/ b1 m4 S8 T304
5 f+ l: l/ t* n: `, i) D" q0 Q- @305
306
307
* s. w( l) k& B9 x- d; ^6 v308
309
310
; k+ {* L, h* \# a# X! e311
2 _; x- Z5 e% g$ ^312
1 \7 f9 X- P" Y. K! w6 i) Q  T313
314
315
316
317
6 e8 b* a! f1 q/ H$ V' f; J" ]318
$ q" R0 }0 H5 n  h4 S/ x319
( t3 w4 W0 }- P' b9 e320
321
322
& z. |# ?& t$ C% j- b2 S323
( a( Y9 f& s% w7 j324
6 b* X7 ?: q6 A+ R* l2 z9 w( C325
326
1 Z% [: _! \# u4 F3 ]% w& g327
328
329
* G# `$ F. E- `% e' w% x) d330
5 X0 q/ p; N4 \5 T331
' M6 |3 S# B/ ~! _# F- S( X


: z/ b1 w3 `( y3 {, e! P, p* j

8 u& [+ T7 k. E9 P% B0 a

1 c/ B# |; |9 @% D* d) C) o
! e! m8 c* p' }- Q- q
* k( O# ?1 ~2 L: T. i* s; d1 v


————————————————
) o0 e7 f/ D1 ?7 t- h. H. L+ J% x3 n版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242

( A6 q" ]& F/ b( t
- l5 e1 `0 P. z  S