基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型
/ K% m( R8 Z% \1 U- Q8 \
决策树模型
  g  v% ?1 ?9 p! j/ d# w0 b( a# O目录
人工智能第五次实验报告 1
5 z% P$ }: @  O1 ^. y决策树模型 1
一 、问题背景 1
1.1 监督学习简介 1
# E/ O: \$ O. `, ?1 B) j1.2 决策树简介 1
& Q6 H. A7 m' l6 }  T( K二 、程序说明 3
2.1 数据载入 3
2.2 功能函数 3
2.3 决策树模型 4
* t. |4 k. H9 V$ f/ ~三 、程序测试 5
) u  e$ s. ^- k, k7 d3.1 数据集说明 5
3.2 决策树生成和测试 6
, K4 r; g" J, q5 E" B1 R3.3 学习曲线评估算法精度 7
- h3 `) q$ a6 f& f四 、实验总结 8
附 录 - 程序代码 8
一 、问题背景
1.1监督学习简介
& B0 f: s6 q# K! `. \: H1 P! W机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
; H  Y8 i# i% f! E1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
+ ~" T1 C* Q2 ]决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
" i" w# z! A* |8 L0 D
import numpy as np
from matplotlib import pyplot as plt
from math import log
import pandas as pd
import pydotplus as pdp

