基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型
" j4 ~( l3 U( Y3 g& d2 ?% _/ P
决策树模型
$ e3 j* J9 z* R( ~3 i0 |+ _目录
) [" F4 d8 w- b# j0 D人工智能第五次实验报告 1
7 a& V, O. O3 u决策树模型 1
' Y' }1 w! w; K( H一 、问题背景 1
2 [6 A9 T4 x& b9 y4 k1.1 监督学习简介 1
  j6 b+ C( [/ `. h' _  [1.2 决策树简介 1
1 M: a6 G+ c/ H5 o$ O9 e. \% q二 、程序说明 3
, J: ]5 S4 v4 Y9 `! z4 S; j2.1 数据载入 3
2.2 功能函数 3
2.3 决策树模型 4
三 、程序测试 5
3.1 数据集说明 5
! i5 G. Y& u9 ?+ k9 Q9 j3.2 决策树生成和测试 6
7 P- f) C" i( m9 W3.3 学习曲线评估算法精度 7
4 s/ h8 n- D# A# F$ C$ [% z四 、实验总结 8
" E  ]( n+ |# d- W! p1 E附 录 - 程序代码 8
" ~/ ?0 _! ?8 R" ^一 、问题背景
1.1监督学习简介
机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
' k6 g7 L- Y$ C# X4 ^' r  [监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
  a7 Y9 Z& W# n& u: |1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
决策树的组成
3 z5 S! D- r# E6 x0 H+ }; Y- M" l- |决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
$ A: W# r0 X# z
import numpy as np
2 M5 f* D8 V9 F* V9 w0 ?from matplotlib import pyplot as plt
% z* v1 a$ ^3 w( J/ y+ c( I) I1 g2 bfrom math import log
- e/ g) U* Y  L( A# z2 k8 dimport pandas as pd
- z) d* t! o" a3 N* O9 x: mimport pydotplus as pdp

"""
  ~1 u2 [$ N$ S: O+ N% P2 b' C9 F19335286 郑有为
人工智能作业 - 实现ID3决策树
: x3 o5 E# C' o6 ^5 M2 R; K"""

2 `6 j% W7 T# r. S$ {+ m- |+ Vnonce = 0  # 用来给节点一个全局ID
, ?5 K( h  j+ T: y. Kcolor_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
  M) J# f  Q% P) t% o  w9 c7 w  Dcolor_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
) m( @$ H+ b1 W' @* Q
4 ?8 e+ Y  O% j; K" d# 载入汽车数据, 判断顾客要不要买
" x2 B0 S3 h/ `. L2 _1 Eclass load_car:
    # 在表格中,最后一列是分类结果
    # feature_names: 属性名列表
/ z. S: t8 a8 m/ d. {! O    # target_names: 标签(分类)名
( q9 `% @) q( q: g' K: h- Y0 L( ^) F    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
* \; R1 `1 A, y        labels = df.columns.values
        data_array = np.array(df[1:])
        self.feature_names = labels[0:-1]
        self.target_names = labels[-1]
& w6 I2 p- F' _7 v, b# [+ B        self.data = data_array[0:,0:-1]
' ^; m" F& T' K' i4 `! ^        self.target = data_array[0:,-1]
- o. ]+ [* r5 L( v) G
# 载入蘑菇数据, 鉴别蘑菇是否有毒
' n5 A/ g' r3 S; G4 J) u  Q# I6 Kclass load_mushroom:
0 e- V4 E) l- s1 f8 Z- `    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
    # feature_names: 属性名列表
2 a- X3 K* d2 S* c! C& _4 b    # target_names: 标签(分类)名
) v" B, n3 q7 k' l" a    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
3 W5 ~7 r* J6 [1 {    def __init__(self):
0 J% v: v5 B% g7 M        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
        data_array = np.array(df)
        labels = ["edible/poisonous", "cap-shape", "cap-surface", "cap-color", "bruises", "odor", "gill-attachment",
+ z0 G  d/ g7 g, w                  "gill-spacing", "gill-size", "gill-color", "stalk-shape", "stalk-root", "stalk-surface-above-ring",
& g2 ]6 E) U- ~- ]                  "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"]
7 i; @7 U, e- t  |        self.feature_names = labels[1:]
6 S. k4 }1 U* K! `        self.target_names = labels[0]
        self.data = data_array[0:,1:]
+ x& r2 j  `( v3 h        self.target = data_array[0:,0]
+ G" Z. p3 x$ ^2 p, m0 X
/ X7 `% t5 V  x; L# l% @( L# 创建一个临时的子数据集, 在划分测试集和训练集时使用
class new_dataset:
8 Y5 }7 \6 \: _7 H( I    # feature_names: 属性名列表
' o# q. D, w3 h    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
4 M3 a5 X# b; P  S        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)$
+ X8 S( |7 V- O  L: ?. Z0 X#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
9 k# J( E; z& Y) h1 o# target: 分类结果的列表, return: 信息熵
def get_h(target):
+ t) q0 e6 |# ^& \    target_count = {}
    for i in range(len(target)):
' l$ W$ b2 D) O3 f        label = target
9 J0 n% e  I( ]9 R: e        if label not in target_count.keys():
            target_count[label] = 1.0
        else:
            target_count[label] += 1.0
    h = 0.0
    for k in target_count:
" _- r1 Q; ?7 s5 j) z        p = target_count[k] / len(target)
        h -= p * log(p, 2)
    return h

% P9 u, _) D- \1 t' @9 k4 p* @) p# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
0 @0 J0 ~! F9 k- s7 \) y7 Z$ cdef get_subset(dataset, feature_name, feature_value):
/ b2 D* ~) ]! T3 D1 p    sub_data = []
. \6 T# \+ @6 d! S& W    sub_target = []
5 S& S4 M* a: E& {5 c    f_index = -1
% g! x  k9 m2 a3 w+ S: s( F0 Q    for i in range(len(dataset.feature_names)):
& c" S( V0 u1 F) D& q, w        if dataset.feature_names == feature_name:
0 T' O4 p* R' ~6 V2 I: q            f_index = i
+ p, s+ g* O' \9 b            break
5 Y' A. R$ G1 h' S# z! w# k
    for i in range(len(dataset.data)):
) ?# c. u. q" X. d! f  P        if dataset.data[f_index] == feature_value:
            l = list(dataset.data[:f_index])
4 q: T8 v" K' P, X/ u- a6 a            l.extend(dataset.data[f_index+1:])
            sub_data.append(l)
            sub_target.append(dataset.target)
" ~. c! H0 v% }1 z
    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)

