基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

: f' A  r8 p" Z, V: Z2 x9 ~决策树模型
目录
, H% m4 p. i9 Q人工智能第五次实验报告 1
, f8 D0 y0 c  Z9 x决策树模型 1
" q; u6 M5 |0 V/ B/ H; k一 、问题背景 1
+ Z3 \6 U0 u* v" S1.1 监督学习简介 1
1.2 决策树简介 1
: e) Y8 a! O. n' T  f二 、程序说明 3
- E3 K4 O' M7 b; |1 k9 e2.1 数据载入 3
2.2 功能函数 3
2.3 决策树模型 4
7 h0 y; G7 _, }8 Y7 I三 、程序测试 5
3.1 数据集说明 5
/ {* [; F2 K6 {% B. n& z5 I3.2 决策树生成和测试 6
3.3 学习曲线评估算法精度 7
四 、实验总结 8
附 录 - 程序代码 8
/ N5 n" ~5 }1 R3 w. U2 p7 z8 f/ d, o一 、问题背景
1.1监督学习简介
; o& [* Q) i. ]: W- |/ u机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
, f- ?1 v' V) A6 A5 H- g  t+ m/ Y1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
+ O6 {" U# |. Z0 z
import numpy as np
from matplotlib import pyplot as plt
from math import log
import pandas as pd
import pydotplus as pdp
) p1 e! P8 B8 x  X. U
4 r; m+ O  R3 m# m"""
19335286 郑有为
* q7 ]4 C7 }! W% F2 e$ I: F# d% Y人工智能作业 - 实现ID3决策树
% ?1 Q# E. I1 d' s"""

nonce = 0  # 用来给节点一个全局ID
" }$ R. y& L2 G$ Wcolor_i = 0
; N8 Q, N0 A" l% t7 d# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
# I2 o1 }8 Z" qcolor_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]

% I5 F% v! e; i  M+ P# 载入汽车数据, 判断顾客要不要买
class load_car:
    # 在表格中,最后一列是分类结果
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
$ s* c8 B8 M5 _. A+ u1 v    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
, i+ }$ N, R. Y- C        labels = df.columns.values
& Z+ ^# _7 G4 x( |3 L        data_array = np.array(df[1:])
        self.feature_names = labels[0:-1]
: A7 P" E; Q$ e) @        self.target_names = labels[-1]
        self.data = data_array[0:,0:-1]
        self.target = data_array[0:,-1]
