基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型
  y6 G% l. O. I$ m
4 Y% C, w% N4 L# e" i8 H1 j决策树模型
目录
人工智能第五次实验报告 1
决策树模型 1
5 L8 ]) C( @; @6 _1 d, t一 、问题背景 1
# u6 V; |: l. F, t. d, J1.1 监督学习简介 1
: p! j) d- f  F0 l+ I1.2 决策树简介 1
二 、程序说明 3
2.1 数据载入 3
2.2 功能函数 3
, p& }" S0 T" L- T7 b2.3 决策树模型 4
* j9 T1 ~% Y$ c3 v! C( n8 G三 、程序测试 5
3.1 数据集说明 5
: i/ q! y. j3 I3 V* q3.2 决策树生成和测试 6
+ Z) \$ d' V( o2 s2 c: v( ?. E% E3.3 学习曲线评估算法精度 7
) u! y2 C! h2 a9 I! }0 y' `0 w; A四 、实验总结 8
6 |5 L+ K0 L# Y5 r* Q; m附 录 - 程序代码 8
7 Q1 _- s# U% q% r  J/ Y一 、问题背景
1.1监督学习简介
6 D( @' _+ ~8 A$ j' F8 n. {机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
9 `) W2 L3 I: i% f8 a4 B监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
& a3 B, f; t+ M1 ?4 g0 W常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
/ {) M' x4 ^2 X7 A1.2决策树简介
, N$ I0 F" U  }4 W2 c$ E+ G4 c" m决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
决策树的组成
! `* ]4 G4 w/ {决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
" j# y/ {0 I: V) D: q6 s
import numpy as np
from matplotlib import pyplot as plt
+ |2 T) G1 M  Pfrom math import log
4 z% T  l; _. w& i+ q3 B3 m0 ]- bimport pandas as pd
import pydotplus as pdp
! `" `3 G: U( L
2 Z2 Z' A' S% ^, j+ w: R7 `"""
0 z/ k/ [8 s/ [  s: s19335286 郑有为
# M: i# L7 w* A  l2 w2 k3 J6 D人工智能作业 - 实现ID3决策树
"""
- L. {1 F7 S  l7 b2 J# V6 F. r) C% f
nonce = 0  # 用来给节点一个全局ID
color_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
color_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
3 V# `% \" M" W
8 f5 ?5 d: n5 R1 A* N8 o0 p# ~# 载入汽车数据, 判断顾客要不要买
/ P5 p% h7 q) K  `class load_car:
/ A" K4 K4 G" t1 ]+ J; J    # 在表格中,最后一列是分类结果
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
% D* Y3 b; I3 ~  i9 C1 C    # target: 目标分类值列表
    def __init__(self):
9 _5 a- U- h0 t9 n        df = pd.read_csv('../dataset/car/car_train.csv')
        labels = df.columns.values
5 h% o3 f) N( M/ d4 [7 I        data_array = np.array(df[1:])
7 Y8 v) i) E2 l% P4 b7 H. C0 s1 G        self.feature_names = labels[0:-1]
        self.target_names = labels[-1]
" u9 S/ l- U' ?* U7 p        self.data = data_array[0:,0:-1]
        self.target = data_array[0:,-1]

# 载入蘑菇数据, 鉴别蘑菇是否有毒
class load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
    # feature_names: 属性名列表
+ K" `' V+ U. \- r; C" {8 n    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
! X8 }/ N) u9 l& a: T" H' ]/ |! w    # target: 目标分类值列表
    def __init__(self):
