基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

, M, }! Z) s+ {: O; i4 h决策树模型
/ y4 Q9 p. j' e' J目录
2 C; Y1 k3 N! j8 k5 N! H人工智能第五次实验报告 1
9 Z, z5 p, _% l决策树模型 1
一 、问题背景 1
3 l# d, S8 b9 |8 [1.1 监督学习简介 1
1.2 决策树简介 1
( h8 t+ w' m4 t& o二 、程序说明 3
# W4 s6 {/ e' x" m( O4 ]9 J4 d" U2 ^2 x2.1 数据载入 3
2.2 功能函数 3
2.3 决策树模型 4
三 、程序测试 5
! e7 \- D1 A4 H1 C4 X9 l0 H' t3.1 数据集说明 5
2 n/ ~* \& }/ F! d& ?' f: p7 g; b3.2 决策树生成和测试 6
3.3 学习曲线评估算法精度 7
0 h/ C% ^* h( E7 |- a4 z8 S四 、实验总结 8
6 D* O) i% w3 p. j# D附 录 - 程序代码 8
/ z9 w  Z: Q% _$ @/ ^3 f, }一 、问题背景
8 n# \6 K& K7 ~$ h8 z1.1监督学习简介
" E8 B% D) I  x" X& ~机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
9 u. I$ n; ~0 I6 O; T监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
6 `9 v/ c6 N# C+ n' p6 @6 I常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
" k$ ]" D5 P: Z5 T3 `7 j/ W1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
% s! T' t* }( c0 [决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
/ W, r) \2 w/ O, q3 A+ _  O
) ?8 W) Q! M5 j) Z/ E/ o2 `% \' dimport numpy as np
! O$ v) t5 o) h/ }* S9 Z( ofrom matplotlib import pyplot as plt
from math import log
import pandas as pd
import pydotplus as pdp

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

nonce = 0  # 用来给节点一个全局ID
4 i, ?# A7 R7 Z; g4 O8 E) mcolor_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
, k. W9 w# }: _color_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
) c: K% x4 {. ^8 l
! [' r' X$ r4 Q# 载入汽车数据, 判断顾客要不要买
& N& w4 g; G4 s! ^8 yclass load_car:
9 [3 y* E2 ?9 W, B. Q: ^    # 在表格中,最后一列是分类结果
    # feature_names: 属性名列表
- z* m* I% W& ?& `- ?    # target_names: 标签(分类)名
5 e  @3 P. A8 L/ ^& C; Y    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
$ W. g2 ]2 t9 s2 \% ~    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
# K4 G8 s$ C- T" _% t        labels = df.columns.values
        data_array = np.array(df[1:])
9 d1 d0 c7 N% ]+ u. V# x        self.feature_names = labels[0:-1]
        self.target_names = labels[-1]
( p/ f% Y3 L9 d9 ]; P9 l        self.data = data_array[0:,0:-1]
" J& E6 J9 g/ S        self.target = data_array[0:,-1]

7 o) n$ B. D0 X6 i! Q# 载入蘑菇数据, 鉴别蘑菇是否有毒
class load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
3 ?) f: T: m5 e    # target: 目标分类值列表
    def __init__(self):
& [. _2 i, R2 O. @# h. E) a5 A# q        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
        data_array = np.array(df)
2 Q* n0 c/ ^1 d+ V- e$ u        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",
                  "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"]
' h7 F8 L8 k8 J, i4 N7 [3 u. _        self.feature_names = labels[1:]
        self.target_names = labels[0]
+ `) I1 `! ^2 i+ R2 P  X1 ~9 b        self.data = data_array[0:,1:]
        self.target = data_array[0:,0]

