基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

决策树模型
2 g! `, y& n9 T$ O% ]  m5 S目录
" A5 V& @$ p! K7 e人工智能第五次实验报告 1
决策树模型 1
一 、问题背景 1
* v7 q* \/ w6 f8 q+ M  A- y: n/ M1.1 监督学习简介 1
, I& f3 [& h! \5 Q1.2 决策树简介 1
二 、程序说明 3
2.1 数据载入 3
9 c1 A$ O6 n& Y. a; J) L6 u9 I2.2 功能函数 3
2.3 决策树模型 4
三 、程序测试 5
3.1 数据集说明 5
3.2 决策树生成和测试 6
3.3 学习曲线评估算法精度 7
四 、实验总结 8
1 r2 z6 B# P! \附 录 - 程序代码 8
# ?8 ~2 j$ P. f3 p一 、问题背景
1.1监督学习简介
  ]2 I2 }0 a: D/ N8 f% P9 ^机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
' _9 f. D% Y, R, o1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
' W5 D. n" H+ [, z
9 I, C. N* p* c+ Z3 wimport numpy as np
% B* ~  @7 H/ m; e' _% bfrom matplotlib import pyplot as plt
from math import log
import pandas as pd
# T5 J* M8 S4 w( F% Himport pydotplus as pdp

- t- D: S2 j7 G. m2 g8 G"""
, W9 Z7 E* `) e, W19335286 郑有为
人工智能作业 - 实现ID3决策树
/ M$ z+ d; {) c9 ?0 u. k"""

nonce = 0  # 用来给节点一个全局ID
* ^+ I1 i! l4 P0 K  h* C$ f- acolor_i = 0
2 Z5 E; ^' j2 d# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
3 `+ q3 x3 R8 g0 j9 I# X3 D! i3 [! K! `color_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]

# 载入汽车数据, 判断顾客要不要买
class load_car:
    # 在表格中,最后一列是分类结果
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
& _" X6 d6 K& C$ o    # target: 目标分类值列表
, F, N5 E. L  @* A8 W    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
        labels = df.columns.values
        data_array = np.array(df[1:])
/ [2 P) N0 [# P        self.feature_names = labels[0:-1]
        self.target_names = labels[-1]
4 E9 e1 T5 `! x8 x        self.data = data_array[0:,0:-1]
$ n2 i3 I2 F  E+ a        self.target = data_array[0:,-1]
, k. h# z; Z: G- ?' V' `- O
! z, k, Q9 B+ B3 Y: w1 a& Z# 载入蘑菇数据, 鉴别蘑菇是否有毒
class load_mushroom:
% z& {+ ~& |$ X0 E! v  D5 e    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
. o0 ~; v) J( |$ K, H, Y: g# w" B# g    def __init__(self):
% \( X% [. e* j        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
& u$ B+ c& n) N8 z3 r        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",
                  "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"]
5 r& l1 C, ?2 i) z# m; f        self.feature_names = labels[1:]
- Z+ d& W& {6 A# @- P* V        self.target_names = labels[0]
        self.data = data_array[0:,1:]
5 }+ _8 m( U% g, e        self.target = data_array[0:,0]

# 创建一个临时的子数据集, 在划分测试集和训练集时使用
class new_dataset:
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
2 k% X/ n: ]+ [+ E    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
4 }( s  V& j+ g0 ~    # target: 目标分类值列表
" J9 c2 s" h6 `* d, s& J  t1 l    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
2 v! P; O# s5 K! b) v/ T
# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
3 E% B/ l3 ~4 j; f: p#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
# target: 分类结果的列表, return: 信息熵
def get_h(target):
    target_count = {}
& t. |4 q0 Z+ a0 m+ `    for i in range(len(target)):
        label = target
' |% D# e+ n0 ]$ d        if label not in target_count.keys():
            target_count[label] = 1.0
        else:
. _9 r" B( U$ H8 d/ ^) K5 A" \            target_count[label] += 1.0
' e9 ^  E/ }- ^) T' r- i4 @! O  g    h = 0.0
    for k in target_count:
' E3 k8 S  ?6 L1 n" H& @( l) ]        p = target_count[k] / len(target)
        h -= p * log(p, 2)
5 \) c! M+ h+ u7 q1 N5 ]! u    return h

7 l+ t/ n4 A, N$ b2 i# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
" r- d, V$ K$ Q( U5 _, C# G# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
def get_subset(dataset, feature_name, feature_value):
    sub_data = []
8 T7 E& _6 C5 a1 r    sub_target = []
4 K: l% k$ ^) U0 r# O3 t0 }" H2 K    f_index = -1
+ A; o/ D- S7 X( N    for i in range(len(dataset.feature_names)):
/ w" P, ?# e! E        if dataset.feature_names == feature_name:
8 h* _  I! O! i4 \            f_index = i
            break
' C& E+ z  s4 d. T5 m+ z, D
    for i in range(len(dataset.data)):
        if dataset.data[f_index] == feature_value:
4 h% X: q/ Y2 @. r6 p            l = list(dataset.data[:f_index])
            l.extend(dataset.data[f_index+1:])
            sub_data.append(l)
            sub_target.append(dataset.target)
1 w* }# n6 w9 I: O7 x/ V9 h
    sub_feature_names = list(dataset.feature_names[:f_index])
    sub_feature_names.extend(dataset.feature_names[f_index+1:])
    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)
' h7 {5 ]1 O5 K$ w+ F+ P
# 寻找并返回信息收益最大的属性划分
# 信息收益值划分该数据集前后的熵减
4 Y3 ]8 p5 S* X' l6 j5 |) u, m# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
; j7 m! m' G9 ^3 L3 T( l  h3 U  L2 Kdef best_spilt(dataset):
+ [3 W0 |7 f, U1 k4 Z
. C7 _: l( z8 s. U- o& C/ b/ k3 |    base_h = get_h(dataset.target)
$ K5 c9 v$ T6 q0 t    best_gain = 0.0
4 n4 k' z0 d2 u1 i% x6 ]    best_feature = None
# t. G  U3 m* x8 w    for i in range(len(dataset.feature_names)):
        feature_range = []
/ s; Z" F' n0 F$ B' N        for j in range(len(dataset.data)):
            if dataset.data[j] not in feature_range:
. K5 C) M& [* S6 `                feature_range.append(dataset.data[j])

        spilt_h = 0.0
        for feature_value in feature_range:
& u0 g0 S- k+ ?7 k  y3 g1 ^3 V            subset = get_subset(dataset, dataset.feature_names, feature_value)
1 {+ ?) Q5 x) P$ X) r2 U            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)

        if best_gain <= base_h - spilt_h:
+ k, ], `( l( V1 Y  R  h9 H5 d, d            best_gain = base_h - spilt_h
7 B; ], v9 I1 Z: B3 x! m- f6 ^            best_feature = dataset.feature_names

    return best_feature

) n3 L& e  U7 c% d# 返回数据集中一个数据最可能的标签
9 c" }  f8 S9 e- b# J5 X! ~0 ldef vote_most(dataset):
    target_range = {}
    best_target = None
    best_vote = 0

& h/ q1 ^6 Q" d2 Y    for t in dataset.target:
        if t not in target_range.keys():
            target_range[t] = 1
        else:
            target_range[t] += 1
: `1 d( x, {3 ^6 i- {
* S  ?; K  D- Y0 B% V9 C    for t in target_range.keys():
! U/ J5 d0 @; ]1 X" |% ~9 W( o        if target_range[t] > best_vote:
            best_vote = target_range[t]
            best_target = t

) }& s# C2 J& U) u    return best_target

# 返回测试的正确率
7 h/ e6 C" j. X; X$ b# predict_result: 预测标签列表, target_result: 实际标签列表
def accuracy_rate(predict_result, target_result):
    # print("Predict Result: ", predict_result)
6 g$ q- E9 e  d( i4 u* Q7 S! _6 s    # print("Target Result:  ", target_result)
$ \' n( k( S4 @/ i+ @    accuracy_score = 0
) R9 U, ~! ?) [; n7 u    for i in range(len(predict_result)):
6 x' l! M" K$ _' z# @        if predict_result == target_result:
            accuracy_score += 1
    return accuracy_score / len(predict_result)

! ~5 J: T# ?. H. |+ f% ?+ B# 决策树的节点结构
+ j# U/ e: ]9 ^- C# C  B" Hclass dt_node:

6 s- k( B% W! F/ x    def __init__(self, content, is_leaf=False, parent=None):
9 `$ ?0 l3 G0 i+ D        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
        nonce += 1
        self.feature_name = None
  g# e* z! t6 M& |2 w5 o: [$ N& N0 s        self.target_value = None
) M6 E0 D  m& Z        self.vote_most = None # 记录当前节点最可能的标签
  I: a$ \% y# U3 M/ E8 N        if not is_leaf:
# O, i: t' A: n% N            self.feature_name = content # 非叶子节点的属性名
        else:
            self.target_value = content # 叶子节点的标签

        self.parent = parent
; ^+ G1 q. ]" u' B1 G2 t" S- }$ b        self.child = {} # 以当前节点的属性对应的属性值作为键值

# 决策树模型
# n$ O" u" N+ p9 y4 ]class dt_tree:

    def __init__(self):
( A5 |% y$ P3 n        self.tree = None # 决策树的根节点
        self.map_str = """
            digraph demo{
            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
            edge [fontname="Microsoft YaHei"];
            """ # 用于作图: pydotplus 格式的树图生成代码结构
+ f2 \( P# _" Z9 P# A8 y        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值
4 S- @) j2 n2 H, b! l$ C1 w
    # 训练模型, train_set: 训练集
    def fit(self, train_set):

        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
+ w+ y2 X/ l/ W' @            return None

: c' z# d. }. n3 x* [, Z8 @        target_all_same = True
        for i in train_set.target:
            if i != train_set.target[0]:
                target_all_same = False
& e! d! ]2 E  `% P: z; H                break
- {4 Q2 x. Y2 j( A
        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
            node = dt_node(train_set.target[0], is_leaf=True)
; C. g% a2 O6 m6 k            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
- ^! o- Z4 n  W& \3 N/ y                self.tree = node

            # 用于作图, 更新 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"

            return node
        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
4 s3 l/ A: Z0 ^0 m$ |                self.color_dir[vote_most(train_set)] = color_set[0]
                self.tree = node

  R+ h. N- U8 r4 S, z( _            # 用于作图, 更新 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, {6 P+ {* |3 d# J1 j& P6 X' d            return node
) f0 Y' e: ]) k3 f5 g* I) D# {( m        else: # 普通情况, 构建一个内容为属性的非叶子节点
            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
2 Y( l, ]4 g, }" d3 b9 |( P6 w" h            best_feature_index = -1
- T  T6 ?7 w: d% P' D            for i in range(len(train_set.feature_names)):
                if train_set.feature_names == best_feature:
                    best_feature_index = i
                    break
' T( Z9 |- v  W3 R
            node = dt_node(best_feature)
            node.vote_most = vote_most(train_set)
$ _- O" T# T' j2 ~5 `! L( V' i            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
( `8 u) J+ V% v7 n6 C1 ?* A                self.tree = node
! q' r2 M6 z  A" D                # 用于作图, 初始化叶子节点可选颜色
& T2 c; E* _; f' H  }                for i in range(len(train_set.target)):
                    if train_set.target not in self.color_dir:
                        global color_i
1 v& H  C( y8 g                        self.color_dir[train_set.target] = color_set[color_i]
: n' ^. y' R0 k! ^" I# g                        color_i += 1
                        color_i %= len(color_set)

            feature_range = [] # 获取该属性出现在数据集中的可选属性值
0 y& z# j! X2 Z0 f- R' I            for t in train_set.data:
7 U: U# @% l! [+ G. s                if t[best_feature_index] not in feature_range:
                    feature_range.append(t[best_feature_index])

- Q$ d/ X7 L2 `            # 用于做图, 创建一个内容为属性的非叶子节点
            node_content = "属性：" + node.feature_name
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"

            for feature_value in feature_range:
                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
" i9 N& D, P" e" i' T5 P# [9 u7 Q! s                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
                if node.child[feature_value] == None:
$ k$ A7 \7 U' c* |. ]* ^6 @* c0 D                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
# z* n8 h$ H5 b' F- f5 E1 F3 x                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"
% d# w& R, g0 M* w6 L1 o6 s+ Q
            # print("Rest Festure: ", train_set.feature_names)
1 G& K9 D0 k) P9 T            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
4 d6 K. ]/ V: ]1 o            # for feature_value in feature_range:
            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
4 z4 I- \) Q, U            return node
& o- A- E1 L, I& d
! |8 U# |- e8 |3 c8 |+ ?* Z    # 测试模型, 对测试集 test_set 进行预测
) z8 s9 |1 D/ W    def predict(self, test_set):
  v& O; w$ D$ S3 Z# X        test_result = []
4 [  j# l/ _, Y! x, ~        for test in test_set.data:
            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
% u  Y8 s! o: F0 {9 g8 @3 V            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:
  {8 P. Y" h( p* H. W                        feature_name_index = i
                        break
                if test[feature_name_index] not in node.child.keys():
                    break
                else:
% {5 c$ h$ O$ W" e1 L4 M' v                    node = node.child[test[feature_name_index]]

, L; l& ?; h3 G6 k; G            if node.target_value == None:
                test_result.append(node.vote_most)
            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
+ k. ^7 g- G/ C                test_result.append(node.target_value)

) ^1 z' A5 T2 t- d8 o# u; |3 Y$ T        return test_result

    # 输出树, 生成图片, path: 图片的位置
    def show_tree(self, path="demo.png"):
  w" v/ \9 d) Q! O( V        map = self.map_str + "}"
        print(map)
/ H% y. g& g  s; K  t        graph = pdp.graph_from_dot_data(map)
6 s# P/ u' j1 B% S4 y        graph.write_png(path)
* H8 E' R7 J( L0 U2 I0 ?* c  `
# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
" D% J0 u( Y; S. L/ v6 `+ Jdef incremental_train_scale_test(dataset, label, interval=1):
    c = dataset
    r = range(5, len(c.data) - 1, interval)
* K! u9 |5 c1 ?; X6 n4 a    rates = []
3 x# k/ {" I+ ~  R  _+ K  i    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])
) l$ J( E, d7 ]" V. B2 L        test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
        dt = dt_tree()
6 }' J( |2 j4 u  N0 u2 e6 a        dt.fit(train_set)
, K# q  [( Q; m1 E" f        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))
) C9 M  [, G5 T3 ^- A
3 d- G& W5 t/ g8 H    print(rates)
: r3 P, e( w# t0 x' H    plt.plot(r, rates)
$ Q7 ]& N; v" V# M% y' r" g: |    plt.ylabel(label)
  p3 W1 T4 d7 J" r( Z% O    plt.show()
+ ~2 ~$ S% h3 G4 Q( J
if __name__ == '__main__':
* `7 P/ d" X; G: O* G
    c = load_car()  # 载入汽车数据集
    # c = load_mushroom()  # 载入蘑菇数据集
    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
- G+ A. h' N, X- }% }# T0 f    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)  # 训练
    dt.show_tree("../image/demo.png") # 输出决策树图片
8 d1 u3 ^7 S* a; X6 X' U    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)

6 ~' [+ N4 v3 B( B; h) Z

1
% u  n4 D* V' W: Q2
6 ^8 D' P  A' _8 C+ Z3
4
5
/ w1 B( M" ^% U8 M6
9 J$ A2 _3 E6 k8 f5 C7
8
9
( u$ O9 }2 c7 l, d4 x3 L10
- l( [7 O6 v1 C; i& G: W2 z0 r+ @5 U2 O11
# M! K5 M& g+ D. ]( L6 d7 I" ~12
  q) h) G1 R1 x( D7 w; S13
1 O  s- W/ t- x7 g7 S0 P0 ?/ B& a14
15
16
; n. }! S9 X  a& ]* \5 @' w3 e17
+ h3 z8 A% l7 ?2 y0 A) d18
+ Y& q$ o) {# V% ~& U5 V2 _19
9 f: V- A* x, H  g20
21
3 z9 v: W1 f8 h22
23
+ @2 K: @" B9 [7 I) B# k8 k& h24
/ u6 N" ~0 D6 ]25
0 V' F% J$ x) Y$ W$ I26
27
28
9 @2 z- e) ]. w; s6 d1 B$ I& B29
. S* U& x' U3 C+ t4 S3 ^30
31
; r& G. G$ ]  T9 s32
33
34
35
5 P& ]1 o  i$ d2 s: g36
9 k% `) t' I7 ?# U5 R6 P0 ^. L37
# N* Z6 ~9 c  O  ^38
39
  E3 n$ e& J. l! ~0 j- H' h40
! Q4 k  O3 ~$ l41
42
43
9 c8 C, j( u' k# R) @44
45
& x, ^+ N+ H+ S. ]) L  J; B. M9 T46
+ }2 R. m1 |9 L% v. @! ^47
+ H6 {6 G. e$ l8 d48
; ~8 C$ p" \2 A. Y6 t! y5 v+ t49
& Z" M! s0 X8 L50
) [7 L+ r* R8 _' r2 S; U51
52
53
54
# z. Q! r4 Z  T: E" A# Q55
$ ]( E5 @6 @& S* e/ ~6 r56
57
: G% |1 j" ?0 i# n. q: m58
6 n4 j9 `+ `* _# X3 @+ ~) k5 F! x. l59
60
61
/ q- t! u- ~4 {% b) Z62
. |# _5 X+ W# h63
, n& n) M2 Q; c6 T% F( i64
65
. f1 R: ?; j: D66
67
68
. O2 c& y+ ?4 _- Z69
70
  \+ L% E& G" ~) D$ F; y- H71
6 W- {: h7 j6 t1 P72
9 v# k" D. K. k+ B! y! M5 L73
* ^8 ~: x9 Q. f. ?% p74
75
7 l8 g' _+ a; I. V' z; d76
77
' ?- L( J9 N/ Q, e& R  U78
6 i7 Q1 h' k9 \79
% }$ U' ]  D4 g6 E80
0 i: M) H- a  D, F0 q0 q8 h2 v( j81
82
$ [: z: M- I6 B  D, j83
84
85
86
$ ^9 [+ m9 I$ ]! N87
88
89
1 f2 H8 u- j! A: g# @90
5 x0 n# F6 x+ _5 q: M. r91
92
0 T: W% Y3 V% `6 u* m93
94
9 A' ?0 j; G0 i! C5 r95
% H9 m9 q+ l/ K) B6 D2 ^( b96
& v" ^1 p- Y' u0 Q' N2 c97
7 U! W4 D+ K; V3 z$ d, t" z98
99
- Q2 x/ ]7 D; r100
/ \8 p# ~* t; P# l2 Y101
102
& K' u& N. E& `6 Y9 h7 {: I103
104
105
106
+ }4 j6 ^, Q0 }107
108
109
110
111
6 a7 N3 z8 ^& a! p  M! [8 e) |112
113
114
115
116
* c7 R& D9 n& m( R- m  k+ |8 c5 a! @117
3 `- g6 v5 S+ M- r  Q118
: r! G9 P- I4 K( O% P119
120
121
122
123
124
1 Z, U- H) P  ~7 t. J/ V125
& \) N8 m. }) q4 q; q& |2 D126
0 A4 O$ Q1 @# U+ u: _127
128
129
; N+ G# y7 N5 D6 L- _130
5 c- \; z! T8 Q; l131
132
133
/ l7 y1 m& R; e: i$ _134
135
0 a& q# @  h- [136
137
7 w9 r* N6 r" ]138
, m; G, A6 B: _% j# D% M139
140
141
- @# V9 J6 |: {* {142
4 Q/ k: V) U' e, r  q/ F143
* o  P9 M! _- H2 a. t144
145
146
2 P/ a) g4 J7 n- g' `( b( Q147
9 m9 z4 o5 ], ~. d8 R148
8 [6 s& ]6 x: j# D$ _. X149
* y8 ^  O  o+ b' r6 C' A150
151
& Q# I/ P# e; u1 i8 i152
& D, q" u3 ^: s6 p6 r153
* k$ ?' T) U" I0 w  }154
6 b4 g/ G  i4 ~/ _) B+ W155
, X+ f6 o  n% w6 o: ]156
157
158
159
160
161
8 r5 ?0 g- j! O- z* C. B! }& _162
, ~/ N" V' w( d163
164
& ?  z. @1 a8 C0 x3 F8 s, h165
8 G' Z# ]( \/ j/ y166
167
0 u8 b4 X' R) h2 f1 Y168
) }7 [$ r" U# z, i7 z$ O169
170
4 Y3 q# l8 a, [2 w6 W171
5 c4 N0 x; T: ^$ ?) R; x, t5 v+ {172
173
174
4 {0 O1 ~* A+ f9 }9 A& h% G175
& h6 K* H+ |5 N. P# p) ^* @1 s176
: L0 p0 ~. \; f' D& Z2 q% u* e177
4 N" B. @: I, z$ j178
179
180
7 n: t( e( {- p+ a/ v181
) H8 T6 h6 k" X# m; U' `182
2 _0 V) a- q6 w183
184
185
186
) W. {3 Q4 A/ T187
( B' \- |6 g! Q& J5 ?6 a, X188
4 x8 f; c* I8 @5 W189
" P( h0 Y1 W1 M3 w4 J190
191
3 W9 d' v6 E1 ^) o' ~" p$ e6 E192
193
194
195
196
197
. a* j& Z4 n( u2 p' W  g198
199
200
5 |$ f" I; ^* L" D201
202
7 t+ i6 d  G3 k/ u0 E; W4 y! t203
1 f5 h  i" ~3 |5 o204
205
9 p  S5 E# H; I1 x206
207
208
209
4 j2 `9 ]  I+ P, _; {210
211
1 F% J/ h- z: Z1 I& h# E212
% ^( g9 W, a5 n  {213
6 c, |' L2 Q. e  D$ e8 j214
215
216
3 C& A1 x1 D1 z- b: y; r1 V& [# Z217
0 S4 D, V4 {: A% l# B9 @$ H0 {218
219
( ?/ ]1 R9 t+ N220
221
222
3 C' Y) p. ~* o2 W7 {. h$ d223
# J* T9 d2 T' t224
' _" z& m% V5 _+ A225
- S5 t& o. S, {, E226
227
228
' \6 S  t4 B) v$ i7 O- b/ u8 L+ x229
230
231
; m, ]1 }  m8 [6 y% F& n& j232
233
% u: \( G* X9 \/ ^234
235
236
237
238
7 L/ ?; L* g2 x  L239
  a3 R+ s9 k, B# Z2 I9 L240
241
  ^& E. T* L4 Y, U. N+ y* F242
' |, A& W" H; m6 c+ h( Z243
7 c  _! ~+ G" {244
245
246
# c6 R7 \; I( H# g$ \" n" f247
: L0 N0 ], v/ f3 x# S248
249
% A. }1 `/ i& Q2 L9 Z: O* P250
251
252
, K9 z' T8 F& B+ a- ~253
& U" e& M. V- p5 y% D9 t& q: @254
6 n( J1 a8 p4 `3 }. f" b255
2 k( Y5 Z4 U- U/ L# f: A256
5 N8 ^+ p" A! @  T257
258
259
2 p# q# m1 p$ I7 U+ {) e260
- |7 g% x" O: o8 ^) ?  h# U- O261
262
8 u+ \$ b4 M8 B8 T263
, n+ W1 A5 k5 ^8 n264
265
9 `% F2 Z4 H9 J266
267
268
269
1 k* F$ n* T: |270
) @: f* K( ]* y  L; r8 w% y271
  h4 v- Q8 v: D3 W' P- X272
& d( K# q6 B7 \, c273
( p' L. f5 P0 K. `274
/ `. d! c$ {- T275
- c$ ~2 V, @) m  B; Z# O3 c276
277
278
279
280
281
282
283
284
0 D+ B. \$ ^: K; }285
286
. R, m/ b' D4 U7 V4 ^% U8 s, w287
288
! {: D; }( V5 a289
290
: D4 i  P' r3 c* Z291
" u5 A9 W8 X$ _292
293
, E* f6 Z) I* _  o; l1 m294
! `$ M9 D, ]& q2 S- ^9 _$ ?295
296
297
298
299
) E# P( B. n) p& ]$ P: Y8 `) t300
3 y5 F' \' m6 q0 I301
& {% [. j  Q$ I0 o( E$ \302
303
304
305
1 X8 t0 }+ J0 e3 L) E2 \306
307
/ k0 l3 g2 K( m  U' o308
1 L$ K4 n# k" @/ R; f1 a( V# j9 Q; j309
310
; S. [) j2 }# s) [7 F( l9 E311
- o7 b0 _' j% Q( o! s312
- X4 u) `2 [  s7 l313
314
315
316
9 k( ^2 f( d1 Z317
318
' z) h  _0 u+ C2 C) K319
+ x; t) @2 W0 \- A320
0 H, ?- A) D4 r5 ]. [* @321
4 R: O! R" ~" w% F322
6 M2 @9 Y9 k# _2 q323
+ r% \2 V, @# z9 F" e+ e) E324
3 l9 y6 M2 O5 D; L9 n9 ~* l325
6 ~2 B6 \$ t2 `" b5 }8 L326
327
328
329
330
331

9 i+ [; V9 z$ R# ]% Z" t

0 Y) W: P2 q5 c5 l
- f" H  A6 ?/ a! L( M+ d

9 }% W7 p$ Y, c8 n0 {

6 u7 d9 N& s, B6 a/ K7 z- i0 f7 ^
9 w& w9 F2 }# e7 F


3 E9 S, E! e; G————————————————
' Y# Z2 b4 |. S5 O6 s* t* J$ ?- y版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
- m, M0 \3 z# |% T原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242
2 q" S* C" T. w' e$ f
: y7 r0 A7 g  V1 v/ K+ U5 h
7 y, O/ C+ z. G4 S7 c7 z