基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

决策树模型
7 K$ l' _5 z; T4 o% J; Q目录
人工智能第五次实验报告 1
4 o# p* b5 l5 {* u1 [决策树模型 1
  X' u1 z& G' d一 、问题背景 1
1.1 监督学习简介 1
% A; r- w& ], h1.2 决策树简介 1
二 、程序说明 3
2.1 数据载入 3
8 t) W. _2 |% R$ j2.2 功能函数 3
2.3 决策树模型 4
9 F( A5 n! m: B  |/ o) y6 ~% w三 、程序测试 5
# b0 L3 g' y) E6 D  u# p3.1 数据集说明 5
4 y- G& F, V. U/ t  {3.2 决策树生成和测试 6
3.3 学习曲线评估算法精度 7
$ o3 W' _# n; F$ E1 ^' l" G" Y四 、实验总结 8
附 录 - 程序代码 8
一 、问题背景
5 g+ N0 a! ~: E) d" Q1.1监督学习简介
5 c/ H( h( k; I3 a机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
5 h/ h% A3 Z. m/ S2 \1.2决策树简介
- @" A+ D6 |2 c( R+ X决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
0 k0 x* a0 l' r; n/ t% v" B
import numpy as np
from matplotlib import pyplot as plt
6 b- N) [5 k4 H3 ^; c5 [from math import log
import pandas as pd
import pydotplus as pdp

"""
19335286 郑有为
# \; E4 Z" \( b人工智能作业 - 实现ID3决策树
"""
$ Z! s3 N% r+ l( J/ H3 v; Y) J: K
" y5 Q2 p$ v. [- K) H9 K2 vnonce = 0  # 用来给节点一个全局ID
, L7 y0 D4 e, |+ ^: |7 ucolor_i = 0
" @/ v; I2 y/ e+ k6 a5 P0 d" K# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
color_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]

- M; R8 r, x: B5 L$ d# 载入汽车数据, 判断顾客要不要买
) `7 i. f) E5 q7 h4 ^. Mclass load_car:
6 B" G6 I8 K# V) m3 o5 N" Y    # 在表格中,最后一列是分类结果
    # feature_names: 属性名列表
, |  M/ d: @* |3 P7 U    # target_names: 标签(分类)名
. n" j! A- V1 {5 k: Y    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
( k  R. Z: @1 _    # target: 目标分类值列表
9 g$ `7 b# M2 [' H+ b" w    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
$ g2 a2 g' Z! [        labels = df.columns.values
8 w; g" g1 N2 ~0 g0 {9 T        data_array = np.array(df[1:])
        self.feature_names = labels[0:-1]
        self.target_names = labels[-1]
        self.data = data_array[0:,0:-1]
        self.target = data_array[0:,-1]

7 n! O! Z7 W- _# 载入蘑菇数据, 鉴别蘑菇是否有毒
3 [0 k+ n( S8 j8 x9 O+ j& dclass load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
% z* D2 e9 n. V: v, y3 \  }3 J    # feature_names: 属性名列表
    # target_names: 标签(分类)名
! r( C" e+ H* b) `# B% d, R  Q4 q    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
: A3 Z: t& A) E5 i! @2 b, X7 ~        data_array = np.array(df)
6 z7 U, b  k% c" o: n3 y        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"]
1 l9 X0 \3 S5 `% x4 d7 t7 A* g        self.feature_names = labels[1:]
8 k2 ~3 G4 G/ t* [, Y$ R' M        self.target_names = labels[0]
        self.data = data_array[0:,1:]
        self.target = data_array[0:,0]
$ ?1 W; t  T0 B  }1 N1 w
5 h  K) ]6 ]8 f2 e; L" O# 创建一个临时的子数据集, 在划分测试集和训练集时使用
class new_dataset:
7 L& T7 Z+ e  J! y' v3 H* B    # feature_names: 属性名列表
6 n+ [: h0 o- x    # target_names: 标签(分类)名
: {; S' C) y; B" A# o& F1 E    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
) k: f8 r3 u0 o' Y* Y. \. C1 u8 ]        self.feature_names = f_n
        self.target_names = t_n
        self.data = d
; H0 C  H5 C& f        self.target = t
1 M5 Y% k, h- L6 W! J! l+ Y. u
# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
! y/ d9 P, K. x1 D9 g; @& s0 u#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
! y9 q5 T7 R, @4 Z0 r/ o) q# target: 分类结果的列表, return: 信息熵
+ G0 O  o; S2 P+ P7 Ddef get_h(target):
3 H% |; a' s1 Y- c. |, A    target_count = {}
    for i in range(len(target)):
: K# z1 ?! u; j- q1 @* O; ~# ]        label = target
; C& C% U  j; _1 W" p( e        if label not in target_count.keys():
            target_count[label] = 1.0
        else:
            target_count[label] += 1.0
# Y, _' o  Q0 \/ ~    h = 0.0
    for k in target_count:
" R' D+ |7 I3 `( W' B/ K% s# z3 N        p = target_count[k] / len(target)
) ^, j2 `* t% O( |) w9 I4 \: G% ?        h -= p * log(p, 2)
, M9 Y/ n( X7 C7 P$ ^0 R2 A" a  V    return h

# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
" ^5 e* z' f% z/ i9 [9 \6 ]def get_subset(dataset, feature_name, feature_value):
3 B* H$ K- u$ z' S    sub_data = []
8 A0 V, C5 z7 H& y! G6 L    sub_target = []
    f_index = -1
    for i in range(len(dataset.feature_names)):
        if dataset.feature_names == feature_name:
            f_index = i
            break

    for i in range(len(dataset.data)):
        if dataset.data[f_index] == feature_value:
/ f! r8 ~% Y3 }, V6 ^- r            l = list(dataset.data[:f_index])
            l.extend(dataset.data[f_index+1:])
& E% q/ t6 E6 ?; W5 x            sub_data.append(l)
+ _! ~) }. @! Y. V6 w            sub_target.append(dataset.target)
' `& B0 z% o3 V: u+ p
/ n# H* t% H0 _9 B0 n    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)

. y3 E# h) Q5 `. S$ y# 寻找并返回信息收益最大的属性划分
' T0 W! ]. ^  V' r# F# 信息收益值划分该数据集前后的熵减
# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
& @% h8 C; N) {; Y* rdef best_spilt(dataset):
/ o5 ^+ j; i) ]: ?/ `0 A& T6 F' \
# L2 c" u# ^" Y! G7 H( {    base_h = get_h(dataset.target)
    best_gain = 0.0
# {+ v8 g- F: }    best_feature = None
    for i in range(len(dataset.feature_names)):
; |: ~6 F$ W) O9 O% Y' X( n7 v, v1 B, b        feature_range = []
        for j in range(len(dataset.data)):
            if dataset.data[j] not in feature_range:
                feature_range.append(dataset.data[j])

$ X  d% k: i: {4 A% L  r$ ^        spilt_h = 0.0
        for feature_value in feature_range:
0 u, F, n7 s: @3 j            subset = get_subset(dataset, dataset.feature_names, feature_value)
            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)
  O+ l- a- f, a. x8 L; V+ D  C
1 A5 e5 Z% y2 V6 @5 g4 r; g        if best_gain <= base_h - spilt_h:
8 J9 W% f9 K: w% |5 h+ U            best_gain = base_h - spilt_h
5 g( V! N6 a/ U# {" ]; c) T8 X; m; `# i            best_feature = dataset.feature_names

