基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

决策树模型
目录
- d/ ^, v. N% @+ k4 _人工智能第五次实验报告 1
决策树模型 1
5 T  X3 m$ [- |1 B: L一 、问题背景 1
" b' T8 ?% ^# ]7 r( {. ~) k- ~1.1 监督学习简介 1
1.2 决策树简介 1
二 、程序说明 3
2.1 数据载入 3
2.2 功能函数 3
# L9 O, a% l' j0 J2.3 决策树模型 4
三 、程序测试 5
3.1 数据集说明 5
2 s" l) B8 \5 g. A1 E3.2 决策树生成和测试 6
& C9 z- }4 G* q8 W1 i3.3 学习曲线评估算法精度 7
5 e, ]) H& t* s9 f四 、实验总结 8
附 录 - 程序代码 8
( Z/ U' E. I. \$ R' f) V一 、问题背景
1.1监督学习简介
* u" C% W7 v+ `; g机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
; H! o: W# W% [+ _常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
1.2决策树简介
* }4 k; Q, m! }+ y2 A决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
( ?" @+ E4 l" D+ k; u) X% W决策树的组成
* X: a% }' U( C1 I4 x+ c, n决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。

! b$ A- a, K+ w; Jimport numpy as np
from matplotlib import pyplot as plt
from math import log
2 E& b/ Z/ m: l' `import pandas as pd
import pydotplus as pdp
/ v# }9 r( n# v% R4 F. P* t9 z) T. p
) Y: U" @1 q, e7 F( Z- V, ["""
19335286 郑有为
人工智能作业 - 实现ID3决策树
* p" z+ S' O3 w2 |"""

nonce = 0  # 用来给节点一个全局ID
3 o# u3 }. Z+ {color_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
  D1 N4 O7 r, tcolor_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]

: ]/ k1 \% ?% \" C' }5 k2 b& S# 载入汽车数据, 判断顾客要不要买
class load_car:
    # 在表格中,最后一列是分类结果