9 K- ~9 B1 [+ U$ i" G) i: C# e"""
- L" b3 i$ e6 M3 |) ~1 x# B  O19335286 郑有为
3 w7 w8 [% M; N8 M. |: h1 i6 C人工智能作业 - 实现ID3决策树
"""

  O5 `5 t5 ^! anonce = 0  # 用来给节点一个全局ID
: f# Y% B3 e5 K8 ^& Dcolor_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
: c6 K. F) W/ [! u% Zcolor_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
' a/ H. k" N" W9 c) ~
+ ]/ ]9 y! d7 \$ \+ b9 a3 N# 载入汽车数据, 判断顾客要不要买
class load_car:
    # 在表格中,最后一列是分类结果
6 E- a# R. {1 n9 o# |    # feature_names: 属性名列表
0 v& [: E9 J; {( A( _    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
" O% {! p! ]! d7 l. P$ }    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
        labels = df.columns.values
        data_array = np.array(df[1:])
0 I$ W" Z" ~  l0 o        self.feature_names = labels[0:-1]
        self.target_names = labels[-1]
/ J/ e, v# |8 h6 Z        self.data = data_array[0:,0:-1]
; F5 _* U- I9 Z1 J) F# N' d        self.target = data_array[0:,-1]

+ S5 p0 ^( ^- M1 O& K+ s' @- ?# 载入蘑菇数据, 鉴别蘑菇是否有毒
class load_mushroom:
3 U2 r$ Y+ _4 G% p% e  d    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
0 {: p$ b9 I3 ^' {. t) M. r% h    # feature_names: 属性名列表
6 m# k7 g* o9 Z    # target_names: 标签(分类)名
4 H9 U1 W/ J( s9 i0 t5 v4 K    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
' w  ~# C* b0 V0 }1 V    # target: 目标分类值列表
! O$ J' I! P3 I. \4 N9 ]" }0 p( Y    def __init__(self):
        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
        data_array = np.array(df)
0 c+ P  u/ c" h! y$ f        labels = ["edible/poisonous", "cap-shape", "cap-surface", "cap-color", "bruises", "odor", "gill-attachment",
' z1 n' `2 F1 e7 ?/ I                  "gill-spacing", "gill-size", "gill-color", "stalk-shape", "stalk-root", "stalk-surface-above-ring",
  q4 g- e9 i- e1 f; Q" O, H8 J                  "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"]
        self.feature_names = labels[1:]
( I! Y2 Z. m, y3 V# k. O( d5 ^        self.target_names = labels[0]
4 K# N1 _1 a' J) B6 @$ [5 Z        self.data = data_array[0:,1:]
        self.target = data_array[0:,0]

# 创建一个临时的子数据集, 在划分测试集和训练集时使用
class new_dataset:
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
4 ]4 n3 {- r! d    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
5 X" N0 @) s* E    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
1 _# @* V" e1 n9 x& e+ e        self.feature_names = f_n
        self.target_names = t_n
( t) ]! K$ A# _6 Z5 B1 A0 y        self.data = d
        self.target = t

# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
# target: 分类结果的列表, return: 信息熵
def get_h(target):
    target_count = {}
    for i in range(len(target)):
, J8 U/ x" D. I8 `. q1 A7 g, \- R2 e        label = target
        if label not in target_count.keys():
! L7 M3 A0 J" Y            target_count[label] = 1.0
4 b" O. Y$ }. z        else:
            target_count[label] += 1.0
    h = 0.0
) v. I5 X6 W* S& s  Y    for k in target_count:
9 o  r+ r/ t3 N( m        p = target_count[k] / len(target)
        h -= p * log(p, 2)
    return h

' f% W2 H' A; K# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
6 U. j+ l( _" D" g+ c  e: q* a# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
def get_subset(dataset, feature_name, feature_value):
6 b, v4 [5 g8 ~8 a    sub_data = []
! C7 G% w; I) c7 P    sub_target = []
8 u  Y8 x, P3 C3 K    f_index = -1
    for i in range(len(dataset.feature_names)):
3 T+ O9 v/ v5 ?5 A        if dataset.feature_names == feature_name:
8 |* A6 b0 |& n! Z$ ?            f_index = i
            break

    for i in range(len(dataset.data)):
        if dataset.data[f_index] == feature_value:
  z+ g- J" n% W8 ^& _            l = list(dataset.data[:f_index])
            l.extend(dataset.data[f_index+1:])
            sub_data.append(l)
7 J" [$ K$ ~9 ]8 `, W# g3 p7 x# W            sub_target.append(dataset.target)

( d6 N- l; \8 Y$ b& Q    sub_feature_names = list(dataset.feature_names[:f_index])
7 J- b3 ?/ y8 D    sub_feature_names.extend(dataset.feature_names[f_index+1:])
0 Y$ Q. h  P' J& l4 r1 F    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)
( G8 c7 l: k2 a3 i# K3 j
# 寻找并返回信息收益最大的属性划分
# 信息收益值划分该数据集前后的熵减
# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
& ^1 g0 m3 d7 b# w4 a% R8 \  Fdef best_spilt(dataset):

    base_h = get_h(dataset.target)
: l1 u/ ]' v+ m" ]    best_gain = 0.0
    best_feature = None
    for i in range(len(dataset.feature_names)):
        feature_range = []
        for j in range(len(dataset.data)):
2 r9 B5 E& K9 ]7 h& p+ G            if dataset.data[j] not in feature_range:
                feature_range.append(dataset.data[j])
4 Z" {( J5 A0 I+ m
) Z( G; u0 y' h: V7 \        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:
# W1 t" r& t# d/ [% n2 Q            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names

. p9 d% {) w* H1 \, O- k    return best_feature
/ C; z: ?/ v( _, S7 m4 M$ l
# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
    target_range = {}
    best_target = None
/ R8 ], H1 g2 B' H    best_vote = 0
0 e; [0 y1 \$ g+ |
: y4 }  Y7 p& r1 ^4 b  Z    for t in dataset.target:
        if t not in target_range.keys():
, W# h$ \8 v% ^! L8 g            target_range[t] = 1
        else:
) j5 E) P2 Z9 q4 }            target_range[t] += 1

    for t in target_range.keys():
        if target_range[t] > best_vote:
            best_vote = target_range[t]
            best_target = t

    return best_target
" o$ h7 r& [, `4 R1 f5 o4 Q
: k) [! R1 I: T# 返回测试的正确率
9 _7 q. s4 Y4 _# predict_result: 预测标签列表, target_result: 实际标签列表
def accuracy_rate(predict_result, target_result):
    # print("Predict Result: ", predict_result)
. U# M: ^5 a% G  s4 J) R4 ?8 k4 B7 C    # print("Target Result:  ", target_result)
# G% t, e6 ^# f3 w8 ?6 `) g2 U' P    accuracy_score = 0
    for i in range(len(predict_result)):
        if predict_result == target_result:
            accuracy_score += 1
  ]% x! o" Y! s  s8 ]9 S& j( n6 Y5 {    return accuracy_score / len(predict_result)

' e% A6 S& R( ~; D) I! r# B# 决策树的节点结构
' N2 I( u# d% f/ ?. vclass dt_node:
' v( o- ^! L. G4 S" f6 i6 v$ k. T4 S
    def __init__(self, content, is_leaf=False, parent=None):
* R" W) h0 G) b6 ~% C. J        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
  D$ T* S8 w( I, ?, L' _8 g5 s) M" b( @        nonce += 1
        self.feature_name = None
        self.target_value = None
! R( E) v- l5 P+ N        self.vote_most = None # 记录当前节点最可能的标签
        if not is_leaf:
            self.feature_name = content # 非叶子节点的属性名
7 f7 T0 H) \2 _+ v/ E/ }) K        else:
5 L, U: J. r6 g+ Q; a* P" q/ A            self.target_value = content # 叶子节点的标签

& Q4 {& }* w9 I6 A        self.parent = parent
; N7 Z3 e6 }, i- H' K        self.child = {} # 以当前节点的属性对应的属性值作为键值

' E- n/ m4 h, q$ _# 决策树模型
class dt_tree:

    def __init__(self):
        self.tree = None # 决策树的根节点
        self.map_str = """
            digraph demo{
- }0 N- s" s  |2 d            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
" A5 _' @2 `# L1 S9 V) z: ]            edge [fontname="Microsoft YaHei"];
            """ # 用于作图: pydotplus 格式的树图生成代码结构
2 Z3 }$ b/ q6 ^  [& t  V) G. H        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值
" ^% \* c1 y5 ~# x* p
6 c4 W- h( g: I/ J8 ]$ O$ [    # 训练模型, train_set: 训练集
; w) o" z1 X& l& C2 L* ?    def fit(self, train_set):
2 _" {2 Y  q0 D* R7 g
        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
2 C( V* Q( {! x+ ~' j            return None

' R( b/ u: N0 A! I        target_all_same = True
+ z5 \* @, Y# V+ x! l. Q) ?; u1 E        for i in train_set.target:
            if i != train_set.target[0]:
$ a) x+ b! y$ P, M                target_all_same = False
                break

        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
            node = dt_node(train_set.target[0], is_leaf=True)
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
6 l: r2 x& z: P; i                self.tree = node
' v6 s0 C# `3 y+ y: W2 A& ^
# I: a: \: ?( `            # 用于作图, 更新 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"
6 ^. r2 ^+ r+ y5 \. ]0 J
            return node
        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
8 Q. x+ |6 ^! a( b0 W            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.color_dir[vote_most(train_set)] = color_set[0]
* G' n" a) v$ e) F+ e                self.tree = node
: k% D. p" N4 u
            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            node_content = "标签：" + str(node.target_value)
7 w6 @- h- l2 e" y6 t& x0 g            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"

            return node
        else: # 普通情况, 构建一个内容为属性的非叶子节点
2 e3 D" E" `* u  t2 P- e6 B  H; g            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
            best_feature_index = -1
            for i in range(len(train_set.feature_names)):
( |1 x! K6 [2 _( D9 g. \9 S                if train_set.feature_names == best_feature:
                    best_feature_index = i
                    break

+ |  K7 \4 [3 X) M/ x            node = dt_node(best_feature)
            node.vote_most = vote_most(train_set)
9 F- z& H$ z( o' _" g            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
, S) b7 [2 l. I3 {( |2 @                self.tree = node
; O5 M' x8 \3 Y# p+ S/ \                # 用于作图, 初始化叶子节点可选颜色
/ M! I% m5 h% H8 ?+ x( F* n+ H6 h                for i in range(len(train_set.target)):
" \7 v" i. e# ?9 ~# L                    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
. {- N5 l- r# T0 {" K: k0 K$ C                        color_i %= len(color_set)
% t  O5 K5 G+ I; r/ v
6 _, i4 h5 Q# @  F) z& i            feature_range = [] # 获取该属性出现在数据集中的可选属性值
! z8 E: }4 `: _8 ?' U+ D            for t in train_set.data:
                if t[best_feature_index] not in feature_range:
                    feature_range.append(t[best_feature_index])

            # 用于做图, 创建一个内容为属性的非叶子节点
$ V0 G$ L! R* n1 h$ Y. C# L! N            node_content = "属性：" + node.feature_name
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"

+ C" B5 |8 l+ ]' Q# V            for feature_value in feature_range:
  }# h& v' Q* ~6 `                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
% j3 m9 F4 R& G' @1 N                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
- M" K, i, H3 R" N                if node.child[feature_value] == None:
                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
8 d6 Z7 r. q( V. |  r                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
                node.child[feature_value].parent = node
# n4 l  [* D" {! H0 U
- |9 t! {- r1 r& ~$ k0 r                # 用于做图, 创建当前节点到所有子节点的连线
  P# l1 E* s( K/ t- \2 H! C                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"
) T6 |3 _) p3 }! S3 X8 `7 I
            # print("Rest Festure: ", train_set.feature_names)
            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
  f1 W# Q- s$ I2 m0 M. n5 ?) E" l( d            # for feature_value in feature_range:
            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
            return node
& ^+ D* i4 u' f* w6 a/ T
    # 测试模型, 对测试集 test_set 进行预测
( ?5 b7 W6 r( j1 q" S1 e    def predict(self, test_set):
8 F( I: n# F- I        test_result = []
        for test in test_set.data:
            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
( {" b+ A* j+ s$ u, i            while node.target_value == None:
                feature_name_index = -1
! s; i, j% T8 j# \- |                for i in range(len(test_set.feature_names)):
                    if test_set.feature_names == node.feature_name:
                        feature_name_index = i
                        break
$ C* ~/ r3 w  w( o5 ~) o8 H( X                if test[feature_name_index] not in node.child.keys():
                    break
5 }4 @* d* U) R9 n                else:
                    node = node.child[test[feature_name_index]]
& x: d/ v; _1 S2 T/ |3 l
. J" s3 J- |8 E: J9 d" Z' {; M            if node.target_value == None:
) {4 A% v# F2 z9 a) o, \& O- u                test_result.append(node.vote_most)
            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
                test_result.append(node.target_value)
( d# i/ L/ t* H4 z
        return test_result

% ^$ E- B( T  A* }    # 输出树, 生成图片, path: 图片的位置
5 s; n: M/ I7 _; Q- ?    def show_tree(self, path="demo.png"):
5 d: ^- @3 u" L7 p        map = self.map_str + "}"
( p0 Y: d2 A- t; g        print(map)
4 m; p5 ~4 S. `, ~1 Y$ \3 {        graph = pdp.graph_from_dot_data(map)
        graph.write_png(path)

- X8 L7 ~9 P  E) Y  {, F# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
) Y; C2 }/ l+ N9 p! J4 y: Ydef incremental_train_scale_test(dataset, label, interval=1):
    c = dataset
- O  p9 v  ]$ q' K5 Q* g, n    r = range(5, len(c.data) - 1, interval)
. T. {/ U, R: }: M/ K& q. w/ a    rates = []
3 {! c& T# U  e: `/ c  x* D3 c# U) B    for train_num in r:
        print(train_num)
$ Q1 ~; t. G4 r* u5 `6 E# M$ V- M        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:])
; b, Y+ B! {* Z0 g        dt = dt_tree()
        dt.fit(train_set)
        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))

    print(rates)
    plt.plot(r, rates)
    plt.ylabel(label)
    plt.show()

if __name__ == '__main__':

    c = load_car()  # 载入汽车数据集
    # c = load_mushroom()  # 载入蘑菇数据集
( B4 F  N) e, [  f( r# P$ w) \    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
    train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
; M  Z, |3 V. J. n# U    test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
! D7 K# L/ h2 q0 L" u( m
    dt = dt_tree()  # 初始化决策树模型
2 m- v4 @% ]% I* G6 R2 c( H1 q    dt.fit(train_set)  # 训练
    dt.show_tree("../image/demo.png") # 输出决策树图片
    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧
* V$ @) O+ y  v. f/ e9 S
2 @7 I; }  a- B' F1 N/ L6 W    # incremental_train_scale_test(load_car(), "car")
    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)



1
; o* ?: T' h( B2
0 R) r! {! A" V+ Q; I! o5 ~# t3
! B6 p) j+ j8 m, T% j4
! J! H, x. ^4 }% f9 Z5 l" G/ X5
1 w0 _! j$ p# m, n, U6
7
8
3 p. D' \" a0 |, W8 c& T9
. j5 m* q, Y6 P) z0 Y10
11
12
13
14
15
16
# [$ ]5 p  d  }% p3 Y9 {5 j17
; v" c' k  D6 @! J; E18
19
1 R! e5 [6 u- x! A6 R, ]20
21
22
23
" q$ h4 Z; B, R5 H" s24
25
26
3 E: Z/ c. \$ e: I27
28
29
- q: N8 X' A! T# r30
% Q/ K% Q4 M9 X7 f31
32
33
34
35
36
9 v9 U4 T/ B; e5 A7 C# i3 i# p37
- x$ |2 j& Q( h- [5 s4 C. F# v38
39
4 @) J8 N5 z/ x1 G9 f$ u" |5 P40
+ g+ Q# S3 |0 a- q. x. \41
+ w7 C( T0 e' a; y5 W, m4 a0 ^42
43
' \5 s3 Y- X9 k  P44
45
46
47
48
49
1 G# {. }- \9 i50
51
52
53
54
. P, Y2 g+ L/ W& B, l4 t; g55
6 }  E; b* H9 C- S$ {; h% M56
57
* K2 }3 w. H) Z- b& P0 T/ b58
* t1 i( _* h& e59
60
61
- M" U/ Q  N1 Q5 f62
$ O! D. c9 E* f/ ?1 A63
6 B4 r- \! N! ?7 U# f6 _64
65
* H" Y3 y5 D: z: Y; v/ s66
2 Q  z6 d" W5 Z/ {7 W67
' U0 L! z( r% T; Z68
69
70
71
72
, n- b' u2 O% N! W2 a73
74
. T. V3 @2 B4 K6 J, o75
76
77
' ~$ U" C5 d* _# ?78
7 S% k) }/ a3 m3 r79
80
. k* J9 b8 J$ j1 b81
" _# ]" R1 |* E/ Q9 ^82
" Z) S3 S; {* a83
9 d* l# f3 a7 D' ~' C* n84
85
86
" Q; @+ H* Q' P8 p( {) w2 G" p87
. m9 a* c) @3 K88
89
90
" T# w1 w; Z. L! ]7 |1 n91
92
93
94
95
96
97
, o1 D" ]' Y. M5 h8 ]( N+ L# r7 T" }98
9 p7 g1 j: n% Y% E; l" i4 X: o99
; J/ R: [% r, k+ Y100
101
102
6 V" W& O/ Z5 L$ h103
) u5 M# m7 ^) R9 v/ t! ]' A104
7 G9 Z8 Q* l; C105
106
107
3 t0 M; T- L  ^  U2 K+ Z108
109
4 I: I8 ~- J; {" @7 l2 K110
111
112
# l# P  b/ t/ V8 P113
# G* h% I/ o7 D% R! D( M3 Y114
115
116
117
$ ~! ?+ e! K; F" |8 s8 p# V118
119
120
121
" ]5 z% d3 Q; x8 W" H: C- D122
123
124
3 I8 s% [  a# W. `$ c+ C125
126
127
128
7 r+ w+ N* D" ^129
3 l) @& ~7 L1 Y" S1 ?130
& m- Q0 ]( Z, ]+ L7 l- l$ h( Y/ L131
! U8 Y7 a: g: _$ T. v132
133
. j( x- Q4 v' E" t7 s/ w9 Q134
6 l9 c" t5 `; c' n: |5 p7 v8 D, C135
: b7 p2 f& t2 j3 t' s136
137
138
139
( H5 V3 H0 u8 P& t1 ~2 X4 G8 G" M140
7 ?: V) ]8 P6 ^- f& M! I141
142
143
3 R5 d0 ~! [. r/ D: `144
145
146
& A! _7 L  {# i7 s3 D' K; h5 j147
148
149
0 c) l2 L2 o/ D# y; b8 f4 E150
151
+ X6 ^- n9 m5 c& t7 T9 T152
+ G# e# ^9 Q: w153
154
155
/ G8 |( I, }2 |5 h* p0 u) P6 x156
* q+ X2 z3 o6 C# N9 z' x157
158
159
160
( d$ ]( ^! U( t1 O4 S1 r/ E( b161
162
7 G7 g3 V  F$ h! [$ Y6 ]163
164
165
166
167
9 M/ M+ b$ @' ?, }* U168
169
+ k) R% a, ?6 c1 q+ e, \! ?5 B170
( Y) U9 o* h& {. h! V2 i171
/ X) h( H/ z5 K; A  P. }172
: M- k" V0 r9 v1 f/ v173
174
; Y; Q# B3 E  l0 \175
176
177
178
179
180
181
) K5 _0 B( @5 _+ x182
% d5 r6 g3 R; d$ \183
184
% y, b, K5 \+ G. {185
5 z* ]+ T1 H8 [- v- t186
187
# y) |; r6 L8 W& z9 g188
189
190
7 A" ^: ]& S6 p191
192
% z0 [! n" i. n+ F4 T193
194
195
$ K; y) V5 ^3 q6 R6 v196
1 a& M+ t, F: Y8 H197
198
) m+ @9 p7 P7 a199
200
201
202
203
204
205
/ ?* A, {$ \; Q$ W: z206
207
208
/ Z+ B, A4 K' B, i, _& ~! Y" |209
210
211
212
213
; ?( h7 g9 Y* v' p$ b7 z214
3 \" z. L$ o2 {3 Q$ Y$ g, ]( ]215
# u1 z4 a8 Z0 Q0 H216
, y# Z0 m$ {/ x217
4 S6 I: Z( g) X6 A3 x7 W! E218
+ D5 M  s0 F! B( x  c3 J2 u0 w- N219
220
& a- b# R1 x# Z4 ?3 ]& K) V221
222
. r5 D  S2 m  z" S( M' v223
+ p# s$ x. h0 O! C224
225
226
2 d8 u; f- ^( g% w7 p  w227
/ o! t2 Z3 i+ K& V: k$ J228
229
1 Y4 i" r# a/ d230
231
& C( F, m9 Y- t  k  {# b' I232
233
7 h$ ?: D. j$ _8 p3 ?2 C* a234
8 K# y; U/ a+ ^235
+ E5 N* Y0 Z5 g4 S1 m, r236
3 U, A; Q" ^! U6 O- t237
7 a- b$ \9 T  b! a7 W238
. r8 I: X: A/ U, k; I& m8 d4 w- f' u239
8 D% A& F( r' u* n+ I4 f5 Y( x1 G9 O240
% L$ G) |$ ]; j241
242
243
* C' \8 u, A, t$ b244
7 O* V9 O; I* i  F) b( L9 x9 ]: {. j245
$ R% V" ^1 O& I; L( A+ P246
247
, n7 B& H! [( Z2 X0 T248
# s  \7 B( A, ~# M% l1 w& W249
1 x+ ~$ ]5 ^0 C5 F) y: J" k  c: y250
251
252
( ]! z$ o" c7 X0 b253
254
6 |! `, T/ ~- R( P! I255
256
257
+ n1 Y+ [9 H6 d) {5 h/ \258
4 L* ]! V, E: i; T+ L( W# ~259
6 S5 K5 `5 f" O) M7 ~6 S5 _" l260
! m/ Z* V' }6 w+ T# l2 f1 T261
262
# w4 k( d( E( N+ e, d* Q2 W263
1 i5 \, P# F, A: l. m: c& G: F" d, i264
265
& s% ^1 x4 S" `3 c3 P2 z6 O266
267
268
269
3 e# }9 ~2 U) h2 o+ z270
271
272
273
274
3 H5 X; P( Y$ z% Y( {275
$ q9 I- M2 q0 k, b9 ?276
277
278
, z6 F( d! z8 h( V6 U6 b4 h& P279
7 H' t- @* c9 v+ u* C# G* q, w* Z/ R: C280
281
282
$ W6 O* Q( M: Q7 H283
0 c6 Z6 I, R# [' M8 X' z284
8 X- i5 @" I' _285
286
287
1 F! b7 _& @* n  w* k" [# r288
) }3 v! x% o8 v7 G7 ?4 c+ s0 i289
/ {9 s1 \3 q7 D& G9 V/ k1 T290
291
292
293
; e6 m5 Z$ s- H294
- k+ _0 q* g5 R3 f295
" f! e+ n+ I& a. _296
297
5 Z: i- K4 J1 b' m/ w1 D298
299
1 R7 V8 N9 {$ W& p6 B300
( t, n& T! V  U3 r; @; j301
8 E( T5 e+ V% v. Q& D1 Y302
" z7 r3 d/ X9 T0 |% {303
304
9 w" b; a/ ^4 F. u; t7 L5 q) O305
' E$ G1 H- l% ]! c* i. U. c306
3 w( [7 ~  l! l' F$ a. _3 C307
1 @4 X$ ]6 ]% K* V308
309
, s& p  U" V6 N- e( f310
  [  Z. x7 O# t+ i. O7 y311
7 Z# @3 r1 ^3 P! ]) ?- O312
313
314
" K# @$ a6 d$ R5 V7 T+ x- y( Z2 k315
  Z3 o2 O, f$ ]316
317
+ W4 T1 q4 G/ P: `% G" N8 @318
319
320
321
322
( N/ i. S$ j; M# k; o" Z& o! M7 p323
( U4 D/ ?2 E0 b; F' }' T6 H324
+ s: w0 u8 C1 x! `1 Y/ e; r3 o325
' y; n- }! b: W6 M0 b" g  ?2 p326
( e' ]) k( A$ i% L3 d5 L" i. r* C327
328
329
330
331
& p2 G3 b2 o5 W% z9 n$ l
7 w& |8 |' X  [0 R

0 |. R* k1 y9 @9 r





  Y5 ~! s' {4 d/ u) _

4 B' X5 k: G/ l
————————————————
, S" Q9 R0 `& e3 l版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
& q; o% G  @' @6 L/ y原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242