基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

决策树模型
目录
人工智能第五次实验报告 1
% Q4 U8 O. K1 F' b6 W2 z" ]' w决策树模型 1
一 、问题背景 1
: I- }) h. j$ G3 P! H/ U  ]( `1.1 监督学习简介 1
; U; w1 c& ~4 `  ]  V' L. u1.2 决策树简介 1
二 、程序说明 3
  n3 ]2 i! m! a2.1 数据载入 3
2.2 功能函数 3
2.3 决策树模型 4
& g$ M" U- m" W9 O三 、程序测试 5
* g! b  F0 Y1 ^) q3.1 数据集说明 5
( M0 S) A# ^% h2 d  d  i; N9 e& `; [3.2 决策树生成和测试 6
3.3 学习曲线评估算法精度 7
四 、实验总结 8
附 录 - 程序代码 8
1 i6 M/ \# q3 H" T/ z3 \一 、问题背景
1.1监督学习简介
机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
$ k! n7 ?- W, u( P+ i2 g- |监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
; J# H4 i( g& N8 I1 A常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
8 b& y1 g4 V' ]  ^$ V1 J决策树的组成
9 }( A2 l  f/ n决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。

import numpy as np
from matplotlib import pyplot as plt
from math import log
# {. l- J3 c( Dimport pandas as pd
( n+ J( x* e  f2 h4 T) P- aimport pydotplus as pdp
0 Q0 n& I! u. c4 g) ?
+ g3 F% {4 _$ s6 P: }6 T7 Q, V"""
2 ?, n' V1 C9 n19335286 郑有为
0 n9 z# g4 z' `人工智能作业 - 实现ID3决策树
9 O4 P" l& |& i% E; ?"""

. Z7 y' W* s+ R, ]1 l. B0 d; ?nonce = 0  # 用来给节点一个全局ID
color_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
color_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
  ^2 e' @6 s# T
' J1 d2 Y0 T3 p! {# 载入汽车数据, 判断顾客要不要买
9 B6 P# q5 `2 ^4 m2 P( d! Gclass load_car:
    # 在表格中,最后一列是分类结果
    # feature_names: 属性名列表
  I, j" {: {0 k3 b1 T    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
) o% x+ s4 J. v# C! E* w    # target: 目标分类值列表
3 F* A- F8 K; m2 c6 f    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
% z& o1 Q/ T' Z) C* d9 J        labels = df.columns.values
        data_array = np.array(df[1:])
        self.feature_names = labels[0:-1]
        self.target_names = labels[-1]
" n8 w7 B0 X# G& u  b( H' m1 L8 @        self.data = data_array[0:,0:-1]
        self.target = data_array[0:,-1]
