基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

决策树模型
& D) v# Z2 |$ D/ f; ~目录
人工智能第五次实验报告 1
决策树模型 1
一 、问题背景 1
1.1 监督学习简介 1
1.2 决策树简介 1
( e' I4 q$ s9 W7 L' a1 d# ]/ N二 、程序说明 3
  ^: ]: f$ d9 d$ D2 \/ D2.1 数据载入 3
/ r* R$ |5 d3 h; W4 X& j( u2.2 功能函数 3
4 t* O  ]# s! v2.3 决策树模型 4
/ n( s- A, E8 m- |三 、程序测试 5
; n& b7 F7 j4 H6 A3.1 数据集说明 5
3.2 决策树生成和测试 6
3.3 学习曲线评估算法精度 7
四 、实验总结 8
附 录 - 程序代码 8
一 、问题背景
: l  O4 |4 ~0 {8 w& b1.1监督学习简介
机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
2 Z9 F& \2 L/ P1.2决策树简介
# u: H$ {" t# f) G' d0 s决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
% K. F$ K; B6 t0 h0 i
import numpy as np
- A+ ~* |; R( i' Dfrom matplotlib import pyplot as plt
from math import log
import pandas as pd
import pydotplus as pdp
9 W$ h( i/ Z) S! S* s* A7 G+ q# O% K1 _
8 g, u! Q+ Z! d, P! ?"""
  s' M$ y7 u6 @6 [3 W# I19335286 郑有为
人工智能作业 - 实现ID3决策树
/ Y( I$ c. h. |' |7 T1 ]"""
. m+ a! q. y1 B9 T1 ^# p4 ~/ A
6 M5 n* x4 I2 g6 K2 ]nonce = 0  # 用来给节点一个全局ID
3 Z1 H) t. y1 `* S  ucolor_i = 0
9 \: ]& A/ V# j; Y2 {1 U, D3 k" n# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
% T, T  n, h5 O2 qcolor_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]

# 载入汽车数据, 判断顾客要不要买
class load_car:
    # 在表格中,最后一列是分类结果
3 z, C* w" D3 Q- o# P$ ~- j* G1 S( v7 |    # feature_names: 属性名列表
; U' J( n; O0 a    # target_names: 标签(分类)名
* K" z# ~& m+ j9 E- g- j6 d4 k    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
5 L$ V; P4 i3 C* \    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
        labels = df.columns.values
        data_array = np.array(df[1:])
        self.feature_names = labels[0:-1]
2 }6 P2 Q9 e$ H) h; y" t1 D        self.target_names = labels[-1]
  H0 D/ j- v5 W: b& G7 |3 Y        self.data = data_array[0:,0:-1]
5 m( F6 Q/ }* E" V) y$ k6 @        self.target = data_array[0:,-1]
+ C$ K6 l0 U5 O. Y
/ k' U, X+ W9 r7 r( ^2 _# 载入蘑菇数据, 鉴别蘑菇是否有毒
class load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
    # feature_names: 属性名列表
8 @3 i! O1 K) G' Y( N    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
: `. b$ }6 e. q; J    # target: 目标分类值列表
    def __init__(self):