% W$ p) ]- L1 a* h9 A& @
/ H- ]7 F5 M( {: D' v' p. E# 载入蘑菇数据, 鉴别蘑菇是否有毒
class load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
) a4 V3 d& d# f3 }    # feature_names: 属性名列表
9 E. }! |  }+ w; D3 W    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
7 ^/ I- T! Z( p" R5 ?# O    # target: 目标分类值列表
    def __init__(self):
! V& o- L4 z% x8 R        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
7 ^* [1 _: l( @) d( b  o        data_array = np.array(df)
8 }4 P& W% G# ]/ g: l7 o        labels = ["edible/poisonous", "cap-shape", "cap-surface", "cap-color", "bruises", "odor", "gill-attachment",
& U' \$ b# {3 ~8 ^% c! ~' S* J" z" 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",
; g: F1 H+ G  {$ a  l                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
! |# s+ a" K- z) L* q, P. w        self.feature_names = labels[1:]
        self.target_names = labels[0]
        self.data = data_array[0:,1:]
: W6 K; x8 h7 {        self.target = data_array[0:,0]

# 创建一个临时的子数据集, 在划分测试集和训练集时使用
class new_dataset:
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
( ]0 W, Y, F' ], n* `. }. ^  n    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
        self.feature_names = f_n
- C) H0 Q5 L- B1 y8 [4 l" ?& w        self.target_names = t_n
+ Y* \* H* P" @- K% R+ c4 ]        self.data = d
        self.target = t

3 d& [  g1 a  `+ M. f5 x9 u# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
, t+ W% I" t& x$ B; W/ ~' m% F#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
2 i* {& |' O4 E6 i2 G( u- |# target: 分类结果的列表, return: 信息熵
def get_h(target):
3 ?" T( \4 A( b0 f$ s' {: \    target_count = {}
' j1 x8 i1 H  ~- d  j9 r    for i in range(len(target)):
9 B) L9 M1 f$ m' B/ @) B        label = target
& \7 j% ?& z3 n" ~; g- O0 L1 J        if label not in target_count.keys():
            target_count[label] = 1.0
; r( B( W# j/ g) q- X- V0 W1 y( s        else:
            target_count[label] += 1.0
    h = 0.0
! E1 ?: X, i$ o( n7 \    for k in target_count:
        p = target_count[k] / len(target)
9 V3 |- d% q  C, l        h -= p * log(p, 2)
9 M& U: b0 c0 ?  B  ~    return h
8 c, C: s4 P% Y, H: ^* z
# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
5 S; ~. b2 O, u5 {  tdef get_subset(dataset, feature_name, feature_value):
    sub_data = []
    sub_target = []
    f_index = -1
    for i in range(len(dataset.feature_names)):
        if dataset.feature_names == feature_name:
            f_index = i
. E2 F6 {& I4 A            break

    for i in range(len(dataset.data)):
        if dataset.data[f_index] == feature_value:
+ {, k2 L+ N7 ~            l = list(dataset.data[:f_index])
2 O& }- r1 a" R            l.extend(dataset.data[f_index+1:])
            sub_data.append(l)
+ r* k5 F/ Z+ I, X3 U4 y6 o1 ~- W            sub_target.append(dataset.target)
! p: B7 ~% d7 F5 \$ c" e. s- I
. a$ K$ l/ I" I    sub_feature_names = list(dataset.feature_names[:f_index])
" s/ H: ?9 b, C( V    sub_feature_names.extend(dataset.feature_names[f_index+1:])
    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)
0 R8 N+ r7 I! [$ w! X$ \: P1 D/ D
. ?* o6 Q* o9 Y$ I3 S5 j# 寻找并返回信息收益最大的属性划分
2 n( L2 j  _6 }# Y. {8 C; y# 信息收益值划分该数据集前后的熵减
# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
6 R7 |; x& A% J: R" Ddef best_spilt(dataset):

    base_h = get_h(dataset.target)
    best_gain = 0.0
    best_feature = None
    for i in range(len(dataset.feature_names)):
8 p2 `4 k6 m/ d( U        feature_range = []
$ O; U1 ^' y/ U7 k* d% g/ T        for j in range(len(dataset.data)):
7 f5 k0 g* {2 k  x, G8 L9 K( B/ a0 r0 [. r            if dataset.data[j] not in feature_range:
, l. q; [( |0 [. B0 J( L' U                feature_range.append(dataset.data[j])

        spilt_h = 0.0
$ z5 _# E$ A$ k6 F        for feature_value in feature_range:
            subset = get_subset(dataset, dataset.feature_names, feature_value)
            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)

        if best_gain <= base_h - spilt_h:
4 S0 a: F6 z; C* b            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names

    return best_feature
* v+ {9 n/ q  k  z3 Z, s' F
# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
    target_range = {}
" d! k  k, `1 n* N    best_target = None
" Z: |9 I# g6 \& T8 \    best_vote = 0

    for t in dataset.target:
0 u( f# P+ a/ c5 z3 U: [3 l        if t not in target_range.keys():
& e* g0 }: N$ D0 b8 }            target_range[t] = 1
# H+ j5 V' {# o% |' ]+ U4 O+ t        else:
0 u7 l4 T5 ^- K% D, e            target_range[t] += 1

/ N: ^) {5 |( [/ F- X  v    for t in target_range.keys():
. b. x+ g. I8 q9 O3 U        if target_range[t] > best_vote:
+ f7 N7 \4 C  M( }$ U            best_vote = target_range[t]
* X4 c! m* r, R3 S            best_target = t
$ }. c( c3 U' p  ]  T/ }
1 Q3 c: \) ~- @    return best_target

) t6 L' `; q- M" s0 r# 返回测试的正确率
# predict_result: 预测标签列表, target_result: 实际标签列表
# ^: C, T. m  _! l# g+ A0 d1 P6 Idef accuracy_rate(predict_result, target_result):
    # print("Predict Result: ", predict_result)
    # print("Target Result:  ", target_result)
    accuracy_score = 0
7 s# d/ c7 v3 E4 e    for i in range(len(predict_result)):
        if predict_result == target_result:
            accuracy_score += 1
    return accuracy_score / len(predict_result)

* Q/ \9 @$ q( [' {4 B  J$ y, V# 决策树的节点结构
class dt_node:

1 X" V: e: i8 b- Q% x. V    def __init__(self, content, is_leaf=False, parent=None):
3 x1 |; N5 _2 b" A        global nonce
& U0 `* }" A% m  W& k, s$ M        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
        nonce += 1
! Z! `: c1 F) U7 f. d/ C        self.feature_name = None
& x3 h% u+ C7 S) }; [) B2 U+ \+ ?0 D        self.target_value = None
- `  Q, l" ~' t# Z( ]        self.vote_most = None # 记录当前节点最可能的标签
        if not is_leaf:
4 f5 N) _9 O3 p5 S4 z3 B5 v2 w            self.feature_name = content # 非叶子节点的属性名
        else:
$ ^' D; |8 @3 [! j- q            self.target_value = content # 叶子节点的标签

        self.parent = parent
" K2 W$ s! K' U4 z+ E$ M8 p  `        self.child = {} # 以当前节点的属性对应的属性值作为键值

+ ?9 L9 m5 N; C4 D# W# 决策树模型
class dt_tree:

' n* C4 D  k, k    def __init__(self):
3 k+ N  V6 ?" o. e; N8 l% \        self.tree = None # 决策树的根节点
        self.map_str = """
            digraph demo{
& J2 _8 Y1 a& j  T! }            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
- M4 s! l7 s( {3 k+ l            edge [fontname="Microsoft YaHei"];
3 L2 A2 d2 @; [# a8 a$ B; k( P            """ # 用于作图: pydotplus 格式的树图生成代码结构
0 e! I6 h# Q% H3 C9 L        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值

2 V: c$ d* B! J6 C- A2 c6 Q    # 训练模型, train_set: 训练集
- A1 D' s1 N" m, H. T9 L    def fit(self, train_set):

/ n$ q& ]( j; x  W0 W9 W        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
2 w4 H1 C7 T/ q0 i, r) V6 {            return None
. F1 i- x* R+ D* m# P
        target_all_same = True
        for i in train_set.target:
            if i != train_set.target[0]:
4 b$ p5 ~2 u! p/ Q                target_all_same = False
) w& Y! M1 x! \3 {                break

- M% y5 h+ _: o- k; u# \$ W        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
            node = dt_node(train_set.target[0], is_leaf=True)
  ~) k# p8 q3 g2 f            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
% H0 c2 F! @: u; @3 x                self.tree = node
' r8 c4 B8 R* E& g* E2 D
            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
! W# ~, X  u; q$ L9 N+ p- N5 y5 e            node_content = "标签：" + str(node.target_value)
7 f) {) _1 H. I; Q            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
- ?" G3 |/ D" |! H+ }+ H
            return node
        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
8 @; r% k6 C, }% q            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
. x' x! q% t: S0 V            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
$ w: Y7 {. v2 A$ D8 z                self.color_dir[vote_most(train_set)] = color_set[0]
                self.tree = node
5 G) ^( b8 R" O+ Z2 R2 c' l  W
            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
) \) ?& J" S) P! [) s            node_content = "标签：" + str(node.target_value)
3 w: {" F1 B$ O4 _2 X            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
! u0 I* s) m* P* j6 l( K7 e
2 N6 P: S6 [7 x" K5 n+ Q& o: E8 ]+ [            return node
9 T0 s5 d* P% v/ r, P& s        else: # 普通情况, 构建一个内容为属性的非叶子节点
            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
            best_feature_index = -1
* w1 a5 ], Y3 Z, ?) m            for i in range(len(train_set.feature_names)):
                if train_set.feature_names == best_feature:
& f5 l, v* N+ l, t# a                    best_feature_index = i
! k6 ~' Z5 Q3 `/ T1 ^                    break

            node = dt_node(best_feature)
            node.vote_most = vote_most(train_set)
            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
                self.tree = node
                # 用于作图, 初始化叶子节点可选颜色
$ x" F0 w- l. P; Y1 S0 u; d9 |                for i in range(len(train_set.target)):
                    if train_set.target not in self.color_dir:
                        global color_i
2 T, [9 O2 d. O9 `                        self.color_dir[train_set.target] = color_set[color_i]
( G4 h( C8 J0 T& T$ f/ D                        color_i += 1
                        color_i %= len(color_set)

0 g9 ^7 s& C! D/ Z' K6 s. X" W            feature_range = [] # 获取该属性出现在数据集中的可选属性值
8 T- d4 O* C# _; _( W; c. b$ X1 y: y            for t in train_set.data:
# X* G7 }3 Z9 B0 D9 h* D! B                if t[best_feature_index] not in feature_range:
                    feature_range.append(t[best_feature_index])
9 a; v1 s( M7 R) {) }
% n4 ?$ O# X$ x3 \            # 用于做图, 创建一个内容为属性的非叶子节点
            node_content = "属性：" + node.feature_name
: s$ J& D8 N9 y( t            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)  # 获取每一个子集
                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
7 ~/ J1 L% R1 N) g( ~4 v$ Y                if node.child[feature_value] == None:
                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
9 e) |' S1 i) ]3 L2 C1 C                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
; |: ?/ I% l! q; f# }                node.child[feature_value].parent = node

2 o- g. H& A( @: n$ S                # 用于做图, 创建当前节点到所有子节点的连线
* N$ z) U# l+ q" V5 _) E3 U                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"
  u9 P: p1 x$ J& v" g) z
* h. i9 G" G' x, O            # print("Rest Festure: ", train_set.feature_names)
2 J& E  _3 L+ ~! ~4 j            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
            # for feature_value in feature_range:
" s6 r, v3 F- I) o7 |3 \" }# F            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
            return node

& h. ~5 k/ p9 G, r) z9 U6 y* |9 T+ l    # 测试模型, 对测试集 test_set 进行预测
. ^/ N! \+ }( G& x/ M    def predict(self, test_set):
        test_result = []
        for test in test_set.data:
0 g/ }2 d) A* j+ ?8 C            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
. ^% ]: g- W  |) O2 s0 e4 N            while node.target_value == None:
' j) _# f) g$ B) q5 m" Z& w                feature_name_index = -1
9 e+ o0 Z3 A; Y8 A                for i in range(len(test_set.feature_names)):
  a" \# ?/ ?. a! u1 f7 M                    if test_set.feature_names == node.feature_name:
) m1 |2 R  l% ?' B2 ]                        feature_name_index = i
) H+ p* {6 z* K0 w/ w; X7 W- _- n                        break
                if test[feature_name_index] not in node.child.keys():
0 b6 M( P7 x6 u+ ]6 ~& E# B. L3 t                    break
                else:
                    node = node.child[test[feature_name_index]]

            if node.target_value == None:
                test_result.append(node.vote_most)
! ~  c# |8 M  K, }2 N            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
                test_result.append(node.target_value)

7 _" t  {1 ]/ }3 |$ a        return test_result
- C- u1 x5 Y2 a' @3 \$ f! x( w' W
. p9 O4 i( }& }  H: R# f    # 输出树, 生成图片, path: 图片的位置
    def show_tree(self, path="demo.png"):
, [9 w! \# W& ~7 E+ O4 }- p: w        map = self.map_str + "}"
3 C2 t' L. f- y: [        print(map)
4 z6 W! D9 b. [* W5 w0 D        graph = pdp.graph_from_dot_data(map)
        graph.write_png(path)
$ u: R( S  c3 }
# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
! K5 C5 x  q/ Y5 odef incremental_train_scale_test(dataset, label, interval=1):
    c = dataset
    r = range(5, len(c.data) - 1, interval)
    rates = []
* B# s8 P# R! l! z4 b+ O# x0 {( j    for train_num in r:
5 }( Y8 ]+ Z9 a        print(train_num)
0 M" t5 K0 Y+ o  _" x        train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
$ q7 i3 U1 }7 E) o- r: H; u) u        test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
% k2 q9 ^+ y3 @& @* k; K        dt = dt_tree()
) h7 }5 n5 K! u2 V5 k( ?        dt.fit(train_set)
( j+ a+ }! M8 v- @6 A9 i% ]        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))

7 X+ ]! N; ]7 T- P7 \% y    print(rates)
    plt.plot(r, rates)
, X- x1 q% ^9 O$ q& k; M    plt.ylabel(label)
" b8 g3 C* q' s% A4 J    plt.show()
4 U) ~2 K* e0 Y  W
if __name__ == '__main__':

    c = load_car()  # 载入汽车数据集
    # c = load_mushroom()  # 载入蘑菇数据集
    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
) K2 T, |, M" {( l, O5 u$ ^    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()  # 初始化决策树模型
    dt.fit(train_set)  # 训练
    dt.show_tree("../image/demo.png") # 输出决策树图片
    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧
  G9 I% E* @/ w$ r: O9 K( v
; E: S9 \; W. a  N    # incremental_train_scale_test(load_car(), "car")
# Q7 e& B( S7 ~9 `  b0 W, p    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)
# Q: b/ O8 H$ e
+ |- p2 |9 b+ @4 y( q8 ]5 h( U. L
% O( r" p/ i* u$ B0 e- D* E! I
1
2
( f% S7 z1 M/ v6 Q3
) R' Z5 Y1 ?& I6 b4
+ w# x/ V2 i, D/ N6 p# ^- o5
6
7
! i- k: F5 B& L' v1 ?8
* l6 X! B) f& i: h9
10
11
12
. j( @  n) J7 F13
0 K6 s8 A4 s0 O" ]- h3 u14
15
! b7 i  H6 L7 j  w% y% h16
17
18
19
$ s/ O. Q6 O9 W, W20
21
1 j3 s# r9 U1 s, N; h22
) Z& C. c( S# b23
24
25
26
; `& e7 q5 c0 O9 ~# w5 c2 J27
" x) R5 j  K- z4 \3 u# o28
29
7 z% Y& {! Y. m2 R, |$ J% B' b30
6 h' [4 _! M& X3 F31
32
33
34
35
# I& a1 _8 Y2 i8 ?36
7 N) K: O$ h& [$ M9 \37
  G- T& I4 l! U8 v, E! `38
' t  E1 ]1 n7 }" j39
40
/ l( P! {/ i# o/ K7 t/ h( A2 t& O  ~41
42
43
44
45
% O9 C+ ]/ ~4 X; _/ X" r46
47
, ^$ }* o0 g; ~48
49
' \& p  z6 B% d' R. x1 M1 g; v2 |50
" }, B1 h; A' h6 d51
52
: }. @: n8 G! v8 |53
( h9 t! m1 [$ P- G( m2 T9 u54
55
56
. h4 W, O5 _3 x4 ]4 i# u57
58
, ?. l# q, `( z: G+ n% n59
60
3 R" S$ l) d2 `  ^. B- B& `; u5 U1 ?61
8 ~# }# x6 R) V5 l1 b- T' F  |& B62
# P1 P9 s) Z2 T) a7 e8 S* N" j63
$ ^4 D" N: i+ K/ B" T64
65
* X# Q6 ^- s# z) |. Q66
& x6 ^+ k. D, D$ L7 Y67
68
69
8 ^6 p8 ~$ M; P, J70
6 O% t& T# \( {: u4 ]3 F) b  S! X71
72
73
: J6 l3 i5 M2 y$ {3 ?74
75
7 P) j. r: ^& X76
- a" C3 ^# T* Q; \; L  f77
78
79
8 Y3 l; p% R) T( u9 q+ |! z. N80
81
82
1 q4 ^0 ]9 Q9 x1 j' T83
. V6 b( c0 h! P9 y84
85
% Q9 A* \& B; g. w/ N2 Y! x86
87
88
89
90
91
+ O, N; X  W- N4 x9 g0 X- s92
93
94
1 U  N- x/ w& D& B95
96
5 A- C; p1 }$ x6 {: \& _97
6 W7 l  O9 `6 Q" _& Z98
+ r) o% S0 r) P8 ^99
100
, l' _" T, I2 T2 W& r" s101
102
103
104
105
+ R, {) S- `5 Z" M, d# U; ?106
107
108
109
2 n/ z: K5 K* M110
111
112
113
114
115
116
117
+ b# |9 F/ n; u) r% A118
( G0 [& p0 ?7 Y& F$ i8 y119
4 c. w( x) @# B9 }120
) t0 ]3 y: a) r6 L9 j- E+ E121
1 {4 v) K$ j, A3 R5 f6 I122
' d$ N( L" t3 c7 {' v123
* ]' T& x" ]" I% E( \% M124
125
+ `& [( H5 E5 t9 v7 d8 m126
127
128
129
130
; E# A9 ~- q/ d6 \: [6 r0 s$ |7 B131
132
133
134
2 O* ^; v+ w7 s: M: c( I1 _, F% ?135
136
5 Q, e8 Y6 y- }! F' n4 M; }: h137
# r$ I$ H, k  J5 q" {138
8 O: `* e0 O( J+ ^139
140
3 X; f$ J' w1 U* Q1 g141
' Y) q* \4 s3 n# j6 ]! O142
143
& x2 J+ p3 V* }, `8 K% f4 B144
145
146
147
$ H0 l$ }, F9 e& I& ?- B6 Y148
149
150
151
152
153
154
7 F/ v) U; C9 D9 U" J( @( x155
156
157
; U/ Y) d$ Y' a. @, w) S; m& A/ R158
159
160
161
162
' h% B, d" \9 ]. Y# x163
* n- j4 `+ H% |+ ?164
165
166
8 _, o2 Z0 x3 D/ `! H167
! K' s1 v' A( u! r# C; U168
; y5 J9 u1 E5 s4 }" _. W$ i' C169
% W; v* J- V- ~) m) H5 T- z- S7 G170
* g8 i# R' x7 K) ~171
172
173
174
+ t9 l% h' R6 A/ Q5 a175
176
: N6 K% e* O5 ?5 O; P& Q. N177
178
179
7 P  a8 j- J  u( ?8 W" P/ Y180
181
- S9 q4 {& M! a0 a6 h* D/ ^182
+ g' \0 C. w4 Y  J0 H  \183
184
# l) @& C( u3 ?8 L185
186
0 l  Y- V8 A3 W" q: z187
7 ]5 j; [  U; T* r- `, x; R188
189
' t  e, B7 L/ p# x/ t4 p190
  S& a6 j# E8 }9 \191
192
193
194
' G. B. c# e6 I& q- n( O) b) E195
$ R: P- ^' N( f5 j' [4 G196
197
198
199
200
/ X' S3 `3 _5 e+ R) ^201
202
5 p+ v2 |$ a% S5 P1 v203
204
205
* J2 U/ s& ^" p) y9 m$ ?206
207
# k9 M( r6 q6 R7 G( H3 v208
209
210
% D' `2 N7 J0 Z2 L211
212
) A' g, X) u) b( u4 |8 h9 T2 M213
214
8 E+ C4 ?$ E  t0 F( k1 E' W215
" A7 n- \: d8 `9 j1 w8 p; ]1 J* v9 X216
6 c* Q/ o9 o6 L9 Y3 u# L. P/ M217
218
& m/ M9 x/ l: U" w  v219
; s) `# `1 M+ N/ _8 j220
221
222
5 F& Y* H" \0 [2 o3 G223
224
225
226
8 E$ O/ i) ?! _: Q' h( O' c227
228
4 ]3 r$ e! ~7 ~4 z7 P) C+ N229
$ U5 d2 w& y& {2 c$ ]7 G230
231
% J: x, h+ T6 r; I' ?% J# A232
233
( K1 v/ T( A" g( D7 N9 O234
6 Y1 h# X$ x7 [3 y7 b) n& i235
236
5 O; s8 y2 A( e. U' H, O237
9 C. Z% o, l! L7 t238
: K6 U1 Y) n5 h/ a* q4 ~9 G) Z239
8 i2 h. N6 z+ I) o! Q; _240
241
242
0 o( x# t7 |7 D! k+ W5 H243
244
9 I' D; Q( }+ A: @245
: X2 x' i" U& i! I* q3 P9 q3 r246
% }( X+ L7 r" J2 S0 w247
/ l  [  q( S! a. |0 \3 D( y+ ^248
1 _1 r, |, c2 L9 S- e249
; o! Y; R9 E4 X2 w250
7 `: Q; s1 p. A) n: a9 l+ m251
: n; e; W1 p5 k+ x8 L8 @% D252
/ W. F  Y2 N% r; @! I253
254
255
* P/ V9 ~& l4 c6 Y6 p256
! T6 {. {4 v& ~7 E# v  X/ }257
258
259
260
0 s+ Q- o, o) }261
262
263
264
# i# ]! }: @. E. ]% K265
266
$ {# @) [% @. v. c  B267
268
269
- Z6 N, \8 c0 W9 Y) d270
271
272
273
% S1 n5 d7 w( x1 l% a274
275
276
277
! y' x' K/ K. a6 ?7 r# N278
279
" ?) ^! J* n0 S% R9 J280
9 A1 ~0 h9 Q6 L6 p. L0 G. ]281
282
* @. w: r+ {4 e/ C283
284
0 [" W2 A! q" H8 @: W5 v0 k285
3 N! d) u  J, T. s/ e/ K! O286
287
288
289
$ v/ Q# r% D6 x/ O; C290
- s5 L  Y9 }+ ~7 |291
3 |8 b, A4 |- F, o292
293
294
295
( E9 w5 k6 d  `8 x296
" E6 F% N. N  q+ e297
" x7 _" y4 c3 k7 H& Q298
299
5 f; X( u  P: W8 x! z) Y300
+ z) G+ a0 W2 u, ^301
302
303
304
305
306
  M9 P$ x0 _' u: H307
  x+ T% c0 x' D- e" q, z308
309
: d0 q5 R0 O" f) [  H( C2 A310
311
) ?, ~# I1 j! a( B) g2 E312
313
314
315
8 z' b7 A5 G% Y7 O  X6 i3 I! Q) |5 u316
317
318
319
0 |" P. h6 h- `( v$ J320
3 x% ^! G, F8 b. ~  L321
1 K6 @9 T- p. K$ S+ p322
323
324
. U# i. F7 x( ?# P, ~% P0 B- D325
326
- s' _! d- E1 I327
0 H' s+ @% s/ a+ ^- U- n: w328
! O; ~! W8 l7 U( b329
# s& u  f( p" y. {+ n330
331
3 e5 P! J, t' ?5 \+ ^- `


3 A3 {5 U5 r$ z6 c
: ]* W& u3 H( T" h7 [) O2 w

* o, W3 a8 E3 |
4 J' I, z" O+ S/ t( ?
5 b3 C$ u$ k* w8 z, R

) B0 u' x: j! Y! U/ I" m

5 D% k! |- g8 h  v————————————————
版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242
5 b' t: a. J7 D( q* N0 ?7 x) P
0 {$ ~: d+ s: n