. ~4 f7 y2 t  l! m: r
4 }) V. M' c+ o1 j0 `8 b$ l. [# 载入蘑菇数据, 鉴别蘑菇是否有毒
3 @) [$ T0 B/ ?class load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
; w; m+ X! V9 P; R4 n8 T7 K( J    # feature_names: 属性名列表
6 [+ z4 L% U' l    # target_names: 标签(分类)名
) ?7 O. \$ i8 |* w  E  A4 g4 g    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
( I1 b3 b. x3 g  ?! C6 F        data_array = np.array(df)
        labels = ["edible/poisonous", "cap-shape", "cap-surface", "cap-color", "bruises", "odor", "gill-attachment",
- q  ^  \5 O' c% b8 H+ g: Z8 W, }                  "gill-spacing", "gill-size", "gill-color", "stalk-shape", "stalk-root", "stalk-surface-above-ring",
( s* o, R, L1 [' S& @                  "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:]
        self.target_names = labels[0]
) K1 G0 B: p" v6 a# ?% Q        self.data = data_array[0:,1:]
        self.target = data_array[0:,0]
% x  n; i/ h" H# h* o
9 e" f" X& S& V. o% p) b' ^# |4 ?! |# 创建一个临时的子数据集, 在划分测试集和训练集时使用
4 q; @" z/ w0 y+ F3 j: kclass new_dataset:
  w7 v: R- X: d) n' N7 ~) [    # feature_names: 属性名列表
    # target_names: 标签(分类)名
9 _1 m& V' J& N, Z" q0 z    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
  y$ B6 ^4 i0 c9 m1 ?    # target: 目标分类值列表
6 e9 I4 h& @, L    def __init__(self, f_n, t_n, d, t):
- ^5 {7 e2 W8 R6 l# S  t5 o! E        self.feature_names = f_n
) M2 |! b9 N  \/ m+ }; t3 m" @        self.target_names = t_n
) g- K; n! k. i$ f# J        self.data = d
1 Y* M, v8 z( O" K+ G7 q        self.target = t
! k8 h9 H8 w5 B. R+ ?. v/ {
# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
+ T% B- N: _! {+ z, F#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
# target: 分类结果的列表, return: 信息熵
def get_h(target):
/ d" E# \# H; y( j: P: f: m5 D* z    target_count = {}
    for i in range(len(target)):
        label = target
        if label not in target_count.keys():
# S/ e+ p! V' e& b: {+ i) Y1 v            target_count[label] = 1.0
        else:
            target_count[label] += 1.0
) W) t, e! v8 d3 Z$ Z  j9 k; l8 m% v, I    h = 0.0
( o- W7 n% R# t. t: G) B' @. i2 x" ^    for k in target_count:
        p = target_count[k] / len(target)
0 B; G# f% C* C$ ?        h -= p * log(p, 2)
    return h
# G& p  K6 n# m$ o) Z* V8 ]8 g  v# a! E
/ `  }# [) `$ ^. ]. J: y2 ]# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
def get_subset(dataset, feature_name, feature_value):
8 f; a8 w- \4 A. O$ H! M# R+ i$ m9 m    sub_data = []
    sub_target = []
    f_index = -1
4 H# R# j9 z' D    for i in range(len(dataset.feature_names)):
        if dataset.feature_names == feature_name:
; Q8 ~- o* J. q8 q            f_index = i
            break

    for i in range(len(dataset.data)):
        if dataset.data[f_index] == feature_value:
            l = list(dataset.data[:f_index])
! j3 ]& }) x( @7 B) M1 y6 i$ g* Q            l.extend(dataset.data[f_index+1:])
            sub_data.append(l)