* |8 r% k; E( e" q  N9 v! g        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",
                  "gill-spacing", "gill-size", "gill-color", "stalk-shape", "stalk-root", "stalk-surface-above-ring",
' \: |/ j* L8 I/ s8 v' p, a0 H                  "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"]
. |3 l( t/ H* D: Y0 f/ w" |        self.feature_names = labels[1:]
9 C( p1 S2 o7 T, X  j        self.target_names = labels[0]
        self.data = data_array[0:,1:]
        self.target = data_array[0:,0]

+ C. O& l: o# h0 T# 创建一个临时的子数据集, 在划分测试集和训练集时使用
! m# T6 m" E3 }$ Q0 Fclass new_dataset:
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
' W2 p1 d. H# X. P) z    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
        self.feature_names = f_n
( ~, s; n- I$ B* G9 O4 S. E        self.target_names = t_n
        self.data = d
, m. s  [! c3 ^: e2 B- N* w  r        self.target = t
9 {& _- R! B/ ^: g
( J! Y6 l( p+ J+ P3 ~# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
8 W' P! r& l1 D7 T8 w#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
# target: 分类结果的列表, return: 信息熵
def get_h(target):
    target_count = {}
' y* v& Q: x, C0 `1 P& T- p    for i in range(len(target)):
        label = target
7 ]+ W" \& x% b% R; o0 P0 Q        if label not in target_count.keys():
1 [6 B3 f* s6 X3 ~! r9 k            target_count[label] = 1.0
        else:
4 g, B2 F  o1 a) g            target_count[label] += 1.0
    h = 0.0
    for k in target_count:
  o' g) u7 I. G& T& ^1 G/ T        p = target_count[k] / len(target)
        h -= p * log(p, 2)
/ p* m) _) j( l  x    return h
, `1 Y$ E. E/ F4 {) J7 U
: U9 o7 b. `% H# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
9 S9 }& `6 [5 r* h% V  p3 c2 T6 ldef get_subset(dataset, feature_name, feature_value):
& u: R9 K8 W) e) N: N    sub_data = []
    sub_target = []
    f_index = -1
) v+ x/ G8 B, }4 c. o2 N    for i in range(len(dataset.feature_names)):
        if dataset.feature_names == feature_name:
            f_index = i
            break
" \% X7 F! L, }) V. s3 w& s
    for i in range(len(dataset.data)):
; F, t2 c: }4 S" g1 C        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)

    sub_feature_names = list(dataset.feature_names[:f_index])
7 x& P0 n' R& \    sub_feature_names.extend(dataset.feature_names[f_index+1:])
2 J: v7 b8 Y5 U7 Z/ Q  |7 P8 A    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)
0 z# m# U* c+ B* Y  i
# 寻找并返回信息收益最大的属性划分
# 信息收益值划分该数据集前后的熵减
# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
1 ^* E9 T) P/ d4 W( ^5 |def best_spilt(dataset):
# ~; U1 l. M2 s0 K) J
    base_h = get_h(dataset.target)
    best_gain = 0.0
    best_feature = None
    for i in range(len(dataset.feature_names)):
7 o4 e! z, B2 ~        feature_range = []
- D/ m3 \+ N" o  z$ J8 [0 F        for j in range(len(dataset.data)):
            if dataset.data[j] not in feature_range:
/ D4 @& G8 {9 W* X                feature_range.append(dataset.data[j])
) `6 y& c% F: j) F
: z% I, j. g: B; }9 l        spilt_h = 0.0
        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:
0 z1 S0 |7 H' x6 C: O            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names
1 R1 z, h1 l6 C0 Y& T
- B4 Y0 w" H0 l" J. J    return best_feature

# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
    target_range = {}
, f% x2 U, j$ y$ N    best_target = None
    best_vote = 0

    for t in dataset.target:
        if t not in target_range.keys():
* s' b. L; l4 ?. W4 S& n$ c* R            target_range[t] = 1
        else:
            target_range[t] += 1
2 g8 N; N! u- I1 @
    for t in target_range.keys():
        if target_range[t] > best_vote:
            best_vote = target_range[t]
1 K  R5 T. D7 o6 I2 m2 F/ F) ~            best_target = t
# G" T; n; y& n, B; U
    return best_target

# 返回测试的正确率
6 R/ ~" C2 Y$ S+ D: s# predict_result: 预测标签列表, target_result: 实际标签列表
def accuracy_rate(predict_result, target_result):
- P/ l2 W6 L+ _% j) ?# q    # print("Predict Result: ", predict_result)
  J% G9 z' E: [7 u    # print("Target Result:  ", target_result)
1 K2 G" \2 q: _2 Y% m$ J+ i    accuracy_score = 0
    for i in range(len(predict_result)):