# 寻找并返回信息收益最大的属性划分
# 信息收益值划分该数据集前后的熵减
# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
" w+ r: C( X) u7 `* s& `def best_spilt(dataset):

% s, i  X9 K' t# v7 _) U% Y    base_h = get_h(dataset.target)
; R5 |5 |- ^  M0 U$ T    best_gain = 0.0
) H- s8 [/ p& s, p3 R' R    best_feature = None
" }' G. Y' e7 \2 f4 D  {5 r3 q' E    for i in range(len(dataset.feature_names)):
        feature_range = []
' W9 j% I( B6 l. p/ ~/ Q5 Q        for j in range(len(dataset.data)):
            if dataset.data[j] not in feature_range:
                feature_range.append(dataset.data[j])
6 y: D; Q& N" N: Z
        spilt_h = 0.0
* P/ ]0 w/ j; Z( L        for feature_value in feature_range:
( U) o7 e- x# r6 C            subset = get_subset(dataset, dataset.feature_names, feature_value)
* P6 {% u& D) h! s2 c' E; s            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)
" \( d. X4 z6 k6 ]
        if best_gain <= base_h - spilt_h:
% f6 j& E$ z7 g# }            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names
) p, I8 P+ U6 V4 V
    return best_feature

# 返回数据集中一个数据最可能的标签
/ e0 c; g. k. W& f/ qdef vote_most(dataset):
4 z7 j. x6 z$ x6 f+ Y    target_range = {}
    best_target = None