3 ]+ B1 t0 M* g; _8 E; @' g5 r        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
2 w! `0 R' Q  @; ^: ~        data_array = np.array(df)
* J4 i; ~5 w" j3 H        labels = ["edible/poisonous", "cap-shape", "cap-surface", "cap-color", "bruises", "odor", "gill-attachment",
6 @6 R; n/ y3 L. h7 u6 O5 g                  "gill-spacing", "gill-size", "gill-color", "stalk-shape", "stalk-root", "stalk-surface-above-ring",
8 z. [1 ]9 ^5 \) @; t/ J                  "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:]
0 _0 _1 d; [% U  v& Q4 B. a- U! f        self.target_names = labels[0]
        self.data = data_array[0:,1:]
        self.target = data_array[0:,0]
) ^/ q+ N9 f! B* {* e. [5 ^/ E# H
- [* o! P- Y+ s- W0 \# 创建一个临时的子数据集, 在划分测试集和训练集时使用
$ f- s' m7 O' P# K" n+ Vclass new_dataset:
; U+ o/ D3 u" T, j0 @; k% u3 F    # feature_names: 属性名列表
8 z8 O7 H$ {" G% f    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
7 s$ x6 L6 j2 k1 ~3 f( m3 R5 p    # target: 目标分类值列表
" D# A* |5 V$ H% e    def __init__(self, f_n, t_n, d, t):
        self.feature_names = f_n
        self.target_names = t_n
        self.data = d
        self.target = t

" E8 ?$ K9 Z' t+ \! Y8 _7 D# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
# target: 分类结果的列表, return: 信息熵
def get_h(target):
" S3 F* x4 X1 ?$ W3 I    target_count = {}
* m9 p! x: o/ C! W# q6 o    for i in range(len(target)):
4 V6 \, b9 z" U& H1 @        label = target
) ]* X% _6 L( g$ S        if label not in target_count.keys():
            target_count[label] = 1.0
$ @. K9 x! n, C, Z1 @( o  \        else:
: {: e2 A7 k. _$ D0 ~( C3 j            target_count[label] += 1.0
" G3 Y/ S9 O4 H% G7 \6 {' Z    h = 0.0
    for k in target_count:
% M( p" i0 G$ r/ p# u% b        p = target_count[k] / len(target)
        h -= p * log(p, 2)
9 M: A2 Y2 D1 y6 Q    return h
: G- L" v% h- [7 r6 o! F5 F
# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
5 j4 N+ w$ S5 k/ ydef get_subset(dataset, feature_name, feature_value):
. L5 ^5 C, ?( Z9 ?: o5 ?# L* q    sub_data = []
    sub_target = []
5 M, x& ]3 x$ I    f_index = -1
    for i in range(len(dataset.feature_names)):
5 K8 G$ S8 Y/ y# {; t        if dataset.feature_names == feature_name:
3 P8 ]. w) r% y            f_index = i
            break
: s' I, o# |" ?2 }1 N# R% d4 Z$ i9 Q
9 y5 m; U! ~) Q) D4 E/ r# \    for i in range(len(dataset.data)):
" t/ x, ~5 `. l        if dataset.data[f_index] == feature_value:
            l = list(dataset.data[:f_index])
1 |$ l/ @& p; `            l.extend(dataset.data[f_index+1:])
            sub_data.append(l)
            sub_target.append(dataset.target)

    sub_feature_names = list(dataset.feature_names[:f_index])
    sub_feature_names.extend(dataset.feature_names[f_index+1:])
. |9 C- g3 g6 `2 q: Y  V    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)
0 p) q8 _# ^% b. x. H1 D7 t
# 寻找并返回信息收益最大的属性划分
# 信息收益值划分该数据集前后的熵减
# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
def best_spilt(dataset):
. W" ]/ X  f' U0 v9 e* k
1 O3 k# m* z$ h; g# Q+ m5 g    base_h = get_h(dataset.target)
! B5 d3 m! B$ z1 X    best_gain = 0.0
4 @$ k4 `# S5 U0 l    best_feature = None
    for i in range(len(dataset.feature_names)):
        feature_range = []
8 A9 Z6 k3 V7 v9 k" Z1 {- i& H& d        for j in range(len(dataset.data)):
6 B- W' {  e2 n            if dataset.data[j] not in feature_range:
! ]" t: V' c, S* }$ p                feature_range.append(dataset.data[j])

: i) o* n/ L' H        spilt_h = 0.0
& V) Q: O$ R, x" t        for feature_value in feature_range:
0 O* s& f5 N. V            subset = get_subset(dataset, dataset.feature_names, feature_value)
& u6 s5 u+ u# ?/ v1 G8 }! V            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)
. i3 I- G2 {' F* P3 Q
( a) O: O. m9 p" o        if best_gain <= base_h - spilt_h:
            best_gain = base_h - spilt_h
4 H1 A' W% c, h; `; Z( U2 O- E1 p" Z            best_feature = dataset.feature_names
! k6 ]" e' t5 H+ j# ?; |! x* K9 _
9 \$ d$ i' e+ `) k    return best_feature
4 r; I, |" n4 \& G) L' r
# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
    target_range = {}
