基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型
6 [+ }* S/ J# Q  V* E+ g" k$ D
决策树模型
目录
; x, M* p/ b2 Z6 I2 V人工智能第五次实验报告 1
决策树模型 1
1 P/ y6 K6 a! t" x$ R一 、问题背景 1
1.1 监督学习简介 1
. `3 u! q1 t$ q2 ]+ ?7 \1.2 决策树简介 1
$ u' A+ ^! H4 U! l. [二 、程序说明 3
# j, I/ T. ]2 N+ p4 M2.1 数据载入 3
2.2 功能函数 3
7 F, N# u4 i9 _8 O) Q( n2.3 决策树模型 4
# y0 e+ S! a+ y0 n4 j  d4 ]" K' o三 、程序测试 5
6 b2 y2 D% M4 R% N' H2 j3.1 数据集说明 5
7 k$ B0 z+ e. Z# @# ~; p3.2 决策树生成和测试 6
8 e% V8 Z* m1 b- a3.3 学习曲线评估算法精度 7
四 、实验总结 8
附 录 - 程序代码 8
% T" N0 W8 o/ G; B+ D. t" @% x一 、问题背景
1.1监督学习简介
1 t; s: S* B2 x3 G4 S- b% {" W6 ^6 @- Z" i机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
5 i# V) P% A4 g' u8 K常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
/ t. M  X+ W) @: ^' B" e5 f' }1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
" B# J0 K/ H. `9 m# W6 S7 K决策树的组成
& b; Q; R7 z; N0 j0 [决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
4 @/ F- B$ b% q2 Q) M7 h+ \* n# \
import numpy as np
from matplotlib import pyplot as plt
: q0 a7 C6 `5 }* Z. C! H& Vfrom math import log
import pandas as pd
import pydotplus as pdp

& T9 n( w2 q$ I9 w4 q0 r0 i"""
: x, b) R& \, X) V) K" t: ~19335286 郑有为
人工智能作业 - 实现ID3决策树
# e! ~" _9 N+ b% s"""

; i4 i# Y, B" L' u1 unonce = 0  # 用来给节点一个全局ID
2 C; |& X. e& m. y9 Zcolor_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
color_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
/ x* j) a. O6 X( x( e% c; {
. o* v7 Z2 l' W$ s# 载入汽车数据, 判断顾客要不要买
2 _0 R# Z$ }# U2 q8 {& g, ~class load_car:
# P1 `4 g/ ~6 C% ~    # 在表格中,最后一列是分类结果
    # feature_names: 属性名列表
0 M8 A9 m% |! a. i$ Y    # target_names: 标签(分类)名
" r' Q% D% o7 f+ a7 D0 [    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
7 `! P- r4 H3 x0 q- u    def __init__(self):
2 U- r2 l! V  x) b* d" F        df = pd.read_csv('../dataset/car/car_train.csv')
2 [$ o7 a, k* @# N        labels = df.columns.values
! b- [& H0 }! ~4 v& j" ^7 Z# e% x' j% r        data_array = np.array(df[1:])
4 ^- P9 V6 I6 l6 X        self.feature_names = labels[0:-1]
7 Q& u2 A$ _+ L; @        self.target_names = labels[-1]
1 h: R0 l5 k% Q, s) O        self.data = data_array[0:,0:-1]
  {9 X0 i! b0 `# }! f9 W1 d$ E        self.target = data_array[0:,-1]