/ Y! @2 }9 C" z6 a! @            sub_target.append(dataset.target)
2 f, v3 I: O5 Y* H( r" p
    sub_feature_names = list(dataset.feature_names[:f_index])
: {4 U) {9 `' k/ L    sub_feature_names.extend(dataset.feature_names[f_index+1:])
' b, V( ?) q# g- W( b4 u) T    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)
/ a' q" }, }3 O, h
5 r1 o4 u7 M/ b5 c% c( i" _6 B6 b5 G. A# 寻找并返回信息收益最大的属性划分
4 w; S) e2 Y( |# 信息收益值划分该数据集前后的熵减
# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
def best_spilt(dataset):

; Q) D' A1 d5 E    base_h = get_h(dataset.target)
    best_gain = 0.0
    best_feature = None
4 o) i6 w" n) n9 J$ v    for i in range(len(dataset.feature_names)):
        feature_range = []
        for j in range(len(dataset.data)):
            if dataset.data[j] not in feature_range:
' f6 a1 B' _9 E/ D                feature_range.append(dataset.data[j])

        spilt_h = 0.0
' l+ k9 h- f' `* S        for feature_value in feature_range:
            subset = get_subset(dataset, dataset.feature_names, feature_value)
# K) ~; d# T' I) i            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)
9 Q, r( o/ I% z) i& g1 E+ `! X
- }1 {7 ~+ q, M( c4 t/ Q        if best_gain <= base_h - spilt_h:
            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names
8 x  G0 P/ V1 m
9 I' z7 E. T/ Q9 w$ f8 O    return best_feature
* z* o% u( }" ~1 O
# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
- F# v% D2 {0 Y( s    target_range = {}
  O( S' p- K# K& j3 v4 I    best_target = None
. q$ H9 \5 R, s$ Y/ z  B* P    best_vote = 0
" F& O; g& s. e+ J2 m; U2 W
    for t in dataset.target:
        if t not in target_range.keys():
            target_range[t] = 1
        else:
4 ^) E8 N4 n& P/ f            target_range[t] += 1
5 K7 n5 I- P9 R7 O
9 J( T; p; R0 H3 r  ^9 F    for t in target_range.keys():
. c; `# B& m: N  a        if target_range[t] > best_vote:
! K5 M( w# M6 M" h( \" v" `            best_vote = target_range[t]
; `8 J# j* }! Y            best_target = t
' M5 D& k; X* R& b0 m8 E) e
: o+ D6 e. b( O6 O    return best_target
  e! Y0 ]# F2 T9 P) s
2 c" P7 |4 I3 X( |7 i  D" _# 返回测试的正确率
8 s: _  F) w" A# predict_result: 预测标签列表, target_result: 实际标签列表
def accuracy_rate(predict_result, target_result):
  h0 J& Y4 ~' }$ p& z* V    # print("Predict Result: ", predict_result)
* c6 {9 D/ J9 c, O8 J9 _/ ~5 D: v    # print("Target Result:  ", target_result)
    accuracy_score = 0
    for i in range(len(predict_result)):
        if predict_result == target_result:
            accuracy_score += 1
1 `" N$ M: Y$ v% m    return accuracy_score / len(predict_result)

# 决策树的节点结构
class dt_node:

    def __init__(self, content, is_leaf=False, parent=None):
: B9 r" i9 q8 r& I- E        global nonce
' b' v6 @: u# w' f4 f, V3 e$ v        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
% t; u2 Q3 I& }( g0 y6 b# O        nonce += 1
        self.feature_name = None
        self.target_value = None
        self.vote_most = None # 记录当前节点最可能的标签
7 ?  K) x5 m; Z. W        if not is_leaf:
            self.feature_name = content # 非叶子节点的属性名
$ ]: Q% r/ Y$ d" T; h( |        else:
            self.target_value = content # 叶子节点的标签

        self.parent = parent
        self.child = {} # 以当前节点的属性对应的属性值作为键值

& _1 i8 O  D0 I* i% L0 H# 决策树模型
class dt_tree:
0 a. K# p4 \* V, M
    def __init__(self):
        self.tree = None # 决策树的根节点
; Y* f, Q( u* d0 }1 l, I        self.map_str = """
            digraph demo{
            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
; S6 B/ }1 F4 U1 `            edge [fontname="Microsoft YaHei"];
9 k, C& Z9 x+ x: W2 B9 Y            """ # 用于作图: pydotplus 格式的树图生成代码结构
        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值
5 [3 Z$ Q0 f( J! [6 b
) K; p2 S4 l0 q4 |7 G" K0 z    # 训练模型, train_set: 训练集
    def fit(self, train_set):
  v. n/ {1 A* \1 E
+ s9 ^2 d: R7 E        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
. w  F' Q, \& `, t            return None

# S  ^# h. p$ e6 P, n        target_all_same = True
        for i in train_set.target:
            if i != train_set.target[0]:
" r0 B6 C& A# U) X# e+ ?/ }                target_all_same = False
                break
; J* k9 V( k) a- R8 y4 \1 {* ?0 [1 s
        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
            node = dt_node(train_set.target[0], is_leaf=True)
# F' _9 C4 D, k            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.tree = node

( L) F) v' n$ q9 D            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            node_content = "标签：" + str(node.target_value)
6 w$ d  `9 b! ^) {: q+ Z            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
2 h; p( O. v- q' R; S3 P6 p7 h
' K, c( S+ l& M7 i- r! q# I3 C            return node
        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
" w! q: P3 N: ^, i. x7 S            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
) _, |$ b2 o7 ]                self.color_dir[vote_most(train_set)] = color_set[0]
                self.tree = node

            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
1 R" G0 x& }% v$ ]            node_content = "标签：" + str(node.target_value)
  p! _* Q7 h+ B8 a' w; @2 n9 x            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
  h- z0 [7 m5 d6 f9 p" n5 V7 J
1 Z+ J8 w% o% x6 W; x' y            return node
        else: # 普通情况, 构建一个内容为属性的非叶子节点
0 ]; ^7 J( k. c: s            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
+ Q7 L7 c# m& ~            best_feature_index = -1
            for i in range(len(train_set.feature_names)):
                if train_set.feature_names == best_feature:
% N. }) _$ I/ |! l                    best_feature_index = i
6 A. Q; b8 |  J4 m                    break
* {* @0 L6 l7 T. `. P. K
            node = dt_node(best_feature)
( f( z, G  i1 K! W0 S            node.vote_most = vote_most(train_set)
            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
0 l! c; e$ F  }8 j# Y                self.tree = node
; p! P: k7 E! D& x3 y9 d: F                # 用于作图, 初始化叶子节点可选颜色
8 O1 U2 D1 ]& D. G5 r                for i in range(len(train_set.target)):
                    if train_set.target not in self.color_dir:
                        global color_i
5 i* f3 S. p7 v" ~& h2 Y1 K* V; ?2 o                        self.color_dir[train_set.target] = color_set[color_i]
8 {/ H. `. T' I                        color_i += 1
                        color_i %= len(color_set)
7 g3 p6 r5 `# W0 p" d6 u  x+ l/ p! c
            feature_range = [] # 获取该属性出现在数据集中的可选属性值
" A$ C% v+ N+ {7 a8 R( y            for t in train_set.data:
                if t[best_feature_index] not in feature_range:
                    feature_range.append(t[best_feature_index])

            # 用于做图, 创建一个内容为属性的非叶子节点
: Y/ Z  v1 \& d' e            node_content = "属性：" + node.feature_name
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"

1 W+ T4 ?0 ]) K1 C            for feature_value in feature_range:
                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
. M* ]! y/ b2 _; w                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
                if node.child[feature_value] == None:
                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
, E( X  m4 O. L4 x0 _                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
                node.child[feature_value].parent = node

                # 用于做图, 创建当前节点到所有子节点的连线
" c! K9 k% _2 ?7 a                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)
, N* T3 E' j2 X1 C  X# d            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
! R+ q* a/ u! T+ f& w  I, d# z; G: V1 @& L            # for feature_value in feature_range:
            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
            return node
; u0 u9 S, |3 \5 E7 Q. J
    # 测试模型, 对测试集 test_set 进行预测
    def predict(self, test_set):
3 r  C' I  }% Z/ g# d        test_result = []
! {) c0 w* P: ?* M' A        for test in test_set.data:
            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
            while node.target_value == None:
# z- U* M: M9 ~& a) U3 {8 @                feature_name_index = -1
, w0 I8 h; }  R( z' y) Q9 j                for i in range(len(test_set.feature_names)):
                    if test_set.feature_names == node.feature_name:
                        feature_name_index = i
                        break
6 e) B; ]( [, z                if test[feature_name_index] not in node.child.keys():
                    break
                else:
                    node = node.child[test[feature_name_index]]
. s% y9 `' p/ r2 C, J
            if node.target_value == None:
                test_result.append(node.vote_most)
            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
$ W  ]2 A, v& W( x                test_result.append(node.target_value)

( W# @+ s9 b3 V6 b2 |; O: T! y        return test_result
" v, H- W, D3 `/ S  O
4 e% Y6 {+ \! S1 R    # 输出树, 生成图片, path: 图片的位置
. z! B- \* q: i( i% Y5 {    def show_tree(self, path="demo.png"):
        map = self.map_str + "}"
        print(map)
        graph = pdp.graph_from_dot_data(map)
% @! B8 V, g) r3 l+ Q. i        graph.write_png(path)

* n% C2 ]) |, L$ p8 g# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
    c = dataset
    r = range(5, len(c.data) - 1, interval)
    rates = []
) @7 D, y" G5 b* z    for train_num in r:
* s+ F4 H1 G. `& u        print(train_num)
4 u8 e5 R+ _- a; ~! s/ U' v" U        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()
' O0 t( n/ ~: a( Y, Q        dt.fit(train_set)
6 \" G1 j5 H; a) V        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))

7 X$ E- Z, I2 Z    print(rates)
& K' ?$ n2 g6 M1 v* J    plt.plot(r, rates)
    plt.ylabel(label)
    plt.show()

- u+ J% _, g0 `% Z& A1 Y; Kif __name__ == '__main__':

    c = load_car()  # 载入汽车数据集
    # c = load_mushroom()  # 载入蘑菇数据集
3 {7 x5 v; _: V* N    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:])

    dt = dt_tree()  # 初始化决策树模型
9 O0 m% X& o" l3 u    dt.fit(train_set)  # 训练
    dt.show_tree("../image/demo.png") # 输出决策树图片
    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧

2 p6 w! I9 E7 G6 f+ S' X, Y$ V    # incremental_train_scale_test(load_car(), "car")
7 l  Y" R/ z: W: O    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)

4 \# }( D, @6 E
3 i+ @4 }1 ?( B# f) x& K" i
6 ^9 e/ T% ]7 e/ h: f1
# L. ?# o/ t4 V, B; i0 d2
3
4
5
) w: C! _) b  |/ b6
: ~+ y, k, F" S7
8
& y, K; j9 p1 I. H! F9
10
11
12
7 V6 w$ z$ L, d7 B' n  r( w13
1 J% u" S8 R' g6 J6 S5 x3 G5 s14
+ D0 \, F/ [; _" U" T) T* s15
16
6 v+ p. p7 ]  V5 b; |9 k- E17
18
19
20
21
( S# o6 u3 Q+ `& c4 G: p5 e22
23
6 b% X2 L4 @" N2 b1 J3 }24
+ N) P1 h( n5 \' `25
9 L  G/ q5 `# j+ a  r6 {9 r- Z26
27
) n' S" Q! O8 x. n5 a7 t28
" Y( N+ N  v% l. f* D5 J( g29
30
+ X3 Z& q# B: }31
- G+ D0 r& a% U- @" S! {32
/ m2 s6 s, v8 Z8 n, s* h* S& K* w- A33
34
$ J; s9 a2 r& l3 c35
  F% ~. ^; F: z; D! F) K" r4 z36
! P9 s4 J; K9 g- v5 z37
38
' ?( V% P4 s- ]$ X/ G- X5 X! Q39
7 v1 B1 H7 L' s6 m40
41
42
% e/ @8 ~5 F7 [0 z; u# t( K1 F43
44
8 A+ x2 p4 |) h: Z3 B. k& o45
2 f9 R1 I; u0 J4 G5 e4 n+ F+ E* I$ w7 j46
47
- n$ M; T- [0 }48
- Y# O# z! P. A49
! u4 I. {0 o! Z: ~' t! i( `8 J50
3 C( P8 {; `# S2 w6 Z% k% C6 q51
0 J! Y+ A9 g# J7 x5 x52
& R; {$ O) @' g: H' ?  g; Y, E! h53
+ f- r7 _7 {1 x3 b/ X/ c54
% }& j2 F7 F1 @8 W. n, x- l9 y# k, ?55
56
1 v9 t6 R% [2 e2 U) S7 @" h57
58
5 h, s9 v$ k. X$ Q% S" i59
" M7 ?& F0 ~) i2 z8 ~, U% u60
61
1 w$ N: s/ \7 A' i( W: x62
% m. ~8 K) i' b' p9 a  \& s63
9 E' t& Y& I$ D7 u% J# T64
: I3 D( ?. n/ z65
66
67
68
/ O5 |3 B2 z& _69
. `. D9 ~. t+ s+ u! M2 I70
" M! x5 F) W# A- k" L! b9 i4 X& S71
2 |& H5 q% o& m3 t9 ?3 V$ m72
& N" r- q) C+ \9 r# H$ |" |73
0 C$ R2 A- D! X* n74
0 @  N3 {& R; p2 Z8 L75
( L7 g/ I. q# z; h" q76
5 u) S! L* H$ g) p77
78
79
$ M6 I* A' }# Y9 t80
81
82
83
; O: l- J( G! F84
! ~. p+ F( y8 q7 Y85
86
; P2 E6 I3 \2 u. f6 S% ^87
88
89
90
91
  z5 R  G0 n( e, B* a! s. Y* S6 v4 H92
93
94
95
96
0 }3 w! X- j5 x$ y% E' G% x97
98
99
100
101
102
103
104
) n$ S) b2 v" O. m+ w& k105
4 \0 o& \3 g6 X" [4 R106
107
7 L; q- J# ]% u) B& m' G108
" M( q- ^- R/ N109
110
6 i1 Z3 v  V1 B: K6 X& q3 }, F111
$ z) s1 C2 C% y' W# W112
  z* R( w* M; F5 g1 M4 \% L113
114
4 a0 Z! t+ x  h3 V115
116
117
* a9 `6 L2 t5 U. s" L; Z7 n& d118
4 N4 e8 \; }( X) o) }  z9 p119
120
121
122
123
4 Z- c) {/ Q0 \9 y124
125
126
# p+ t; _6 [& g- l" H127
128
129
$ Q( m( V. ]0 j( y0 |- R130
2 z7 {1 {1 D5 r# Q9 ~  J- _131
6 J' r+ F$ {+ e  v5 m  q6 I132
3 v! _; F* L9 j: h: A133
134
135
" \% s, r; ~0 q* R136
- ?3 ~. G" [0 z& Y! S: m137
138
139
# Y2 W( @  q* u# w. f5 Z7 b140
141
142
8 x% _! u% j7 W' q% Y4 D% {143
- G7 X4 N& N( ^: V( g- h144
' A% F: ?" _3 s6 `/ e# u# U145
& J- Y8 U# O$ ~) r146
3 ]$ n+ E1 w) n" o! h. h147
148
149
150
151
  }( w: Q1 }' q152
