基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型
1 V% F3 y& X/ o# `4 [9 f9 j
" s) G# U' U" `. j; M' G决策树模型
目录
人工智能第五次实验报告 1
. Z% s+ |1 }- i! k3 R( i, x决策树模型 1
一 、问题背景 1
# s7 ~- x+ D0 t1.1 监督学习简介 1
& a8 H8 s  u* N4 J: K+ w' n3 t1.2 决策树简介 1
二 、程序说明 3
: O* r7 p9 G+ s2.1 数据载入 3
/ C! D" j% H% t* Q' v2.2 功能函数 3
2.3 决策树模型 4
三 、程序测试 5
3.1 数据集说明 5
; X+ X1 N5 w0 D7 b4 X) r% w3.2 决策树生成和测试 6
3.3 学习曲线评估算法精度 7
  P. t; d* ^9 o' Y* G& L  v四 、实验总结 8
" E1 n0 ?  g* R  X  N4 e附 录 - 程序代码 8
  @* E! U; ^& {一 、问题背景
1.1监督学习简介
( s: k2 z: z: Q& y机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
8 h: V8 d5 j* |% _" _1 V
& a1 J7 T, O6 l2 Jimport numpy as np
& B1 y$ b, Y. E! _from matplotlib import pyplot as plt
8 Z- O- w1 d7 g4 H. bfrom math import log
import pandas as pd
5 @) |9 S# x  C4 y7 W7 s) Y  simport pydotplus as pdp

"""
19335286 郑有为
人工智能作业 - 实现ID3决策树
"""
4 L% v, N* `+ w) Q" u: u1 k
' U6 c3 Q1 m5 E# g9 U8 W1 M$ p. Mnonce = 0  # 用来给节点一个全局ID
color_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
- K6 J) m0 ~, p4 i5 J* u" |color_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
; X' B0 S* _. M" R. ^( @
# 载入汽车数据, 判断顾客要不要买
$ i. P. W/ K* S& J1 gclass load_car:
2 C; i6 X! v, j    # 在表格中,最后一列是分类结果
/ T& m2 @, [& o0 ]    # feature_names: 属性名列表
, ?2 [+ G6 m3 b8 m) `5 r    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
" F! }1 P) {/ N# ]        labels = df.columns.values
1 t6 B5 g0 A) X, y6 J) ^5 T        data_array = np.array(df[1:])
; }8 c: T& E" s# ~        self.feature_names = labels[0:-1]
  J( {6 `6 T5 X4 L9 D+ `; Z        self.target_names = labels[-1]
+ B) s! U5 `, o) V( ?        self.data = data_array[0:,0:-1]
        self.target = data_array[0:,-1]
* F+ ?' [+ h0 p. E
' Q2 W) C- C% Q# 载入蘑菇数据, 鉴别蘑菇是否有毒
- D) f+ f9 p1 rclass load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
+ H8 c7 E% s# M3 w8 q8 A    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
3 B  J5 F1 c4 T1 {1 w- x6 r4 F    # target: 目标分类值列表
    def __init__(self):
: C% F0 a) R0 l2 D/ [" p* i# A        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
2 O# v8 W- X) _: N1 ~        data_array = np.array(df)
# B6 S! d* l% t* |        labels = ["edible/poisonous", "cap-shape", "cap-surface", "cap-color", "bruises", "odor", "gill-attachment",
8 w7 s2 M, A7 Q2 m" X* u! f7 r                  "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",
0 V7 }4 G8 J; H0 m                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
        self.feature_names = labels[1:]
1 w) b3 \/ E& c0 ]        self.target_names = labels[0]
- h4 Z6 i! `8 n; a7 g- [+ f        self.data = data_array[0:,1:]
+ Y5 ?3 W& ?2 O# h) N/ t; j6 v        self.target = data_array[0:,0]
: a# V* t) P( U; i6 C* ?" m
# 创建一个临时的子数据集, 在划分测试集和训练集时使用
class new_dataset:
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
, n: s! N7 y' J2 [+ x6 w) b    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
2 I6 v: H' _( t4 L" ^. Q9 g        self.feature_names = f_n
        self.target_names = t_n
; d5 m- V8 b5 [  J& z        self.data = d
# v% @5 A7 V( N5 g: e* V: N        self.target = t
7 I1 G0 n9 C, V% W' e
# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
' o8 K/ W) c! o9 n5 P: d% c" P5 S# target: 分类结果的列表, return: 信息熵
+ g! E. @, ~  Z! _2 }3 x! `def get_h(target):
    target_count = {}
    for i in range(len(target)):