! S4 S8 ?# K) F) |        if predict_result == target_result:
/ Y; a$ j; F# _5 p            accuracy_score += 1
% a1 M3 V: S( ^7 z6 [6 x$ t    return accuracy_score / len(predict_result)
; k% P) Z; f, M9 b
7 I$ W) l7 B; ~& A) @( ]$ u; ^# 决策树的节点结构
class dt_node:
3 X% l& i. |' I3 D5 `5 o2 {
    def __init__(self, content, is_leaf=False, parent=None):
* @0 R# {! Q  r' W( e3 {5 r        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
        nonce += 1
6 _8 c& v+ f+ b0 `$ k1 W        self.feature_name = None
7 j0 n" j5 Y% `' i' S0 ~        self.target_value = None
        self.vote_most = None # 记录当前节点最可能的标签
        if not is_leaf:
            self.feature_name = content # 非叶子节点的属性名
9 R4 z& n5 t) d0 a% Q        else:
$ s, v; Z& u& @! ?0 ~% a            self.target_value = content # 叶子节点的标签
0 s% a! w; f! X9 I* A9 d' N! B! _2 R
, N2 ^( S& J* F* w0 c        self.parent = parent
        self.child = {} # 以当前节点的属性对应的属性值作为键值

# 决策树模型
& i( c  m' ^; z% Zclass dt_tree:
7 O0 C$ n) D  m, ~1 U
    def __init__(self):
        self.tree = None # 决策树的根节点
        self.map_str = """
            digraph demo{
  v, B: R! X  v+ \( S& T8 X            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
            edge [fontname="Microsoft YaHei"];
            """ # 用于作图: pydotplus 格式的树图生成代码结构
        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值

3 H8 T( {% a; a9 y# d    # 训练模型, train_set: 训练集
4 _: f7 x8 |3 j$ ]5 V    def fit(self, train_set):
" Q" A6 D. N( y! K2 g
        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
            return None
9 [; v, c" \$ |* h+ `: M  u
; `5 U# u3 t( z* b$ `, \        target_all_same = True
        for i in train_set.target:
6 q9 x+ j9 D( f" `            if i != train_set.target[0]:
/ x) r$ `$ |( N  ]                target_all_same = False
                break
; a6 \, l2 w9 R' J3 C/ |0 J
4 L2 p( x  @: N( }$ U  s9 K* P        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
            node = dt_node(train_set.target[0], is_leaf=True)
5 \# n$ V) q, x1 \2 G; q( b9 E3 D            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.tree = node

5 G. E1 I. P5 N% C) y5 _, g            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
/ G/ @5 S/ E5 T4 E( V            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"
! n' E/ o/ W* q0 E% E+ ]
# I2 p2 A7 E9 M1 {3 J- A7 _            return node
9 e+ o: Q2 E4 `        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
# D7 J5 `4 p. E1 L& t: M            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
5 d3 U+ ]2 v; f            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.color_dir[vote_most(train_set)] = color_set[0]
3 E# y9 B( z' J$ M) x: m                self.tree = node

            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
+ n% Y+ K1 U4 Q" A0 i& T; J            node_content = "标签：" + str(node.target_value)
. f1 _4 e) c" g0 P            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
5 T, j# ~! F* o8 n/ ~
6 G' q7 J9 a9 H$ f3 Q8 y* K            return node
# H: z$ X5 ~. P        else: # 普通情况, 构建一个内容为属性的非叶子节点
" [5 L9 n9 z& K, A; g            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
- ~; e0 v' ]7 [            best_feature_index = -1
            for i in range(len(train_set.feature_names)):
                if train_set.feature_names == best_feature:
" q7 }: U9 {1 i! I  j                    best_feature_index = i
0 P; |3 J- b3 Y                    break
9 z& E# [' j9 q' _7 m5 O9 p
            node = dt_node(best_feature)
            node.vote_most = vote_most(train_set)
! S7 `- d* v0 K+ j            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
- a& r/ q2 r+ A) g4 S0 W                self.tree = node
                # 用于作图, 初始化叶子节点可选颜色
                for i in range(len(train_set.target)):
+ k# ]1 W' `9 g3 N  x5 _, R/ D                    if train_set.target not in self.color_dir:
                        global color_i
                        self.color_dir[train_set.target] = color_set[color_i]
                        color_i += 1
                        color_i %= len(color_set)

% L; i  Q1 H( n7 s6 q. u+ m8 B2 ?            feature_range = [] # 获取该属性出现在数据集中的可选属性值
            for t in train_set.data:
# S* @: ~; e( M: g4 o4 ~0 k                if t[best_feature_index] not in feature_range:
! w- T) s* v  f  O                    feature_range.append(t[best_feature_index])
. S6 c# y  A& V3 T5 E0 G! K+ l
; \6 h. g4 K" l' F  E# G            # 用于做图, 创建一个内容为属性的非叶子节点
4 w. p2 i8 A- G) }1 P" R  x            node_content = "属性：" + node.feature_name
+ G7 m; U4 N% q0 A+ c            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
3 j2 |9 k8 I1 w) _: w
0 h) t5 S/ e3 b9 W# h& H            for feature_value in feature_range:
5 N; M6 v3 i; i: U                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
/ N: t# S4 T& l8 x                if node.child[feature_value] == None:
) k' q  ~) ]2 d5 q& j" b                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
9 a- `" s7 d3 D0 F" W% Y& ?                node.child[feature_value].parent = node
$ p+ ~! S' v: J0 c3 u
                # 用于做图, 创建当前节点到所有子节点的连线
                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)
! h$ _% V& I7 |& A1 r% s            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
3 B# M: v( l: }2 _8 I  {# E- B8 w            # for feature_value in feature_range:
            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
; S9 B1 N  G' i0 C6 [5 }* @! M            return node

    # 测试模型, 对测试集 test_set 进行预测
    def predict(self, test_set):
        test_result = []
        for test in test_set.data:
            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
7 T5 t8 c/ p1 {# U, e- V            while node.target_value == None:
' P" ~) G8 h1 T. D; P# C                feature_name_index = -1
3 s1 ^; r; ]  R! [7 a2 o2 I( x, d6 l                for i in range(len(test_set.feature_names)):
4 l; v3 p* H& U; V" g8 c; G                    if test_set.feature_names == node.feature_name:
+ Q2 M6 T, o# ^) S                        feature_name_index = i
, ~0 f! D. q& z  m, r                        break
                if test[feature_name_index] not in node.child.keys():
- ^* h% j1 K+ \6 _0 h                    break
                else:
                    node = node.child[test[feature_name_index]]
& W$ Q) X) \1 N
            if node.target_value == None:
) x4 w" H1 [$ l7 R2 `1 n6 ^                test_result.append(node.vote_most)
            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