153
154
155
; x$ {* A  k& n7 q156
157
158
# k- D% e/ x3 E* p: B159
160
161
; j: P" H5 |& b9 Q) a& ?; n162
7 w, H7 `6 S/ u4 {2 u163
164
165
166
167
; J" u: g  ?6 a168
5 k, f7 ~/ ?- k8 e169
7 _- {- V" j. v% {4 t170
6 K# Q/ x( \! \8 r171
3 t/ ?$ e! J) [6 U9 L9 X172
; w; ]& z2 b: F% q. f3 e5 N) x* b# }173
) L! |% {5 [4 e9 L  A& z174
175
5 p4 K+ ~& j( o8 |, [) ~$ L4 n3 x176
177
0 B& i1 l  \4 \2 B# T" }178
+ Z8 o) N$ B5 a8 `6 l- d- R- \179
180
! U- t: r+ R( W3 p  l$ W181
- [+ Y  g9 g6 S7 m182
3 O+ ?; A  g  R3 \; _" y183
184
4 g7 y7 ]6 @7 S5 z( r185
; F9 C$ S9 R* t5 |. R) t3 q186
: I7 q3 K6 l: q  a; D/ e0 }; I187
. _7 e3 `7 q! `6 w188
2 _: k% X1 s) o189
190
$ U, x3 O) k6 f3 B) s  U191
* L4 V$ t+ {# b: J/ o192
2 H) b9 j# S& D: f& E% \193
194
' @4 b( Y  X% k7 g* P& z1 U. e195
! z% o3 O& }3 R196
197
, [3 l, ^: T; a$ b9 `. H198
1 t/ Y& W6 m' H" I3 m! J% N199
! Y. X" n3 O$ c) ]200
3 q/ p: c3 h, m: \201
202
203
204
205
206
, |: B5 H# x! B! }# d. L/ b2 Z207
208
209
210
211
8 i( L) v& }5 V212
6 ]# r' U$ O* `6 O0 [# `213
, O! f- i) L+ a3 i" F1 O* C! v: z214
+ ]. h/ X* p, K# N& G$ Q215
7 @( Y+ {2 o0 C1 N2 X, t7 B4 Q1 k216
217
218
& \5 l7 y+ i! s% _! Y7 H( L219
220
221
2 J6 P+ j9 k. |7 \) {222
9 Y1 N7 t- C; z; V: M5 O223
224
225
& {9 d# U8 Y( G$ L226
227
1 i$ k" {8 d% O4 h$ n# Q5 W4 }: Z228
229
; j, c, C$ ^7 D1 h230
231
( S7 b4 N" ?. y% U# m232
6 d% W5 Y) h! U; E8 w1 U233
234
) k# b  N) S9 w& d7 z3 q235
236
237
238
239
. q1 ]$ h2 p, _5 A; m240
241
8 J* |6 `, k9 l+ g0 O% `/ `242
, B: E6 R, b( v0 N6 }$ E/ ^/ b243
244
245
246
- G+ y/ c" ]6 Z247
248
249
4 o" S  F* f' e% F' b3 Z* l6 v250
2 Y1 ^. L  K. r8 z3 N5 }; d* p251
252
) L4 P9 {0 k2 G; l: q! ?% L9 i1 O253
254
/ ?7 P5 |* L; @3 w& c5 B" Y2 Z255
256
257
258
2 Q  ?. L( L* E2 c- L& J0 `/ G259
260
261
& }( U% j( o  c- _262
4 @* F5 k! \# J4 u263
; L& h3 R$ E' N" I264
/ e1 \1 k9 ]. {! @* L265
8 A' Y  s1 _( k1 Z266
267
268
269
! e. Y% F7 C) K0 R/ [+ D270
271
. ^: ^/ b9 j8 T( W272
273
274
275
( f! _3 P" ~+ ~276
) M0 z- G2 \# I( U1 P9 f277
8 n& D0 m/ {) G278
279
" V6 ^0 m% R2 ^: q' W5 t280
0 \' K/ {3 m2 k  ~  I3 x281
& F* n6 s, a) E; P2 O0 A7 ~282
4 D6 x6 u1 I8 J283
284
285
/ \& a) J' S" S5 ?. M" K7 H) b286
6 d8 x8 ~1 o+ p' A8 M: J; l287
6 V% x( \2 G9 f- U4 ?  l: E288
& A) l4 u$ B8 a, |289
8 ~+ I9 M, W, ]3 c290
291
( I& S" C- g/ x9 {$ k0 j9 B0 R4 z292
& Z$ `# ~" k) o$ ?  R, L! S  n8 _293
294
% z  A4 d) k- Q, C1 h, j, t295
. i" v8 G- |) @3 R296
297
298
299
300
8 U. J; G, I- |: X. n& X) b9 G! E301
+ n$ a! v" T8 i1 u  S302
303
1 Q2 b- W' b6 S* \( u304
305
306
307
2 R5 ^9 x% t! K5 a308
309
, J% J# |6 r- g/ @7 k. }310
311
; t. a; V, i& T7 }5 R; y312
& ^6 I" F/ J; r6 C; K1 G313
/ a3 w( R" n  b/ J314
& I, c" Y' _  {4 v7 V/ N& T, Q315
316
317
318
7 y+ v' T  \' t& N' o3 ?319
320
321
322
2 K( c" j9 H% x% l3 W- C# o323
: _0 X1 A4 e6 _6 w0 k0 y$ S324
325
326
327
328
2 q: ?+ E2 f: @: v6 P) w329
, `$ m% [8 v. L/ ~6 K330
3 k! p0 H2 ?% W# w, s" T331
6 d; g: z' l, K# o9 G7 |
" Q% F$ ^& ?4 H
0 [) N% i! L' X

) f4 j  t% n+ P4 k

' _- }0 f! n/ y9 \5 n8 s+ i" ^
3 ]0 i, F1 s: m" z/ w

, f' q1 Y) |) _% l


! U+ M* r3 c; W5 ~/ w& S————————————————
版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
; J; M/ T" i; h  o2 Q. m$ p原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242
* [+ Z$ n9 r. K1 w  g5 @6 T% F