基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型
& w( r% W+ j1 `7 I; p" d- V
+ U" Q, ?/ f+ m  g决策树模型
- q+ M; t3 T( y- h0 l; f$ c; m8 B$ D目录
人工智能第五次实验报告 1
决策树模型 1
6 |+ z, k1 O! M, Q一 、问题背景 1
/ H1 X: v- b1 z. ^1.1 监督学习简介 1
0 g" F: r6 f# `+ L1.2 决策树简介 1
二 、程序说明 3
2.1 数据载入 3
4 R; ^/ \7 {2 A- c! L" m4 e2.2 功能函数 3
5 C- q" y) S, E) q/ L5 e2.3 决策树模型 4
三 、程序测试 5
3.1 数据集说明 5
+ p; }5 \" W1 m' l' g2 y/ P3.2 决策树生成和测试 6
3.3 学习曲线评估算法精度 7
3 ~+ x1 a0 Y- A6 b% |- x8 R5 `3 k四 、实验总结 8
  n& @9 q+ f9 b; n8 v附 录 - 程序代码 8
一 、问题背景
1.1监督学习简介
, `0 S+ Z- Y( r; G2 _+ m机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
3 T- g" O. t+ \常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
1.2决策树简介
1 a7 K* ^& t' O+ \5 Q决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
决策树的组成
; j1 S3 E0 R* V0 }% S: H, j决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
) M! Z, r. ]. z/ ^! @
( Z' n. B8 z+ M; S5 a: jimport numpy as np
, g0 o4 \9 a$ r; I" P+ e# b; bfrom matplotlib import pyplot as plt
9 X/ L& K% _3 F( z3 pfrom math import log
7 ~5 l% r9 J% Z/ U$ Iimport pandas as pd
( [& q, d7 X2 \import pydotplus as pdp

"""
19335286 郑有为
人工智能作业 - 实现ID3决策树
"""

nonce = 0  # 用来给节点一个全局ID
color_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
color_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]

# 载入汽车数据, 判断顾客要不要买
class load_car:
    # 在表格中,最后一列是分类结果
    # feature_names: 属性名列表
/ }5 C& E) B  h# p, V& ]! ~# O. F5 G    # target_names: 标签(分类)名
8 I5 ?: S# J4 ^! F; k& [    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
/ B7 \4 W1 @9 \6 ~* s+ b( w5 a  |    def __init__(self):
! s9 u, f7 S( n& u$ a/ B7 r; i- O6 x        df = pd.read_csv('../dataset/car/car_train.csv')
        labels = df.columns.values
; M/ G. h; A% n. L0 u% Z  y        data_array = np.array(df[1:])
) Z9 f9 H* `" [7 S" S" A3 v        self.feature_names = labels[0:-1]
2 }( O; I9 o1 C. V( {6 W3 D% t/ t        self.target_names = labels[-1]
% @9 W+ `7 ~/ c" e8 n% Q7 I        self.data = data_array[0:,0:-1]
        self.target = data_array[0:,-1]
: e) Z9 r1 \. y7 t6 W0 ]0 U7 u5 {
# 载入蘑菇数据, 鉴别蘑菇是否有毒
& F; W! x1 x! v! x5 g/ P2 c1 Z) Yclass load_mushroom:
5 V7 d7 Y5 R/ D; m7 ^; m" g    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
1 m" I. ?; @( f2 n4 ]    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
# T( l5 l* {' V7 |9 J    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
/ a0 p- z/ D% j        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",
0 C( U" `' ]; x+ N3 q% y                  "stalk-surface-below-ring", "stalk-color-above-ring", "stalk-color-below-ring",
3 N! m2 |% h5 d                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
. \4 r) V/ a- Z4 w- \        self.feature_names = labels[1:]
        self.target_names = labels[0]
$ ]( j) D4 z+ B' P" @        self.data = data_array[0:,1:]
        self.target = data_array[0:,0]
