基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

* G* z/ E7 `& `7 A9 L决策树模型
9 S! }/ c4 l* Q4 Z% ~1 Y目录
( {2 ~6 m5 U6 n' O3 k; {人工智能第五次实验报告 1
! g: K  J0 n% V' i: ^# h8 Y7 ^决策树模型 1
; r+ T, T- E7 Z5 a+ B. D一 、问题背景 1
1.1 监督学习简介 1
1.2 决策树简介 1
二 、程序说明 3
. w9 }! |' \( ]7 n2.1 数据载入 3
, c$ A9 {6 G1 Y, K% q6 c$ V9 a5 O2.2 功能函数 3
2.3 决策树模型 4
三 、程序测试 5
3.1 数据集说明 5
1 l' v& ?6 a$ R3.2 决策树生成和测试 6
  v( `' N4 |  C  b3 _3.3 学习曲线评估算法精度 7
5 ~- A6 X+ j: U3 g4 f) |/ R四 、实验总结 8
附 录 - 程序代码 8
! P4 V/ o& t5 B4 s' M+ E一 、问题背景
1.1监督学习简介
机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
+ j) D+ o4 r7 K决策树的组成
* Y/ I) o8 _2 [/ `; ^决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
* {9 G' w0 _0 Y) E8 J2 O
5 J. L( N7 N! w% ?+ I! w4 m! h, J1 qimport numpy as np
from matplotlib import pyplot as plt
from math import log
import pandas as pd
import pydotplus as pdp
* B3 I9 I( ^" F* `( Q
"""
% r! P2 G) `# Y. {8 B19335286 郑有为
" F4 |; P' _+ D+ F1 x人工智能作业 - 实现ID3决策树
"""
6 T; `5 s4 P: I1 E7 e$ `
) U: N: y; Y6 k  L9 pnonce = 0  # 用来给节点一个全局ID
color_i = 0
  J" v2 q! G9 k' k# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
% S4 u! G% Z6 g# @* j, v  g5 Rcolor_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]

& ~7 A' _5 H, R, b% P9 D1 A) i# 载入汽车数据, 判断顾客要不要买
class load_car:
; o+ |. o  x* S! S- I  j    # 在表格中,最后一列是分类结果
$ g3 y- H, n7 L  \% A    # feature_names: 属性名列表
- I0 B- z( A& s) r2 L7 l: ]    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
% g( u4 J, j0 f* {    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
        labels = df.columns.values
" y% p0 H# V$ l, p2 C        data_array = np.array(df[1:])
        self.feature_names = labels[0:-1]
, B0 ?6 S9 a' T+ P8 t0 q: ~        self.target_names = labels[-1]
        self.data = data_array[0:,0:-1]
        self.target = data_array[0:,-1]

$ _6 p0 w# u5 \1 e* `7 ^8 d" ^6 y0 [# 载入蘑菇数据, 鉴别蘑菇是否有毒
class load_mushroom:
4 l) x$ i+ D2 b    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
- Q1 N0 E4 ~. j0 v+ c  f    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
! }' p* r; X% f    # target: 目标分类值列表
    def __init__(self):
        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",
                  "gill-spacing", "gill-size", "gill-color", "stalk-shape", "stalk-root", "stalk-surface-above-ring",
7 O$ g- R+ R2 o9 R                  "stalk-surface-below-ring", "stalk-color-above-ring", "stalk-color-below-ring",
  u+ h1 E: r/ w! [1 B                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
        self.feature_names = labels[1:]
        self.target_names = labels[0]
& `# n2 K5 ]$ g        self.data = data_array[0:,1:]
        self.target = data_array[0:,0]

: h; m0 G! s. v# 创建一个临时的子数据集, 在划分测试集和训练集时使用
+ Y) [5 K  ?3 a0 Jclass new_dataset:
    # feature_names: 属性名列表
- r2 P+ Y3 a- o5 c    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
9 U& @) J$ p1 Y6 ]6 W% [- ^    # target: 目标分类值列表
% O4 Q. z; T8 I/ H+ p    def __init__(self, f_n, t_n, d, t):
        self.feature_names = f_n
        self.target_names = t_n
/ Y: t  O$ C# \6 _3 O1 ]: o( l        self.data = d
        self.target = t
, \* Y. M4 u! o' v# _& ]# H. q
# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
* O- }4 [2 q: c$ L; m5 ?#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
& J* @" G) h7 a  [# target: 分类结果的列表, return: 信息熵
( Y& h( b: I2 v8 {- j# `$ P/ udef get_h(target):
& I4 N8 P9 n& T, A/ s$ |    target_count = {}
8 L2 s8 I; L$ M    for i in range(len(target)):
        label = target
+ E- H+ c/ ^* i' t        if label not in target_count.keys():
6 S0 R, K% m! |* l            target_count[label] = 1.0
        else:
            target_count[label] += 1.0
    h = 0.0
    for k in target_count:
6 p$ C# t& w( ]- t2 }1 A/ ]        p = target_count[k] / len(target)
$ ~5 E- R6 _5 Y0 Q; u0 K, q        h -= p * log(p, 2)
1 p, h1 Y: G  N4 I5 @* Y    return h
7 `1 X9 i6 \: \3 P$ G# Z/ S
# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
def get_subset(dataset, feature_name, feature_value):
/ v# u9 t+ L$ E4 v; k# I    sub_data = []
3 m' E2 u+ V) I  B    sub_target = []
    f_index = -1
% S1 G( ~7 W% Z& C" p0 s. o: j# V# ~+ X    for i in range(len(dataset.feature_names)):
        if dataset.feature_names == feature_name:
' i8 q9 Q  x3 s- g8 {            f_index = i
            break
) p( \. D) q) Y3 c. s
    for i in range(len(dataset.data)):
5 g9 v  O8 V/ ]2 d4 u+ @6 y' W        if dataset.data[f_index] == feature_value:
            l = list(dataset.data[:f_index])
7 d( e& p' i7 U3 g8 d' @2 R            l.extend(dataset.data[f_index+1:])
) B& h! E* z/ e! F5 A; I            sub_data.append(l)
3 W  S5 F- N# y- _3 E            sub_target.append(dataset.target)
  s+ ?3 m2 V4 Y  W3 b
4 m) K5 {0 [: m; Z* l& a+ T. M    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)
! @5 q0 d7 ?. o. P
# 寻找并返回信息收益最大的属性划分
0 _% e* Y1 R( D, T1 R" f* k7 Q. @# 信息收益值划分该数据集前后的熵减
- Z4 T% {- l- v6 y# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
def best_spilt(dataset):

    base_h = get_h(dataset.target)
% {7 S" d' a& ?% x" M( w  W    best_gain = 0.0
! ]+ A9 @; S7 ?3 D0 ~4 Z    best_feature = None
    for i in range(len(dataset.feature_names)):
        feature_range = []
        for j in range(len(dataset.data)):
+ Y: ]& ~5 d: Y- j1 ~/ Z            if dataset.data[j] not in feature_range:
                feature_range.append(dataset.data[j])
! W. {2 x1 m, |3 L
        spilt_h = 0.0
        for feature_value in feature_range:
            subset = get_subset(dataset, dataset.feature_names, feature_value)
0 Y4 j' K1 e! \  N            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)

        if best_gain <= base_h - spilt_h:
            best_gain = base_h - spilt_h
) M; _9 P) r6 o2 ~            best_feature = dataset.feature_names
, u7 X# m9 ]  ?& L
    return best_feature

& }: n/ ^  F9 |5 e; S  A) e1 J# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
2 C8 O' v' h* B    target_range = {}
- w; @; a/ R& W    best_target = None
    best_vote = 0

( l1 N8 J! Q4 {+ `& ^    for t in dataset.target:
* C" C1 ]- g$ p3 g: [! K        if t not in target_range.keys():
            target_range[t] = 1
$ F5 x3 a/ G( ~: r* u4 }        else:
            target_range[t] += 1
- ~, V5 B! }0 ^: I3 ]% \4 d! m
    for t in target_range.keys():
        if target_range[t] > best_vote:
            best_vote = target_range[t]
) _8 c$ @" j' a; b' r            best_target = t
; h0 i4 ?5 n* k+ d) |: j( {
1 ^4 O! K3 `3 G, F2 f    return best_target

# 返回测试的正确率
, O6 h! C# y' E) u0 ?# predict_result: 预测标签列表, target_result: 实际标签列表
def accuracy_rate(predict_result, target_result):
0 G! z0 o0 e1 w" y; c8 {    # print("Predict Result: ", predict_result)
    # print("Target Result:  ", target_result)
    accuracy_score = 0
    for i in range(len(predict_result)):
        if predict_result == target_result:
7 w1 z5 z0 J5 ~8 T) b" C( |4 Y! ~            accuracy_score += 1
% {) s8 o+ f6 P/ e1 Z    return accuracy_score / len(predict_result)
' ]1 s' H- t# V. N1 i& n( D; f8 r
) ]3 I0 d9 f: |3 a# 决策树的节点结构
5 d* q2 d0 e- y& f# u4 Aclass dt_node:
' J/ o6 E4 l) Z/ g
8 b$ R! v! C) D, Q* w+ o+ `8 z2 T) U    def __init__(self, content, is_leaf=False, parent=None):
        global nonce
; G% X! Q& _/ t1 ^        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
        nonce += 1
        self.feature_name = None
$ V+ Z) |9 F" o" X3 x; r) y; P        self.target_value = None
0 W) [+ V, X5 `; U        self.vote_most = None # 记录当前节点最可能的标签
        if not is_leaf:
& o/ u( N$ S: }            self.feature_name = content # 非叶子节点的属性名
% w" A+ }2 Y  H+ W3 ?        else:
            self.target_value = content # 叶子节点的标签
8 j' ?9 q' W* F* Z$ v5 |
        self.parent = parent
        self.child = {} # 以当前节点的属性对应的属性值作为键值

# 决策树模型
+ R# y$ O  C# x$ t( @" a. dclass dt_tree:
* \; K; H/ K+ C+ |. R# K
    def __init__(self):
        self.tree = None # 决策树的根节点
7 H) c* J( `3 S2 [        self.map_str = """
* i- K% ~  c; h) g2 a/ [            digraph demo{
            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
            edge [fontname="Microsoft YaHei"];
            """ # 用于作图: pydotplus 格式的树图生成代码结构
3 W% Z. h# o; ~" U' ?  V        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值

: ]8 n  u  j0 Y+ l- ^. _    # 训练模型, train_set: 训练集
    def fit(self, train_set):
# h7 z6 x/ O7 H2 N/ q4 N
        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
            return None
5 B% ~# Z5 ?/ V/ Z- t
        target_all_same = True
        for i in train_set.target:
            if i != train_set.target[0]:
                target_all_same = False
0 h2 E3 F9 b3 i9 O# b                break

, L$ A+ I# B7 a% q/ o- Y        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
            node = dt_node(train_set.target[0], is_leaf=True)
$ h% U! X6 Z! }  u1 Q' G1 g; P! m            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.tree = node