# 创建一个临时的子数据集, 在划分测试集和训练集时使用
  k% D0 s, ~3 t" Bclass new_dataset:
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
4 D, A% C! U1 L9 d- r0 l2 ?5 L    # target: 目标分类值列表
; V  U( z, o; Q" d- S- C* N    def __init__(self, f_n, t_n, d, t):
7 K/ {; h) ?( r  P2 A% d! Z7 j        self.feature_names = f_n
        self.target_names = t_n
        self.data = d
        self.target = t

# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
% }3 x3 W( E: t0 P1 H3 f% }! r#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
# target: 分类结果的列表, return: 信息熵
7 Y! D  {# n" \& f: Jdef get_h(target):
: L) `0 R- [# k& B/ e    target_count = {}
    for i in range(len(target)):
        label = target
6 }6 R# ]! n) ?! F        if label not in target_count.keys():
            target_count[label] = 1.0
        else:
+ |1 E( i% {0 m/ h' g# M' J$ \3 g! K            target_count[label] += 1.0
    h = 0.0
" w( R% K) Q( O    for k in target_count:
, K  g$ P3 a& M        p = target_count[k] / len(target)
( \8 O# F& a5 H- u; s% z; p# Q/ q        h -= p * log(p, 2)
) a  a/ w5 G. e/ [    return h

3 M  Z4 a: P" R% C! ^7 ]- t# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
2 J7 R9 J* h% m# z* W# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
def get_subset(dataset, feature_name, feature_value):
% [4 f+ A+ \. V    sub_data = []
    sub_target = []
    f_index = -1
1 `: \. H" b2 g* N8 n3 d6 F* a    for i in range(len(dataset.feature_names)):
        if dataset.feature_names == feature_name:
            f_index = i
, I, v3 ?9 n/ m6 W! F8 t            break

1 b' S' ]0 C( i9 W* O# I0 L+ |3 Y6 J    for i in range(len(dataset.data)):
* U$ r! m# e5 s        if dataset.data[f_index] == feature_value:
            l = list(dataset.data[:f_index])
4 [( b: T7 O3 I. v4 `: O            l.extend(dataset.data[f_index+1:])
            sub_data.append(l)
, d7 U# V$ T3 ?8 a$ Q- w- p; c            sub_target.append(dataset.target)
% s9 b. A0 h( W
    sub_feature_names = list(dataset.feature_names[:f_index])
8 q; j+ g$ A) v    sub_feature_names.extend(dataset.feature_names[f_index+1:])
9 t" r, Z2 E, {4 J9 f' i. A    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)
/ y. g8 @" x0 O: X
# 寻找并返回信息收益最大的属性划分
# ?' ?) E5 ?# d& ]. T/ `$ s7 U# 信息收益值划分该数据集前后的熵减
( f/ g* t$ A: `$ y4 ]1 F: Y# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
def best_spilt(dataset):

! D2 ^/ K! \1 I# Z4 P3 W7 _& P    base_h = get_h(dataset.target)
! N. \8 L2 A( Q4 J4 z    best_gain = 0.0
    best_feature = None
    for i in range(len(dataset.feature_names)):
        feature_range = []
7 Q! r! j( @. i9 Q/ U        for j in range(len(dataset.data)):
1 s0 Q% ?, h; `- Y, A, _, H            if dataset.data[j] not in feature_range:
                feature_range.append(dataset.data[j])

* g% y/ f5 C# T. C! y        spilt_h = 0.0
) {5 ^# H* H! a        for feature_value in feature_range:
; V' v* L3 D, k            subset = get_subset(dataset, dataset.feature_names, feature_value)
/ ?2 q% F3 S( W  k6 m            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)

        if best_gain <= base_h - spilt_h:
  A  U8 p5 y3 L. |0 U4 a, E            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names

4 S0 t; q3 Z/ ^1 |    return best_feature
" N# P' k& g7 f/ b, V2 X5 A
# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
: X1 m7 x) D1 y) V3 C' Q& D. m    target_range = {}
    best_target = None
1 Q/ h4 U! j* c' L    best_vote = 0

    for t in dataset.target:
        if t not in target_range.keys():
            target_range[t] = 1
        else:
            target_range[t] += 1

* ^* d3 |0 e+ E    for t in target_range.keys():
        if target_range[t] > best_vote:
$ [1 V" P5 j& Q5 q3 O( p  ?            best_vote = target_range[t]
3 X! x5 C5 e8 Z5 @5 t% U! t            best_target = t
; L2 f, |# q1 O% A: h: U0 B$ m. ^
    return best_target

6 D- b, S0 b# ]% Y! S( v, k/ K1 ^' D# 返回测试的正确率
# predict_result: 预测标签列表, target_result: 实际标签列表
def accuracy_rate(predict_result, target_result):
    # print("Predict Result: ", predict_result)
6 d0 d; p8 E/ U  T    # print("Target Result:  ", target_result)
( @4 C- d2 s$ x: o    accuracy_score = 0
    for i in range(len(predict_result)):
8 \$ N! @# ]4 W: v( l* f" I        if predict_result == target_result:
            accuracy_score += 1
, q  O! x" o. D: b    return accuracy_score / len(predict_result)

# 决策树的节点结构
: J$ K: T7 E8 ^class dt_node:
! S6 i! N3 {& \, P" x+ }
    def __init__(self, content, is_leaf=False, parent=None):
        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
        nonce += 1
        self.feature_name = None
        self.target_value = None
        self.vote_most = None # 记录当前节点最可能的标签
        if not is_leaf:
            self.feature_name = content # 非叶子节点的属性名
        else:
9 D5 ~+ z; I- h% Q' w; \            self.target_value = content # 叶子节点的标签

        self.parent = parent
+ V$ c# Y+ o' |; D        self.child = {} # 以当前节点的属性对应的属性值作为键值
2 m, `8 G6 w$ y3 \- T/ ]' m( j2 F
# 决策树模型
class dt_tree:
7 r+ R; T& ~8 a. i3 Q4 d
4 `( D- {! g. h0 o    def __init__(self):
6 B. b& K+ H, l% p* p9 X        self.tree = None # 决策树的根节点
7 ?# F; W/ `; N/ B/ R        self.map_str = """
            digraph demo{
            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
8 k4 T  \6 n- y% e& h1 O7 d            edge [fontname="Microsoft YaHei"];
" n+ R; X& ~9 V$ y% H# w1 A            """ # 用于作图: pydotplus 格式的树图生成代码结构
  j* R3 m  w6 `4 r        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值

0 z. u  g" R2 c2 }5 w# E    # 训练模型, train_set: 训练集
, W, w* B: c5 E" a3 F    def fit(self, train_set):

) G# y0 w& J9 f1 w7 r) I# ]% W        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
: i+ g1 E9 N5 P0 f) ^3 }9 i            return None
# j4 c! e3 A% R  c, P
/ {3 F+ [' x1 g! j        target_all_same = True
' a8 Y. M3 H) K; Q( o" J8 H  E        for i in train_set.target:
            if i != train_set.target[0]:
- V9 M: n+ b5 @7 S* x3 p& v                target_all_same = False
  g+ P$ E! ^! g: L1 p, `! e                break
, k' V* I. k2 \  H# z
' U1 W4 m5 T" t& W% A        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
1 k( [3 y2 [4 }: }( `7 ?            node = dt_node(train_set.target[0], is_leaf=True)
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.tree = node
. P7 z$ q4 d1 l$ d: N5 p4 p" 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"
, [7 S; Y/ {8 Q# r" T$ o* A/ k1 K
            return node
$ p8 T2 G" e% z1 C! z; |* M$ p! ^        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
  a. z* H5 r! S7 Y, ?            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
9 T4 {9 Q9 [1 @1 j' X2 p: O            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.color_dir[vote_most(train_set)] = color_set[0]
9 y$ S9 k* N* p4 S/ R                self.tree = node
8 B% D$ y# o( q3 z
; x; L% V6 d4 r            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
0 O  F- l. \3 o6 H- L% o9 X9 B; ^            node_content = "标签：" + str(node.target_value)
" w. P% D: |7 v1 }            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
. a' n1 O5 j0 V8 v7 F1 y7 t
+ P. U* ?8 ?8 E2 w, w& N2 H            return node
# e7 x$ R7 j1 U- r/ K- C/ o        else: # 普通情况, 构建一个内容为属性的非叶子节点
            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
            best_feature_index = -1
            for i in range(len(train_set.feature_names)):
5 q, k$ `' Z3 ~2 f/ U/ F- S/ ?                if train_set.feature_names == best_feature:
                    best_feature_index = i
                    break
% @: u* k8 M, U$ A+ j$ w
! V7 j2 n7 H3 F+ W6 I: f& L! X/ v* M            node = dt_node(best_feature)
4 j+ I5 X9 M+ ?# o( U            node.vote_most = vote_most(train_set)
            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
                self.tree = node
- {3 p: r# P' u! V( K" N- l                # 用于作图, 初始化叶子节点可选颜色
% e; M! q; m# Y2 V/ L                for i in range(len(train_set.target)):
                    if train_set.target not in self.color_dir:
                        global color_i
                        self.color_dir[train_set.target] = color_set[color_i]
) w; ~/ ]& s0 a% u6 J7 J                        color_i += 1
                        color_i %= len(color_set)
/ s$ a$ x; |& g! _' k
; Q# B8 G: |) O            feature_range = [] # 获取该属性出现在数据集中的可选属性值
7 S- h+ U9 L9 O9 x            for t in train_set.data:
0 P, l' ~3 n7 M: a; Z: D- S                if t[best_feature_index] not in feature_range:
' M' J. Q. w; R, h5 D                    feature_range.append(t[best_feature_index])

+ l( t$ h- ^7 v5 O6 T! m/ p            # 用于做图, 创建一个内容为属性的非叶子节点
            node_content = "属性：" + node.feature_name
  W" @' S# V$ |' V: [            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
+ t0 u+ J) X8 W9 j4 g2 v
8 ^, S6 Y; e% n$ y' R8 c            for feature_value in feature_range:
9 C9 t$ O3 \/ @, m) A                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
# ~  Q# }& j" \$ `9 Y                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
                if node.child[feature_value] == None:
7 L4 e7 J& K/ U" s+ p/ a                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
  l) w9 p; H6 e/ l                node.child[feature_value].parent = node

4 S3 S6 H% O+ O: R/ w                # 用于做图, 创建当前节点到所有子节点的连线
! q- [( ]* E! }) L. I0 P                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"
' x/ y% a3 I& e4 L4 ]. i
6 I3 y, ^1 \9 S* @8 O+ R% o8 z            # 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)
: c1 O0 C: B' d/ o  P  c& M            return node

    # 测试模型, 对测试集 test_set 进行预测
: O; k! X+ r: g" w: h% J% z* t    def predict(self, test_set):
        test_result = []
. _, _' b6 F; s/ e( M2 X        for test in test_set.data:
            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
0 ?: t% J: g# p6 i# `8 v0 M* o3 r            while node.target_value == None:
& ~- Q) b5 a* M                feature_name_index = -1
                for i in range(len(test_set.feature_names)):
                    if test_set.feature_names == node.feature_name:
' A+ Z3 f. b/ x1 P( L& s                        feature_name_index = i
9 E* \! X3 c& G4 O- h6 Z                        break
- a- {* j; O) U$ M3 A1 ^                if test[feature_name_index] not in node.child.keys():
                    break
% h4 t, f$ o) G  x% O9 i                else:
                    node = node.child[test[feature_name_index]]
$ u( Q- c' ?* O3 s# E: c# g: _
            if node.target_value == None:
( M/ y* F' |9 B/ _3 u                test_result.append(node.vote_most)
- u3 Z% J5 r0 q' Q  a            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
                test_result.append(node.target_value)
9 Q3 v4 f0 {" M' F+ b9 l, \
        return test_result
. i7 U1 ~$ ^' t  i5 t
    # 输出树, 生成图片, path: 图片的位置
7 F6 @4 n/ f# m3 v9 k. C* d9 @  Z    def show_tree(self, path="demo.png"):
        map = self.map_str + "}"
" _8 B7 u3 a/ c, M: o* W/ q        print(map)
8 p* K/ |1 f- a        graph = pdp.graph_from_dot_data(map)
        graph.write_png(path)
1 p5 f0 ?) U. ]# l
# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
$ M# X  E6 A* p0 L6 R( M" Rdef incremental_train_scale_test(dataset, label, interval=1):
    c = dataset
9 f  G' D4 m) c1 U* p4 W6 u# S) `    r = range(5, len(c.data) - 1, interval)
    rates = []
    for train_num in r:
        print(train_num)
        train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
2 u) ?+ L; a2 Y        test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
; I. C7 O9 z! o# C        dt = dt_tree()
- t4 T  }7 T# {8 ~7 Z4 r  O        dt.fit(train_set)
9 _. e  Q; g* O, A, x5 Y5 |. t, l        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))

9 `3 r) P& U( ^$ |    print(rates)
6 n6 G  ~5 A8 d+ `7 X/ _' K    plt.plot(r, rates)
0 F% O* k7 D! q1 q! W& Y    plt.ylabel(label)
( G% ?" p7 v% y1 T8 O    plt.show()
6 d. i; u; J+ W. j
if __name__ == '__main__':

    c = load_car()  # 载入汽车数据集
    # c = load_mushroom()  # 载入蘑菇数据集
/ N) I! N  {  e4 {! x    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:])
5 F# O6 ?+ |- x# W( Z6 o) j
    dt = dt_tree()  # 初始化决策树模型
1 W; w0 Y4 z9 l( s) x    dt.fit(train_set)  # 训练
6 h( K( f6 u# l3 i8 q    dt.show_tree("../image/demo.png") # 输出决策树图片
/ C9 q6 v! Q' D. @, A- |4 f/ ^5 A    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)

; L. m# [* p  M( I/ ^% B* _
5 G0 K7 i1 o- B3 Y) `1 [' {5 c
1
2
3
4
$ w: J5 c: ?4 ?; {  X& l. V8 f5
6
1 Z' A4 g) u& E* R0 |: @7
) U. Y6 g# N- [, _$ v: x5 X# r2 [8
9
10
11
- b; O3 ~, T: N& i( |7 R; T12
13
14
/ w. ?. d) @6 K15
16
17
18
8 Q( Q; [* O) T! i19
20
8 j4 J! @) l/ x21
22
0 h3 S  [( }2 y: {/ I% p( S" G: t23
24
6 p- h* L1 O  B2 I% a25
26
27
28
29
30
; d% f1 R' }: u2 b31
32
33
' V  b  A. a% B" _4 a* O34
35
6 d7 ?7 M. \$ `' V0 l5 S36
37
38
& e: X, a- H3 e6 R! W3 X6 d' R8 e39
40
: u" H' ^- J& T; s41
% w* ^2 y7 Z% `42
43
0 x) F% H$ t% E44
45
2 n! |6 b' E! a7 b9 W46
47
48
1 n# F6 H4 L5 l0 \# a4 z, D- c49
, i/ L- S% B3 R. F50
51
52
53
54
55
56
4 V  `+ g6 j  I$ d+ e+ J3 v0 _5 ?57
58
59
2 {2 b; ^* S% t  u/ U2 y60
61
8 L+ x' `: X( s9 O( ]& A62
63
64
9 r* w% {* _. p) |& `0 F+ t; h& u65
66
67
68
69
! A" X8 [% Q9 _3 g  {70
71
, ?; E9 v! x* l72
6 I: m- a. Q, ~, t+ S  C' a73
74
75
' g/ J! Q4 U* b  a76
, U# c+ v6 A0 |8 x77
2 V8 \: f7 E5 Z7 E8 M. J) A" a78
79
80
81
82
' |4 t& d( z! X8 L83
84
+ i2 v/ C- M" u, H( ]4 u3 T85
; S5 O6 C2 H' K2 s# J& p86
  f1 ]" m) Q( Y0 s1 H87
88
89
90
91
92
93
94
" V6 @4 ^3 C$ s" U2 U7 _" F95
: C6 N. D1 s9 m$ [& x: ]( u96
97
. G, E& M1 M# k1 c2 \98
; |+ @3 ]  L9 b. x0 z. ~99
! S/ u5 T4 t4 i; w7 A! I+ u100
/ j$ M' ~' K# w+ Z0 F3 g0 C' U+ i101
102
1 i* O" N0 ~4 g( L3 L1 g, T' j103
5 \2 ]" N8 D- }: j0 j9 v& Z104
105
- U/ m0 ^/ A2 }5 p$ D  \3 U106
- s5 b+ U* _2 z" A" v107
8 v+ v: ?! j! Z# c+ ^108
109
; ?9 L# W% U' s110
111
* t6 S2 R6 s$ U0 `6 V9 W: \112
8 ]) r; T( `- u" A$ I$ ]( @/ b113
114
& B$ ~3 L# \2 `9 N2 Y115
. j+ Y/ T# \% y116
117
118
5 U% Y+ g/ N$ i9 z) d" y119
' C" s* h! ~! d- b/ T) G0 ?. Z' E120
: Q; K- e# J9 C- r. J" j121
' E. w! v& U5 ~" v122
3 [0 f5 M9 C! P8 f" t123
124
125
126
127
128
129
0 J- b" C% R0 a130
131
8 C' c' z  A  i. N132
2 {6 m$ t/ p) ]% o) N4 h133
8 N- e: J9 c. ]% M- `134
% R& f) S& Q5 F0 H% o! p( @135
- P9 Z+ H( f. F9 c9 o+ n136
137
138
% p% t' _3 S, i- ?% O139
6 x8 n+ g! g# u4 T2 t( H140
: Q; w5 w; d4 h4 z& {141
# y! h) k# u; S2 t- z0 f: N142
143
144
145
146
147
$ z+ \% \9 b" x* e" k: r148
( J1 l% |! k; o; [9 W' {  s149
150
151
  V$ i& Z" F1 e: z0 F4 M152
153
1 i3 I6 ~, B  L& k154
155
# [4 P! \5 O; _* E2 Z: `" L156
8 n) G$ q+ i$ c+ j% f157
158
159
& @5 g% @0 {: g* e' v$ R, P160
161
2 }7 E% s0 R- o; C' j# c" d162
1 S/ o) K1 u" n3 P  x7 G163
164
165
166
! h4 Q! p& J! Q! {9 z- x5 O167
, E0 A" f- E9 Q4 l/ [( L4 G$ g168
169
3 }+ |# n  n; j, f% y, I170
' Z* z& o, y3 C3 ~" u$ d( }! M- G171
172
' t) m3 C8 P$ L9 l) G- B* N173
9 D% F* V: s4 f6 G" T& j" c174
( m. y0 h  C- A# D* F175
176
3 ^& [/ m  ]3 g( P: t' @& R: `177
178
179
4 n! N8 ?0 W. V8 `) {6 r1 P% m180
. ]* `5 I- Y. g( F181
! K. _* l. L; x3 t  P  G9 z6 j2 H182
183
  H" z+ z8 v' k& k5 o* p$ ~184
185
* r; ^$ g" a) U' f( P; Z: L186
187
2 N& d# H" N+ e$ c% g+ w1 x188
. I& P0 Z1 k  ]. T189
190
2 ]% E) C" q$ |% N4 n, [191
192
$ ~% Y  w% a2 ?1 K. u: g) ~, S  c. ]193
( k- H/ {( c) `2 X8 Q194
195
196
& A( w; K: A' C+ d% \- z* `. U197
% T( n0 q% L$ ]: A, c$ v# z198
199
) W" o: |; C3 |5 f0 ~200
! h$ M% L& A" K9 R. Q201
202
203
204
205
. H2 K: ]8 r$ C+ L206
* ]- @5 ^% L8 X& O207
" A' k+ b7 }  |* T! S- t& v* }208
- x  v1 C) A% a1 x209
5 d4 S/ e  i' `' f210
211
* v/ |- {* v) ]212
6 X- ]% r" D) E+ D213
214
215
216
217
218
& M8 ?) ^$ a6 L2 n1 q2 }219
220
221
222
9 s1 l& m7 ?7 p& `. I223
1 n! Z" s' |) C0 F1 b) M5 u224
! b) R$ H8 |$ c/ J225
226
227
, V  ~! H- p' R228
+ @! }% H2 x/ V229
' n8 s' m/ f* B) N, {230
231
, \) s2 E8 b6 X: b- t' B/ A232
# d9 q+ P2 y( m! z233
234
235
; \" v4 U, l  x' j236
; \% C% q# Y6 u2 A$ Z6 D# z# f9 R. |3 L237
; S- ?: P/ v* Z1 Y3 a- {238
239
240
241
242
243
: B: S6 n- z  U9 E244
245
246
247
* D4 Z, H& O& u3 O248
4 z% w* K+ z+ C7 V  P" ?/ g  Z249
2 U. i8 v  n+ D4 e4 f7 \5 {& N, R250
251
252
1 ^; U/ P2 c( ~) V7 `253
254
255
256
- h; B. I! h: S* J1 Z/ v257
& w$ w3 R; E" e  g  s! }4 U7 {258
259
260
( X6 P* I1 K, X1 \# L261
6 L3 d/ o/ M+ B* w9 k1 _262
263
$ N1 P5 g" N; _+ [  d* o* B264
: F8 o) e) K/ x( `265
266
267
268
  y7 D$ M9 Q! J9 V" a269
! @: V1 a5 b& n! l/ X% e* q# d; x7 P270
271
- @, W( b6 b5 u# Q. e! f8 _2 l272
- F' |# M  g7 j1 d$ t  I7 S, w273
. ^" s$ S) K# ~* S, u2 g1 _274
; O9 D! `# [1 A, J0 }# v. e275
: B1 ?% |" D( J( m( P276
277
4 t9 O5 }0 L/ e3 Q! h2 ?278
279
280
281
. J7 ~4 o1 y0 B. D/ Q282
283
284
, n, ^$ L) b, \; `/ g285
6 e/ z0 U1 f& f7 X286
$ a, T3 J0 b* N287
) n2 k  c  q% a2 K4 Q, U( c: `; N  k288
289
/ k# O+ h5 [1 {/ {6 U. N$ G* K290
3 m$ b+ X7 i' W' i291
+ M: ~$ o* c4 N: H/ p, X2 @292
$ A2 p  L0 j% |1 ?293
294
295
! C8 I) _, e# J296
297
) |0 {' k8 l2 }2 ~& C/ C8 Z7 K298
6 _( c0 b, S" t# ?) ^299
5 o, ^* N* r9 y0 O' _( f4 s300
301
302
303
304
305
2 @3 ]5 ]1 B4 A: a% C306
, r$ Q" ^2 {  f9 ]4 Q( U8 ^307
0 B* B) U0 k- ^- E- s308
309
) e6 o) D1 p4 K/ U$ a8 F2 `310
311
312
; _# y( W+ F+ l& B9 A( d& g313
; T4 t7 w! _) A! F314
315
316
317
- `* u; w" I$ T4 Q" V' k. ~6 \318
319
9 ~5 u' L) I0 m" n+ c% t320
321
322
; z+ i- `& h3 n: j323
9 h" ]6 F+ O" w$ W" }324
% u5 Z' L8 q$ w9 C  C% k325
326
327
4 C: z6 _" r& _  I328
329
& Z" u( i4 {+ E# G8 r" V330
3 o, z$ `0 _. |331





* @3 ]- }$ M2 D% T
9 ]. U1 C( c0 R( G" f1 p
- r2 u& m2 y5 P% q3 S' T
' a$ i6 J; ?. r7 m


* y0 Q) w+ y) ~' J, e& A
& S$ z/ N. {! c1 ~7 }: w( b————————————————
版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
/ C( B7 l/ ~; m' W原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242
9 }2 A2 [) l; _) `6 N+ _5 B$ F