0 i) e2 X& I% B1 x: A( D/ B
# `# K, u1 C( @8 f8 N+ w# 创建一个临时的子数据集, 在划分测试集和训练集时使用
class new_dataset:
    # feature_names: 属性名列表
  A, a! M. F7 s8 H    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
4 {  d% p; p. i7 r" D9 S    # target: 目标分类值列表
- f9 y9 r4 Y1 M6 J- e! q    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
/ t, d5 q. N" k& O
# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
6 E$ A+ X7 `7 b) c& B' ]7 [% a# target: 分类结果的列表, return: 信息熵
- J: \5 E$ d$ S4 C8 S/ B  E# ^def get_h(target):
; ?4 {: p8 F  f" i    target_count = {}
    for i in range(len(target)):
- X4 e7 g/ h+ u! T, j$ w! w" T, J1 [        label = target
8 s6 w% n6 Z! v& B2 d7 u        if label not in target_count.keys():
            target_count[label] = 1.0
3 s" |% v( |( m! _1 V$ F+ O& m        else:
( U3 g/ s- K" `) W            target_count[label] += 1.0
; m: p. V8 a) {* N" a8 K    h = 0.0
    for k in target_count:
        p = target_count[k] / len(target)
$ b6 x+ S5 R- C7 p        h -= p * log(p, 2)
' l. v+ x, e' J& c% q2 A    return h
3 O% p8 r1 o6 [$ T
- I( E1 Z: z% T$ m  S. k; Y# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
- f. m4 F8 |. e) j) o$ }0 b; ]# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
- `$ }* \0 _! r" M( _1 Y+ Wdef get_subset(dataset, feature_name, feature_value):
: F) D: ?* ~4 N    sub_data = []
( M! z9 ]) e# R, P0 _    sub_target = []
    f_index = -1
5 ~# R) {; w9 I& O4 w# H    for i in range(len(dataset.feature_names)):
- \( H5 O9 v3 k2 M. q6 R2 _' Y        if dataset.feature_names == feature_name:
            f_index = i
8 ]0 C2 s/ X' k0 R4 y! T5 \            break
: P' G1 X0 S: s$ ]' r
    for i in range(len(dataset.data)):
3 V3 j; D$ M  Q5 K) ?        if dataset.data[f_index] == feature_value:
- e4 o& \( z% q            l = list(dataset.data[:f_index])
" ^3 U& {% i) a. R) V9 E; O            l.extend(dataset.data[f_index+1:])
6 i1 Z; E1 F2 f8 R3 t" o" i            sub_data.append(l)
, v. |0 |: V( C: m            sub_target.append(dataset.target)
9 }! H' B. y, h( ?& K9 _+ s) m
0 N' x- J4 E- v8 V# I3 v) i9 T; U! _    sub_feature_names = list(dataset.feature_names[:f_index])
    sub_feature_names.extend(dataset.feature_names[f_index+1:])
" P$ E* i2 Z8 O" `9 [    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)

# 寻找并返回信息收益最大的属性划分
" Y: }9 G, a! P# 信息收益值划分该数据集前后的熵减
# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
, i8 \0 l0 Z( x9 h* Wdef best_spilt(dataset):
% @4 g2 |6 F& r
    base_h = get_h(dataset.target)
, w- @% m2 R! Y, q8 s5 y' n  |. @    best_gain = 0.0
    best_feature = None
; O( q. L' t* n8 M. ~6 B( f    for i in range(len(dataset.feature_names)):
        feature_range = []
( ]4 ]  G) Q6 p0 P2 t/ O" u7 ]3 g" I        for j in range(len(dataset.data)):
            if dataset.data[j] not in feature_range:
                feature_range.append(dataset.data[j])
9 G/ i7 k' @- c( R- A
        spilt_h = 0.0