7 g/ H7 T  u2 p: W    best_target = None
    best_vote = 0

0 G4 J5 |- y: P2 W1 ^    for t in dataset.target:
        if t not in target_range.keys():
            target_range[t] = 1
0 a, m0 |3 h4 _% i        else:
            target_range[t] += 1

    for t in target_range.keys():
        if target_range[t] > best_vote:
            best_vote = target_range[t]
            best_target = t

6 J- q# u; g: V* `3 a3 P" Z5 C+ ~    return best_target

# 返回测试的正确率
# predict_result: 预测标签列表, target_result: 实际标签列表
# ?6 A9 i* e6 x  N1 z8 Xdef accuracy_rate(predict_result, target_result):
    # print("Predict Result: ", predict_result)
* j) Y/ M1 m! |: v  B" C/ a    # print("Target Result:  ", target_result)
    accuracy_score = 0
9 ^/ }) _! S3 o8 J$ F) p8 @    for i in range(len(predict_result)):
        if predict_result == target_result:
2 C4 d1 c8 G, W# S! d            accuracy_score += 1
3 H( W. X; x$ w) b, {    return accuracy_score / len(predict_result)

) T) p3 U2 l/ [; Q" [& f/ Q) ~# 决策树的节点结构
class dt_node:

4 r5 o4 n0 Z" |+ y    def __init__(self, content, is_leaf=False, parent=None):
        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
8 ~- K1 Z4 w" x. A5 l+ V0 D) I        nonce += 1
$ ~0 ?0 R$ c: d; S        self.feature_name = None
        self.target_value = None
        self.vote_most = None # 记录当前节点最可能的标签
& B- h. J; Y# e9 M1 _0 X3 g. c        if not is_leaf:
            self.feature_name = content # 非叶子节点的属性名
0 ]0 _4 r" j+ Z, l8 d2 w: l4 ~: n        else:
            self.target_value = content # 叶子节点的标签
