基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

决策树模型
0 X% ?" m0 K# D目录
5 E0 q1 o4 z6 V6 J$ Z人工智能第五次实验报告 1
% i  p- z7 h  Z% z+ I决策树模型 1
一 、问题背景 1
- @6 `# ?4 x: P  a( H1.1 监督学习简介 1
1.2 决策树简介 1
二 、程序说明 3
2.1 数据载入 3
0 P% q$ [: `/ Y6 d* {" A; C& m9 W5 Y2.2 功能函数 3
9 _5 h" j5 e$ h3 |9 ~: h2.3 决策树模型 4
. `  S+ F3 D. I3 }) j, f. J/ M三 、程序测试 5
3.1 数据集说明 5
+ K3 a1 N/ t& Z; Y3 ~$ r: j; Y4 J3.2 决策树生成和测试 6
; R5 k/ Y: R' }3 A$ J8 K3.3 学习曲线评估算法精度 7
; A% y/ |& I7 m; e! N! y四 、实验总结 8
: ~2 Q7 w, g, ]附 录 - 程序代码 8
. R* _$ q, t9 K3 M# A一 、问题背景
: D% _- K% B+ r& a( A5 D0 W8 m1.1监督学习简介
9 ^" x7 e7 D' H/ F: a机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
7 ]* }' @; D* d2 v0 Z/ r6 M监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。

import numpy as np
9 t7 f. j9 b* k* p8 X" N3 Hfrom matplotlib import pyplot as plt
# `1 W+ s2 I3 q. V. H  d& ~from math import log
# G  G  e3 A7 }; o- h* ~, u) eimport pandas as pd
# |& S( a% ]/ Timport pydotplus as pdp
* q+ x% u2 t9 T5 n
"""
19335286 郑有为
人工智能作业 - 实现ID3决策树
"""

, |/ F/ l/ T5 K* h- m1 Anonce = 0  # 用来给节点一个全局ID
color_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
: X! v7 q8 m0 I* O# C5 A1 ]$ Gcolor_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
/ E8 C, F* E& R% F  j4 ?+ |
& v5 W8 @1 q9 `3 W. ?# 载入汽车数据, 判断顾客要不要买
class load_car:
: U, N% N. z, [! d5 I4 V    # 在表格中,最后一列是分类结果
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
) m: P8 J# y- X" ?9 j* j    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
( S  Z+ q/ w5 M: Z: n        labels = df.columns.values
        data_array = np.array(df[1:])
        self.feature_names = labels[0:-1]
( U- t( c3 T' o, Y5 Q) [; v3 o' I/ j        self.target_names = labels[-1]
6 Q5 ?7 Y0 R" }  p        self.data = data_array[0:,0:-1]
6 I0 V6 b4 g. w6 g$ e9 @7 s5 G        self.target = data_array[0:,-1]

# 载入蘑菇数据, 鉴别蘑菇是否有毒
5 t- \& _, J8 J' cclass load_mushroom:
% T; k, i, f+ a* p" R7 l7 ?# b# O    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
( o- W0 p: `9 s/ ?$ p* r- _) v    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
5 Y2 @8 c' r$ Q6 g" g    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
  R; L! a. d8 r        data_array = np.array(df)