/ C6 h- \& W1 {9 o6 m& b            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            node_content = "标签：" + str(node.target_value)
, ~  y3 s( k1 }2 @7 w$ ~3 a            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
. [+ n1 ~0 g- C9 J* ]2 X
0 L7 {) \" b, y5 e, B            return node
, |  E7 {& p5 i! v4 l6 c0 j& C/ x        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
# v/ ?$ o# j! J6 D/ I            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
3 O0 Z! N2 K3 a3 S8 k; l, _            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.color_dir[vote_most(train_set)] = color_set[0]
. o1 H3 k1 M, Z5 Z4 n9 y                self.tree = node
$ P8 v4 \: e; O9 Z3 a, i8 }
; r4 A, N# ?! i. I3 [            # 用于作图, 更新 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
6 N( p: {1 s  S# o, U        else: # 普通情况, 构建一个内容为属性的非叶子节点
- E3 l- S/ |, c' q# k            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
' ]( M  r9 U1 s: A+ z% }            best_feature_index = -1
            for i in range(len(train_set.feature_names)):
                if train_set.feature_names == best_feature:
2 `5 s4 M. d  q% }! U                    best_feature_index = i
                    break

! V2 b& ^7 u, L  f% V            node = dt_node(best_feature)
2 f; G+ K' F- W1 {1 ^6 p            node.vote_most = vote_most(train_set)
            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
                self.tree = node
8 g$ P! u5 K' k8 _6 f2 B5 |                # 用于作图, 初始化叶子节点可选颜色
4 `' c2 M1 S, {. k                for i in range(len(train_set.target)):
                    if train_set.target not in self.color_dir:
$ G3 }) R. {) r, u( t                        global color_i
  J! ?$ l7 W" l5 t4 l- i! Y# \& G+ g                        self.color_dir[train_set.target] = color_set[color_i]
# U( A5 A/ ?" M' m                        color_i += 1
2 f) H6 q, l8 ~$ v, j" n( J$ l                        color_i %= len(color_set)
: U5 m7 X3 g2 p  n9 b6 L
            feature_range = [] # 获取该属性出现在数据集中的可选属性值
            for t in train_set.data:
3 E4 m* g6 |0 |, I# t                if t[best_feature_index] not in feature_range:
4 y. b# S5 e- N" k0 u6 |                    feature_range.append(t[best_feature_index])
* J" O4 H/ P) c8 V$ J  b
! ?! P* N; D' O1 J- Q4 \! u- g4 @            # 用于做图, 创建一个内容为属性的非叶子节点
: v+ ?8 e% ?, I            node_content = "属性：" + node.feature_name
3 h: Y6 Q$ h( O5 ~( D8 T            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
6 D/ Q5 `) l, f0 A
0 X# E* G! x9 A$ c9 A. |            for feature_value in feature_range:
* D5 A& k6 s! c) `: D2 ~/ a                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
$ ^& C: M, H  f5 B  |# c                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
                if node.child[feature_value] == None:
) b( z, g. ^% T" F                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
' Q4 |* j7 _! l+ i                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
& K! M+ G% p, ^$ h, p  }2 L3 w- D5 J                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"

            # print("Rest Festure: ", train_set.feature_names)
, b+ [2 ]" k; V8 b! z            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
            # for feature_value in feature_range:
# [2 B, f! @: o% O. u            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
            return node

    # 测试模型, 对测试集 test_set 进行预测
    def predict(self, test_set):
        test_result = []
. }* N6 `! Y" U0 \  m        for test in test_set.data:
+ B) g1 ?) ?: ~7 ?9 }* Q1 u            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
6 H6 s- m) r3 S, [6 L            while node.target_value == None:
# q: p4 p4 I# z+ D0 n                feature_name_index = -1
                for i in range(len(test_set.feature_names)):
/ E1 K+ O5 N1 M                    if test_set.feature_names == node.feature_name:
                        feature_name_index = i
                        break
8 X1 n/ z& x: h" Z& Y2 X6 d                if test[feature_name_index] not in node.child.keys():
' G) B* U$ o- i( d# Q0 d9 H                    break
$ ]2 _( x8 w" Y                else:
, s* p' u1 s9 |; r4 j6 f/ X                    node = node.child[test[feature_name_index]]

5 S; o; r) c) U  z5 J* F            if node.target_value == None:
                test_result.append(node.vote_most)
3 d% j9 Y# ]+ n$ h            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
2 B, v; a% H+ Z, ~8 B                test_result.append(node.target_value)

7 }7 @8 ?/ `0 _; G5 i- O6 D        return test_result

    # 输出树, 生成图片, path: 图片的位置
    def show_tree(self, path="demo.png"):
5 D1 ^# W# [2 V5 n2 q        map = self.map_str + "}"
  V$ V8 {, N' |. c# b        print(map)
        graph = pdp.graph_from_dot_data(map)
        graph.write_png(path)
5 C- y2 w) j) @+ S9 K! y. ]
# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
, R7 X  G& J, \6 r. N& X/ b    c = dataset
7 T1 Y  `: Y( \  N5 H6 v3 M8 }    r = range(5, len(c.data) - 1, interval)
    rates = []
    for train_num in r:
        print(train_num)
8 d; y# z6 }8 o: Q: a        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:])
: V- Q% Z$ P6 O6 k        dt = dt_tree()
. _; N- [( [( q        dt.fit(train_set)
/ B, B+ f7 \+ S+ U9 Y* W6 E        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))
2 ]7 M0 u- A( \) ^( O
    print(rates)
- C7 @, P0 F! C, h5 \4 w+ q9 H    plt.plot(r, rates)
$ x  F: w' ?0 |& {1 W, Y9 l3 w2 J    plt.ylabel(label)
    plt.show()

if __name__ == '__main__':
4 {5 ?' T6 l; ?% J! H
    c = load_car()  # 载入汽车数据集
    # c = load_mushroom()  # 载入蘑菇数据集
    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
    train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
5 E+ M* B. x  L    test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
: H( R& F- X/ \# e6 V6 }
$ m" O3 J2 v' w$ F    dt = dt_tree()  # 初始化决策树模型
5 r! Z5 A8 Q5 z    dt.fit(train_set)  # 训练
    dt.show_tree("../image/demo.png") # 输出决策树图片
    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧

! _* C0 C8 Y  w9 q5 m2 [* Q    # incremental_train_scale_test(load_car(), "car")
: ]" g. }1 r$ Y7 E( |7 {    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)


! u! T; V, b% D
1
2 i- |3 m8 H0 k/ ]* y: e# l. V2
5 g. }' v3 M- W, ^$ ]3
4
5
7 D+ {  i+ `% R% U; K2 J6
) P$ ^# c+ l. G; A; ^7
. V- U/ x$ q! q# h! R/ Y8
9
10
2 x  D0 J" a3 {9 N" V0 M( n; w3 B  f11
12
13
14
3 m) g" H5 p' y1 r15
" C% x- @9 R" V( [0 z' ]16
5 M6 Y$ k; X) N; S17
18
% r+ f0 U) h2 j2 B3 X- \9 H& Q19
# O# N4 i8 U0 `+ B8 T20
21
! l: J0 |, Z% S# ]/ t22
23
24
2 @/ I5 J, k' O: A25
! N% Z+ Y5 A7 Q, ~26
" e, U6 D" X7 v! |7 j3 i* w* A27
28
29
30
31
32
33
34
35
36
8 l2 B+ }3 Z# z0 _5 P37
38
; ^9 V2 y% c3 ~$ e39
* W  S8 H  t( G2 b40
% g- |7 @; z6 ~0 q3 w+ s) G41
! Y* T# ?2 Q! P: |" l" y1 k! H42
43
+ @5 s) N0 ^) v9 s+ `& r  @44
45
46
47
48
49
50
6 f3 }* e4 e6 X' v) E9 O% |51
  p7 T8 h. L0 D2 l52
53
54
55
56
, A! l. Q, P# G2 N2 _57
58
- @9 o4 q/ W, K+ W# d+ m59
60
61
6 O+ L" q! x9 K# N3 o( R1 ?8 o62
63
64
65
. l, M, N& @9 F0 y7 O/ R/ h. Z66
67
5 S$ t" ^. @' D0 Y; p3 S9 M68
4 A% r) X& g1 s) Y8 A* Q69
70
71
72
) W% O$ }8 e; M! ^: r: J8 O' t4 H73
3 i! ^& ~6 ]: E8 s$ Q74
75
76
1 f) e) C  L) l$ D1 k( z77
. H# S. |6 z* F# `+ C78
79
80
81
82
83
84
9 P9 n* i0 @% E  R0 X. \1 \85
86
87
88
3 i- ]' J! u7 P7 ]0 c9 e89
90
% b; R' X* V! ]4 m91
92
93
94
95
5 J* T4 c/ s5 Y1 S( ~7 ]- {9 P7 u96
97
98
" ^1 v1 A: z3 l4 _99
. m& N5 G% Y/ {/ v- C* X1 \2 Z100
* P( W  I: v2 s3 X. H101
8 p7 M6 n0 T! i  Q1 g: ~8 r102
103
104
105
106
5 b. I& i0 W6 s4 U) B* {7 n: D; h9 v107
. Z, R# u5 e) L+ l108
$ {* O' h! G. |& v% j0 R  M' A109
110
  z2 y% C, G9 S3 w* ~7 l111
112
: m* f- h- \! Q' H/ R0 ~: A113
114
" y: i1 f" O6 _3 U6 T- V. P  x115
; _; |6 c2 o6 b4 ?9 v" G$ {5 o116
117
118
+ e( ]. @+ M' N6 X119
4 ^# Z- n0 E" o120
121
122
123
( _$ L& q! b* Q* }  o% F. E9 o124
125
126
- ~- Z/ o$ e- X' P/ f127
. X& j4 B- Z' c# i; t4 s128
+ `  i/ C7 h5 L' S5 l129
130
1 [3 H& @% n, c4 K) F131
9 U) Z# g4 l- W9 z1 T132
133
4 `- j: h( b; V) Q134
135
136
0 G- u! H: v! P9 g4 v- |: F# N137
( I2 `9 W  u  s4 e2 q, E. r- M- U138
139
140
' ?- b! u9 t8 R+ {# r141
142
% y% Z! G. ~, \7 J) p" ]5 Z143
/ u9 @- W/ x. y( ?: ]3 j3 y144
3 I5 k# o; s+ W/ x1 Z, F' h145
1 x, @& d' `$ q" {* A% G0 E146
0 _1 w, {. H( t6 s  [- @147
7 _+ t$ p5 u; O) `. j) d! L148
149
9 G$ {+ r' y  c% p! E150
) a8 ]! _; l; e* ^- L+ D7 l151
152
153
& B0 X& O6 [7 Q8 n4 y& O154
155
156
$ B% `; `% r2 \1 q157
/ D# P# o* b$ c) e: o" b  U) M158
159
160
161
162
$ V: w+ e; j7 j8 L8 e$ q163
164
& s' E5 j( w, I165
166
167
168
169
+ h& L! \# u+ T/ w: k170
* h8 I5 y4 `& B2 H$ N9 E0 I: l- b171
, _8 j% L9 Z% h172
173
: n* I0 t/ H4 u! b/ Y  ^2 d174
$ z* a- s3 p) E! z( h' I* C175
176
177
4 [8 J% ^* `" J6 I5 F" k( X9 N, w178
179
/ Z  ]) x; `$ b180
$ x+ {9 G, L. Q, @181
182
183
184
185
186
% G1 J. V2 Z2 J; F! O* w3 N187
188
2 M+ r& m3 k! L' S  w189
) Z- @$ p3 c3 \% `1 k% Y( m190
8 Y& Y9 Q7 L, x7 M& d' r  W! M3 l8 g3 j191
192
193
7 E# f8 _& f' c" l' J2 K/ X1 y5 ]194
195
196
. b9 o' o2 k0 Y% t  B197
7 a  D! t1 P' X4 s198
$ t! k- D$ K4 l0 o" A2 Y199
200
201
3 V9 S( `/ i- r% G+ t5 z3 ?3 I  j202
203
204
1 T6 K% J+ c2 {) y( Q* ~205
/ L6 H! _7 N' C2 M* b: o8 V! r* r; R206
207
: j0 y+ H9 |- T5 z208
209
- g) x* Y: h% v* @; s0 B+ ^210
211
, {( w$ b$ ]6 r212
213
214
4 L! U1 a  N- b. o215
  s3 O: W0 b3 N% T216
217
8 l% Z2 c  g" X/ [218
219
220
, R3 s. o. ]* \4 w221
. s& h* m) |4 p1 h: L$ `222
223
9 X6 y: c' J4 W. p- V: X4 P. P# b224
225
226
227
228
0 c2 g2 F- |. M% \229
3 f+ w0 y1 C5 e; Z230
231
232
+ L; Y; @% S( ]233
- q0 |% g( I3 g6 d8 U234
235
, e' o2 ?; }4 g9 e; P" q236
237
; c, {8 k- a! A238
239
! X0 h$ o0 ]4 \0 g240
241
( X! g4 I, p: x4 Q242
243
' f$ q+ H: ~; Y5 R244
245
246
2 h+ j( d/ k$ X( N247
4 @2 Q( }9 M+ C248
249
) M% `0 W2 o/ I250
251
252
253
3 A' g- U0 u7 w/ Q9 ~/ U6 H: [) v254
255
  l( M1 _/ x$ S. C256
257
9 [# o" x( s3 |4 S+ v8 Y9 W258
( }3 Y" x% R7 `& k259
* g2 A; j  ~# ~3 z* i260
261
3 \3 L/ W* E4 I& u  _6 b262
263
264
265
266
* u  U% W6 b% }! r8 z' I267
268
269
% n# ]: M0 r: `# R270
271
272
273
274
" p0 k8 L9 W' Z. v1 x275
, g7 R4 s( H4 y6 s! S( q276
3 R$ B7 J- p& J) g# h$ q/ G277
" Z9 j4 G2 {) S4 X278
  M; X) G1 w& |$ M/ }6 W( l279
280
6 M# |5 `8 I3 n0 {281
& y  f4 @6 \6 Y8 {2 p7 v282
" Z3 G4 E3 N6 ^; a283
/ Y1 `! k9 \) M4 Z, H$ x284
  q& `% c) V; [1 c* N285
. z. I/ F0 V. T# Z8 ]286
( `7 o" P9 m- f& v( o0 e287
. D" m) |, B: W288
3 G( @* p% i3 W7 n5 ?289
290
, h5 E7 Q3 ~  M/ r291
5 F8 s/ Z# ?8 v/ f! _292
293
294
295
296
297
+ v6 r& B+ e1 z% {298
299
, x7 n, l9 L7 Z5 o; k0 N& z  U! ?) w300
301
302
303
304
" y7 f6 M4 U4 h$ u# t9 Z) L. R305
306
307
! `8 @( g4 t$ _3 ]+ Y308
/ o' N" S* H( `5 H) ]309
* w, D8 |1 N' ?6 w0 O0 Y, q310
311
312
0 v8 @& Q+ N+ Q8 B313
314
! g, F3 C7 q3 c- s- z315
316
317
4 \) O# V9 ~2 q0 P& e5 b& _+ `318
319
& N7 |0 Z3 d1 S. Z: a# F320
* f; L# ^! N+ y3 v) x- o321
322
4 c( R0 x0 P* b323
8 V& F* i! W% O' d3 `+ Z324
# h% m9 X0 i' _% ?325
326
327
5 x7 L3 e: M# W7 O328
329
; `# ~6 F5 Q$ u6 x8 ]& u) X) F330
$ P6 A5 o' l+ v+ N& O  [, S6 s331
' X& z- D% S% d# a5 ?4 c9 Z




& {2 z0 K/ ^0 G$ n4 ?
0 L! _' N# u+ n. c5 c' J
* @2 i; g+ F  u8 s& z

; U7 C2 U) K  t) p/ c$ Z
: Z' U7 c2 ?5 ]3 w" E- b- B

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