$ n- e7 i6 d- x( N
        self.parent = parent
        self.child = {} # 以当前节点的属性对应的属性值作为键值

6 x8 D; n. y" v* _# d# 决策树模型
. p7 I& R# K# d% K1 g! Rclass dt_tree:
4 z$ b, Q3 \0 {7 q- c6 |- i+ P8 I9 ^
( P/ O2 h5 A/ `3 r+ d1 X; Y    def __init__(self):
9 Q9 m8 [. v  [3 z: u        self.tree = None # 决策树的根节点
/ O' Z6 E$ `# d        self.map_str = """
0 V3 E$ X+ J  X+ `! Y            digraph demo{
- }, p  X5 w- b1 \7 I! O            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
            edge [fontname="Microsoft YaHei"];
            """ # 用于作图: pydotplus 格式的树图生成代码结构
# m, p; W7 K" Z/ P* d        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值
! N  S9 E1 F/ a6 R
    # 训练模型, train_set: 训练集
    def fit(self, train_set):
, @& ~$ z) w/ L
6 \4 t  u" l1 l2 p        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
+ C/ J) h9 F0 g            return None

( ?" G0 a) v2 g0 G- H        target_all_same = True
% p: X5 Z; l7 z! V2 U        for i in train_set.target:
            if i != train_set.target[0]:
                target_all_same = False
                break

6 Z  A3 b2 z, }+ R        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
            node = dt_node(train_set.target[0], is_leaf=True)
; L# ~9 m" w& R3 A8 r; S            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.tree = node
& i5 o0 r8 y: r9 t& D, H$ \
            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
1 c0 O/ m6 l( U$ P# L6 E            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"

. b5 `- F, `, o  K            return node
/ D: |( ]1 i0 K( U2 H        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]
* L) V- z! k& T( N/ K$ Z9 z7 Z9 C                self.tree = node
4 B0 _! l7 }0 b! S. }9 w) F9 d
' |! w, a6 k8 ?* w            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            node_content = "标签：" + str(node.target_value)
" |; f7 K/ d* D( y- y  C            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"

1 k3 I. y0 o) \7 p- i            return node
6 |: A* Y; {/ D- z$ H/ ?: n/ K        else: # 普通情况, 构建一个内容为属性的非叶子节点
2 f+ e: g! Y* G) j+ V            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
            best_feature_index = -1
$ u1 |( f6 `7 [1 ]1 R, A8 V* E. Y            for i in range(len(train_set.feature_names)):
                if train_set.feature_names == best_feature:
                    best_feature_index = i
2 z8 L8 y0 p" P                    break

: T3 ?" V3 H  c  p$ [# m. D            node = dt_node(best_feature)
            node.vote_most = vote_most(train_set)
            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
                self.tree = node
                # 用于作图, 初始化叶子节点可选颜色
- q4 M# O3 @7 B                for i in range(len(train_set.target)):
- m6 Q, f7 h  k% I0 U' }                    if train_set.target not in self.color_dir:
                        global color_i
                        self.color_dir[train_set.target] = color_set[color_i]
* _8 ~9 Z) J0 d1 c2 V                        color_i += 1
) f) N% |+ A" F  H) u                        color_i %= len(color_set)

            feature_range = [] # 获取该属性出现在数据集中的可选属性值
0 n# }' e& l" J+ _9 ~2 v$ j            for t in train_set.data:
2 O+ N# T! L0 A7 z8 R; A4 q                if t[best_feature_index] not in feature_range:
                    feature_range.append(t[best_feature_index])
! r* o2 ]' F/ K7 B5 x) J
* K' z9 v: I0 c7 m            # 用于做图, 创建一个内容为属性的非叶子节点
            node_content = "属性：" + node.feature_name
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
; P* V9 y4 z, ]' |8 C0 [5 C
            for feature_value in feature_range:
                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
                if node.child[feature_value] == None:
                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
/ g7 k3 l1 C5 ?6 r) x5 r                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
                node.child[feature_value].parent = node
. Z: D; M% @# \" ~$ e
% w6 B6 J2 h. r. q# s) X8 r                # 用于做图, 创建当前节点到所有子节点的连线
                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"
7 z; k0 Z/ J/ ~
            # print("Rest Festure: ", train_set.feature_names)
$ L2 O# C  {6 u! B9 Y7 P) L            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
* C0 V7 j$ v1 V9 f1 v& y+ s9 r            # for feature_value in feature_range:
            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
            return node
; U% E) u, w3 ]
    # 测试模型, 对测试集 test_set 进行预测
    def predict(self, test_set):
' B( S) d9 M/ q" W2 k        test_result = []
        for test in test_set.data:
            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