, T: \+ |! `; p                test_result.append(node.target_value)

4 C' ?% i% K+ E- Z; p7 q        return test_result
! C8 x* n( i/ `/ E
9 _5 B+ j0 ]$ ~3 D0 I    # 输出树, 生成图片, path: 图片的位置
' p: ~6 G* D' ~' L! g7 o+ Y0 N    def show_tree(self, path="demo.png"):
        map = self.map_str + "}"
3 q/ H  p  x% l& I2 K0 r        print(map)
        graph = pdp.graph_from_dot_data(map)
  p3 N2 t3 {5 b$ n& ^* |) W7 j  ~& Q        graph.write_png(path)

& r8 m5 x7 ~( v$ N( I) A9 @# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
  \4 a6 J- Q  M/ ]/ P0 A+ v& Zdef incremental_train_scale_test(dataset, label, interval=1):
    c = dataset
! ~! e8 L# ]6 l" }; |    r = range(5, len(c.data) - 1, interval)
    rates = []
3 d% Z* w4 D8 i( @% m0 v    for train_num in r:
  ~- `% l$ p0 E7 y8 \        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:])
5 V4 U) v1 Y  P" j$ l+ P) M        dt = dt_tree()
& l* C1 ~* G+ q/ v        dt.fit(train_set)
        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))
# p6 t( E$ \: |: Z( o2 t
# y) E+ P5 A/ w& Q2 y/ f    print(rates)
0 K% t& f' e* w7 V+ X    plt.plot(r, rates)
    plt.ylabel(label)
    plt.show()
7 t3 }  M3 _# `* X& y
& ]+ k: `2 ^2 E( V3 [if __name__ == '__main__':
+ B/ ?  `, [2 j' z/ z2 m
4 V9 h' s% Y/ A. u+ k    c = load_car()  # 载入汽车数据集
$ a' ~4 Y# o# V7 F! ^0 F    # c = load_mushroom()  # 载入蘑菇数据集
& N8 a; Z, [+ x* s5 O2 M    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:])

    dt = dt_tree()  # 初始化决策树模型