$ X& N1 P) ]( E1 `3 C        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",
  C2 Y! {3 I& O                  "stalk-surface-below-ring", "stalk-color-above-ring", "stalk-color-below-ring",
. n3 `: O1 m5 u  ~; U, ?                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
$ L& B6 q/ {$ I        self.feature_names = labels[1:]
        self.target_names = labels[0]
+ u: C' I8 p  o  c0 F* b: w9 u% A        self.data = data_array[0:,1:]
( A& h2 e9 E4 r9 U) N/ m        self.target = data_array[0:,0]

# 创建一个临时的子数据集, 在划分测试集和训练集时使用
class new_dataset:
    # feature_names: 属性名列表
2 q7 n2 a0 V7 V8 J5 e* u! H% g    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
' P4 y3 ?; H, a: v& \        self.feature_names = f_n
        self.target_names = t_n
        self.data = d
/ k6 c8 x- L) s' f, d        self.target = t
! h4 e% Y9 Z; h5 l6 m. y- N* k
& x9 U6 c- J. ?. k( l# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
  q8 `" o0 |! p% W+ _$ l. f#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
) @! j$ i9 Y( U$ n! S4 n% b( ?# target: 分类结果的列表, return: 信息熵
def get_h(target):
' B1 {+ r* k- j    target_count = {}
0 [; p7 v  m9 c# s4 i$ j    for i in range(len(target)):
        label = target
        if label not in target_count.keys():
; j& u8 L- K1 o  v* [* `% T' @5 c            target_count[label] = 1.0
        else:
4 T+ J" Z" K4 m6 K: k+ ]% G            target_count[label] += 1.0
; f  h7 [& K; Z, Y% }    h = 0.0
: i; l* D# t* o    for k in target_count:
3 b9 C" P9 }- R+ `% j/ o6 v        p = target_count[k] / len(target)
        h -= p * log(p, 2)
8 ?6 Q' W1 f$ {0 k: t6 U    return h
4 A8 ]% N. o* K& w
# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
: l$ R& R, _' p4 k: i7 I8 qdef get_subset(dataset, feature_name, feature_value):
' P/ F# J, ?: N0 t+ g' ^2 _    sub_data = []
, Z1 _2 c  r7 ~6 Q# y    sub_target = []
" G( t6 }: _* ~1 `2 m& E    f_index = -1
' ]* G: U  B4 M4 i    for i in range(len(dataset.feature_names)):
* G/ O5 d' N5 C8 U) t        if dataset.feature_names == feature_name:
            f_index = i
            break

, X; k1 o  T) v" i- T: s; o  ?3 J* e    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:])
! k5 J! ^0 S4 z            sub_data.append(l)
            sub_target.append(dataset.target)
" F- g6 G( B5 v4 _  w
1 m. j" x( a9 t/ c' J4 ~    sub_feature_names = list(dataset.feature_names[:f_index])
    sub_feature_names.extend(dataset.feature_names[f_index+1:])
% o, e+ A! A# v' ~9 F$ A6 f7 ]( t. x    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)
# E: _' C! h' L& w
# 寻找并返回信息收益最大的属性划分
# 信息收益值划分该数据集前后的熵减
# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
7 Y. u( ]8 c  t& |, Ddef best_spilt(dataset):
- a& W1 K* H7 `/ N) C5 {/ A4 c
: `* Y: D# I! B& x' C. Y; T    base_h = get_h(dataset.target)
    best_gain = 0.0
# A- y) `8 @  y" q    best_feature = None
    for i in range(len(dataset.feature_names)):