( ?: J+ a' G, R5 \4 O  p1 H        label = target
: c8 S) H) i* O9 f- @! ~" L        if label not in target_count.keys():
            target_count[label] = 1.0
5 f3 \3 j% c( R! z        else:
            target_count[label] += 1.0
# X2 y; r% e+ B. H    h = 0.0
& v* ]7 C: b3 \' b3 _! q0 ~! r4 H& D    for k in target_count:
  z6 H& y4 N4 L5 P  q( X$ E        p = target_count[k] / len(target)
9 _; C2 U% a- Z        h -= p * log(p, 2)
    return h
1 ]) `5 }& y4 z3 |9 J" @9 ]
# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
def get_subset(dataset, feature_name, feature_value):
    sub_data = []
    sub_target = []
    f_index = -1
4 u) E7 ~; q. E( G) [3 [% p    for i in range(len(dataset.feature_names)):
( S! ^/ T) P# q: Z* o        if dataset.feature_names == feature_name:
5 L7 Z$ S; o% r  G; p            f_index = i
! _' s9 o' a+ B( _            break

$ Z# s) t2 t9 S    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:])
) y* Q: P6 A/ `- t' c% }! s            sub_data.append(l)
            sub_target.append(dataset.target)

) ]% _- [0 q& ?$ C    sub_feature_names = list(dataset.feature_names[:f_index])
. C" d& u2 {( {4 S    sub_feature_names.extend(dataset.feature_names[f_index+1:])
9 E! B" v" U) }    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)
: @/ I+ F# E  T: g! L
# 寻找并返回信息收益最大的属性划分
# 信息收益值划分该数据集前后的熵减
& f9 t  n; O/ w# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
def best_spilt(dataset):
) v3 K# W* f0 F
    base_h = get_h(dataset.target)
+ p- `) h. S* @    best_gain = 0.0
) Y$ {8 `7 v1 L  M: Z# t! @    best_feature = None
    for i in range(len(dataset.feature_names)):
        feature_range = []