, t9 n5 ?7 e5 w  R: a1 \8 X    return best_feature

# 返回数据集中一个数据最可能的标签
% q, o) f; T) y1 Q/ `* ?7 b: a$ h8 Adef vote_most(dataset):
    target_range = {}
    best_target = None
    best_vote = 0

    for t in dataset.target:
4 ~4 T" i5 ^; ]# R/ s2 ]        if t not in target_range.keys():
            target_range[t] = 1
        else:
; G- Y3 J3 D/ K) @# A6 U* i            target_range[t] += 1

    for t in target_range.keys():
5 ^# p9 i- A. h6 ]1 i        if target_range[t] > best_vote:
            best_vote = target_range[t]
% a- Q! [8 P3 S1 s" p            best_target = t

    return best_target

# 返回测试的正确率
' F' f& b) C& P5 B# predict_result: 预测标签列表, target_result: 实际标签列表
' L4 ]7 s: L, c( F; P) cdef accuracy_rate(predict_result, target_result):
% M3 m/ i/ ]2 U; @' p- f: f    # print("Predict Result: ", predict_result)
) Y( m8 h4 y2 O! j5 x3 |+ a    # 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)
2 r/ R3 s( c2 _2 D$ i
- |: s/ A; V  O# 决策树的节点结构
1 K" D  S5 M% lclass dt_node:

    def __init__(self, content, is_leaf=False, parent=None):
        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
9 f* n& m, ]3 Z* y# Y- L  ]' ?        nonce += 1
        self.feature_name = None
  d! l& |+ w  U1 v' i        self.target_value = None
$ e# |" \1 d9 k1 A8 B, P: [        self.vote_most = None # 记录当前节点最可能的标签
* d; }# N6 U. I        if not is_leaf:
4 |* D% G; k" I1 g! W, ^9 b            self.feature_name = content # 非叶子节点的属性名
! k9 B1 j" X/ W' w        else:
            self.target_value = content # 叶子节点的标签

5 L9 j, \5 ]. j. I" l        self.parent = parent
        self.child = {} # 以当前节点的属性对应的属性值作为键值

# 决策树模型
class dt_tree:

6 q+ m- \) c' C    def __init__(self):
$ T, n6 W4 T" U5 C  J        self.tree = None # 决策树的根节点
0 h, |6 G6 J" i) w( T: J        self.map_str = """
9 k' g, H$ I& i. J            digraph demo{
3 m( w; w; y( z. }            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
* @3 a- o9 s" _$ Z1 y            edge [fontname="Microsoft YaHei"];
! D5 i0 l& S& G; r% h, ?            """ # 用于作图: pydotplus 格式的树图生成代码结构
  y, a9 Z  N; Y. Y        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值
. U" b+ q2 z( B0 R  k/ n
, a" W! M9 x/ b6 m1 J5 t5 b    # 训练模型, train_set: 训练集
    def fit(self, train_set):
' Q  Y& X! b# }0 A  w0 p1 K
5 J7 P% C  F' a; u$ O) _7 b% r' k2 M        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
            return None
# o; w2 O4 f$ ~4 N; m
        target_all_same = True
        for i in train_set.target:
            if i != train_set.target[0]:
# e9 w& i- w9 D, B                target_all_same = False
                break

  y# U/ q+ X. c' _. s        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
            node = dt_node(train_set.target[0], is_leaf=True)
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.tree = node
& e. o4 ~( H. m
  O% f! e, f1 M' M6 T8 `' A- p4 H. P( f4 D            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