1 d) }& {" [% p        feature_range = []
        for j in range(len(dataset.data)):
            if dataset.data[j] not in feature_range:
/ [. j6 G/ K8 B8 w$ S, }: K$ r                feature_range.append(dataset.data[j])
0 p8 h* j% F' D$ d' J7 T3 ~5 j( @& z9 k5 Z
        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)
+ A7 q! T) t, h* f8 X5 e, q
# o' h# Q; s( m# Z9 U4 u        if best_gain <= base_h - spilt_h:
' r0 ~9 v7 j, Y& L2 A' R            best_gain = base_h - spilt_h
2 L) e2 n* G- l- w& I+ c            best_feature = dataset.feature_names
; K4 K8 ?& `& \5 S6 U) I, z9 r
    return best_feature

# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
    target_range = {}
: u+ m9 ?- y" r2 A, t  v    best_target = None
    best_vote = 0

    for t in dataset.target:
        if t not in target_range.keys():
3 L9 x5 E9 b1 f* v            target_range[t] = 1
        else:
            target_range[t] += 1
; a, Y* A" o$ C; a; l2 B
$ k9 h% w' p* I7 s    for t in target_range.keys():
        if target_range[t] > best_vote:
# a" c& K0 r- \: o) F% C            best_vote = target_range[t]
( ?. k; g' N4 {            best_target = t
3 x$ Y1 c" t0 V; O  Z2 H' D" S  \
$ Q6 b; f( O9 q% ?' S0 z3 b' E    return best_target
, O$ v9 W8 Z: a7 L4 ^1 j. k
1 {; l( W( S! S' @/ t# 返回测试的正确率
  {4 O0 E3 P$ ]* p( Y" _7 z# predict_result: 预测标签列表, target_result: 实际标签列表
, s3 {. b; j  H+ |7 Wdef accuracy_rate(predict_result, target_result):
    # print("Predict Result: ", predict_result)
    # print("Target Result:  ", target_result)
$ J7 L9 F  i  d; b% G    accuracy_score = 0
    for i in range(len(predict_result)):
5 [4 g9 J% G# F; W2 q" }        if predict_result == target_result:
6 v, U6 o5 h/ s: Z( O            accuracy_score += 1
& B  [9 U9 o* S2 N; h$ }: a) c    return accuracy_score / len(predict_result)

# H* c- t) }" O, Q4 z# 决策树的节点结构
+ ?7 L/ r. o3 F' e/ F8 hclass dt_node:
: D4 O7 ^  a8 B5 L$ q
    def __init__(self, content, is_leaf=False, parent=None):
        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
; a  C5 O( [5 P; ]8 E        nonce += 1
) s8 C1 \' ^  x6 }4 c        self.feature_name = None
5 S' Y  o3 k  }1 \2 M- m8 x- w        self.target_value = None
        self.vote_most = None # 记录当前节点最可能的标签
2 w/ D; t; N3 l* [* r4 {7 J# u        if not is_leaf:
6 G7 q4 L  k4 X            self.feature_name = content # 非叶子节点的属性名
        else:
0 J* v& a* l/ E+ U  W" }            self.target_value = content # 叶子节点的标签
, a$ p& L% d( e% k
  o8 O4 v2 ?: a! M        self.parent = parent
        self.child = {} # 以当前节点的属性对应的属性值作为键值
1 x$ p% l) J! a' j9 v
# 决策树模型
0 T" [, a. M( u$ j2 b. I/ _+ Oclass dt_tree:

! j$ Q! v1 Y% S% s1 `3 e. }    def __init__(self):
. m: s/ n1 Y0 r& k. \% s        self.tree = None # 决策树的根节点
; |$ q& U0 |' w- n! E0 m        self.map_str = """
% O. p/ [, l8 Y# U' X! X( N            digraph demo{
            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
            edge [fontname="Microsoft YaHei"];
" s8 O& Z. ?8 m            """ # 用于作图: pydotplus 格式的树图生成代码结构
7 Q' O3 J1 w; h% l% r        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值

    # 训练模型, train_set: 训练集
    def fit(self, train_set):
4 W& t* e/ K( L
, t0 x* _- @0 V& L" B' E" p        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
: E$ o8 o( J8 X8 W            return None
/ K3 s, t5 M' E+ }( Q7 k) `0 {( T
        target_all_same = True
$ L* l$ ~6 h8 @4 o        for i in train_set.target:
            if i != train_set.target[0]:
                target_all_same = False
                break
( b3 ]; {2 n) q4 V! U, P
2 G5 D" {- A5 a' V* ]: G; k4 j        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
: Q2 b# y" B' S. }/ Y/ e0 ~            node = dt_node(train_set.target[0], is_leaf=True)
1 ?$ J! L. o& O5 C' P" }/ U            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
9 d; d4 v$ F. U, @* p8 p                self.tree = node

- w9 f; V% V# k3 h; N  M! i$ x0 Z            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            node_content = "标签：" + str(node.target_value)
4 E# Z) D( i# V" m9 O* V            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"

1 [: [: I7 t) m( j* P) X            return node
        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
6 n* q# A2 y* O( J/ z. b. x1 N            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
# W/ V# E& m( C- b( H7 ^            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.color_dir[vote_most(train_set)] = color_set[0]
                self.tree = node

            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            node_content = "标签：" + str(node.target_value)
) n9 t' @2 W  t7 [# {" l- s7 N            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
' V( Y7 C# n4 _; u
  j5 v8 U  i8 \% a: P4 K) ^            return node
        else: # 普通情况, 构建一个内容为属性的非叶子节点
7 ~( ~5 y! K5 i' l: p# u, C            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
0 i9 I, n) p" Y) j2 i# F            best_feature_index = -1
            for i in range(len(train_set.feature_names)):
                if train_set.feature_names == best_feature:
                    best_feature_index = i
' n: @& w  N, K- U( t+ j                    break
9 C2 w- a+ m" |  J" Q
            node = dt_node(best_feature)
            node.vote_most = vote_most(train_set)
; y. n- r! F( \+ P5 f1 p            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
, O0 T; @. P4 r6 M% a* c                self.tree = node
2 u2 O9 d4 [4 j& x2 Z2 F  z* `                # 用于作图, 初始化叶子节点可选颜色
                for i in range(len(train_set.target)):
8 d/ }0 d2 {2 \  p                    if train_set.target not in self.color_dir:
4 @$ F. t- \% A                        global color_i
9 l8 {& S9 l! d. K, c8 B/ H) K+ e. T" G                        self.color_dir[train_set.target] = color_set[color_i]
                        color_i += 1
                        color_i %= len(color_set)
' u/ ~5 z4 ^9 m7 j7 a+ x. [/ f
            feature_range = [] # 获取该属性出现在数据集中的可选属性值
            for t in train_set.data:
% G) `* t4 M7 r                if t[best_feature_index] not in feature_range:
                    feature_range.append(t[best_feature_index])
9 S  b3 p6 [/ w
+ w( s9 x' h( U            # 用于做图, 创建一个内容为属性的非叶子节点
- l; {. z/ s. l# ?- d            node_content = "属性：" + node.feature_name
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
7 }5 P8 B1 j, q/ m, d2 u; u
            for feature_value in feature_range:
                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
  t. l* e  d1 x6 z' i" o                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
( `# W9 l. v6 |2 ~6 Y0 V  Z                if node.child[feature_value] == None:
                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
  F) W) `9 k6 X+ s. d8 ]                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
                node.child[feature_value].parent = node

                # 用于做图, 创建当前节点到所有子节点的连线
                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)
0 e1 s* R* E( S3 p2 R5 Q. F$ y            # for feature_value in feature_range:
+ M  j3 V( s/ P/ L( R" d, l            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
' ?% K: N- _2 w  i: F            return node
; m1 V* z1 f3 K" y
    # 测试模型, 对测试集 test_set 进行预测
    def predict(self, test_set):
        test_result = []
  t. z& q$ i8 O- Q( N        for test in test_set.data:
            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
! ?( l* n- ]" U% ~            while node.target_value == None:
                feature_name_index = -1
                for i in range(len(test_set.feature_names)):
                    if test_set.feature_names == node.feature_name:
5 J5 W8 p# }3 p* T  h% E, L                        feature_name_index = i
                        break
                if test[feature_name_index] not in node.child.keys():
1 b& t3 K/ G" i                    break
                else:
                    node = node.child[test[feature_name_index]]

$ J2 x! H- W8 Q! f! w            if node.target_value == None:
1 @( y1 x! r* r. g! M+ Z                test_result.append(node.vote_most)
            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
                test_result.append(node.target_value)

        return test_result

    # 输出树, 生成图片, path: 图片的位置
    def show_tree(self, path="demo.png"):
1 S: W7 N$ F  B( R) a        map = self.map_str + "}"
        print(map)
6 B4 e, N9 l1 |* g* Z: e1 F/ t% J        graph = pdp.graph_from_dot_data(map)
        graph.write_png(path)

4 \6 F  o1 j; R3 U8 U7 ?- B# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
9 ^! ^+ Y/ U& e6 u& V1 edef incremental_train_scale_test(dataset, label, interval=1):
. w, ?9 X  M) i/ K- h/ q+ d8 T    c = dataset
    r = range(5, len(c.data) - 1, interval)
( v. s  h/ Z. O& p; {" K    rates = []
    for train_num in r:
( W+ d3 {6 v2 V1 ]' f: a' ]        print(train_num)
3 f" |0 \- [! }6 T7 f" |# g& }        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)))

" B: y, |$ l! l! T' |2 N+ G$ S    print(rates)
! G: y, g) e' p$ q    plt.plot(r, rates)
2 i8 [1 M! p' W1 F+ |7 ?: Y+ W    plt.ylabel(label)
, T: t$ e' T0 L% g' f    plt.show()
* \$ m" i4 h, D5 @, M
if __name__ == '__main__':
2 C7 L0 g! U/ y. U
    c = load_car()  # 载入汽车数据集
5 o' R; H8 ]) ^: m    # c = load_mushroom()  # 载入蘑菇数据集
% ?2 F8 p- |6 V# n    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
, D6 y7 j1 {" d. S1 D- y4 Q( r    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()  # 初始化决策树模型
& Y: Z% H$ H& b* ?! W& ~; a% a    dt.fit(train_set)  # 训练
! a. s/ e% W+ c- c& T# |7 u( A    dt.show_tree("../image/demo.png") # 输出决策树图片
, W. O' V) c1 C& \& j- h    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)

2 [' |# U$ T9 B/ ~3 G" M7 k
) N" [3 h$ @7 ~) k, b
, G4 S) s% z$ ]- a, b, M  ~: R1
2
  ~8 {1 H- b' l3
4
: \4 t- `3 l7 a' ?: Q" r5 u4 n/ U5
- n; p7 S9 L$ v6
9 `; w( n- Y! e6 X' R+ Y# j3 H/ E7
9 S# v. o! t; ?' B) {8
9
, x. y! m+ L) a" P; Y( i10
11
12
13
$ y0 ?0 G- Z( h9 z14
5 {6 B) Y) q; ^# m, h. w! J1 O15
: G& A3 l; e: E. z3 m! u" ?9 x16
17
  _/ F' c7 C) a' k18
9 a; b% R3 u- u& i5 g' b19
6 V2 D0 A4 |' e. U5 b1 a- N20
; D2 J2 [* N8 O21
22
! q7 l. T0 j2 g; Q2 r' v( c23
24
: _7 l3 ^! I) K/ k: U$ |% V25
0 Z3 U: R2 c3 H- o( o  L26
27
28
' O5 v/ Q3 @. Y* ?2 s; \* G29
30
' L1 V5 ^  t7 V% S7 ^1 D0 P4 n" W31
32
33
34
4 t+ B# `. Z2 K" b% N9 z35
36
. K. L9 ?' b$ a& B0 ]37
38
9 E/ J2 u7 ?, L* i39
40
* u: D5 C! {( j/ n41
9 ~$ @- E; ^0 E' Z. Z* ^42
43
44
45
46
/ N" K% x4 n! `  B! q8 I47
48
  g* N+ r: n' H+ m49
50
. J1 \. w- r& J0 D2 g9 S  P$ B" t51
52
53
0 A& s$ I( ~8 u) P' n) \54
55
6 ~2 E, Q6 P$ I56
. r' ]$ h- p$ N' t1 [4 U1 N57
58
/ ~" ?# f* L! d+ C59
60
" J" X6 G3 H5 T1 o. }2 f' ?61
" q) q0 K) b; _; F1 J  G( S% E62
63
$ E$ x; u, t! Y% I2 Z64
65
" S* |8 C1 T  v( M66
, d4 C" ^2 c2 A& h% m4 v67
68
69
" p" x, {8 ?5 Y70
71
72
+ ?; f" n" B' i( r8 k73
74
* D- c7 q6 i' \& K3 L1 R6 L75
76
77
78
( A4 s' h& [! A& v% P79
80
. N; l% M9 Z$ v9 H81
- b4 p, Z* u5 \0 E* Y1 M82
83
84
' y% ~( D0 G' L: E7 U. P" V7 d85
( J( v( r, Y7 R$ u. h% h" o86
0 e+ @1 V2 q2 t6 `* x& I5 ^87
88
89
90
91
92
93
% l* D8 T6 J( h9 J* z" W0 e94
95
96
  t0 j( V" @1 q: v) M97
98
. }/ @5 d& z0 z; n* e7 U99
9 d! t  u+ u0 z/ o& f4 ?+ E100
101
# Q, V  k4 t  }- j0 n102
: \& c, u7 c6 ]0 j9 }& P% ?103
6 H2 {* ?- Q7 ~) e104
105
0 j+ U- L! w1 N- E7 I9 W" z5 t. y106
107
) g9 k+ @6 ^  E6 z. V! w2 x# E108
109
; @8 r2 K  ~0 t0 e2 L3 v3 O' q110
7 L: K$ G3 c+ Q3 o! H/ H111
3 J! U9 o) {: h+ y1 @112
113
114
115
. y* R* D  O3 T, P5 w116
117
' C9 Z4 T, G) w- _6 t9 J5 [: t118
119
120
121
122
123
124
) {& m) G) G: I% {  v1 d& c125
& m5 o* e  A' m2 Q+ R* @126
127
128
129
130
# c: H* \" d- X  M6 z131
% R# j* a9 \8 P3 ~# k, U; `1 m! _132
133
134
135
136
137
138
139
/ Z" p' h& W% S140
141
142
) j# q7 p/ f' W2 F4 Z  i143
( }5 g: q$ K  Z, Y1 j% h" g% N144
% x. z: o. ~5 t9 R0 r% p) w; Q145
# A; D$ B) {9 u$ f146
147
148
  C  \, {; W) H1 ]7 W/ z8 U149
+ H/ e% N; g* x6 O8 B150
151
6 p8 [+ F! V' p" s, ]152
6 s* w; D3 N" E153
8 o0 Y, Z. k# D154
  ?, Y. b) ?4 R* l# k5 `155
156
157
) p9 z( ]# @- T3 I& m1 s/ `9 b- X158
159
160
& [8 F; _# B5 {9 |5 f+ m161
162
163
164
165
" V: g& m* H1 V" Z" s8 o166
, e# T* t# z5 E; L5 F; ~. b+ v167
168
! {( \2 @- Y5 a" H5 {+ h( V169
170
" ?) O( }8 O2 b" S( {! h' Z! W171
172
. w- F% u7 ~$ G& v+ N. [173
, G$ q( a* @$ q4 m7 \9 t174
' B8 q9 X8 T6 t- B% a! i175
# k6 X; T! t) u$ h, d' L176
/ p  }3 \& H3 X' k  }0 |7 t' U$ t0 |177
0 B* @! Y1 `7 G2 Y178
179
6 e$ p3 I2 F1 a  t: L2 `180
. M' z' @) }5 D% z2 j+ C+ @* [4 B8 z181
* \* n0 H- Y, x1 ]* E* c182
3 m& ~: y8 `; f2 x! R183
184
) A/ j4 O/ ?! w; B; p( t185
7 j& R7 m/ L) F186
187
# L. i5 L  ]4 e. ~188
189
190
191
192
2 \" v6 F3 T# M' A193
194
195
- w) W9 ]2 J  F& k3 [" D; d196
197
198
! }1 n, g: ?$ x2 N) _1 T8 K- [199
6 F+ V2 W# q; A1 \1 N; U: r- _200
' `( `1 F/ _, ]5 a' V201
, C  H6 a% b  w* k+ B7 H) ~202
203
; ]- `4 P) O& G5 m1 x# j! F4 U204
205
. j$ T5 @  t' Z7 P) V- t" h206
207
208
209
( H; Q( D" d+ q- w210
$ @9 ?( a( j/ i* x  {211
5 f6 Q! T, E; B212
' ]" N6 I/ g) X0 o% g213
  g3 N( J. o$ ]0 z' v- w214
215
8 m7 V& J. W; ^# t7 f1 V216
217
* W5 o- x& ~7 Y218
, S/ [* w  C, V3 `5 u7 e9 Z219
1 z% c9 l- {# ]: ~' V% r220
221
222
223
+ @6 c# u% A% w- E% t224
225
226
* ^9 Q( h0 A3 O8 j% T5 ^227
228
  b0 [4 l8 f1 C7 o! }229
- P5 I0 K2 O5 @( s3 \3 G6 L/ q5 J230
231
232
233
' G* G: f1 m+ {7 }9 R234
0 v1 U- x8 X" ^! |235
5 B( d: i+ Q* m236
237
238
$ L3 c# h0 f  T$ x* }' v239
0 `( y+ |. w8 B240
241
. E1 y, e1 v% B1 Q. i) ]$ h242
243
  R6 A" E1 ?7 B0 S" p. E244
9 c% {5 ?) t, G$ `! K2 I245
246
! U4 B' F3 Q0 J% X247
8 ?; J" {: `% L" W# F248
249
  ]' t' D' {: T. e" b250
6 Z5 F. {# y& B; k/ G2 O251
252
253
$ U+ \6 }, m6 X: x6 Q254
255
256
257
258
259
# L" h) a4 @0 Y) D  m  J- i, }. ~260
261
262
263
( F" }" [- s9 `/ E) l264
265
266
267
# O, ]# ?0 J# @/ O5 F$ ?' Y268
' V7 b, ~* I  p- l3 J269
: v- A! t8 t8 a6 Z( D9 ]- z) a6 q270
271
9 @3 v( M2 z1 v" K272
273
3 G4 \. o9 O# }+ ^) T- ~274
( @: n; E; G. x9 s8 b/ {275
276
3 R5 n0 B* X7 X" U% T7 m+ D277
6 W* P4 o5 ^. E8 r278
3 ~! W( c1 N0 j9 c+ o- r279
280
  e8 P" k( Q5 b% r( x. _. D& N" I281
' E2 C* Y% j; ~  _" h+ \" l282
283
. t" r9 y  V( B284
7 U1 h, V6 |5 h  j9 q285
3 }4 @5 X3 R* [3 D286
287
% e  V' @, q) Q: Y5 r3 S0 B9 W8 V6 V288
, z& c: U4 q* k" l* U: t) y: m- N289
290
5 }, T- e6 i/ b" Q* c+ K! f5 G  ]291
292
293
294
295
296
297
298
+ _3 K$ U! \: [' g0 [: G299
300
301
302
303
/ e" g% Q6 W/ x% q" o304
305
306
2 h( x2 T% ^4 V4 C) R1 q307
2 b2 A! x! r/ c308
! [3 S( u; X: k, E309
310
, x0 z; _- \+ P7 F311
0 n/ A/ q: ^% ?, a8 M5 w- ]312
313
314
0 n4 x1 z2 h3 P315
316
" |# E- Z% ]. W$ R317
318
) _0 o0 ~3 [9 o) [319
+ _# u  I9 d5 W; _8 E6 U) W4 q320
( t  }2 m7 D1 m& @321
322
; L! j8 S& ~# Y. x+ |323
) X" j* Z; k! m! F, N324
# F8 S$ `5 Z9 F' {325
326
3 J; R# W( p1 k+ v, n) U! K327
4 @; Z1 u) r; {328
8 E8 o, s. ?0 |6 }! {329
330
331
! k9 Y& Z/ |  X, c" i* x
4 v# e7 n7 a2 x; q9 a: l0 y


) r1 V) }) ]; X% r9 b

: N  x) H3 J& b, I. r; H4 S/ X' p) `
: J, d* R" Q' L, o


7 S& Q3 M: }. L$ P3 u( C
+ v/ r3 Z5 u2 U) S# L5 p
————————————————
版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
. C, z: O! ~9 P  O原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242
8 i7 w. }. O' k3 x5 {8 y

- V( g) I$ _% r! v; I. F' ]7 u