. g1 s7 _) A5 K1 N- I* f3 }    # feature_names: 属性名列表
; Z4 ^. T( W1 h/ y' \  }    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
5 \, x, _& I0 |    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
% F% J8 ^$ K- T' M- G- D5 x/ e/ a4 u        labels = df.columns.values
# A6 ]) y) u* k' g        data_array = np.array(df[1:])
        self.feature_names = labels[0:-1]
        self.target_names = labels[-1]
        self.data = data_array[0:,0:-1]
. Y0 i$ a# K3 w        self.target = data_array[0:,-1]
4 T3 ?( r' U+ n. @5 J
# 载入蘑菇数据, 鉴别蘑菇是否有毒
' L; _3 M2 r; J3 [1 hclass load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
$ l  g; y4 |" A    # target: 目标分类值列表
6 W  A1 U. \/ |5 f    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",
% }7 d9 S' @+ T" X1 `$ k5 t                  "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",
                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
        self.feature_names = labels[1:]
        self.target_names = labels[0]
4 g/ z. t4 ~) ~2 a( B        self.data = data_array[0:,1:]
. a9 `! Q( M7 o( a" |& K5 M        self.target = data_array[0:,0]
# {( L: C+ \4 b/ X. |9 k, q
# 创建一个临时的子数据集, 在划分测试集和训练集时使用
/ u4 z0 W( V* n+ ?, kclass new_dataset:
1 `4 ?! r$ p4 Z    # feature_names: 属性名列表
    # target_names: 标签(分类)名
4 y/ M$ f! `2 s+ K8 ]3 |' I    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
! z6 \# u* ^8 X4 L" x' {        self.feature_names = f_n
        self.target_names = t_n
. D6 J( ]; _# p6 Z4 }! s        self.data = d
% F4 v5 T1 ^9 c) y        self.target = t

# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
# target: 分类结果的列表, return: 信息熵
5 V- H8 Z4 n1 d. t3 W0 q* edef get_h(target):
    target_count = {}
    for i in range(len(target)):
- Y9 \  S' x! X( U4 D" D        label = target
        if label not in target_count.keys():
            target_count[label] = 1.0
        else:
            target_count[label] += 1.0
1 j. F+ K) ?1 i    h = 0.0
2 R, V8 ?8 o0 p% J6 T2 a    for k in target_count:
6 P) o) c* a! N+ j. A" O3 X        p = target_count[k] / len(target)
6 G+ y5 J6 U( B4 ^/ a1 n0 `        h -= p * log(p, 2)
( `; ]8 d8 {$ f- T( H4 a& _    return h
# i* X" \9 E( l7 G/ v* ^! I
3 `& d8 B9 F0 `5 G  x. U5 O# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
def get_subset(dataset, feature_name, feature_value):
3 s' T9 r: `2 H% t    sub_data = []
    sub_target = []
    f_index = -1
    for i in range(len(dataset.feature_names)):
  u8 [6 \% i# K5 t2 ]        if dataset.feature_names == feature_name:
            f_index = i
            break

    for i in range(len(dataset.data)):
        if dataset.data[f_index] == feature_value:
            l = list(dataset.data[:f_index])
            l.extend(dataset.data[f_index+1:])
' C% D# i  W* k/ T1 q            sub_data.append(l)
            sub_target.append(dataset.target)
( P7 P' u6 m, k5 Y6 r
    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)
; u5 h$ x: B2 y; _/ v
1 F# A3 a! v( k8 D. p& Z6 t# 寻找并返回信息收益最大的属性划分
# 信息收益值划分该数据集前后的熵减
) z0 O: E! x; z$ m# Z( {# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
def best_spilt(dataset):

9 b$ B- w' H; }9 ]: c  Q    base_h = get_h(dataset.target)
9 e0 d4 T8 `7 R    best_gain = 0.0
8 N6 O/ o# Q0 v% Y4 d4 V. N7 q    best_feature = None
    for i in range(len(dataset.feature_names)):
        feature_range = []
        for j in range(len(dataset.data)):
9 X; `* f7 c$ S' ?$ K! d7 G% H            if dataset.data[j] not in feature_range:
                feature_range.append(dataset.data[j])

        spilt_h = 0.0
        for feature_value in feature_range:
            subset = get_subset(dataset, dataset.feature_names, feature_value)
" G6 X0 `* T( M  ~$ y" s8 j            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)

& k3 d1 q7 N+ F        if best_gain <= base_h - spilt_h:
            best_gain = base_h - spilt_h
3 Z9 R8 H  g5 S' i1 p( Q1 W            best_feature = dataset.feature_names

( D& |6 E& O. |    return best_feature

# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
    target_range = {}
7 |, G0 B1 W( F  V' K: o- W3 \! K    best_target = None
, \1 w- N* e9 f, @    best_vote = 0
4 G- S$ J0 n$ K$ D# q4 _
3 J( _. n: z' l, b/ _$ u$ |- f: u    for t in dataset.target:
        if t not in target_range.keys():
            target_range[t] = 1
        else:
            target_range[t] += 1

    for t in target_range.keys():
8 A, x7 T) z' n5 J) {& X6 B& X* y        if target_range[t] > best_vote:
+ t( t* z% o+ C* a& u3 j3 L: e            best_vote = target_range[t]
            best_target = t
* E8 c, p& j7 g1 ^+ V
2 y% C, v. X3 o) O+ h) U# D/ S# K    return best_target

5 ?+ e1 k- p) z# 返回测试的正确率
) @/ t# ?% v$ w4 x& `. I+ ^2 E# predict_result: 预测标签列表, target_result: 实际标签列表
def accuracy_rate(predict_result, target_result):
    # print("Predict Result: ", predict_result)
    # print("Target Result:  ", target_result)
    accuracy_score = 0
    for i in range(len(predict_result)):
7 }) K% C8 K% ?. t( i+ D) A/ @0 p$ H        if predict_result == target_result:
) T0 L# J" x5 S' C5 k  z4 j. l            accuracy_score += 1
    return accuracy_score / len(predict_result)