$ Y: k9 P/ E( p* ^' Y* N    best_vote = 0
: i) Y& R* |% D+ \3 z" v% o
" T$ G; S% p  T6 e% y" X    for t in dataset.target:
        if t not in target_range.keys():
            target_range[t] = 1
3 Y6 o* a7 W- j5 t+ Q4 I1 J, ^        else:
( G9 \3 @+ S* s% z7 y/ G            target_range[t] += 1

4 ^: G  ^2 a8 ^: x  s6 [3 w    for t in target_range.keys():
% y) k* S/ A- g; W" n% v3 e        if target_range[t] > best_vote:
- q2 {) |& q1 [0 ^# l/ Z            best_vote = target_range[t]
            best_target = t
3 b9 e' m. p, x
    return best_target

# 返回测试的正确率
# predict_result: 预测标签列表, target_result: 实际标签列表
+ x* @; P3 U1 U7 k+ tdef accuracy_rate(predict_result, target_result):
    # print("Predict Result: ", predict_result)
5 m6 P( R  R7 u; T    # print("Target Result:  ", target_result)
    accuracy_score = 0
    for i in range(len(predict_result)):
) Z) |' P5 B. ]8 P3 D/ W8 {! F        if predict_result == target_result:
            accuracy_score += 1
    return accuracy_score / len(predict_result)

7 O. p, @: q8 p# 决策树的节点结构
class dt_node:
; |$ W# l5 P" ?* m/ Q* ~# O+ c1 O
    def __init__(self, content, is_leaf=False, parent=None):
7 d( d! x' \, d" }1 e        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
        nonce += 1
1 H9 Z% m8 K( I/ t+ x        self.feature_name = None
( }/ S4 y: W2 t6 [" N- k        self.target_value = None
        self.vote_most = None # 记录当前节点最可能的标签
        if not is_leaf:
            self.feature_name = content # 非叶子节点的属性名
        else:
1 i3 Y2 k/ x7 D) ]9 j: r7 ~! P            self.target_value = content # 叶子节点的标签
9 }. N# [: R  P. c( f1 |
( c4 u# J  J! x) e9 b        self.parent = parent
/ {+ B5 n$ O. V7 B        self.child = {} # 以当前节点的属性对应的属性值作为键值

# 决策树模型
: f; r4 x& ~' p. ]class dt_tree:

    def __init__(self):
        self.tree = None # 决策树的根节点
5 g1 U* n# y6 R! O! a+ C# L        self.map_str = """
            digraph demo{
            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
$ ]. p- a! r. I# b0 W  Z            edge [fontname="Microsoft YaHei"];
            """ # 用于作图: pydotplus 格式的树图生成代码结构
        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值
/ x* ?) c( N6 r- {' P5 `
    # 训练模型, train_set: 训练集
9 o4 K7 Q0 }. z) m! V, h0 ?* v/ a    def fit(self, train_set):

        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
! `# \* O& F! Q7 D% @2 R) X            return None

" E8 r  s3 m# q8 f! e        target_all_same = True
        for i in train_set.target:
' h+ n7 D+ [4 o; t1 i            if i != train_set.target[0]:
  |, o3 T. U) o% H; y* V& |6 ?& y, C2 {                target_all_same = False
2 W$ [; a1 T/ L, p) |  Z$ T                break

        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
            node = dt_node(train_set.target[0], is_leaf=True)
+ B8 Y- k$ V$ T) ?( f            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.tree = node
8 @% t8 s# ]9 e( W: G  S- t) {
            # 用于作图, 更新 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"

3 D7 ]  L/ H1 R7 A            return node
+ q. X0 O  @7 L% i5 ~* H        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
+ f5 [' N/ `. V; Z. }* D            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
/ F5 }, O( @9 V7 n% }8 v                self.color_dir[vote_most(train_set)] = color_set[0]
* u# R0 P2 O: e9 F                self.tree = node

$ @3 r; _. d  Z9 ~2 `            # 用于作图, 更新 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"
* ]4 h) r) Y6 z, j0 E4 C; W
            return node
        else: # 普通情况, 构建一个内容为属性的非叶子节点
& n1 c0 R7 @1 O  h/ B' C/ d- r# P            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
& {  J, y9 w# L            best_feature_index = -1
' x, b* F% w; o            for i in range(len(train_set.feature_names)):
                if train_set.feature_names == best_feature:
$ ]9 h8 a% s7 Q! P                    best_feature_index = i
/ ]- F0 F/ O/ t                    break

: g6 Y* E2 |, ^9 |7 `            node = dt_node(best_feature)
, A% I. F( _. G$ a( o$ [; w6 H            node.vote_most = vote_most(train_set)
            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
3 R, |8 ^4 Z! v7 m                self.tree = node
2 f0 M( z- y! f% x                # 用于作图, 初始化叶子节点可选颜色
' I4 h' Q; r6 ]/ d7 T; X( J                for i in range(len(train_set.target)):
  o6 t/ t5 H: Y                    if train_set.target not in self.color_dir:
8 r& |+ c0 O$ A8 F( k                        global color_i
                        self.color_dir[train_set.target] = color_set[color_i]
                        color_i += 1
# _- ?! Q6 r0 @4 s                        color_i %= len(color_set)

. H  W( F7 u2 J- p) C  S/ u            feature_range = [] # 获取该属性出现在数据集中的可选属性值
4 o5 S! D" `0 e1 Z            for t in train_set.data:
9 l) n4 G- \+ w9 |" I                if t[best_feature_index] not in feature_range:
9 h! s2 a% a- l9 Q' i                    feature_range.append(t[best_feature_index])

/ H7 F4 d" D3 T! B. q4 h            # 用于做图, 创建一个内容为属性的非叶子节点
+ `! `% q0 c) q" _            node_content = "属性：" + node.feature_name
% o0 \! e3 r8 k+ ?+ `" t# K1 F            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
2 D* E0 k7 J/ ]/ a- k
            for feature_value in feature_range:
  j/ u1 s* h3 M  i' @1 T                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
, H; p$ p, B+ s  s- R                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
: t  ~! i8 o. I; K5 U) `                if node.child[feature_value] == None:
                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
$ t7 q3 L& }# _3 h4 P4 q                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
                node.child[feature_value].parent = node

; e3 Q! K- g# T8 n5 q) L3 A                # 用于做图, 创建当前节点到所有子节点的连线
  w. e8 K) I: p* A4 p9 }) \" r$ a+ P  t                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"
9 K" w6 B4 z2 P( C: G
" e" L+ E9 n& l  U1 ^& o            # print("Rest Festure: ", train_set.feature_names)
            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
" u% @; L3 |7 \            # for feature_value in feature_range:
# n& r# `& d! n9 Z" [7 r8 C1 _# [            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
1 p( s( Y, \" r8 u# A2 I1 L; _0 i            return node

" C$ q) x5 G( ]8 `- [    # 测试模型, 对测试集 test_set 进行预测
    def predict(self, test_set):
        test_result = []
        for test in test_set.data:
8 S: x  W0 E) E& `            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
6 j/ y5 L* e9 j            while node.target_value == None:
1 e9 g# F9 A0 U* O  `! J                feature_name_index = -1
3 ]( O* H! G7 C* x$ G8 G& O                for i in range(len(test_set.feature_names)):
1 K' C  J* v- g: ^                    if test_set.feature_names == node.feature_name:
1 E6 D5 J, l  [3 |5 M                        feature_name_index = i
7 w7 J6 M' G7 t                        break
5 R/ D) H7 e9 f                if test[feature_name_index] not in node.child.keys():
4 N) S2 b! ^3 g" s7 W+ s* I" a9 U% u4 r                    break
                else:
                    node = node.child[test[feature_name_index]]
2 w$ f9 n2 V7 \
) D6 ^# A8 x2 f+ `            if node.target_value == None:
                test_result.append(node.vote_most)
8 C7 o7 q0 V5 B* r, R            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
                test_result.append(node.target_value)

7 C) c6 U2 J# h% L        return test_result

    # 输出树, 生成图片, path: 图片的位置
6 z. d7 J6 @: s7 ]: B8 y    def show_tree(self, path="demo.png"):
        map = self.map_str + "}"
        print(map)
        graph = pdp.graph_from_dot_data(map)
        graph.write_png(path)

# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
8 r/ V, A9 q: R7 B( B    c = dataset
    r = range(5, len(c.data) - 1, interval)
3 |. e" Z/ r; [    rates = []
    for train_num in r:
        print(train_num)
! u$ [  N1 t6 M1 k& N$ v        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()
8 q2 M% W, J& e3 C6 E* M% g- r        dt.fit(train_set)
        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))

    print(rates)
- Z6 \; Q( H9 K4 H& V. i    plt.plot(r, rates)
% b9 C  J7 W3 h% U( [3 \6 @    plt.ylabel(label)
    plt.show()
( U; i- e2 D+ x
! y/ q" }4 B8 v4 g0 ?$ R  mif __name__ == '__main__':

0 |( M) G. g+ u  m    c = load_car()  # 载入汽车数据集
. S# r0 S/ J* [& \6 x4 O* |    # c = load_mushroom()  # 载入蘑菇数据集
2 m5 y' t$ k, H6 D, {    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
' A* s' F% E1 A    train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
& S0 `, I9 q* V' Z+ l0 x5 S    test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
: f5 u1 I  f; y% {7 |
% ]. [& X8 x' ~    dt = dt_tree()  # 初始化决策树模型
, r, q. ]) O0 ^    dt.fit(train_set)  # 训练
8 ?: Z5 W/ n  }0 G    dt.show_tree("../image/demo.png") # 输出决策树图片
    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧

$ S& g- ~  {) H, m    # incremental_train_scale_test(load_car(), "car")
    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)

  H2 ^: I. j/ i+ `$ t

5 L9 [) v4 Z# `: [1
2
3
4
5
6
7 x6 h, z' p+ @7
* \, a; \0 Q7 X  Y4 X' L: o  X8
. T! N& V* b! y( f! L4 I9
10
% \, p9 y$ J. M# z- h11
' u# [- a& D1 j" g" c$ l* W12
13
14
15
2 L5 N7 P+ E" b- A16
17
18
$ L" R& H! R! l5 `7 w2 s19
20
* T6 L( `0 d6 V21
( k1 C2 `  Y$ v% U8 Y5 Z% `! x22
23
+ r. \0 L: O" Y4 j/ ]24
25
26
1 Z6 p- |6 C% y: H27
/ Z/ b# F  c5 ~) }2 P28
29
1 O* \7 A+ r$ w0 ~" E# ]9 U30
/ n& n9 ~; E% I: o31
' o/ s8 J, f+ n1 N' ?5 [" R32
33
34
/ R& M& u2 g9 I35
& J& B. E2 S# ?2 w- f36
37
38
$ {1 ~2 R) j9 B3 D, F4 y39
40
9 E* o  Z- D, M, X41
42
43
$ f! A) U1 L  x$ c; T3 |( y44
45
46
4 w" e( e' t/ p$ R. Z4 t& U- ^9 n47
$ N. I. P2 J5 T& p/ t' v48
49
" ~$ \  C5 F; h( s9 h, Z- J50
51
6 h# s* ?* a% c. u6 r52
53
54
7 U! A7 a! ]( W# u" ]5 Z55
56
57
8 O- `4 Y; f7 b8 L58
9 ?* L  o7 {9 K+ A59
/ K+ i3 c- {* j9 g! D60
! y* ?1 O$ e6 e9 b. _- n. h$ J  K9 r* n61
62
63
4 T2 C1 O5 ^  I! K64
65
66
67
4 `# H* K! T! g6 U68
69
$ G! ?' [5 X) \6 Z' m70
71
. E) ?1 H, j/ E9 |72
2 A; M" I7 o: m73
74
8 F4 h6 f. W/ ~" U5 X75
2 ~* L1 x8 z" l4 h1 j2 V5 e76
77
78
) Z1 R% h% i" X6 z# t79
8 B6 F7 u8 y: s8 Z% f& R/ [. L80
5 _5 G: n2 D: O! A# C0 F81
82
83
84
85
86
87
88
89
90
91
; V2 Y( A+ H8 L+ k1 R92
93
94
3 b- Y6 b# ~9 C0 P, R* ^) z95
96
97
98
99
100
) V( N2 U% C" K3 z8 ]" ^101
102
103
: ], q8 ], _: I4 q4 P104
105
( S7 G3 d: S' C7 M106
107
. d1 R7 V- A/ C+ b$ D108
109
4 G  e4 C' g( x; d110
111
6 F9 T2 t5 `$ [9 H( z( _112
113
114
115
1 U; e; B/ a' C; q116
117
118
, p4 `; n+ b$ K  n& C  H5 z# l119
  I3 V! n$ P5 V& y* C120
121
+ O4 a0 e9 \7 L1 W122
123
7 `% E" D3 W- s4 N& @124
( T9 d. v# y5 k" ^125
126
127
0 _# i6 d# Q* J7 |128
129
130
) U( V, B  S: \' V+ p$ Q131
9 o0 D/ \4 N" f$ V3 E132
133
134
* f* V; A& i: U+ }) @# Y135
8 w; c, Y5 @3 Y8 r9 Z5 q7 a136
. D: k. H% ]) l, U- ]& E137
# d: L9 D( s& u; h5 G. ^( |138
139
140
141
142
1 v6 p/ t7 B% F/ j; H/ l+ [3 N0 m143
) K' ?2 G" R# y  d144
145
146
2 n' N- [; w$ ]5 d$ \% j147
148
149
1 S+ U, y5 C& b. u150
+ s7 X4 y# }$ A8 C  G1 I9 W0 o151
152
4 c) N) M) |% k153
- N1 x4 |% c1 W2 ]" b154
155
156
157
& S' _- Y- j' g) D5 n2 a- q/ K5 C158
159
3 V$ s; g! y' h/ G& N5 }160
5 T: q/ ]7 I, X2 }/ |161
; E9 V9 ?) O9 C' R& e162
% Q0 R5 N2 Q7 j163
164
, C, u. Z% _9 a( E* k4 b" D7 x165
& n) m7 o9 {1 K$ V9 _166
0 S) D; q/ ~3 P: K167
168
169
170
171
172
7 a6 z+ V5 y2 h, P$ o1 i1 l- r173
: X2 C5 F3 x' M! W6 T( Z; Y' ]174
* D5 Q7 Y$ k" A5 ]175
" }  ]4 r$ |% \176
177
178
6 C' O/ S5 h1 v/ ~0 T0 y4 E5 D179
8 B' l' x6 a$ t180
181
182
. B% Z5 N3 W1 g! X183
184
/ b* i+ n: w: T4 G2 b: v8 P; H( O185
186
187
188
8 s& P0 x* q# _4 B8 u189
190
: I- s! S1 i" @191
; V/ p, Q8 U6 I$ r6 O1 C- T8 d" Q! C192
: s4 Y4 t" b4 Z5 L4 G# D  [1 o193
194
3 T: n  ~% @, d! c* |$ }195
4 x9 x- @3 ?" T: d- D& X& ^196
3 c) n" [- E2 C5 S197
198
* q2 g  G+ Q8 J4 C199
, ^3 _) f# u& x7 }4 n8 y200
201
% T2 S) B& x( i4 p202
203
' Z3 s2 O+ y% x' K' [- \204
0 O0 B; K+ N6 p' `205
& |, i6 V" A8 H% k" C* [# w; M" k* o206
2 Y# V" d2 n- V+ l' L207
0 t4 a3 i% W3 y) b0 J# f" R- H3 l1 X208
* m6 c9 Z, e7 c# v/ U209
210
0 `& ~3 j5 X3 u8 C6 R211
212
/ t3 `% t% }5 @& q213
4 d" Y8 [9 O3 F7 f214
215
216
5 W! N( V, f. A% `* N6 j  N217
218
219
) {2 L5 }" T  `( \- c220
221
222
% R& J2 @! c7 u2 a223
224
5 N& A  @4 T# f225
. L! m# \0 S3 Y4 l4 G  A7 l! T0 _226
+ M7 [$ `) m5 ^% t227
# s8 }  ]- `' c: M0 ^228
+ ?  m8 h4 R; o5 d229
$ k$ z7 R5 l7 T230
231
9 m- Z0 ^  e9 ~; ?8 D# O232
# @/ F4 o  P7 P  P7 ~233
234
5 B' {7 n: q) u% N235
236
237
238
$ p3 R- c7 Q& v( ]239
( _' f' X- N  x240
% K# z- i9 V% ?" i0 l4 N241
242
243
: q- ?2 A5 T! k# i3 q! @" b( ^/ y244
245
246
247
* k2 q3 U) p  B2 q* ?$ j- O% z- w6 [( j248
4 A* `0 I$ h* I; ^249
0 }1 d$ Q' y+ j' E3 C250
. ^1 B: o: c' k1 ?, A* j251
252
, Y3 ^7 H" m' w, S) E253
254
4 L3 F3 v0 U# W3 I255
256
257
) a* X3 Q6 p, G) l- j- F# z258
) q: @! d4 s- g5 y. ^. g259
260
3 a5 X/ F! O  ^! J: r0 i0 z2 G261
0 t- J  o) @0 B5 n262
263
7 N7 U6 {$ i! v: s; a* L, G264
" ^2 s4 q! \- V& D( n! `265
266
+ n1 ~6 ]8 B4 g+ h# g1 Q2 R, I9 _0 |0 @267
" u: w: O* O3 B# X. S268
0 |6 Q( S  j6 p; Q- f269
( V( g; |6 g6 h$ Y/ M" `+ P270
271
272
9 z* f/ n( L$ Z$ X# Y: i) l273
274
275
) E- d  B3 A( [' E276
277
278
: K/ {: ^# T! t% A. `5 R% O279
280
281
282
283
2 [4 K  O" j4 R: r! u: z284
: ^% V( Z. F& `. v6 c285
9 u6 f, X0 U# t6 s286
287
; l  y( a- L( u0 V) D288
289
290
* @  h) v, ?+ p8 b: m291
292
* Q* j# D$ W- f293
3 t! d! w# [1 O  t. r294
  E; \+ V1 K( J! F$ Y295
296
297
5 R/ V. U1 A2 d' H& h/ M: L/ _298
299
300
6 ]$ V+ D% ~6 Q5 y9 z301
302
303
  |! T6 x) s3 P% K( q9 [, h304
305
306
307
308
* y) f; }7 V$ [309
310
311
1 E2 ?! Y% V$ N) X1 i3 O) T312
313
314
315
2 S- U8 G* E: `2 z316
317
318
319
320
321
; ]: A/ @& B" K8 j" @322
' {% s  S/ }, p1 S323
# V0 Y" W$ s) z; z324
) [- L0 ?3 z! D, F, {# ^7 M325
326
- D  h( m8 X2 c$ n; R* P! e; W327
0 y6 s9 p/ N- S7 Q# {' E: x328
329
330
4 c1 @# D) B" Y) R% @: O( h331


- h, B* d- A7 c

( J8 t" |0 z% d7 R3 H
( n5 K6 n! I7 q( y# k
6 r. P% o* @6 |0 I, b/ T
! |4 b: C8 R" l; V


+ h9 `1 k, @/ i# v' b

————————————————
版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242