4 K: n# t7 C+ t3 o            while node.target_value == None:
4 [5 `  U9 B! t, G) Q7 @                feature_name_index = -1
                for i in range(len(test_set.feature_names)):
. E0 v3 |5 j6 B) c, O& O1 z" B& l* c                    if test_set.feature_names == node.feature_name:
) S" f, D; g* Y+ P                        feature_name_index = i
                        break
+ ^* M& G8 @; }# y! v                if test[feature_name_index] not in node.child.keys():
                    break
                else:
5 K) I3 L5 K- l3 B% W0 ]  a6 k& V                    node = node.child[test[feature_name_index]]
, ~6 s  T; |" b: q
* v: d; k  U* z6 q# K0 A$ b  c            if node.target_value == None:
% z( v2 }# u' m/ @4 S$ z) z; y                test_result.append(node.vote_most)
" e# R1 d7 O$ A* c: u# [5 O6 O            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
                test_result.append(node.target_value)

        return test_result
1 S7 _+ ]  e2 A9 W
    # 输出树, 生成图片, path: 图片的位置
% G, I7 B* a* q* j8 M. G" d4 ?9 s& T2 l    def show_tree(self, path="demo.png"):
        map = self.map_str + "}"
        print(map)
6 h7 E$ A& J/ _4 ~0 ~        graph = pdp.graph_from_dot_data(map)
9 |) v  _* e% i/ N$ y* T, E        graph.write_png(path)
+ x5 c1 U' H5 M
# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
    c = dataset
    r = range(5, len(c.data) - 1, interval)
# K1 {: n& ]- l- i& L9 J5 E    rates = []
    for train_num in r:
- R0 i( ?' I3 ?( e! G0 J& Z( C/ x        print(train_num)
        train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
+ Y2 E" N3 n2 A" P( I! B: V- p        test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
6 r8 }- ~% Q! ~        dt = dt_tree()
        dt.fit(train_set)
        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))
, ?+ `) X! u% p+ F, {' }  r$ G* m: a- _
! G2 j# S0 F3 W) `- P7 b9 j    print(rates)
- Q( ]: Q# g+ b' \1 X: u$ Y    plt.plot(r, rates)
    plt.ylabel(label)
* o2 O) T" ~1 a    plt.show()
' j* Q6 W9 q1 X0 B8 f) p/ A
) J( X3 u7 x/ N, Q4 Xif __name__ == '__main__':
& R/ V2 B! o; @' B% H' M
    c = load_car()  # 载入汽车数据集
% v4 U: J7 C3 \7 v    # c = load_mushroom()  # 载入蘑菇数据集
    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
    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:])

5 k$ }: X, }. F* \/ e1 r    dt = dt_tree()  # 初始化决策树模型
% ^* R/ i# L% U: Y* r    dt.fit(train_set)  # 训练
" C9 f( T! p4 \' G) M    dt.show_tree("../image/demo.png") # 输出决策树图片
    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧
( [) _# o, ?' r& j; i3 U5 U
    # incremental_train_scale_test(load_car(), "car")
    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)