' f: M$ S9 W7 j- ]  F' ?3 X
5 Z! ~& q* U% }, I' c/ v1 {3 v# 决策树的节点结构
class dt_node:
0 T5 h9 m. r8 H% \/ ~
    def __init__(self, content, is_leaf=False, parent=None):
        global nonce
2 B7 W8 t# \5 x( F0 j" z6 C! Y4 Y        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
/ x7 k5 @/ W4 ?4 f. b& e        nonce += 1
        self.feature_name = None
: ~4 F& N* X& s        self.target_value = None
        self.vote_most = None # 记录当前节点最可能的标签
  Z7 L* w- Z% L( q0 H* ~+ v) ^; V        if not is_leaf:
4 a$ w. h4 J, T) `/ B4 O# K4 L            self.feature_name = content # 非叶子节点的属性名
+ T* x: R2 T) {: N+ o7 s0 C6 Y        else:
            self.target_value = content # 叶子节点的标签
6 p" |2 F% k5 _8 u: R! k, T
        self.parent = parent
. {5 N4 ?  A; Y# R, Q" u! W' w        self.child = {} # 以当前节点的属性对应的属性值作为键值
) o$ Y/ G+ u3 e5 }# D! D% ^- J
# 决策树模型
- ^/ z. H/ w- P' {9 ]+ @class dt_tree:
; O  \) N) l& V9 e( k, j' K
    def __init__(self):
/ ]* `; P( Q! q$ z        self.tree = None # 决策树的根节点
        self.map_str = """
            digraph demo{
1 B- ^$ X; \+ t% Z5 a            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
+ N( W' z' n1 F- ?7 M3 P. L            edge [fontname="Microsoft YaHei"];
9 b* U% N: u  g! {" l            """ # 用于作图: pydotplus 格式的树图生成代码结构
# ~# J1 ~- P' h+ l" ?        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值

; G. D! ]+ D; q    # 训练模型, train_set: 训练集
- D2 _% v, F! B6 |    def fit(self, train_set):

        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
0 a) f: q  N: f6 ^9 r) M7 d            return None

" D: q% a, Z* X/ S4 E: \5 ~  Y        target_all_same = True
        for i in train_set.target:
2 g' n8 K2 v2 d! s            if i != train_set.target[0]:
$ s' S! W2 }' h$ o- r- i) }9 k                target_all_same = False
- o! D* f$ Q$ S* d                break
! M- ~& j/ |5 |1 c: I2 x( k7 Q
        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
' ~' o* k2 N1 x            node = dt_node(train_set.target[0], is_leaf=True)
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.tree = node
4 d; {4 x4 J( e+ N( A" ?
            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
! G+ o$ T4 X8 J4 }9 j6 e+ m2 `            node_content = "标签：" + str(node.target_value)
, [6 T+ X" c" {; n7 `, n            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"

            return node
3 u  E& X9 C) E* s        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
7 q0 U/ d$ y8 T# w6 {. s            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.color_dir[vote_most(train_set)] = color_set[0]
                self.tree = node
. A) o' i+ K9 z+ h4 s# m; I
. c0 I3 T) ?# C5 U% |5 R            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
+ W8 K. H+ T% i5 U0 }7 |            node_content = "标签：" + str(node.target_value)
9 k7 k! _0 B+ A- Z            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
/ C& S. Z2 F1 I% m7 V, O) z& c
            return node