; E8 S8 C  Y1 t$ q$ o    dt.fit(train_set)  # 训练
    dt.show_tree("../image/demo.png") # 输出决策树图片
    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧
! M% e$ M* o9 b0 X7 `# T
    # incremental_train_scale_test(load_car(), "car")
    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)

# \4 K' k4 q. H5 S5 T

1
5 Y6 ~9 X# A/ o# L$ U! t: s2
3
0 h6 L! S) U/ _. i: |4
8 N8 T: q. t! w$ @# f5
6
) z/ d. I9 S; q- ?7
8
9
# X3 `" r7 B- U7 d7 b10
11
12
13
( E5 m1 [7 w# ]$ P% w; R2 c1 x) C, F2 _14
15
0 S- H: o( P9 U/ f: f+ n16
8 z8 \) c0 f4 e3 X17
18
19
20
21
1 ?' [5 G$ n* P( [5 ^22
) `  i  S1 l$ B0 X5 E! T+ e- t23
24
8 K" _6 n: T; t+ M8 Z& r( H3 @25
- g+ V- d& H/ ?; B26
9 N8 ^" D/ S/ X% ~$ M% l9 y27
- d2 p+ M% m. U; h4 A: E- o% {28
5 H( G1 X. E5 L) {: j# w29
; r  B1 I- z7 i9 k) F3 V+ [. Z30
31
32
3 T0 w5 l  [. `2 y( f33
3 S9 i) x. [/ a& v% [1 G34
1 a& H9 u2 O2 h7 A# i, \+ P& ?35
36
" \; y0 m6 j! k3 X) x7 v37
38
39
1 A( ?. i5 x5 Y7 v5 k6 t40
41
42
43
: S1 H. P  r% `% i2 Z44
/ a, j  P3 {% X$ l7 O6 F45
46
0 ]: H/ L. B9 V/ |5 s- _47
' T8 S4 W2 |8 k8 X, ^3 D48
4 v* d. G. F1 I# n( j+ m49
50
# J9 L) v8 ^" l  b9 M5 ~/ M$ M51
; V' f4 x2 J% M" u52
53
; G( U$ N- p! D; X- k54
& r5 O8 e" v! ?& S, l55
56
6 [' l3 T# _) Q) Q: F- W) F& r57
0 Y; ^' `7 B2 A; Z; n58
/ \% k" q* S  _, |3 V59
3 J( d  \- z+ U3 j* b60
61
5 A6 r5 s% C, r+ @62
+ |! Q+ e; g" @( t! S& I+ Y! _63
: N( U6 R9 g$ o0 I64
, @7 f) v" h8 \  `8 n" ^65
) S6 C# p: `, k' p5 Y. p6 @66
67
6 s( r! G8 f7 u* Y68
69
( T! D/ V/ n  c8 g& n- {1 K8 f70
71
/ I) j: t4 q1 s* l- f72
73
74
75
) v1 S5 }6 z+ ]4 m$ m76
3 W1 j6 d2 _. j: N( ?& n$ K77
78
79
80
6 |$ v) w( u2 l4 M0 t81
82
83
8 X5 M/ H0 d+ K% O, }" H7 G0 R$ x( |84
85
1 p' x; X8 b3 o: m86
, D- Y+ ]% v2 l# q- Q6 }87
88
89
. \/ t: W, ]5 G' ?1 V9 V/ ^- n7 C90
+ J  {3 m8 {+ J5 B. w91
92
8 \9 Y0 c- W0 D; u  n4 t93
! T" ^0 U$ h9 O, _* K% v2 N  Q94
95
( u$ j  ~" ?* w6 {7 k96
  y( X8 t& V* X# ^% j: i. W97
7 @5 ~% x0 G) V/ b- ~! E4 I9 x98
99
$ R' l3 D0 @6 `# U4 ~7 ?, S& J* b8 O100
1 F% u7 T" n4 d/ K0 ]$ g1 d101
102
- X6 X* k( E- d# T9 |# k103
( D2 o1 n& F2 w104
% J0 s/ e/ \9 T! J4 l# \105
" L7 e! e. W$ W/ Q) [106
107
) M, X" v" t9 c( j' t108
109
+ [6 C% D: E8 }4 ?7 ^& J# v110
3 B! S1 i; W; n111
112
3 @& o- S. J, F. R: C# s- @( k" M" e113
114
! F/ q- @! b6 S6 m* t" H5 w115
116
; J" J& G# L& \7 E) E% Q8 }117
( c" U  i2 [& s# O7 O' B) Q/ l/ J118
119
; V) M# w2 A% y. I# A120
) v: F1 b( Z. u; w, D121
- B9 P7 |" n. K% q3 a7 ^122
/ ~: r) g! V! M1 `4 Z& X9 x* [' s123
124
: j# g$ V( L- X% I1 C125
: D/ y" a  E( l  A" s- X( W126
6 @; D( G) {0 i3 B/ L127
128
129
0 ^$ G$ S% R, M* ^  N& O2 b3 L% H130
131
132
% \) k. P) {0 \6 ^133
134
135
136
137
5 l$ U' K& b9 [7 R6 ]( Y/ k138
139
+ Q& U/ I1 C4 c2 ]140
141
5 N0 }+ f) D) _. K142
143
* k$ X4 s4 E- R4 Q: c  h% I1 a144
7 }1 ~4 S/ z% F* J145
146
147
; q& o0 j+ W- P+ T. r% b; u148
149
4 @2 m" j6 j+ S' P  T3 p150
/ ~6 t1 Z- n% O' n  _# }3 _3 p151
152
153
: f, h" d: i/ s9 N/ n154
* w0 |& n! k$ m! g' }155
( B6 S$ s# r( V, k156
$ h! l7 h6 j7 j* P157
7 d4 S- m- B3 a+ q& W: g2 \  g158
159
160
& C# a. \5 c) Y5 g# o- ^+ `161
162
! p, c0 J( {9 L; l+ E  B# b163
164
  u0 X/ }! H9 w5 Y) @% v* `" T7 y165
3 C# u9 o8 H; V166
167
6 I6 `2 T! ?- d& _168
169
170
/ C% w2 I  h" G6 ]- I' |. x171
172
173
174
175
176
177
8 I8 W" ]$ [8 ]  E4 s178
3 e6 J+ _1 n. W9 w! ~6 o1 i. m6 N179
180
4 T2 z0 L( F* M, L2 n" N+ D181
182
4 p0 @( S  M, R183
) S: c! b% L% x' U184
2 B# [$ _. R% Z4 F' d185
) U  E3 t/ k! [& ^; U6 h186
. x6 d5 @' y& a- N" ]. [8 U187
188
* _- E% ^  @6 {9 ]6 q* D+ H189
/ a% \2 \! g+ n, T* w0 m  ?190
191
' A9 O3 @) P" e- h8 T! D192
6 I$ V2 S* }3 x9 Z, o1 C' T% D8 c193
194
195
% U9 N* s' c1 ]8 r, R' e4 q196
* J% X7 ^+ G0 S" {9 a0 r8 l9 A197
198
199
1 N* v4 a! c! d8 K4 W4 u; g+ E200
. J; w. p3 Q- r+ k) t; U! C201
202
8 K7 a$ b. ?; W* i, i203
204
205
7 Q3 E$ T0 e& G$ `* N206
207
1 Y- u2 x" F  {( F0 A) ?208
209
210
% j6 S) C8 p6 ?5 a" T, b211
212
213
2 y) B2 d* P% G, A0 X. [3 i6 r3 Z214
6 a8 L6 R5 b* J5 u( Z2 v215
, S9 g' S- v8 _, F8 O, J$ o" B216
217
" ^9 ~+ y! a+ X0 ?218
219
' q3 M( N# C& B8 ]+ F! H0 a( R( x220
221
, \' j" q& [  R" U. U6 G6 x5 R, s222
223
! r7 z# t0 @5 B) e; `5 \( }224
' t- O; X: [% r6 [; v3 b  }! J225
226
% u2 R9 i# A8 h/ E0 E227
5 @+ h( M1 ]( _6 l3 G% Z3 Y# T228
+ _: {  O. h+ H229
; t9 u4 G5 r! b- `+ r; o- L/ o230
4 P2 O- \7 ]6 z8 W. _0 t7 P231
232
233
234
2 L, k# M- |3 m6 l( _235
+ Q3 z+ S/ ]8 i/ c  ~236
; v; X! p0 N" v) ^; N% m5 Y4 K237
0 s9 t2 P& t  X& n238
239
240
241
) u! P8 p' I& N6 S8 Y242
' |) f4 D( G$ P3 F" c' J243
/ @% F  U; w3 u8 G+ \7 `244
245
; Q1 x; J7 r4 a246
" j, q, V) C2 x) z' [6 s247
248
( w6 B' J/ X2 ^! ]' m9 D$ e9 y249
  n% q" b; `$ z+ l2 G) H250
! v5 N" Z% e+ X251
252
253
- [: f0 i/ P0 k$ V7 C6 x254
255
256
257
258
3 P+ I3 r. \" Q" p259
260
, Q. i' z; N4 R, N261
262
263
264
265
266
267
268
269
! p$ |% d' ~' x1 D6 U* m$ ?270
7 E% w8 X$ e# O' N# W! j, f5 b2 g271
272
/ ]! e; i3 R: ~273
274
- E( W1 C  i! y+ W8 X* M) q. [275
7 Y' J. o, M( o" B3 ?9 K276
277
8 \8 r) n+ D0 c: ~+ P+ j' P278
/ k: l+ d4 L. x! X' D; d( L: y' e279
- _* q% k" K3 G280
281
282
283
6 m7 A* F/ ]" ?284
9 Y* \/ f3 L. C9 r* U285
+ T' |6 _8 h( y( a2 p286
' B! Y( _0 R' t. \( Q% P2 o2 f287
288
289
' z  T+ j8 p) u1 H# x9 ~290
2 N; I, ?& b, v* G3 E291
. }  a7 r$ ^: Z2 @7 i- o292
293
' `. u+ q; F9 g# x294
295
" D1 R' w; x9 V& z5 T9 Q$ ^296
& ?- Y; y& k$ [0 `, e1 o297
298
299
300
301
4 p2 x6 L3 Y  N302
303
1 k. [& ]' H& G& P! k' M  C: \304
. K4 J4 S) p, K9 N* c9 {9 J3 D0 L% t305
306
307
308
6 q/ U2 P0 O' Y2 S$ y$ m  B309
310
311
7 h+ b1 U. d, r312
313
314
315
7 I" c, M7 g4 s( ?# Q' M% y8 J316
317
318
319
320
2 L' R" Z' J& G" z  [& X6 @321
322
323
324
325
  F( ?4 ^- Y. T& a# G. k1 Q* V326
327
3 F/ `# ^4 B! n% H328
9 b  J. R) I2 A329
330
331
$ f* v/ i( ]) K, u7 T: g+ t
; g5 W8 Q( d! v8 O% @9 f



# S- M( Z2 W! ]5 \1 J% |' O# d1 l

1 u0 e3 \9 d, J! R0 M1 L4 n7 r/ P



! `; O  k$ ?* S, ]  l' S
————————————————
, G, c+ B& b+ V: j% ?. T( `版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242
8 m) k- z: r& r0 G- y6 f
; ?( m& Z. h3 Z
4 {9 Z2 {. S( @: d% V7 z$ U