" V/ c" u. W! g
* o( M  |/ C1 s- |/ @1
2
* P( _4 s, [- u# b% \0 _/ E9 v- |3
8 Y( j  T3 ?+ C1 D4
5
6
) V9 o2 `# }  b! D2 `: g7
. t; w) F& B& R; c* p7 h6 n8
$ _% E) Q* P! o- Z( k9
' i( q5 F! |0 I6 R10
11
8 E% k- N3 S& D0 V12
13
8 `, y$ w* W) r14
15
: P( e" h. W3 Z* J0 ~. z, |6 t16
17
- T. D' X7 V4 @& F. t18
19
  j3 }4 B7 M+ W8 ~20
21
22
. S& S8 k- T( X* I23
24
25
1 M' I6 K8 H& s" {8 `26
1 \( J% X$ V) r! t( Z5 D) W( D8 @27
$ K; k8 B3 w3 x* R/ P6 W28
29
30
31
32
0 w: A( n8 a& [33
  B5 q0 U4 l$ R+ O( u; M: t34
35
36
( e) Q' h9 k0 T% |" W  u" v. {' ]+ E37
38
. d$ O- Q6 F# W0 f, ~4 I39
! b8 [5 n+ ^2 o0 k1 @# v' ~40
' B* t* V5 @3 c0 B8 U2 C41
42
43
44
45
3 D0 m6 S/ x5 e) X8 P8 R* y& R46
2 l- r6 \* \/ u1 D; ]  J47
48
49
50
51
4 e6 v, x' H/ ?% L52
4 m1 L8 ~9 G# t53
. X  y5 X! z6 J2 k$ ?& _+ Y/ ~54
55
" F5 M8 Q% Z3 g' z4 _8 A56
* V  n: a8 K- W& X. ]9 p& o57
58
& w" p9 s  T: g* V  b59
60
61
62
" f6 Z6 N+ t& }* ?2 a1 _. ]63
6 q9 |* a# n% W1 V! ^' {64
& d  w. r2 C! b8 d# b3 x7 i65
66
67
68
6 n! f/ |& Q+ I& g7 {69
70
, a7 ~5 s; D0 q$ @71
' H* \7 }! }% e+ R$ l72
: v. I/ ~% W7 q( A# ?! x73
7 y8 l( d- c& |* |: W6 w74
) b4 s8 U, D9 C+ c75
76
( ?3 u9 W$ l; C/ f. [, {: d" j77
78
5 @. c3 B; L1 M+ `+ |79
80
81
82
7 G) U& z9 P/ }83
* M$ o* q9 t; z! _# K& V84
* r% E1 Z& F1 t8 i85
86
87
88
89
+ K6 _: _5 e% F1 e* Z( F90
91
92
93
94
95
# x. u/ i9 U% W1 }! j5 d: Y96
97
$ D; n3 l9 U/ {3 `98
% M; m' C9 m, h5 x99
100
% z: b" q1 h+ Z101
3 g5 B: v2 {. z& R6 s102
) m1 D/ R2 ^: p' `. n% W, G103
! K+ ]: y3 K6 W$ g" a1 z104
105
+ v$ @* y+ {+ F$ I/ L106
2 C& V5 M3 P4 {: [3 [107
108
109
110
* X2 m8 _! y7 v: }) y111
112
+ e' S0 N& z% z& e; Q0 A113
114
2 S  y+ w  f7 U8 R! ^7 R. `115
116
2 G- |3 T9 ^- ]/ D* m. R117
118
119
120
6 A  Q# k5 d: t! C& M) q( W/ j121
  t- A( K# a1 U# J122
: |4 `8 w3 }; T123
124
  G6 k' P0 l( @: ~125
126
127
8 I( l! v8 |* p/ z  T9 L( t2 W: {6 A128
129
$ S: r7 V' E2 H% l130
8 r) U5 A  f: y1 O8 m* T131
132
133
$ t( S4 V- w" e0 R# N! I( E134
135
136
- E7 ^' m5 U1 o- X7 `. O2 K137
; V2 z# L: E+ _( e; _9 K+ ^138
139
140
141
7 Q$ [1 o; K2 A, i142
5 q) J/ t* W# `; K143
6 O: j- E6 F  ?- q  q. V( e144
) Z" U1 h& C, \145
146
147
148
7 V3 r% S/ f  j) m149
& w- F* v& _$ X' w0 }  F150
# q* a! \6 g) A6 Q3 M- h151
0 ~, L! Z, d$ ?: F# I( l3 ^152
153
154
155
! C+ v- H3 L5 w  G156
( A, i/ w4 I' a0 Z4 c; h157
8 ]* r3 R1 c6 E. Y0 o158
1 M0 o. f: ^) T; o9 \$ s8 p159
160
+ [1 n8 F1 B  _! {6 K9 D161
162
163
164
165
) c" J$ \) s5 s5 A4 [! Q166
167
168
8 A# J" Y; U7 A% e: _& m9 g  g! V169
: r; C3 m+ Q2 r% R  H170
171
, I4 v4 n5 h1 S1 _3 C1 ~  D172
173
7 y3 [1 S1 K; S( c6 F, a' a8 K+ e174
) T! ]3 J! O+ S175
176
177
- G' D9 s$ A7 E0 z. z178
/ x" d* E; ?- _1 j. u179
) {2 f6 }/ C/ e) [* J! [9 f3 F180
181
1 o! n7 I& L& s3 |. Z/ ^182
; F+ H. t5 O& y: S: P; s5 E183
! D# x/ q9 ?+ I. o184
185
8 x- E* I+ ]- {& p186
187
188
+ l# ^3 N( @" @: ?8 W8 x189
190
191
192
' P4 s, q& V5 m193
+ ~5 v/ E" y+ \4 C* m194
195
2 A3 c4 S1 U; e# y' S196
197
, b' E$ J9 {: W198
5 @% G$ x4 y) ]: m: D( ^. A+ q& o199
200
  J/ U9 Z6 E6 V: \1 J$ X201
1 F) C; f& M7 a202
% W. r& M8 z$ a% }: H* L203
4 K, ?/ c1 `1 W% }204
205
: g; ~6 U; x  s1 q( X1 B& b206
207
9 F# t$ U8 ]' Y& M( j& }2 {208
209
210
- d3 z' C8 `$ A, l( {* j" f211
212
213
5 ^5 L' e: B: c1 q2 `" I214
215
216
- v, i. n; n( v/ n: j7 `217
0 r8 d( k4 E' |. z1 s4 ]3 p5 I2 G218
219
( P5 d) ]# r. S; Q0 s220
221
222
) g9 Q0 g& o8 K223
0 L  i/ e& G- x' j, S' L+ Q224
: b. [4 F3 k: Z5 i) s225
7 j' [9 s9 x: f. v; _) J; ]6 |226
227
228
229
230
231
. ~- G6 S$ M+ l232
233
- m8 Z0 A, O* n* R$ V% h234
235
236
7 V1 q. X$ d5 ^- f- X% P" l5 j237
  H# f8 j  x+ ]( _238
239
8 r  G6 O$ A" P. r240
241
242
243
, |) T6 n+ G* R7 k' n% ^- {1 k244
* _  [$ f/ @+ c245
246
247
5 V9 Z- E6 ]! H6 }: p% c248
249
250
0 B2 L- {8 h3 A, e  a6 a251
1 @8 p& G- u7 z" D  T252
253
$ V' {5 [% R0 l254
# k+ J, C& E! v6 a: G% b! ]255
256
257
258
% R( N0 J  R4 J' \! v7 |259
' t/ v* G! |' J3 _' g0 c% b7 t7 f260
; z# E( [! C6 N8 \. ?261
. C7 p* P! y; I9 u& U262
263
264
8 M  K, V% q5 c& r& o) ?265
266
! q3 h2 V- w( e+ f5 `! k267
( E/ [1 R9 I+ }+ X2 i268
5 ?4 K. R9 V4 G6 w3 L+ Q269
270
271
2 t1 t& b: e0 i2 v& e# r272
273
274
275
4 L. X7 H- {( s. l6 c4 O276
* D( t: }9 b1 U  |9 p277
278
1 M+ u/ j& A! ?+ N8 U3 j279
1 _6 z' [! w( s' y/ b280
281
282
283
5 X1 t" P6 y& d2 G8 k, g! K# j4 @284
285
0 ]! h$ G7 d. ?& d4 X' W" e1 \- z286
# \+ u6 e/ ?5 a& P5 ~2 T, d287
288
289
290
291
292
; ^7 M0 i3 H, \! p0 a$ @293
294
295
296
297
' D: D& U% A7 P+ i' ~4 |298
299
) d9 t0 `1 ?; G9 b300
301
! f6 ~" M. ]1 T0 [302
303
304
1 `, `2 c/ S6 [% o2 B305
) y- `6 f; `1 V: q( Y5 L306
0 x) I8 N9 G) Y+ t. i8 X307
308
6 e5 U! K+ v  Q, [" l# x. a309
310
311
312
( j0 @) Q2 r) E7 W3 `313
7 ^3 J: Q7 R+ y" ]3 f- Z5 {/ f0 U314
315
316
317
318
319
320
0 h& ~' ?& x( k; {: g321
322
323
324
3 `* z0 j2 `, U3 _! k! N325
5 d, o, x' \0 P2 A  ]326
327
328
, m  h$ e4 }6 |* @329
& M& ?/ T4 q* b9 U- F% N( t330
0 S' m5 Y! D# e, @8 c& E1 Y& D5 u331


, {% H- V: U* E, }4 E, o, U: |






" L+ ?3 i. _( M, t5 u. s# y$ l' y
" [5 u& Q2 G" Q' x  }; B; `
) ^" \  m8 h$ r9 q# g, q- _) {2 W
————————————————
0 s1 o% s* N  ^9 _版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242
8 p: E2 \  }3 v+ w! b) i
3 T, Y, t, k# k0 E