4 W7 j1 W! J- j* B+ x. w" y        else: # 普通情况, 构建一个内容为属性的非叶子节点
) z2 r. w# X5 [6 v( X* B            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
4 t+ ]! P5 Y4 E! z' u            best_feature_index = -1
, n2 M* b3 v8 m            for i in range(len(train_set.feature_names)):
. R- D0 K6 q: M" ~* g9 m; l                if train_set.feature_names == best_feature:
( H' N; o# j/ |6 {$ K) o# P- P                    best_feature_index = i
. B8 a( I- x" s* i7 q                    break

            node = dt_node(best_feature)
! C) y7 q- P! ~- D( i, g            node.vote_most = vote_most(train_set)
$ H9 s" T) H0 m. I; V6 K            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
  x, K% U" P1 _. ]3 J                self.tree = node
; X+ ?1 D* }. o                # 用于作图, 初始化叶子节点可选颜色
5 O7 h4 z( a$ \& \" w: |+ z                for i in range(len(train_set.target)):
                    if train_set.target not in self.color_dir:
( N6 ^" j* Z& T1 L                        global color_i
                        self.color_dir[train_set.target] = color_set[color_i]
0 D% [* v$ ~; f, z2 N- u, D                        color_i += 1
. f1 w2 T2 Q# p$ p                        color_i %= len(color_set)
- Q; C, K5 S+ ~9 b7 b5 P6 s
! D8 N% h* {$ T4 {( n$ R# E            feature_range = [] # 获取该属性出现在数据集中的可选属性值
' O  A/ I3 n4 U4 M, p" M            for t in train_set.data:
. h4 U) t7 I+ J                if t[best_feature_index] not in feature_range:
                    feature_range.append(t[best_feature_index])
$ b5 m9 F# U- e" q2 s. s; ?
) p2 _" ~1 o9 Q) Q8 X2 {; P. V. g            # 用于做图, 创建一个内容为属性的非叶子节点
* P- b$ M; p1 a% A& T& ^# I            node_content = "属性：" + node.feature_name
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
9 H3 X* Z! V) A  m4 z# |
            for feature_value in feature_range:
                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
8 c0 `8 h5 g' y& U" x$ `, \1 G                if node.child[feature_value] == None:
                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
                node.child[feature_value].parent = node

                # 用于做图, 创建当前节点到所有子节点的连线
0 N6 c1 x/ o/ y. n0 ^) x# D                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)
            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
( y; p& m# A4 ^* @& {% K/ g! h% B            # for feature_value in feature_range:
            #     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):
+ q( n6 q8 s3 Z0 O        test_result = []
        for test in test_set.data:
0 o: t8 ]5 e$ T8 w- A' m            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
: E: B* P. g' Y1 ?0 ^0 k( R            while node.target_value == None:
5 k0 V$ |) z" h; `' o) ^. r                feature_name_index = -1
9 U, k% e8 N' a# H                for i in range(len(test_set.feature_names)):
; n9 ?4 j* k$ y                    if test_set.feature_names == node.feature_name:
                        feature_name_index = i
                        break
1 p. i. P. s3 q                if test[feature_name_index] not in node.child.keys():
" E6 E1 f+ }( l  _1 q( h% _4 V                    break
                else:
' s8 B  y7 \; D  u# C5 E5 J                    node = node.child[test[feature_name_index]]
4 ~& J$ J! i; w( \/ C3 o2 n
            if node.target_value == None:
                test_result.append(node.vote_most)
* U% \3 @. c% u2 y; y            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
% G8 w$ s4 D# L% E5 d. ?                test_result.append(node.target_value)
; p6 P; |9 ~! L  A" b' y
$ K" B5 X7 V$ t3 P1 n' J6 C4 s" b: S        return test_result

    # 输出树, 生成图片, path: 图片的位置
    def show_tree(self, path="demo.png"):
        map = self.map_str + "}"
        print(map)
        graph = pdp.graph_from_dot_data(map)
        graph.write_png(path)
+ L& l7 i* M! _7 w- L9 X/ H8 A
& o+ i; l; O2 i( a4 e9 s# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
    c = dataset
    r = range(5, len(c.data) - 1, interval)
1 N5 ~3 Y* f6 z8 J  ]$ ?    rates = []
& l% I) J3 p- [! I2 B: x- N: t4 ^0 C    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])
        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)
        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))

    print(rates)