% |) n/ {6 g& w/ V        for j in range(len(dataset.data)):
  n: B  g7 T9 h, Q( ]2 Z6 l            if dataset.data[j] not in feature_range:
0 t3 S* B- a6 ~9 ^+ S& O  G                feature_range.append(dataset.data[j])

8 a  [, \* I3 z4 c( t        spilt_h = 0.0
        for feature_value in feature_range:
& A- Z' ^$ t8 {$ y. ?  U/ K5 G7 n            subset = get_subset(dataset, dataset.feature_names, feature_value)
1 A8 C4 r: z  {            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

1 h- D1 ?0 Q  r2 H" D  f    return best_feature

# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
    target_range = {}
    best_target = None
    best_vote = 0

1 d; O) V4 J/ |# v    for t in dataset.target:
3 c( R, d3 x7 W$ b, i        if t not in target_range.keys():
            target_range[t] = 1
        else:
            target_range[t] += 1
( [) ~. O2 A& Z, W6 C$ [3 w9 {
# a- Y' d" ?  Z+ d) q( c- N% v    for t in target_range.keys():
2 z+ r7 `: N/ ^# M- f( W" t        if target_range[t] > best_vote:
            best_vote = target_range[t]
0 t7 A3 f  s, b- C+ }            best_target = t
4 Z% F3 I6 d( i
    return best_target

: J! ^% x# v: b5 B, k5 ~# 返回测试的正确率
# predict_result: 预测标签列表, target_result: 实际标签列表
def accuracy_rate(predict_result, target_result):
8 s! I" n+ V, t) {    # print("Predict Result: ", predict_result)
    # print("Target Result:  ", target_result)
    accuracy_score = 0
    for i in range(len(predict_result)):
        if predict_result == target_result:
            accuracy_score += 1
    return accuracy_score / len(predict_result)

# 决策树的节点结构
6 w4 {7 v' i4 }% j8 k0 Sclass dt_node:

0 n# q- b1 G, h' d( C& i    def __init__(self, content, is_leaf=False, parent=None):
        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
1 H( f5 r9 P2 y5 ]3 M$ b6 P        nonce += 1
        self.feature_name = None
        self.target_value = None
        self.vote_most = None # 记录当前节点最可能的标签
        if not is_leaf:
6 s1 M- a+ [9 W/ H: k, R2 y7 z            self.feature_name = content # 非叶子节点的属性名
  g  N% R5 J  R        else:
            self.target_value = content # 叶子节点的标签

3 s/ `6 C- I# t/ S3 X        self.parent = parent
        self.child = {} # 以当前节点的属性对应的属性值作为键值

# 决策树模型
class dt_tree:

    def __init__(self):
        self.tree = None # 决策树的根节点
5 }6 u/ f# y" S0 `; C        self.map_str = """
5 J1 U- T0 e8 h            digraph demo{
            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
4 [* `% m6 j  b* u! o7 l! r            edge [fontname="Microsoft YaHei"];
            """ # 用于作图: pydotplus 格式的树图生成代码结构
        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值
  B0 y6 r: q5 B
/ _. H! I5 W  I6 S4 x' i8 t. w- q# t    # 训练模型, train_set: 训练集
    def fit(self, train_set):
) i7 D1 n! Y6 O
7 s! x& q  Z: u# O        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
            return None
) c1 a3 |( ^: R1 F7 J
# J5 v2 q, v+ i- v0 B        target_all_same = True
        for i in train_set.target:
            if i != train_set.target[0]:
                target_all_same = False
% k/ k7 D2 d. [$ O3 m                break

2 r& R' U7 l. r" K8 x( q2 z        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
4 ]/ z/ ~- z; E1 k' |            node = dt_node(train_set.target[0], is_leaf=True)
1 u/ T2 ~% O0 r4 r. `; q# A            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
  J# W1 F+ n5 d1 O" @) Q$ |' ~                self.tree = node
' F9 N! H- ]# c7 E  u1 Z) ~+ H: K
5 Z. u3 ?* B, X            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            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"

; l: M; O: \: G            return node
        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
8 `8 s  A6 x( n$ h4 a6 }" c) F6 E            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
) D, ]' E$ `; E% c            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
. o# T! ]# Y2 K+ V0 w! }, M                self.color_dir[vote_most(train_set)] = color_set[0]
                self.tree = node

            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
9 l+ ?. d5 ]6 l3 \# v1 ?$ Y  `9 R            node_content = "标签：" + str(node.target_value)
1 {& |. @1 f& ~$ p. I            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
- O& o0 f3 f8 O4 J% L
            return node
        else: # 普通情况, 构建一个内容为属性的非叶子节点
  d, q2 D! X1 H' d, I            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
% B1 Q: @6 u1 J% o1 n; c$ @            best_feature_index = -1
            for i in range(len(train_set.feature_names)):
) i" z, Q0 D- e* c9 l9 m* `+ w) w                if train_set.feature_names == best_feature:
                    best_feature_index = i
                    break
: K8 L, ^& P: q0 e9 k
4 d" B. D0 k) u3 ~            node = dt_node(best_feature)
            node.vote_most = vote_most(train_set)
            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
) c- b" e9 @! @' C0 S" f' W                self.tree = node
                # 用于作图, 初始化叶子节点可选颜色
7 t; _2 H& T0 W. j                for i in range(len(train_set.target)):
, A5 _; ?+ {0 [                    if train_set.target not in self.color_dir:
                        global color_i
- r: i8 K" B3 o. Y                        self.color_dir[train_set.target] = color_set[color_i]
" s/ Q) a( O0 J5 y! S                        color_i += 1
7 n: H+ d( a; a! d0 P                        color_i %= len(color_set)
8 B1 d# h, j) [: }) B- n4 B6 ^" k
            feature_range = [] # 获取该属性出现在数据集中的可选属性值
            for t in train_set.data:
                if t[best_feature_index] not in feature_range:
0 ^6 p* k$ h2 @& W5 j8 ^                    feature_range.append(t[best_feature_index])

' e# {/ m$ h  J7 ^            # 用于做图, 创建一个内容为属性的非叶子节点
- G, V: z4 ]! \& M! u8 m            node_content = "属性：" + node.feature_name
: V. S1 F$ x) R, I; b            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"

            for feature_value in feature_range:
& Y5 j. z6 p& T9 z                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
0 D4 p4 l; r2 ?                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
                if node.child[feature_value] == None:
& \0 R& E7 C/ C                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
# E5 @$ |* X" q$ s" q                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
                node.child[feature_value].parent = node
3 ]5 O8 h/ D8 r8 M$ j+ a( w9 N' ~5 `
                # 用于做图, 创建当前节点到所有子节点的连线
                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"
2 [# T: T- ]8 K; J, u. {) u) a" W
            # print("Rest Festure: ", train_set.feature_names)
7 @+ K  M- ]  |" L9 g1 G            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
! `5 x+ V9 x/ |- _            # for feature_value in feature_range:
            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
# B+ o# R! z( M) t+ O# a8 ?            return node

    # 测试模型, 对测试集 test_set 进行预测
    def predict(self, test_set):
: U2 l% ~, Z9 \2 h' ^        test_result = []
5 I' a- Z- T: m' r        for test in test_set.data:
, ], Q& `) v" Y9 S            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
1 N( y8 I# [- ?: y) ]: d            while node.target_value == None:
                feature_name_index = -1
                for i in range(len(test_set.feature_names)):
! E( m/ O5 m$ X9 A9 Z                    if test_set.feature_names == node.feature_name:
/ `9 r- y# m9 S9 `                        feature_name_index = i
" ?! |+ q7 i+ |3 v0 C$ I( U                        break
0 E% ?$ E# }) P$ v- c. P; u                if test[feature_name_index] not in node.child.keys():
                    break
                else:
+ t) x+ _5 P4 T! X4 }% N  F& p/ q4 m( ^                    node = node.child[test[feature_name_index]]

! p- t5 m* q1 S            if node.target_value == None:
! @6 t: [4 @- E8 T2 m                test_result.append(node.vote_most)
            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
                test_result.append(node.target_value)

6 Q+ s! ~! B5 Y3 h) G: b9 q& U        return test_result

    # 输出树, 生成图片, path: 图片的位置
    def show_tree(self, path="demo.png"):
        map = self.map_str + "}"
        print(map)
# K5 r1 `; y$ z+ Q# Q        graph = pdp.graph_from_dot_data(map)
        graph.write_png(path)
' e4 c( Y8 f9 B2 D, e, l5 n+ W
# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
- E  [( @5 B# d! H% j    c = dataset
/ |1 h4 C4 U1 a/ I. L9 \    r = range(5, len(c.data) - 1, interval)
+ q5 @& I+ n+ G0 U& T; i    rates = []
    for train_num in r:
! W& q5 V# J8 N2 u  h! a1 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()
! b; {- L! K. x7 e        dt.fit(train_set)
3 u' {; H0 y5 r* I        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))
# c  M2 \9 Y" s+ _+ h- l: i1 m
5 a# Q6 s& z& K" p) H) J    print(rates)
    plt.plot(r, rates)
    plt.ylabel(label)
" }" n7 s- T  z& E3 ]0 r1 O    plt.show()

if __name__ == '__main__':

    c = load_car()  # 载入汽车数据集
# y6 w1 V! x- W/ [# `" I5 x    # c = load_mushroom()  # 载入蘑菇数据集
    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
    train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
- m! R& G# T/ c2 [% q2 J8 s    test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])

* Q6 h: q2 E" G& {    dt = dt_tree()  # 初始化决策树模型
' H- o/ u  g( B/ G    dt.fit(train_set)  # 训练
, {1 \2 a# e$ h# R5 ?2 w+ u( p5 }    dt.show_tree("../image/demo.png") # 输出决策树图片
    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧
) z+ j4 S% r+ J, z% d7 u, i
    # incremental_train_scale_test(load_car(), "car")
* Y( z6 e; n4 O( Z" ?0 F    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)


* G( e( U6 P# |- q, X
; Y; i: X0 w  M4 M! k7 b1 B, B2 B, r/ _1
2
3
4
$ H& T1 H  s" X- ~" C( S4 [/ d/ m5
6 l2 d- W. ]  d* ]6 y6
7
  ]9 A/ @2 l* O, e8
9
' j( D* `2 x0 _' y  n( W4 |( T10
11
12
13
7 D3 ?/ [9 u4 \( a6 Z' u% }1 [14
) Q  V: ~" S$ X! P8 G( z5 f15
16
17
6 o& D  a- K+ k18
5 b# {) [5 K7 p- z- s4 T: K& K19
20
3 D* p$ l) e1 d6 a" b21
$ }" _0 p2 M4 R- ^+ i' i22
23
24
25
26
27
28
* M# Z  A; I. F; D% E29
, T* T6 |5 P4 N$ t3 ^1 ]30
31
( y' c& H7 Y( G32
3 t5 g, Y5 i: O! A+ k2 k' n$ J33
/ W& J" R6 H, Z4 A7 p4 B  y5 L34
35
36
37
. a0 b0 B/ v& g5 d4 }38
39
40
41
1 x% V# Y% w( n8 h; U/ L42
43
44
( _1 I, r$ z$ i8 G45
46
47
48
% {' o% _# C) X8 F' D3 I49
  B+ {7 S) T2 M8 o* J50
51
5 b: W' ^6 z& f. n- @52
+ l" P3 d+ ]/ t4 u9 y53
54
; S7 w+ h# {* _+ c$ s! z. `55
56
: r9 n- T! y& Q6 ~0 }+ B  I57
58
# X, a, B( R8 N* z/ V3 _59
60
61
62
63
5 P0 Y" i" N: X: T& @9 P7 E+ @- L# t64
65
4 n% O) A) A  m6 Q5 P( t# L/ [7 X66
+ n/ P! U3 d1 U& V$ u67
68
/ T$ Q" t/ s2 S0 S& S+ `& Y69
70
- Z3 P" F, U! z4 k71
1 K* z0 Q7 f; m5 i9 [, v% q72
6 d: G  B( u8 Q: D' J73
  u; d  }) u% E" r  j. u$ D74
/ U1 T4 Q- P7 f75
# C0 b, }/ T' z0 r/ w76
77
. Y( a" F* {( g/ I2 G5 h' b78
& H% j. E& y$ K+ q! u79
! E3 M" D# X5 f7 d80
4 a6 {% i" Q8 i& G81
82
4 P' w! c( N" x$ z+ S83
5 M# s3 ?% V" Y) f, D: B- f0 b$ P84
2 p2 _+ x6 O3 i+ P7 e) J85
# B! W) `, h% P8 R. q5 c+ q86
; w2 I2 b0 G1 l( C8 Z5 ^87
* F! ?* O2 H- J) l9 K+ i  o0 w, [+ q88
8 E, S. [. G5 c; e0 z8 k. `# H89
2 h) l5 L! M% l( ~- ]! q# _; ]90
91
92
93
94
$ ]  c7 x/ C% W" U* E: G6 E95
! \1 \3 [9 p8 K2 P; A  }  j0 a96
97
7 Y0 E1 Z, F2 X2 U6 D/ @98
( [7 c# _6 S2 ]0 p' m- F( M5 e99
2 n5 c0 T& o& l& \' M3 e" J) I6 U100
: J. Z: r2 x# _' J, d/ ^101
102
103
104
105
9 ]9 a, a9 \* W, w3 q106
107
5 n. V7 j" B# G108
109
  m9 O# W' U. \# X: Q9 y7 N110
111
- d. Y# x% s- V8 x# K5 X' \5 ?112
113
/ T' T% Z% U+ W114
9 \. X" {" A& q0 U115
116
; c6 R/ p" t* ~' x+ Y117
118
. r$ u7 [: `, n- i  J% m) e119
+ p" `& R6 W7 e7 |120
121
122
123
124
( m9 F$ V1 e( x) t' H5 K& f7 y125
126
127
4 T! v/ y0 x; v/ P4 E3 `- @128
" T; M  j  ?% I6 u129
130
131
132
6 N9 X$ q+ v) D$ C; i4 I133
134
6 U6 I1 S7 w" K7 M/ [: w135
136
137
4 m. U. U! ?2 @" o2 m138
139
9 i0 h/ w1 ]; @" P, s140
141
142
143
5 @6 W7 U$ H( V144
3 W' @" W& Q4 g. k& R145
$ {: m# f; f/ y2 }; G- u146
147
4 H1 d' O. u% u2 V  ^6 b1 e148
149
4 L* `. o2 ^& \' H/ K: _# c150
151
' ~0 V  e: f6 J& v152
153
! u, v. ^# q  ^" ^- l& r2 F154
155
2 p# j( }/ k) _) B% ?1 a9 u( `156
157
: [. l, ?7 q/ H# N158
; P1 e$ q% m2 c* H1 f, }159
7 ]4 C- _! F: _5 @; U+ k# C160
161
5 J7 H+ a2 Z6 H6 n! u162
163
$ q& D& M8 m- C! f0 H$ d164
165
; Z+ A& s. l' _: L7 a166
167
) _6 I* q4 S7 c1 j, L# w  @  {# Z2 t" V168
. M3 q1 ~1 Z7 M  ~2 Z169
% b) c: b% Z, G# S- `1 r8 _170
( v- n! m1 Z4 c171
172
173
174
175
) t! A& V. g7 L3 D176
177
0 D) P7 V2 L. g# D/ `% A178
3 w- |1 w3 E/ n' _179
8 O  r# s9 |5 @& g5 R. N: G' ]180
181
182
; Q8 H& u8 _( t2 P& g, S& [183
! T% P1 I* _1 Q) A; w, Y. ~184
185
186
187
188
" W3 ]# T  d, t+ i9 e189
190
191
) s& _0 v+ F& h192
( y# v4 }5 X+ j4 \9 ]7 V193
194
195
196
197
. i' K- f8 g, V, _, V, R% ?198
199
200
201
) z2 [9 w8 J0 B% c4 ~) O202
" F, t! d* _3 O; _203
204
205
$ n# C& I/ ]5 }6 K: ^/ y# x206
; l1 F; E" A1 @# q& C/ G. \0 K207
208
. f  s2 N1 G( H- w5 u: \209
210
3 A7 V4 {1 d* ?211
212
! @& ]& d5 Z3 c) `, C213
214
. H/ r' H) ?4 p( ~5 i6 C215
216
4 X  {6 b  A. \! _; h! a9 h  |0 K217
% f5 u; _$ }; \& A218
219
220
221
222
, j2 U8 U" s2 v& d( z+ ?# n223
* V2 ~! M, ]: @& X) L& G. Q* l) |224
225
  v6 T' `) V  p0 p' I# k/ I226
227
% u% N# {  z( }; L+ M9 U' ^228
229
230
231
# J* k% P; m( U/ N. i232
233
) \; `4 h7 O2 ^  I3 j: [* \234
235
' J6 ^' G6 J1 {! b3 N& \" o4 [236
237
& |# e8 I; O. x. A238
239
240
241
8 I5 i3 t! D! B2 a242
243
244
& u2 b, c: o( J/ l$ t2 m245
246
247
248
' C* e. @; h: c$ a3 [249
250
251
; \( o  [8 M- j( ~8 I# ^252
+ x! x" G2 ~3 S# Q253
2 X1 U8 x6 A8 k2 H1 p254
255
: Y/ P' `8 R7 r: v8 ]  H3 o256
257
/ U, K4 @: v7 @# S258
259
260
261
262
263
264
265
266
# Z! ?+ X  W+ e# ?0 D2 ~* y267
: u& a" g2 M: C268
269
270
# L) `% j( s/ t5 F( o: }271
272
273
274
& [9 o% ~% S' t7 J. e# x  C* {275
276
277
278
$ E; f, b( z# a8 ]; L' H* T% T279
4 [  G* M  C3 b% z9 j280
281
282
, b2 X7 o1 \+ E6 C$ ]. f( ~/ E/ Q. j283
' P/ ?- X4 J6 T5 m2 d, i284
) j  |0 z/ [# m" s3 K0 e1 L285
286
287
288
289
290
291
292
& _4 {7 H1 ?3 r5 V293
. @8 Z" ~% ]3 V8 S0 ^8 @2 r294
295
296
297
4 ^: s2 s: Q! |* L# U298
3 s1 _3 e! M! \7 P  \& E7 J299
300
301
302
303
304
305
/ d8 [0 }& n9 N' k, _& j306
307
" m* W% b, {% `! V4 B308
& O0 Q0 R) h  M& d309
" l' c7 I( Y. V* e" F) |310
311
( H$ R4 ^6 K: N/ K$ v312
313
314
315
( M/ _$ b0 T7 }  v( W316
) h! j% \0 T% D' J+ ^6 D) U317
: Y7 w  A  M$ G& v318
3 D9 \  T1 X( Z1 u319
320
/ u4 M+ |+ U( H321
9 o3 a- B: A% V' K* A9 A0 B1 [322
323
+ l# |6 i+ `  `0 Q0 A324
325
326
327
/ \4 w! [, f6 `8 N- z5 K6 x328
329
5 G2 N" A* c. l3 Y' R" \330
331

" Q% h3 q7 q2 z: M) G* n

. a+ ^0 K$ ]/ G+ i3 E4 F


: a4 r; H' }. A



4 y1 {* t+ v5 ^3 d5 l. @
' v0 }, g) t3 v, _9 }! y5 k- R
————————————————
0 ~' B; k6 p; `6 E+ ^* F( |' q版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
9 H/ G) |3 Q) ?# [$ d, j5 ]1 I原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242
. v, m6 Q+ E! N+ r
; T7 s0 U. n& R! F# A8 ]
8 T0 }  W6 H2 G. w# v5 @