9 h( M* d4 H8 o- [. @5 U            node_content = "标签：" + str(node.target_value)
4 e) ^9 H, ?+ }0 E5 x( _4 M' ]            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"

7 e+ i) C2 D) b$ B6 A' ?( e            return node
        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
4 u* O4 H$ H. J0 N, C! q  h3 q$ @            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.color_dir[vote_most(train_set)] = color_set[0]
& E. T6 N3 f! S  n* A  a                self.tree = node

4 `8 t2 }- G  e. g/ W            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
6 e! Q# S# g: w4 v% ~$ H            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
        else: # 普通情况, 构建一个内容为属性的非叶子节点
            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
            best_feature_index = -1
1 Y9 ^' G) i! v, ^& u4 b( \            for i in range(len(train_set.feature_names)):
( c3 C( g# _* s1 G9 D+ ]+ ~                if train_set.feature_names == best_feature:
" H6 c! B: V5 x+ x# N% y                    best_feature_index = i
$ q5 f3 P' l$ j                    break
8 g: ]" `1 y; g6 u! l0 a. ?  r
            node = dt_node(best_feature)
            node.vote_most = vote_most(train_set)
6 t0 p$ n/ r4 g* h6 [0 L" M            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
                self.tree = node
# e1 @; f0 u- e0 \: j! }                # 用于作图, 初始化叶子节点可选颜色
                for i in range(len(train_set.target)):
+ ~8 n3 `+ u7 }                    if train_set.target not in self.color_dir:
3 ]  U4 L: A  v                        global color_i
# }" m/ }, P4 u+ _9 i7 o  A                        self.color_dir[train_set.target] = color_set[color_i]
                        color_i += 1
                        color_i %= len(color_set)

. b: `% z* o+ N. K( [" J- W            feature_range = [] # 获取该属性出现在数据集中的可选属性值
( s. ^" H5 k2 R. i2 ?, l            for t in train_set.data:
                if t[best_feature_index] not in feature_range:
                    feature_range.append(t[best_feature_index])

. R" Q1 t$ j6 I6 i9 i8 s            # 用于做图, 创建一个内容为属性的非叶子节点
            node_content = "属性：" + node.feature_name
9 U. k4 u9 L: o9 \            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
" [. n5 L' K5 J
            for feature_value in feature_range:
                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
$ k5 A: B* S3 }! w1 {3 `                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
                if node.child[feature_value] == None:
0 `# L/ a0 e5 T0 O1 T: {2 f% ^                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
# I# \1 ]6 V! h: `                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
# Y4 c1 K8 P5 H1 R: E/ W4 _: q: W$ Z                node.child[feature_value].parent = node
2 g  W# {8 P/ P5 R7 z
                # 用于做图, 创建当前节点到所有子节点的连线
5 t* L' j7 {# Q/ c5 K7 q: E                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)
+ V& ^& m1 b+ F* k$ R0 E: I            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
            # for feature_value in feature_range:
& s8 O' K) l! {# ?            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
8 Y7 m2 p3 h9 n' R1 B7 Y0 b            return node

) h& k3 x7 I! q7 @, k1 a    # 测试模型, 对测试集 test_set 进行预测
    def predict(self, test_set):
        test_result = []
2 K% ~* M% ]( _* i7 ?8 \. K        for test in test_set.data:
) m& Z/ t7 L: ^# K0 W* ?. f            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
" ^9 O: R6 `0 J! N# b            while node.target_value == None:
                feature_name_index = -1
5 w& e6 u5 D" @6 v# y! T6 q0 F                for i in range(len(test_set.feature_names)):
                    if test_set.feature_names == node.feature_name:
                        feature_name_index = i
                        break
                if test[feature_name_index] not in node.child.keys():
0 \7 n4 }. Y1 R+ s4 ]                    break
6 t7 c1 b% c4 L8 b5 w- P/ {2 s                else:
/ w' l% i1 ?1 b                    node = node.child[test[feature_name_index]]
! ^. l5 z2 ?- R+ n: j
            if node.target_value == None:
                test_result.append(node.vote_most)
& s  {# l/ B7 @            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
                test_result.append(node.target_value)

        return test_result
+ A* l1 h& l% x0 l. P: W0 Y6 @
7 K( i+ P4 a  v    # 输出树, 生成图片, path: 图片的位置
    def show_tree(self, path="demo.png"):
5 v! ?" {" B, T+ A( V0 z* ~/ \        map = self.map_str + "}"
        print(map)
        graph = pdp.graph_from_dot_data(map)
        graph.write_png(path)
- }# m0 u7 O* ~: a8 ~: N
# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
! j( m$ t* r; Y* Bdef incremental_train_scale_test(dataset, label, interval=1):
    c = dataset
    r = range(5, len(c.data) - 1, interval)
7 G5 `5 _7 Z& k( M    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])
; G! ~$ Q& L- i) b7 g        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)
, `; O$ K5 G4 b2 O# Y        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))
, m/ X. ?+ r' L2 H: P1 V  F, u
    print(rates)
/ ]( N( P5 g. h0 A6 i    plt.plot(r, rates)
    plt.ylabel(label)
    plt.show()
9 N1 z! `+ b" T# |/ F, d+ s
if __name__ == '__main__':
5 @( k, F! \) f# Z2 a- g, ~
: b0 a, [* G4 [8 u* A) z: [    c = load_car()  # 载入汽车数据集
    # c = load_mushroom()  # 载入蘑菇数据集
    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
. \! E, g- m3 |& T. m5 Z+ o    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:])

: j# d+ i% D8 e2 b) A    dt = dt_tree()  # 初始化决策树模型
    dt.fit(train_set)  # 训练
9 Y; O5 H/ o' m4 ~    dt.show_tree("../image/demo.png") # 输出决策树图片
% j0 y- a( N- G. I  u    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧
0 \- l8 G, _5 ~) A9 h
    # incremental_train_scale_test(load_car(), "car")
9 t/ R: B4 i3 k9 s: S, {6 t- O) \    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)


) @. D1 A" O- S3 o% o7 W& ?
1
8 B; f. h4 G8 T2
( d6 Q8 P: K- X4 K3
% T5 d/ V: e7 P3 A; i4
* I& T  F6 P  T0 P5
6
: z) Z5 Q8 U7 Z7
8
/ J( B7 J$ X9 x" j9
10
11
12
8 Y" k$ K2 X9 {9 Z( K8 I13
" `: B& D7 C! {+ L% f0 x- q1 x14
15
16
! @7 Q% f) r+ t17
( Z9 Q8 a/ w/ W: [+ V18
19
4 e, F1 o# I; F- u, W  R! D- E20
21
9 i* }/ O4 r" u  _0 X22
23
24
, p( |  l" X  c2 Q# N$ K( K; B7 F, I25
( G7 c2 l4 S  F1 ^+ C2 n26
27
28
7 e$ o  p3 s4 u" \: A5 G7 c- s29
; C' t+ F( r5 d7 c2 L5 P) e30
31
32
# p# `9 B1 o! o( O33
34
35
36
% y# R& N! S+ |- o6 v" I  H) m37
38
  @: m/ A# h2 P39
40
41
7 ^1 N& k+ X' u7 c# H42
43
: ?6 Z/ @$ C  G2 p* }44
45
46
9 M$ z. l% M  c- q  P+ }47
5 K; y: k8 |$ w8 Z2 s+ p48
49
& e" C; G7 M& z( a/ ?1 |# v50
51
52
53
2 @# w: I4 U2 {5 M54
5 J. x& [8 f" B4 s8 \) {55
7 }: H. I/ K* ^+ M& k6 S8 M56
57
58
59
60
61
8 E9 b, r% p4 T5 F$ O: ~; B& V62
8 y: Q, c3 N0 b- a2 j$ ?: L+ f8 n63
64
6 r% G8 r! `# R* l0 e$ q65
) ^* H% @. w% F3 I5 Z; ^. q, \' }66
5 Y6 d2 W+ U* C6 b# U5 @3 ^1 }: u- v  g67
68
69
3 e# B- \$ m4 O* Y0 F. F, _70
3 l. D- x/ f6 w3 w  n7 l  T2 B9 e71
72
0 l0 N/ u# ~1 I& p  X+ b' G% v/ C: @73
$ L/ p* [! A- }74
75
76
' m( S% F( K6 b3 c# g6 I77
78
79
$ J6 Q* e. v0 V5 o, i80
# ~9 S5 |- r5 r5 W81
0 Z2 N. D$ ^- j! D$ I# Y( r82
83
84
3 K! {. R! S6 F5 T3 Y9 \85
0 z2 n# {( L3 o86
8 ^* I7 v% s2 z+ a" V+ `7 ?$ |87
88
, N) G$ {$ g8 a9 i  T5 H89
90
( v, s0 U4 e6 @/ L" q91
92
& Q7 n6 V* m& {93
94
95
1 U$ s4 G; O" B6 D& @: l96
; f  \; h/ H$ E/ N& P97
98
  n+ ~  `4 x8 O9 L99
100
  u/ w) F; }, l6 ~; m0 J101
102
103
! E0 W2 a: d' I2 S+ u+ V4 T104
8 Q* W0 c. \- j# V& D$ H# l9 N105
106
2 f2 u. `" v$ @- S$ t107
! h) D4 u. m! e% {) p# z! w+ ~: x5 \108
109
110
: a" J) m8 n' X7 |$ r111
112
6 j* R9 u" `  v& a& a. N113
114
9 H4 ^# t3 ~1 q6 z6 `115
116
117
5 y3 K! |& x- y118
% F2 n, A% Z2 a1 E" F( `119
120
5 R$ s8 R. Y" y' l+ s5 l, a' u+ L5 ^121
122
123
124
0 c+ T+ E. {; o125
126
4 j2 {- C, j' M' f127
128
129
130
131
( ?! q5 d) E" C& e' v132
' W* K% T( Q1 {% S5 S) k133
% V$ ?' @, S+ h! r6 Q' z8 m134
135
9 ~8 L9 C& L% G4 e3 A1 r5 n136
137
- V3 O* R8 ]) ^- j138
, f$ Z6 V7 L9 W139
( J3 ?  P0 q+ ^2 G140
& x5 I: A' V- W( m141
142
2 |) d# x1 j8 L  h) ]$ C2 x8 X143
144
0 q5 d. {/ r# I, u+ q2 d' L* l+ y! u145
- {! U# N+ {$ C146
; ?, ?& ^& v; R147
' J  n9 \2 A8 ^( j+ G+ Q' K148
149
150
" t5 D- D7 ^' B2 Z. U% |6 z151
152
8 f: e: Z$ y3 s; J9 z) ?153
& ?3 R8 k' F0 G; C$ Z# T2 `154
155
2 l* z, H' G) r7 Y+ A156
157
$ y* I$ I8 |0 j! i158
159
* q! s3 n1 m/ @7 q# i160
161
162
  K- m/ S. i) u$ l163
5 V: q8 O& V0 o$ H( S! Y6 g$ `& x164
165
1 Q' W! e7 p3 x3 p0 k166
5 S6 B' V  b0 Y2 ~  m167
  r- S; Z6 Y5 L+ o168
169
5 {% R0 E) K' P4 x, o* z( N170
171
172
1 k* v7 ^# }# a5 h173
. M: @* c( E' v174
4 J1 D$ b3 v$ S( O7 M: j2 o( e' I175
176
' h1 E  g0 k( V2 i177
178
179
180
" ?3 \1 a/ R) g( v181
182
183
184
185
" F" O3 n) N: b186
187
: c8 }% B7 Z% w4 f! K1 {/ C( h188
6 r! A" c9 _+ C. g! h189
190
191
' N4 _* q8 C3 `) @. q( \- ]192
193
) w- ?  p# Q  {% d! v194
% V& i+ e3 E, t* y" {, w/ v# z5 i195
196
0 ^* @# r" u# k( Y% S' _8 F; ]2 h( h197
198
199
200
' u" m  v4 T3 y1 v1 E% ^201
; a" l/ U5 h" b$ O+ w3 r/ I6 d/ M202
203
204
% k: H. w9 @- l2 A! c% s# R205
9 s2 I& Y: c& _8 O206
207
208
209
210
211
212
3 z. U+ I: b8 f1 @7 k: b  b# k213
214
9 i0 N6 p0 g5 z: N1 t6 s5 ^) _3 Q215
216
0 @7 f: w3 B$ W2 A7 q, @3 a4 ?( y217
218
219
8 A& X- G# E4 F. C5 x8 x7 A220
/ u2 k( G. x- |1 Y: O. T3 l) f221
* I& {  k8 ?' d% [222
* i' {) N0 g5 D) _2 C; A# p( H0 @. z223
7 t4 H, j2 M# N5 I# Y+ S% k224
: P5 ]: [1 D. ~4 f; S. n6 a225
226
$ ~2 z8 p% S: ?/ E. W& D227
228
229
- n0 q" ?4 M) _9 g) C+ v7 C4 A230
; S; o2 H! [& X  {. a% ^231
232
& J- A( p+ @- V! M233
234
235
236
237
238
7 I) x$ Q8 \7 g  o; K/ D239
# S/ b/ p+ j2 A$ X240
# ?1 b* f& P9 }% n  x* j# Z) L( W241
. E7 C) G# b3 U2 v& Q9 B242
6 t0 }3 _, X7 B/ Q, U; S1 T243
244
* J" d- v7 g# b& ?2 A245
246
& e7 o# X# M% Y! w6 K$ C247
248
8 K% K- k( J& [/ U1 f. T, Z  X249
250
251
6 @% \, ^6 x+ U; m4 T252
7 X. o2 }; a- v: C253
254
255
256
257
258
259
4 K7 y, _& u$ G6 d4 g6 I260
3 R1 T# f& E3 X# m5 S8 v* K261
262
/ e% j/ L1 B5 x8 j( t) V263
264
265
0 B6 Q, [: H& j, t! V) W4 `, T266
3 h/ u* o3 K" M8 s0 {' g. n$ D: h267
268
269
5 Q+ k, A* s% g% }! _: j270
271
  O+ L. F/ k! b: E8 M/ D272
273
274
275
276
  P3 q+ R$ d  [9 r" Q& W277
278
279
280
& {9 ?. s% c- c0 d6 n: z281
. a: f4 L8 k: ^282
- R2 M' d7 L& K- [283
284
) D9 C- [5 H) G; i' D285
286
: h+ ]8 P$ I& K8 m. ^& s9 ~% F, S287
# O! s0 f. I4 j288
289
290
291
292
' r; X( P0 [0 Z% i5 A$ r* s/ A% m293
294
295
296
$ |, @# R5 n2 e6 \9 l297
* ], {4 Q0 G$ @6 }298
299
9 V! D$ t6 x& ~( f! |0 r300
6 e: }" Q3 ^! v7 @301
, Q6 w: h( Q  ^302
  h9 w2 Z7 x- V* w, k* `3 w303
304
8 E0 P1 }# M6 u305
) C7 V) O: g) ]) S' m6 h9 e% t& y! m306
# M. f, H6 H. s" H9 O307
308
& O: w' T( q0 ?1 h, \- h309
310
/ O7 r& b% j6 }0 J8 j/ [) Q  b311
  r/ I1 U9 `& g% a312
313
314
& ]7 o# y! M$ E: V+ d9 \315
# [2 y+ h8 |% R0 o& n316
317
318
319
; `- T3 c3 }% D/ T- M# {- q4 L320
321
3 ~$ z( z, N( ~2 S. c* Y, ~322
9 P2 }9 M* \& _  }323
324
325
2 ]5 u* w1 c; T0 F* W0 h326
1 ^9 G. R. o- S+ ]/ ?# T327
328
329
: D8 g, q7 N% q- R4 u% @330
331

& h3 w1 J! L1 N% H; u
, M; j4 L( I+ Q4 e6 k/ p
6 Y% p- v# W; u. E" |- {2 m
% I: F5 m( }. \; L* [, T0 _


4 B% m: p/ s+ l) `. r7 ?


. B# {! l- d! g/ ~0 M
; P# P+ Z8 s" w8 O
8 @; G) b( D- S7 U————————————————
. |4 U& V! c7 h$ S% @* I版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242
$ l; b+ O3 ]! I5 g7 W
/ S1 U* J  V& E# l- o: `) z