; n+ L, E: r2 n% N, \    plt.plot(r, rates)
1 U( ~5 g2 m( @5 _- g    plt.ylabel(label)
$ F0 E6 W3 Q( n3 ]& c* G    plt.show()
6 C8 o( N4 N7 g3 E: i1 x) O
if __name__ == '__main__':

' M( y/ i9 Z% J6 Q, |    c = load_car()  # 载入汽车数据集
    # c = load_mushroom()  # 载入蘑菇数据集
# D- e* L) O+ ?$ e0 Y    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
) _, Y$ B; Q" w    train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
/ t7 m9 H: n' I  r    test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
' J0 q" N$ N  N1 g5 B0 M; d( S, U
    dt = dt_tree()  # 初始化决策树模型
    dt.fit(train_set)  # 训练
6 [: b( `/ B: [; ]* r$ c6 Y1 s    dt.show_tree("../image/demo.png") # 输出决策树图片
4 v" K4 ~3 l: W" S    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧

    # incremental_train_scale_test(load_car(), "car")
0 l/ [" r9 H: X6 E    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)
8 c! }7 x; [. _' \


1
2
3
: Q' \( v. z( n4
5
) k& r1 W- s: u3 P) u6
! t7 J: Q0 a' o  y& |; i4 ~2 g( f7
& w4 B7 w2 x& X5 |% o! Q7 Q8
9
10
0 K- ]3 r" X5 s( g4 @5 Z  n$ w# }11
" h' v/ [0 \2 P" P  E9 C' F6 t/ ^12
13
0 V1 d$ P) I; d; ]+ x14
15
7 }9 E4 g# j2 X0 T) e# X16
17
18
19
" n( h) U+ Q) }; y; ?9 |( y" a# j20
, x. w$ s0 d) |) h21
22
4 o( Y' Y: X6 w7 n23
) g( I: Q' J: v( F2 U24
25
26
27
# I. P- c/ N- A4 A& u% o, k% O28
* L* h5 N  q% R29
30
31
8 D: \' U! _$ e' Z4 l32
' w* Q* }6 f% o; [/ d4 A, G' L" d33
0 Z+ ^4 \4 O* k' [34
35
36
4 R4 ?7 V9 Y0 M- A2 _. [37
: a4 \/ d4 q! s8 p( @2 P38
# A$ Z9 |9 [2 ^, b: A3 ^39
40
8 v- i" \7 f' I1 W. n: @1 O9 a4 u41
' V2 b& D' S5 r) N42
& b7 `; s9 p0 y6 K) V7 |' ?' J43
44
45
4 G8 l. v6 r1 A( r5 i46
47
0 [4 w& C: p& j6 f: n48
49
8 N# ~0 K& q0 f8 t50
" w" V& [. I, ^) I0 a  l51
52
, o5 j: z. v! Q7 a  }53
54
55
3 i8 ~- P6 n- Y- C" ]3 Z56
57
1 T7 j! P0 r9 c; g- [58
% h* x0 J7 L( |59
+ ~) P3 m3 J  Y8 W1 y# t60
61
62
+ V* B6 L. ?3 t% W' l4 n5 x/ X6 w; Z63
: i8 \7 t. j  _  z3 g9 D1 |64
65
- h- a/ ~, L& ?' m, Z2 m66
$ D4 A7 s' h# Q0 v7 K( w% Y67
68
69
/ X. _8 `1 W0 s& Q0 U& ~/ v% t70
" a* ^& K' h+ O  b+ D6 R71
* w$ n4 P5 T( f. d$ I0 X72
. n) ]; N$ `! a* u7 t) q; \73
/ l" Q# ^* U! M' D# f0 ^74
* g9 D/ [" P2 l7 J2 `75
76
; i4 c2 I( u' \$ E6 `8 S5 O77
78
79
: R" e* y, C* |, R, d80
  H% E$ ]' P  B# x  @" t81
82
83
84
85
86
87
88
8 [. ?: B/ Z% v+ n6 N9 ~6 P1 F89
90
91
) m4 {/ T; ~4 |3 K6 l( u2 a92
93
$ [5 |  O) Q  ~9 k$ F* U94
9 n( Y% G' A+ n) G$ K' i. v: R95
# h# w0 _+ J5 p4 ]3 Z96
# D8 t* X7 K* o0 D+ X7 d4 N/ C. B* \97
# Z" B% A' q( x4 ]. ]% g& ?98
99
) T) J; |3 n* Z6 f  e6 \" t7 `100
101
102
103
104
" R5 M; c7 \/ b7 ]$ O: S1 g2 J105
106
7 y9 [2 n# B% H! c4 q" U107
108
109
" `- j$ i1 i& {: a. g# U( b# i4 N110
111
112
  B5 {# k" N" a6 J* ?6 x113
; c% f' U( y1 ]) [/ S114
2 r1 o% U; w9 n9 @& a# M) D4 J115
116
- T6 d3 ^" p; I/ _, @117
118
119
120
" C- c5 j; p) m5 @121
122
$ i" q9 o* }" Z  R& b123
124
& P5 [; E- [0 J' N125
126
127
128
129
( d- A- t& q+ Z" e8 Q. ~# X130
131
! J4 X! e+ y7 q% G( m132
5 y9 W- s! E( W+ m; ~, {0 C" ^5 g133
; E# _# N( L6 [7 [6 _+ M134
135
+ o) |' [. j0 O% u3 o& J# O" Q136
, }: ~+ W- w- }  ?6 i137
# D6 M1 W3 u# B: P0 R4 o138
+ p! Z- Q8 @- ]139
1 [( j3 M0 S! P140
141
" w; N! p7 K; E! |; |4 \142
  C0 F! s4 ~* v# V# C5 `143
144
5 D( e9 r' `0 ?/ c/ @0 W145
146
8 T* m7 q$ y2 F5 A# @' Z147
: P- u; M. `7 Q6 a( M/ J148
/ _: k* S9 S7 O  W( F149
! J# [+ Z' \2 {150
151
0 \5 h3 C& j% `9 B7 X, s152
153
- C* b3 b/ b/ W. h154
155
156
157
- Z$ E  n3 q' r% s7 K158
159
160
& `( ~. ^9 T$ K+ i9 X+ L161
& n! s: r, b( K6 m9 ]) ?5 u* W162
0 Y3 P9 u' f0 M" P! i. E& L+ P* i. P6 o163
4 p0 ?( ?; @  z6 ^164
8 K8 }/ c2 e# `165
( H1 D- U- K- U4 I5 f6 K6 w166
167
. Y2 X6 q1 c' Z: \2 c! ~* W168
5 D- G3 P; n+ c, M, a- D& S( o; c7 ~169
170
& H4 _9 c# K- e; [" j/ B171
7 {* f% a) }7 l: F  S" I/ |172
3 ]- j: T# |& \9 |( w; e! x5 q) G173
174
175
176
0 s( D5 u- S" P3 E) R177
% b1 K4 s3 Q, F5 s  {178
1 @' q# H0 B, I: s1 y' L/ E179
  _5 t# }7 X1 b% K180
7 j+ q2 e5 s3 m8 u4 W9 A181
182
183
4 O( n, C6 M5 X/ x- q; H/ A184
% u5 h  P. |8 z& `, A185
186
/ V' `) J3 u. ~; H7 n9 g187
1 t7 D2 Z0 j( }! P7 t; {188
189
190
: _4 C. d/ o( c& f( U191
192
193
194
195
196
- C& y1 y, R- R8 H( P8 L  R197
' {" B' B2 R$ e" y% @* R198
199
200
' h4 c+ K) ?# ]6 U9 S% g! u201
202
0 l+ c7 e$ [6 d* C& K203
/ J# i2 G# t, L) ?& A4 h204
205
206
/ A4 n+ a9 c' Q9 G! {* y207
208
8 h$ i# K; J, [; |209
210
9 l) z  `0 V( ~211
/ `4 K$ {1 J1 L212
213
. [5 Q6 G+ ~" `' i9 H" `0 E214
215
216
6 I6 ?' b: P0 P: y217
218
219
9 l% ]- ^' M& ]& s& P2 v8 Q220
3 c4 n5 u) N9 ]( g, @* F- w. _221
( r8 X1 \$ L+ k222
223
  E0 {( \3 Q3 E224
225
) O' o2 I$ {7 \8 _" I, Y- z  S226
! }' E+ ]+ B! ?2 V* x4 I# v1 s; G227
228
229
230
231
, E; ]+ d4 j+ b% `8 v0 f232
233
234
( b$ M$ j8 ^) a) h: [% ?/ o5 s235
) Q' a* f6 z8 g2 x1 [236
237
238
239
' l6 v+ c) |5 S8 B; {# ?1 b240
* G+ `% |- e# i, ^. j241
242
243
) U3 }: r, w8 p/ E8 z) a" x* k9 n244
# E7 K, A+ y9 G8 I/ t1 m245
246
247
( n  g& M* ]( @/ f3 Q5 {248
! _, q2 F! r) X& g1 ]' w249
250
251
252
8 g, i+ \5 T6 ~253
5 v' j0 J8 d. t1 l254
2 o4 G; w4 \" k* K8 t8 g9 [( O255
256
257
6 f6 d9 V! R( w! }258
259
- M% U. e7 d# X3 f: z0 p" l( m. k260
6 W5 e2 }. D! F% D- B2 G+ u261
: A) J* j" X- R# b( c262
1 y3 I! l3 W  M% \  I* ~4 [& M263
264
6 N. v/ M4 x1 b; Q265
266
267
268
( S% L/ k  X. m( S269
  g! ~! P# y) ]; }270
% C4 w" F' v+ |  K1 G9 a* j" D$ o3 N271
272
* y* }8 j& }' j( j273
274
275
276
277
( K, ?5 A* t* q0 z278
279
) U2 w: @, S6 T# f280
( p/ F8 ~1 a7 Q1 ~0 \. o5 @$ d281
282
283
2 X6 L' B& ?/ q( ?" u# T284
285
3 M4 E  N7 V; o9 a) J286
7 p# W5 C& N4 {; i- I287
288
289
290
+ X8 }# U3 P  V4 g  O291
4 K. i- ?7 I1 s# T0 y1 S) _292
, D; v( P2 c! q, [' j293
294
. c$ q$ Y! \1 I9 s" A$ j' Z# y295
1 f( l% Q0 m" K( o" ^9 q296
297
+ H) X  O; o% L" X! }* L4 `298
& N+ J8 d; f/ m3 I! Q299
/ e& ?+ `& J6 U  r& S3 [4 g300
9 E  L, I) j+ g! U' i301
302
303
304
305
306
1 O2 z% }( g9 M8 d2 J5 I% J307
308
. i/ v/ O9 D. m/ [$ _309
310
311
312
. V3 a6 y9 u% z& u313
314
315
0 ?9 k# p8 s0 \( P& ?. s* r316
4 t, a6 G* e0 s& E& a1 G317
3 z8 [+ E; X/ x  a% h0 g318
319
. h" W, I  Q4 L! B2 U! k& n320
- N  n+ L5 q9 K( ], V321
6 p0 ?6 @1 d, G% V& s322
323
* g! G7 f' g4 v& f! y* R324
$ U" K2 P9 o( Y325
1 r# i7 [. q; j( [5 a' j0 l: q* ?326
$ w- t. h3 D. y/ |, |+ G9 V327
328
329
330
, c; }! k! H1 u3 v. B331
1 Y( Z+ N5 n. v3 V$ I
0 J7 t" L8 n  L& v9 A% ~
8 V/ D7 W% J' S5 C


$ F' y% Z! U- C& a7 M8 S
0 j* G2 Z9 g/ w" _* E( W
' c3 S% y, F" F2 x



) n) U  j7 p3 w3 |
8 C; y" F- Z' Y0 b————————————————
# P7 u# U1 F* A版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242
* T. Y7 I/ n) ?