0 D$ ~1 a' |) a9 P5 b
# 载入蘑菇数据, 鉴别蘑菇是否有毒
class load_mushroom:
- P  E( J) n( Q; k% _. o" {    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
  s( \8 E& D* s+ Q2 Z4 _    # target: 目标分类值列表
* U; `# `5 v. I- N9 v% p( N5 u    def __init__(self):
5 I" o5 D6 r! _1 M0 |        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",
5 Q4 v7 s$ j8 D: w6 N9 t                  "stalk-surface-below-ring", "stalk-color-above-ring", "stalk-color-below-ring",
5 P. Q+ m$ @% z0 y                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
4 i9 i+ [+ ?! k, h. D, x        self.feature_names = labels[1:]
! R# X( [: p; ~% s) T        self.target_names = labels[0]
        self.data = data_array[0:,1:]
        self.target = data_array[0:,0]

" d5 W# G9 t5 j: ~- d# 创建一个临时的子数据集, 在划分测试集和训练集时使用
class new_dataset:
& \3 u/ |# ~0 F    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
        self.feature_names = f_n
6 x* N' @1 P0 {3 Q: \8 S' G        self.target_names = t_n
8 a' y- A1 K6 l8 L: m! K1 z        self.data = d
1 q% w/ H4 G/ Q& y( W% A% {        self.target = t

# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
# target: 分类结果的列表, return: 信息熵
3 V0 `; c0 F9 t, cdef get_h(target):
    target_count = {}
" m6 @. y$ q9 ~' e, a    for i in range(len(target)):
0 @$ f; V, W' w6 _. A4 |        label = target
        if label not in target_count.keys():
            target_count[label] = 1.0
  ~, y+ I' K& n! G& C  R        else:
/ m8 D& Z# @2 _) ^: o            target_count[label] += 1.0
2 K2 U. T1 k- C* O3 U    h = 0.0
  w; l$ r, n$ A* m7 G3 z    for k in target_count:
7 v. ?* s$ U4 o/ i        p = target_count[k] / len(target)
        h -= p * log(p, 2)
3 g0 C7 W; i3 X. E$ u    return h
0 J5 ^4 F: I+ t9 O5 h. T( f
! A; ]( p. C+ y# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
def get_subset(dataset, feature_name, feature_value):
8 s+ M  B8 L8 u* N0 L    sub_data = []
' U" v& F) T; N    sub_target = []
, a7 i& D+ w; a9 i4 n, l: K" E/ `    f_index = -1
" y  m5 z7 U) d    for i in range(len(dataset.feature_names)):
. a$ m9 }. t' W, P" [        if dataset.feature_names == feature_name:
" D. ?5 {9 p* n            f_index = i
2 V; k+ o. D9 W8 @2 N3 ?$ T9 x            break
, ?1 G! b/ \$ |" b
    for i in range(len(dataset.data)):
4 c' Z& @8 ^- b9 Q$ U0 z        if dataset.data[f_index] == feature_value:
, s2 v- l: [4 U* j8 ^( p- R9 o            l = list(dataset.data[:f_index])
% j! E5 @( {1 ]! I4 r            l.extend(dataset.data[f_index+1:])
5 k) x: \9 j9 E2 h! f. t( J            sub_data.append(l)
0 I& Y. T5 `* z& F3 X            sub_target.append(dataset.target)
5 F5 x7 T4 ^% \) G, F
8 b! l  }5 V3 v5 z0 \# @& e8 p    sub_feature_names = list(dataset.feature_names[:f_index])
- T7 [$ I) f1 y5 V5 L( p    sub_feature_names.extend(dataset.feature_names[f_index+1:])
- _( C4 z# I* r" ^  \    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)

# 寻找并返回信息收益最大的属性划分
# 信息收益值划分该数据集前后的熵减
# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
def best_spilt(dataset):

    base_h = get_h(dataset.target)
    best_gain = 0.0
    best_feature = None
    for i in range(len(dataset.feature_names)):
  `# \. w# F% _        feature_range = []
' X/ y1 H- W$ g- @+ s# L1 c7 }        for j in range(len(dataset.data)):
- K6 t: V. n* m2 w$ _" B* L: M" u: b" K            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)
            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)

        if best_gain <= base_h - spilt_h:
6 V, v, _, P% Q$ a4 I            best_gain = base_h - spilt_h
; Z* j; W- g% u4 V# \4 R' U3 }            best_feature = dataset.feature_names

    return best_feature
+ o# V9 D' X5 }: v
& Z% r- s% e7 c& ]0 j# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
    target_range = {}
    best_target = None
    best_vote = 0

! n- F; Y( @0 E3 h! e    for t in dataset.target:
        if t not in target_range.keys():
            target_range[t] = 1
$ `: F/ F" B# W4 z% f* ]" L        else:
# c7 N$ i; p+ B5 {' U, u            target_range[t] += 1
6 F2 ]+ V: ^1 H
6 t" ?" a9 U, u! x$ d    for t in target_range.keys():
# A' g' A- V( O        if target_range[t] > best_vote:
            best_vote = target_range[t]
2 b$ z4 P, g0 W8 B# r7 C9 [. a            best_target = t
5 z5 o5 X2 [# f9 }. Y$ h- e  y8 q
/ [; M( L- t3 a; l8 f) O    return best_target
! `8 M' ~2 W/ Q6 U8 v( y& r, `- J8 E+ c
' D; R1 h" i. X  d6 s# 返回测试的正确率
, k* {' [1 M) [& `+ a# predict_result: 预测标签列表, target_result: 实际标签列表
7 b# b/ ?3 _3 Kdef accuracy_rate(predict_result, target_result):
    # print("Predict Result: ", predict_result)
# t3 x& m# X* K8 Z# u0 @  Y# O    # print("Target Result:  ", target_result)
    accuracy_score = 0
' i; G( @- x, D    for i in range(len(predict_result)):
/ U2 h' A, d( j        if predict_result == target_result:
! p5 c9 l. e" i" W* E6 h0 }            accuracy_score += 1
1 j- o- `$ W3 o. A8 ~    return accuracy_score / len(predict_result)

& s) N3 n* w, i7 V# 决策树的节点结构
+ e$ n+ H% L2 \5 B+ ~class dt_node:
  t/ S) a9 g$ T9 J
    def __init__(self, content, is_leaf=False, parent=None):
  O% A, \/ g  ^' r        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
, y+ q7 E  X  W3 S        nonce += 1
        self.feature_name = None
3 c8 C! Z! x+ c: |# W4 x. x  z( k        self.target_value = None
        self.vote_most = None # 记录当前节点最可能的标签
        if not is_leaf:
$ A2 `) o/ d1 I$ {7 I/ m0 H1 N$ V9 [            self.feature_name = content # 非叶子节点的属性名
" Y$ T& F5 e/ H7 F4 w        else:
' L' Q' H! k2 C4 |+ a            self.target_value = content # 叶子节点的标签

        self.parent = parent
: c9 f/ b# G4 o! l        self.child = {} # 以当前节点的属性对应的属性值作为键值

# 决策树模型
class dt_tree:
: z9 `4 m: ?! N9 j! P
    def __init__(self):
, n1 n0 y: e& ~1 Q& f4 L- O/ L. F        self.tree = None # 决策树的根节点
        self.map_str = """
2 a" O4 ?! f, k" ]            digraph demo{
            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
; _( J' w& K: y( n. ~0 |. x            edge [fontname="Microsoft YaHei"];
            """ # 用于作图: pydotplus 格式的树图生成代码结构
        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值

! ~$ A# y" n+ L' J3 `# \    # 训练模型, train_set: 训练集
2 u" P0 s- a( y    def fit(self, train_set):

        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
6 i9 ], t/ G" x, h5 _0 H            return None

        target_all_same = True
        for i in train_set.target:
/ j' Q! ]# j6 D& I1 y) z+ J0 r: p            if i != train_set.target[0]:
                target_all_same = False
, S5 ]$ K6 w% k/ ~/ q: g! X                break

; `" h$ y' [0 c- k: U8 Z7 ]4 q        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
            node = dt_node(train_set.target[0], is_leaf=True)
+ [9 ~+ h- l% `# Y            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
5 J9 b  r8 }' A6 U, y8 Z                self.tree = node

7 H+ P% o. m5 H( p            # 用于作图, 更新 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"
5 w; C" o! i0 L. Z7 ?' C
            return node
1 W$ N2 J+ N2 l7 P" n% C, z        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
% G: {7 E4 G% \* j2 j            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
9 J+ ]$ W( u) Y0 N$ L; l" P            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.color_dir[vote_most(train_set)] = color_set[0]
                self.tree = node

8 v0 W, u) T# y# {2 j$ {& C8 ?# S% J            # 用于作图, 更新 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"

* ~. W. p5 z" \0 i            return node
        else: # 普通情况, 构建一个内容为属性的非叶子节点
9 M" M2 i/ X  G8 L- H, S            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
            best_feature_index = -1
. L$ ]" j% c1 c  G0 h! S/ f& ?; G            for i in range(len(train_set.feature_names)):
& ]1 Q* W0 P  _: P6 P) }) h1 e                if train_set.feature_names == best_feature:
3 H9 D$ z! [/ Z8 O8 `                    best_feature_index = i
& n" Z( M) }5 k, y6 L; q                    break

/ q' T& a( v: E% E& }, }            node = dt_node(best_feature)
7 I1 e9 E# j! V' l- G7 B, g            node.vote_most = vote_most(train_set)
7 M/ |% S* h" Q* a  _+ Y            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
                self.tree = node
: n, E' F$ c( `2 P% a! }' `. l                # 用于作图, 初始化叶子节点可选颜色
; F9 I3 R' r3 X; C8 H  j                for i in range(len(train_set.target)):
+ \3 @( k- u1 O0 g6 x                    if train_set.target not in self.color_dir:
$ Y; |, i( W4 q: w5 e1 \& |                        global color_i
                        self.color_dir[train_set.target] = color_set[color_i]
8 x# r$ V" o: u, ?& f  ?0 x                        color_i += 1
                        color_i %= len(color_set)
3 Y$ d1 k: x2 e3 X+ B
( Z; f/ F- R/ e& T7 t5 a2 d; W            feature_range = [] # 获取该属性出现在数据集中的可选属性值
            for t in train_set.data:
                if t[best_feature_index] not in feature_range:
                    feature_range.append(t[best_feature_index])

            # 用于做图, 创建一个内容为属性的非叶子节点
, R9 u! N1 @9 n; S5 p7 O# r. j  s            node_content = "属性：" + node.feature_name
: o( P9 W( J* H0 L' t+ u. U            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"

            for feature_value in feature_range:
* B2 m; @. @* ~8 ]  q5 G6 b$ {2 j2 l                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
! q: @$ o1 X% }8 N" C1 C                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
) L6 O+ Z$ p( G! @" [                if node.child[feature_value] == None:
; y, o5 @0 h) C9 _7 O" \; \* m                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
, \$ D; A1 N# z                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
                node.child[feature_value].parent = node

                # 用于做图, 创建当前节点到所有子节点的连线
5 N" q; T  S- z" M2 E' l                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"
% P- z' f4 L- ~6 B# m" S4 v' P
9 u$ O% Z* [4 U& d            # print("Rest Festure: ", train_set.feature_names)
, |" g. G2 E; y9 W3 P0 f            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
            # for feature_value in feature_range:
            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
" z: T3 N% ~' c& Q2 {: _, Y( G            return node
- _" b, t2 C' \( ]/ h8 @
    # 测试模型, 对测试集 test_set 进行预测
4 D, _2 [) ~" @2 t( C- m9 a    def predict(self, test_set):
0 E) X+ y1 A% X# }* I        test_result = []
3 M2 s$ `- p! x( @        for test in test_set.data:
% I* l; }6 y+ J  O            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
& l1 [1 \7 v; X3 p; k            while node.target_value == None:
                feature_name_index = -1
- [! Y5 G! j3 Q8 {. P5 ?                for i in range(len(test_set.feature_names)):
7 }5 }: |, ^! S+ y                    if test_set.feature_names == node.feature_name:
# q, E, s( k; e6 ?% k2 t/ p                        feature_name_index = i
                        break
/ v. G( m4 a* A" |& |2 e9 P) w                if test[feature_name_index] not in node.child.keys():
3 H* `7 d* m( v% s1 i3 P6 w: v% R                    break
+ V& V% ~! X; y% E8 s3 @" X                else:
0 v! V" I: |+ H( S  o& v: }                    node = node.child[test[feature_name_index]]

( N# P( ~: \2 V+ k4 t$ n/ n            if node.target_value == None:
                test_result.append(node.vote_most)
( u: Y- F% r3 p! h- G0 e9 b            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
" B9 A8 k! c/ T$ R# p                test_result.append(node.target_value)
7 A" ?3 k6 K2 t6 N7 z
        return test_result

" a! x9 R+ ~6 S: B+ ^; O; e; Q0 z    # 输出树, 生成图片, path: 图片的位置
    def show_tree(self, path="demo.png"):
        map = self.map_str + "}"
        print(map)
        graph = pdp.graph_from_dot_data(map)
# N4 f, o4 C* m0 w+ y        graph.write_png(path)

# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
" u2 q# e- s. ldef incremental_train_scale_test(dataset, label, interval=1):
- n) }9 t9 Q  L2 W' h! t8 `    c = dataset
    r = range(5, len(c.data) - 1, interval)
    rates = []
    for train_num in r:
/ K( M6 [/ t: U$ V        print(train_num)
6 f: g( e1 z6 B$ l# Z% T5 d        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:])
9 e# T: b; Y; v- q2 D' z. H3 T        dt = dt_tree()
        dt.fit(train_set)
        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))

! h1 g" T) v" i% q0 o    print(rates)
# T& A. r' b6 ]! T/ [0 T7 n! F    plt.plot(r, rates)
0 p7 Q/ v1 N2 N# K# A7 M2 l    plt.ylabel(label)
- j! ?5 |( A+ B9 {    plt.show()
. f+ }+ d5 M2 e7 r- R- S
if __name__ == '__main__':
4 D" l2 y$ i' F* A
6 \8 c, B& o2 y9 }: r$ U& k    c = load_car()  # 载入汽车数据集
% x* X5 S2 e- h( C- A    # c = load_mushroom()  # 载入蘑菇数据集
( |  Q" i& ^( C& y% s7 |2 M) r; }    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
) o. |7 {- P3 s    train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
2 |) V- p: B% g* u2 v    test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
, a1 H3 b0 b0 A6 S' m3 d
    dt = dt_tree()  # 初始化决策树模型
    dt.fit(train_set)  # 训练
    dt.show_tree("../image/demo.png") # 输出决策树图片
    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧

    # incremental_train_scale_test(load_car(), "car")
2 t) }( s" y! k9 I6 m    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)
6 {% X" u& R, e$ I/ ^" E6 B
; ~5 Z7 w3 E( Q! t0 a: T$ k
% X7 {% V7 r: Z$ [* e9 Z& D) o5 ^
/ L- }) T9 S6 p1
2
3
4
5
# C& i0 `( W: l& b& e0 F6
7
8
( \8 j7 b7 j, S9
10
, V. z6 Y0 k) g1 v4 Z/ T0 x; C5 F* Y11
# V4 r7 S" q0 Z12
1 T6 l9 x% O# X' `) z13
5 P$ L) e  d  X# ?' K2 O: ~14
15
& w) g; J( E- c1 H4 M# [16
17
" k9 |! w( I7 s18
19
6 Z+ u. e, B" B8 j( m% ^20
21
& F: c, O% j, I: C& n22
23
! F0 V5 k9 {" s5 |1 W: q24
! b/ y+ Y. x4 X' V. ^, X25
! ?3 A" p0 S3 j/ }! h" V0 Y26
27
& N+ h9 N  f8 V# g28
29
/ I) \) [& z' n$ f1 a30
31
  r) X. F# W8 S3 y: D32
+ {3 l6 \8 @. D, O7 I  k$ }( E' p33
34
9 Y6 ]5 U% l. p( V( l* ?35
36
0 Q: a; G' ?. i37
6 M5 o0 I$ N' L0 J4 ~9 ~38
$ o( J7 _- L1 {0 G, f7 n39
40
) G! a3 z3 M3 {) w1 G41
42
8 o2 n. \8 h* A+ |% S  b43
44
6 S+ B0 x0 ^7 C9 }' W% L$ G45
46
7 ^. b; k( T* ~! k+ I2 {47
48
49
50
; L4 J- u- E  l, }- t51
, _4 n8 x$ h( ^52
* t, q" b2 d9 U6 K* b8 C53
1 y4 p* c. u, \3 Z7 x8 B5 W54
9 |/ Q$ f$ c) L# e, T4 O& F- r& |55
* A7 n* x: L+ ~7 s2 d4 a$ q1 @56
57
58
59
% ~. t6 b3 o  F7 _9 S60
61
) O0 O0 ^* \/ p6 X7 Q9 E' A62
63
64
4 C) o- B) M1 o) ^  s- V$ l* y+ i0 N65
# a8 z7 Y# r2 P6 N" V66
8 j+ N* L2 u5 i  @67
68
3 v7 P- j# z+ U6 h0 b69
0 Y) C% U5 o# c/ o8 h. r1 `$ _5 J70
71
" f! N2 t3 I  s- j72
73
! M7 M1 H, J. ?; ?7 U: L6 S7 K3 b# ]74
. N$ t/ S0 _# K  u75
7 B& N7 m! ~5 d0 S76
4 |# @  v. ~- Y/ o$ H8 w77
2 \  C. K: g$ L78
79
80
% |# \8 d* x$ i6 n0 [81
82
83
9 g% U/ T7 _+ A, n( [# t7 Y84
0 r' j) n# j7 b85
86
" X2 q& H6 l5 U) u( s87
88
( p4 k; B* C& K% F' d9 A89
! q9 O8 [4 m" \5 t90
% `+ k  X' ~3 Z8 i0 t  b7 L91
92
93
94
95
8 T* l% E( D" e( {/ _1 \! s0 F96
97
) \5 H2 e: S6 C0 O( E98
99
100
101
, h7 O: I7 `: S6 c! c  c102
103
104
+ r' E  ?4 b+ O105
106
107
3 ~0 I9 M+ o8 V' r$ @0 A: o108
109
# x5 Z8 F: t: M1 w' l1 t% B# B110
111
0 L- A. d0 A! o# _# i112
2 m6 O6 l) d/ \7 N4 W4 F* p  x& j' l113
114
  K! Z; U3 |: b* ?! j115
116
117
& a* N/ u% g' D- E  B9 }6 y118
119
$ y' k* J7 `& H, |, B* A5 U$ S120
121
122
1 s; ~% {2 @6 M123
124
125
126
127
128
129
130
: q+ f  o' i9 c0 U# U$ u131
' c2 Q; c: ^* a3 K132
8 v; h8 ?# @2 G133
134
135
7 c! U! t# s# Q+ Z136
137
138
139
140
: Q, y# U5 X( W( a% G. Q3 E* \141
142
- B/ [; `, E0 z4 a  L4 z, b# D' u143
& [6 i6 N/ T5 A% z' ~144
+ @  s0 K& d7 M  H! {145
: c9 k) N4 p/ v( M* }0 H- \146
147
148
149
150
151
, m" p& V7 n0 |$ i3 j  z7 [* {* y152
153
1 T2 o  O2 k  v. Y154
155
/ w; ~7 P. O* O4 Y* c156
157
3 L1 \3 P( J+ S158
159
- ~2 H4 p7 f8 _0 l1 t) l- T160
$ B; b/ y8 q, z: E- j2 Y! s, W161
162
  [; C: q+ H7 E4 g  c163
164
165
166
2 d6 @6 |6 O* ^) ~% U167
168
6 F4 x4 Y) A: P9 U169
$ \7 d7 n1 p: ^! v8 ~170
171
7 l0 L: y) P1 s. L+ ]172
173
1 m2 V4 G, c, n* B4 M6 \" y174
175
. q, D5 }, F" u3 y176
( b# P! ?. g  j* _177
178
1 V* J' P) R- {179
' k" s) Z* }7 {/ M/ A' q/ z180
181
182
1 l. K, C/ I- d+ k0 ]! N183
1 L' F2 _" i/ p/ W5 A4 \7 G0 |( z184
185
$ K4 N8 g) e+ J8 T. X186
  |# m. W* K% }2 ]6 B: o# U187
1 N4 Y9 T- z5 |; M% ?188
! c* j$ o. ~0 K0 [$ L. _* W189
6 F" T2 Q, A* V+ Z/ k1 L+ j190
191
192
2 e4 h6 ^$ |2 r. U& q( b4 [193
& X+ a" t( l3 v' K194
6 _2 r0 j" Z, l195
196
$ Z1 N& R# Z1 T: ]197
/ ?# w1 @- h9 d4 c198
199
200
201
5 K- {4 f. T: k) R$ q202
203
204
205
206
207
/ f+ y- R$ P- f208
209
( `* P/ x$ v" b# a  ^210
* C3 Q. Q, o7 z! X211
2 b% i- q' _, |  h/ A212
213
214
215
216
217
  H1 Q) ?; v/ }$ E3 ^- _218
& c- d7 r! Y; R7 h! N219
3 w0 t' k. Z% H4 J, T) X- \220
* X; Z' \9 G1 H2 n0 k3 r/ D+ \% r221
) I( M# q9 m5 ?: {1 i222
" r6 E0 w9 g7 {6 o/ l1 f% S223
224
225
! m; L) V! Z) a' k! H226
227
3 {: Z) ]: v9 }, F9 z228
229
230
* i) R+ J" [- v+ \4 G5 @/ R2 o231
232
233
234
1 n2 \, ^- B# l, T235
236
6 I5 c/ H3 y# l4 |3 B  Q3 {! k237
" t3 R9 ?# ]+ F6 G7 S1 a238
239
240
: r8 O# d( A4 k  f" J$ F/ q1 Z- a241
" j& |4 h4 j5 I242
) z: [9 k+ j" l; ]: O243
244
245
, K+ m1 I9 B2 f# c3 ?' a# `0 f2 w. w246
247
248
" L7 o, M0 Z; i3 z% E* I3 R249
5 B  w1 @& J) }0 G/ x+ E9 G250
2 b+ R$ v- F( V$ j1 F. C  q  q251
252
/ F% w9 c. B9 H" k253
! X7 {; y6 W! L. o% S, ^. L254
255
256
% i% }& A2 U( C257
258
259
( B% ]4 Q' u& V, L# ^4 J260
8 k* {8 p# @) b8 \2 c261
262
7 K6 z) Y% r! H0 o* [263
264
0 k  q* C& E1 B3 N! Z265
( l/ m0 _% X; s' ~266
# M3 I* b9 m/ Z! x267
268
269
270
6 A4 g9 b/ ]; i+ `271
272
5 F  J8 m) u; q% T: O273
" n6 r7 a0 u/ p4 L6 G# b+ [$ ]274
275
276
: f7 I( O- ], l0 v, d' q. k277
278
' ~" N9 J& m! N4 l7 L9 y279
280
8 t6 W, G5 a% i& q0 i" u- w% _% b281
282
' c" ^7 k) c* M! s# W283
284
$ }+ v4 T) f4 L2 _& c) p: ^285
286
287
) V7 k$ Q8 I6 a+ o- g288
289
290
/ c, F' l* @6 D) q% H+ S  B291
; j! \$ s! @$ |' p, P) }+ ?7 h4 Z3 {292
9 g/ j8 Y6 n+ k; g. u; w5 Z293
9 ?* P+ X. V- g) n8 O294
2 F. h1 W1 U; a3 C295
0 u* K! r4 u# y7 A/ b! X296
297
298
299
300
301
, u0 @( V& w6 r( K4 x8 q5 H302
8 k* |9 ?( b8 O: [! f" I303
  s; X; t3 U" G" O) N5 M304
305
( k/ A8 D" T+ J6 D3 O3 [306
307
308
9 y& d& g$ J, z8 D309
8 O3 k4 N$ r% m, H) f7 |; {310
311
312
313
( E  V) @  W) Y6 |314
" Z# ~4 X. L2 n6 ~# \315
316
' K* b6 [: z& t: R317
& C2 q: X2 Y( u- z. k0 o318
9 a- o; a) N5 R3 _319
  L6 w! Q+ c$ F0 z( m. q320
321
322
323
. d# A7 m* y/ ~6 P3 q3 j324
/ G' |. w2 P* L1 \7 x/ V% a8 x0 x325
326
327
328
329
$ H" K' o$ P* x6 F8 u9 v% E" y: i330
331

# y0 _7 r+ q! o
' p: ~3 W7 w9 C9 L& g
9 D$ X: [( Q" o" r0 d7 P# P







8 T2 J# t# z5 O- B4 L
: m6 }0 v# Q) g' D————————————————
! o( r' J1 N1 ]/ ]. U8 X版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242
5 N: C% r$ k8 `2 q7 ~7 _$ C
1 A. x2 ]' D5 y! N- x7 `9 n