$ v1 [- J9 m, T2 p# T$ i        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:
            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names

: a. z0 }! ]& T" |% v    return best_feature
# X+ S6 |- N- g% U1 D) u  i
# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
5 e; @0 ]0 o0 P  b    target_range = {}
5 {' \5 Z9 q/ O- G    best_target = None
    best_vote = 0
# R" i. r, u! r
    for t in dataset.target:
- U2 v: P7 s! e$ v8 m        if t not in target_range.keys():
# M  y- d. C$ j" f8 E9 q$ l& P            target_range[t] = 1
        else:
+ O% F/ u1 X2 m; r8 {) t2 p, E            target_range[t] += 1

+ T0 G+ p. O* B    for t in target_range.keys():
        if target_range[t] > best_vote:
            best_vote = target_range[t]
8 K5 D$ {  ?/ r. E/ p            best_target = t
# ]8 Q) l: H( m! W! ^, ?- _
  m! [& T8 b2 r% q    return best_target
: g% K# c/ ]/ N+ z# y; d
' D8 ]3 l& s! q: s/ E/ \# 返回测试的正确率
# predict_result: 预测标签列表, target_result: 实际标签列表
) A7 Q2 ]* W* _: L7 N) F/ Adef accuracy_rate(predict_result, target_result):
+ U( X3 L& Y0 ^1 g2 o8 r- R5 r    # 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)

; f1 m6 h, {+ ?5 }3 u8 I7 B0 H# 决策树的节点结构
7 E1 m& W5 x7 n* Iclass dt_node:
9 b0 z- T% l; r; \
    def __init__(self, content, is_leaf=False, parent=None):
, @  F% O5 a. F9 \; r+ ^        global nonce
$ a- R( K4 i! T5 x# K; Z* w        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
( w9 F9 Q8 _5 n0 N. n0 H6 Z% W9 K        nonce += 1
1 u* W, ~/ q$ D; {0 J! {7 U        self.feature_name = None
- Y3 N/ z2 ?3 {/ N; M* o        self.target_value = None
' V8 m8 o* V3 \! Z3 G% K( l        self.vote_most = None # 记录当前节点最可能的标签
        if not is_leaf:
" z) ?" Z3 c$ i; }( {  P6 A% @            self.feature_name = content # 非叶子节点的属性名
        else:
            self.target_value = content # 叶子节点的标签
& U* p6 Y' J+ N5 T
        self.parent = parent
        self.child = {} # 以当前节点的属性对应的属性值作为键值
+ e* z! O. F5 l0 E0 @
3 y; x$ s. @" t. r7 T# 决策树模型
) Y# U& ^! x, l4 g6 A( [5 q* jclass dt_tree:

    def __init__(self):
! s3 N. w! N8 X- W4 i        self.tree = None # 决策树的根节点
# C. A' ?6 l2 q$ s        self.map_str = """
            digraph demo{
+ x  X: L: o3 H0 C& t1 O5 a            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
1 \. Z" `; V! J3 ~& @6 Z6 {            edge [fontname="Microsoft YaHei"];
; y$ k! z4 ^3 a- Q! I            """ # 用于作图: pydotplus 格式的树图生成代码结构
% B9 z* ~( g) F* ~' b        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值

1 y& Q# F5 ]6 W    # 训练模型, train_set: 训练集
$ r: h. k/ ]; Z4 P3 }    def fit(self, train_set):
# ~: A1 _4 H  ~" H
        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
            return None
0 e' u$ ^: p! [& I2 X7 B. K: s4 I
. _7 S% Z: N6 k5 ]% q% G9 @        target_all_same = True
5 w; h) z. ]/ b  I- \) X        for i in train_set.target:
  }0 V. t' S- l5 `1 U9 E            if i != train_set.target[0]:
                target_all_same = False
                break
& t' w' i$ I( x# l
        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
            node = dt_node(train_set.target[0], is_leaf=True)
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
8 ?' p% z) Y1 V# o! j8 L% Y0 r                self.tree = node
* d$ |: m. \* v' G. P
3 v# K& K, `; ?            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            node_content = "标签：" + str(node.target_value)
& U4 l3 b* H& N) r  j5 K2 H9 r2 @            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
6 a! h# q/ ]# B; M
            return node
1 _- G  B& R3 {" V/ i5 u5 K        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
' ~' u. @( M6 ?7 d: s5 P- o" ~            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

, J+ a. B% l) ^+ {6 R! y            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            node_content = "标签：" + str(node.target_value)
& G& m7 K' ~/ {' W; p, v            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"

            return node
        else: # 普通情况, 构建一个内容为属性的非叶子节点
            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
6 W* q, u. }- z            best_feature_index = -1
) d0 g5 ?' G  }) _* ]            for i in range(len(train_set.feature_names)):
                if train_set.feature_names == best_feature:
                    best_feature_index = i
( F: Y- V8 H1 n& [# T2 a                    break
0 @3 k- _) q4 j! U) i7 X8 y8 \' t
            node = dt_node(best_feature)
            node.vote_most = vote_most(train_set)
1 @0 V) ^7 e5 T5 q6 s) H9 D. F            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
                self.tree = node
* J9 @& x1 d" V) ]* Q! G                # 用于作图, 初始化叶子节点可选颜色
                for i in range(len(train_set.target)):
                    if train_set.target not in self.color_dir:
7 B; Y. a* ~' G6 @7 r7 m                        global color_i
                        self.color_dir[train_set.target] = color_set[color_i]
$ R; g0 L* c' {( \; {                        color_i += 1
) M7 z9 `( o5 i2 d                        color_i %= len(color_set)

  v) w% L0 b5 ?+ b' `" y( ~            feature_range = [] # 获取该属性出现在数据集中的可选属性值
- o# c9 [& h+ _! ~) A0 y9 c            for t in train_set.data:
                if t[best_feature_index] not in feature_range:
2 X) [- C$ C. Y5 p                    feature_range.append(t[best_feature_index])
6 D7 ]3 j+ F# y( Y( ?% S6 s
            # 用于做图, 创建一个内容为属性的非叶子节点
            node_content = "属性：" + node.feature_name
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
7 @3 j& a: O6 V
- |4 O+ Z0 e, V7 L* z            for feature_value in feature_range:
                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
# }& i' n5 i+ X. [7 n                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
                if node.child[feature_value] == None:
2 e% u. L7 l2 l8 l! T                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
0 J& U' E9 r. r: R1 R+ t# e                node.child[feature_value].parent = node

" \# D# j; Y, h2 i  o) N. G                # 用于做图, 创建当前节点到所有子节点的连线
8 x0 \% w0 b0 n5 }                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"
  m& z; n9 M. W! R8 n! m: _' J
            # print("Rest Festure: ", train_set.feature_names)
            # 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)
) E9 \, ]4 R# A- O  n4 s! ?. s+ o9 I            return node

/ e. i8 D: W* Y# X$ }3 ~    # 测试模型, 对测试集 test_set 进行预测
    def predict(self, test_set):
8 o! r2 F4 ^& |+ j5 Z$ f* v        test_result = []
; q- D' N. |: Z        for test in test_set.data:
7 k. ]9 h0 |2 S7 o            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
: h# P! Q" V9 j$ `9 E  V% c            while node.target_value == None:
                feature_name_index = -1
                for i in range(len(test_set.feature_names)):
2 M1 A: d  J& k                    if test_set.feature_names == node.feature_name:
/ {' e" s* Z# ]; u0 F                        feature_name_index = i
: N( a. w4 |. }+ }5 v9 b; [                        break
                if test[feature_name_index] not in node.child.keys():
" b( K1 m) c( F, T; O                    break
' H9 k* a  z. g1 ^' {- r5 `                else:
                    node = node.child[test[feature_name_index]]

& n: x, s: P, U            if node.target_value == None:
% _- o; m! ^" H                test_result.append(node.vote_most)
            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
                test_result.append(node.target_value)
' T! c' p) f+ N; v* i0 m
6 ~6 {0 U& z' Z: P  [        return test_result

    # 输出树, 生成图片, path: 图片的位置
- {4 b6 D: ^2 I9 v) ]. s' p    def show_tree(self, path="demo.png"):
        map = self.map_str + "}"
        print(map)
& T7 O1 t" B5 A) f3 v; Y' X' m        graph = pdp.graph_from_dot_data(map)
        graph.write_png(path)

8 {1 B# A1 J! J7 d* l9 Y" r0 f$ S# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
    c = dataset
    r = range(5, len(c.data) - 1, interval)
# @( F  g% q( t. G& I    rates = []
  `0 t( b3 [  F% v. `  H5 d; n    for train_num in r:
$ Q4 |( o$ M6 T* M' N. t        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)))
; X$ N5 a! G1 _; q
* q' U/ _$ l- t$ `/ D- R3 |, J    print(rates)
* N! w1 }6 e+ V+ [4 P7 D8 B. c( d    plt.plot(r, rates)
! X1 }/ s8 D3 ?9 p# x/ V    plt.ylabel(label)
, T2 H2 _" \' T% X5 v    plt.show()

, J9 w* A1 {& ?5 `$ {if __name__ == '__main__':

7 \2 }! s2 h, d) U    c = load_car()  # 载入汽车数据集
1 N. E$ C6 q: F" b$ u    # c = load_mushroom()  # 载入蘑菇数据集
    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
    train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
  q, U, L# @% ]$ l    test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])

2 F3 I, }% a+ y  b0 k    dt = dt_tree()  # 初始化决策树模型
8 A5 M  u* Z1 _& y- e    dt.fit(train_set)  # 训练
0 X8 _8 R# j; U( x& ?    dt.show_tree("../image/demo.png") # 输出决策树图片
$ m6 i% g5 y9 Z: y    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧

    # incremental_train_scale_test(load_car(), "car")
    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)
" i- H( M2 c) O6 a5 h& B' l! o; E


+ k' u% [" @+ G' z7 X0 m; t1
$ G3 T9 R/ k0 `) }. W* [2
' z% O7 n' Z. D9 {' z7 J3
. v3 d2 c. B0 N4
5
) d) P4 `' G1 ~  n1 s5 B" ?6
7
8
9
10
! a  M$ F( _' d9 E' Z3 X11
12
) [( w* f- {0 |" R13
( ~1 s9 h; o" q14
15
16
$ I* d0 X! Z# j$ a17
( l- O3 z8 u) O18
) `6 u% V$ Y6 `, s; D19
! t: y6 n9 {; w" y, n0 W20
21
  X* }0 q* L8 [$ w. i, Z  V22
23
8 {- D4 v+ g) D" B7 I  N24
25
& v- ]8 Q( s4 C# }26
27
28
29
30
31
5 K9 k+ {, ^  T6 z32
33
34
35
36
37
38
/ N/ C# \* q0 y% ]0 y  ]0 s" Y39
40
8 A: @6 o% j6 `# ~* A& Z. [1 K) x0 V41
42
# }& b# a$ H9 F9 }43
, N. T' Y8 h- s  ?; f$ a44
45
. k/ X1 h2 d' }) b  [46
0 e5 b4 S! C2 c8 g47
0 Z/ A2 e9 A/ z: S" E) S, f48
49
50
6 O& i; ?) P& Z$ u51
52
5 C# q+ Y" s! S- j53
* A, z4 m; u, ~9 G3 ?( R54
+ z3 N% C% r% D; j! G55
: v" k3 X" j# Q56
7 o% X7 q: M4 Y" j7 n57
+ O% E5 |4 q$ v9 S; q58
59
60
4 d6 h1 o9 e" |0 ?, X2 @6 g61
3 E8 Q0 X# e+ R& S, T62
63
' M$ |7 Q/ Z$ S2 }& b" Z64
65
2 l0 F3 R" }+ k66
67
68
, q) a: O# R8 _" ^69
- z" d' X: a+ ?, M; @$ |70
9 O( G: d; L* [7 E4 p& D71
: O. m5 ~! ^7 }9 h) S+ A72
73
5 O. s3 J+ E  S4 k) E8 W6 Y74
. g9 z8 ~8 u9 |1 I75
76
3 t  |7 `6 @1 X" i( G77
78
79
80
6 m5 O; x% M1 e* E81
82
$ {7 s- v) |4 s: Y% ?& h+ C83
7 W, }! o! J* V84
8 h+ y* T' l9 p7 d& R$ O3 R6 K85
& v3 t# H) B% k/ Q7 t/ K; X* Q86
4 E) Z9 _& c6 F0 c87
9 R8 B  `1 G; }! v3 m9 O88
* s7 ?: ?5 x( S4 v: s1 l* a89
, E/ B: _! q4 O: A; G$ j8 x" d2 Q90
91
92
93
94
' z7 t+ {3 |! P7 M/ |- F95
96
97
2 R7 Q* J& G, Y' \98
99
100
101
+ L! M, o8 R, g  e& O' A102
103
104
6 l: E, F  H4 W9 c6 i: h5 Z105
. ?2 f3 Y% @$ d0 H106
) f5 r% B5 l, W5 a" ^0 U107
* B; w4 a; R; o; u2 V; P$ y4 f108
; J8 h/ h% G, \" Z6 }" O109
% u+ r4 E$ f& y$ n) K: a+ K110
6 {; @+ v  F/ D- ]111
* s1 d. A4 e' D+ F* J4 k$ s4 N112
6 t% Y/ a& ?8 f+ H( V113
114
115
116
, ]+ y( Y, A5 B# o) N( U117
* a0 j8 h( Y2 [5 V+ D118
" `4 J) ^* ~6 {119
120
0 M9 v% d, `- Z0 x. f6 T" Y121
122
: n# ?  G" E  ^$ X9 p$ B123
! I% w5 X$ `% }1 ?' r124
125
126
127
( o1 i6 o2 A0 e: X4 m128
% `+ m* n* L+ q0 |3 i+ ]5 c  A129
! a8 {; L, |; ~" O, }0 H130
131
132
1 j% _# e: k5 z; k133
134
135
136
& ^2 ^2 W6 j5 N7 s137
138
139
140
% Y: w# c- d# {% l+ e* F) K141
, N2 u" R- M  S+ x142
# e  N0 e- N6 ]* k. M6 D7 f9 n143
; h. H0 [# [2 ]3 T( m144
2 x* q3 M6 f$ r6 T145
- F/ `! M. Z6 F' F' P# L/ j146
147
148
149
150
; u! x7 h' L+ v! F) `151
152
153
154
155
8 n% a! l1 E9 s- ]156
157
0 b- M5 z+ u2 n2 d( Y9 g; u1 l3 }6 ~158
159
160
161
162
163
9 ^- R1 h4 r& g  K& b9 P164
% P. h) @: B! w1 d3 |165
  Y7 C2 ?* |- W2 U: J5 p+ Q% O. }8 f166
167
; N6 I  }( s7 b* X! P/ }! G' v168
169
170
171
172
: x# R. g/ c( G- `- d1 Y0 M& x1 s173
174
175
2 N% v3 M1 H6 f. v. P) G1 ^: E! j; }6 ~5 ]176
! w1 h3 F/ W. k2 L3 U177
$ B3 I/ A  l) b: z178
179
180
181
182
8 ^- {# C! \7 H' b; F. s183
184
185
9 A2 W3 g0 J) r- j1 z186
& K2 c* i. U. l6 }! B2 g% W187
188
8 _* O1 I5 V. M7 b( Q6 e. j( S& u/ ^189
190
191
192
193
% X1 @- @. e7 M' o2 Q+ v194
& v! j6 ^: l5 M% W7 b2 ?195
5 `; v6 I& `* ~1 L0 `% N196
% Q. p; Q; y8 C9 u197
. E( \9 W) l. s3 [9 ^1 \5 U198
. |% J3 w) j: A" `5 N) S" F( ?/ k199
200
201
202
+ X3 l  |8 W* p. r' B" T203
# {" c3 }7 V5 m: b( D( m204
205
206
207
4 b, J$ N2 [- `7 R2 v, b4 u208
/ q, J! a( o4 V( B209
2 l1 s6 e) r9 b; d1 f7 Y: q210
0 B% D2 W& c! s) m1 C6 b, y211
. Y# F! u1 p: R  a+ A212
213
214
215
4 g1 v& t9 m; G5 E3 H; t216
217
218
# Q5 `: b$ v# v: n& m$ @219
220
221
+ {, D& }& l3 C, U222
223
% q6 w  ]5 a  Q# G/ ^224
- G) g0 q  r1 O( F8 m" {225
+ E" j) q: f- {* Y226
7 H+ _* Y: ]: A, ]4 F2 g4 M227
228
229
0 \# N/ Y# ]) W3 ?230
' S! q  P  h, e$ a2 N/ ?( y) }231
232
7 Z$ Q+ W9 `# W9 [; `+ X+ [( Z# M233
. B% T# W& M, r9 o# g$ e4 h9 [# t7 }234
0 ?! S1 F4 x% i235
& S! e1 \6 [2 u5 l0 Y" r4 w7 u236
7 |6 v8 k0 n. P5 J& C+ b. P237
! t$ i/ Y3 f! V+ B& C238
239
% q: r+ j2 n/ B* N" L, p240
241
242
# C2 T0 y4 o0 V" K243
244
7 D+ L& {4 J! e% L/ v! o245
246
247
: j: H/ h. d+ M0 W! i5 b248
; D! }( T$ M8 T$ h6 ^$ V249
250
251
$ n' h+ ]/ W0 a, `252
! I; R4 l) e+ W( L! p253
* _$ ?# D3 S- w! p254
255
5 U2 A/ x% w+ u1 {5 ?- {256
257
258
( [' B! Z9 R4 B$ f3 z! l3 Y259
- u/ C# k  u& V5 ~/ \! T  u0 e260
5 s4 r# R9 ^+ v261
262
263
264
265
266
3 e( I4 R* V7 P- s; l267
268
4 m5 O  \' ^2 p5 M% h' h269
270
271
) `' U4 E& h. E( T9 ]1 X272
273
+ x9 I% c/ \4 `7 s; H274
8 w. K4 }7 V+ A6 H275
+ b, s$ }. F+ A6 ?" o276
277
1 D" D- h. }- F9 h# F8 `5 f278
279
! ~1 J$ \$ p$ ?: W  f# V280
5 f. L5 x; v; o! w# M5 @281
282
3 K: k! E2 T8 A: s6 g$ d3 {8 l283
& @  C$ \) m' ^* p7 l8 u284
285
* O. Z( \- v: Q0 O6 l286
& R. C, A) M$ g287
288
$ W- T* ?$ z, D" |3 F2 L1 u& H289
290
0 [: C/ g/ a+ V& h291
8 s( D# k; C/ J' a; v292
6 n: h0 B9 u" s5 n! i% n293
294
) A9 a, j& w7 d; `9 b4 x295
: t2 w% s- v2 w! R8 ^# q( U' ]296
( ?1 n* v$ E' {% |& q7 A297
' y& K% G: I8 J298
9 {9 X3 t1 h- t) b& {* I3 e2 j299
300
* H& B" m, [8 c3 ~& c3 I/ W301
302
303
304
305
( s8 o+ L2 A' E306
: W0 T: }9 V% L1 n$ }& O( E0 Y307
308
309
4 K/ q( [! |: I) `1 s: K; K" K! E310
* w2 `) Q8 F, M2 P' Y+ `311
312
313
9 }# G, P1 R$ U9 ]# [+ Y314
315
. I3 |, o* ^6 K316
317
318
; N$ Q) i. x' c# i1 M, A319
320
4 h& O3 x# }2 A/ e# h321
322
- U3 R7 b1 Z3 n) r9 X4 E4 m4 _323
324
9 \+ }! C, l% w! k5 p6 c, Z325
  K1 @  K  a/ V* `  W# V+ S, |326
327
328
329
' m  }, {" E% J. y7 L/ W330
331
0 i" c. o9 ~$ \- z6 y+ f9 j. V

/ r$ D+ d5 {: d. @

; O! E( b/ ?0 S$ W5 W
) e$ T+ [! p  M; @4 A9 C0 V

! V& m7 J0 S" f" u& A
$ E3 [# a! t9 d9 @# |
6 r( i/ S- p/ s

% ~+ {4 U% ~& n) ^- U
; f5 S3 ~9 C& {3 q3 |4 ~————————————————
) H1 |+ V* S5 b* k  H6 n版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242

" k$ g0 U$ [1 o% M