基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

/ r8 j; O- a: x. y决策树模型
目录
人工智能第五次实验报告 1
2 \0 v) }7 c) q决策树模型 1
5 n. J3 |4 d0 ~  t" r一 、问题背景 1
1.1 监督学习简介 1
1.2 决策树简介 1
  N$ ?' v1 h: }二 、程序说明 3
2.1 数据载入 3
) F7 D; {- E% {1 M2.2 功能函数 3
2.3 决策树模型 4
3 ~& [: d- W+ w  Z& X. v  ]8 @三 、程序测试 5
3.1 数据集说明 5
% E% E1 i3 \3 c1 q2 U3.2 决策树生成和测试 6
8 L- g8 `  k) v3.3 学习曲线评估算法精度 7
. @% x$ x; x* S! `2 `' m, u9 X四 、实验总结 8
3 |" ]* Z/ D2 x/ U附 录 - 程序代码 8
4 S% F, T- O( M9 T  O一 、问题背景
1.1监督学习简介
机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
0 z& C: h& p- @0 H! x监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
1.2决策树简介
& ]. O! L& F6 G( Q3 _9 K决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
$ Y2 n3 |! l+ U: j( S& R( W4 [7 O决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
' N1 n; Z+ ]: d. ^
import numpy as np
from matplotlib import pyplot as plt
from math import log
import pandas as pd
: X( p! [6 @6 s; ~import pydotplus as pdp

; n' U9 {- S8 o" ?"""
19335286 郑有为
4 x+ Z' E' x, u( \; ?6 M8 K; J9 v) B人工智能作业 - 实现ID3决策树
"""
5 ^- u4 F0 `# u' R# Q  @
nonce = 0  # 用来给节点一个全局ID
color_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
5 h1 ~9 m7 s+ T: ^7 Y% Kcolor_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
% F. y/ R; W! M) u; X; [+ e$ H
# 载入汽车数据, 判断顾客要不要买
+ k  I. y8 J. ^: j: r& F% P& X: W- Oclass load_car:
$ W3 {  o/ J/ n" `2 R8 }8 Y    # 在表格中,最后一列是分类结果
0 C5 [8 {3 Z. ]$ {8 Y9 }5 h    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
8 z& s3 {* s% A    # target: 目标分类值列表
- W' T2 D0 U* B4 X1 v& N    def __init__(self):
) d. `5 W+ ]0 T8 F" ^        df = pd.read_csv('../dataset/car/car_train.csv')
8 L: b$ n; m& E: i, b( _! x        labels = df.columns.values
        data_array = np.array(df[1:])
2 P4 h/ z! j$ G6 Y        self.feature_names = labels[0:-1]
        self.target_names = labels[-1]
9 b' m; P" h9 `, B! o1 D+ m& P: \  Q        self.data = data_array[0:,0:-1]
6 P% o! {2 t, q9 S0 o- |  c( `. `        self.target = data_array[0:,-1]
% G% X4 S- o. y) I4 l
# 载入蘑菇数据, 鉴别蘑菇是否有毒
, U. ^+ [$ k* A" J; \$ _: c) i' Q9 g- wclass load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
1 s' R9 {, P  d+ x6 `    # feature_names: 属性名列表
    # target_names: 标签(分类)名
9 d1 U  h% T. t; R( l    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
* K9 R5 G% M  ]1 Q# Z    def __init__(self):
        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
        data_array = np.array(df)
8 P3 r7 u' e' g* Q* C$ R        labels = ["edible/poisonous", "cap-shape", "cap-surface", "cap-color", "bruises", "odor", "gill-attachment",
. E7 G+ V1 i$ P                  "gill-spacing", "gill-size", "gill-color", "stalk-shape", "stalk-root", "stalk-surface-above-ring",
# U% R$ s5 E4 e$ H3 n* G! T                  "stalk-surface-below-ring", "stalk-color-above-ring", "stalk-color-below-ring",
# g. B* z$ U8 `: k3 v6 g                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
; X, T, F9 D: |: F: {$ o! k+ b        self.feature_names = labels[1:]
) |* V) L" ?1 j$ K3 ]. ^& }: L        self.target_names = labels[0]
" d$ @9 O4 F) Z7 y        self.data = data_array[0:,1:]
        self.target = data_array[0:,0]
0 {8 w" E, R$ Z; m# m8 S" `
# 创建一个临时的子数据集, 在划分测试集和训练集时使用
0 s5 h" l8 Z! b- c! d* _class new_dataset:
$ s* i, Z4 h' }; a    # feature_names: 属性名列表
1 H4 [% C" f' ~2 Q0 x    # target_names: 标签(分类)名
# \# F% v# K0 s  R3 H    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
" Y! b9 _, H7 T+ c7 L    def __init__(self, f_n, t_n, d, t):
& s0 E5 B! M+ P2 B" L4 R        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)$
* d) {5 k& `7 p6 P# _: M#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
# target: 分类结果的列表, return: 信息熵
def get_h(target):
    target_count = {}
    for i in range(len(target)):
# c$ X3 Y$ S6 q0 \        label = target
2 O3 S6 m' B  o( ]# @1 t% b        if label not in target_count.keys():
# U) [' u: @" M% P4 n            target_count[label] = 1.0
4 D9 I/ I3 G2 h7 Y        else:
8 U3 N/ K9 C$ W6 a            target_count[label] += 1.0
    h = 0.0
/ H- n, K6 G5 P% X; ?" M* D    for k in target_count:
. y6 v1 m: A% W2 Z+ C        p = target_count[k] / len(target)
        h -= p * log(p, 2)
    return h
! O4 C5 m% w( _$ S1 G
' f8 Y" b. [6 \. a$ |# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
! }! ]2 g; i1 C- T, g2 @* O# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
def get_subset(dataset, feature_name, feature_value):
3 @' k5 X! \  ]. s5 q/ ~- R* R; T    sub_data = []
* c! u" c- X, h  p; D    sub_target = []
" q  J) _  C- n8 d    f_index = -1
    for i in range(len(dataset.feature_names)):
        if dataset.feature_names == feature_name:
            f_index = i
            break
0 `' U% v4 \+ C/ |. ]' {3 X0 t
' M/ K# v0 T8 z8 l' V9 Z    for i in range(len(dataset.data)):
        if dataset.data[f_index] == feature_value:
            l = list(dataset.data[:f_index])
4 n6 [- N6 p' F4 [  N( W            l.extend(dataset.data[f_index+1:])
" `  ?. c! ]$ R% R            sub_data.append(l)
            sub_target.append(dataset.target)
  _6 J8 r1 h( A# p+ R, q
    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)
! ]! O$ j; t; F. t
" C& |1 d3 I  y# H& y" b$ i6 g) S# 寻找并返回信息收益最大的属性划分
# 信息收益值划分该数据集前后的熵减
# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
- ^* ]% a% |* ~: @* N- B' tdef best_spilt(dataset):
5 A" L" b( k2 s
    base_h = get_h(dataset.target)
    best_gain = 0.0
    best_feature = None
" ]1 T/ S# c8 B$ H$ P! {1 ~; Z    for i in range(len(dataset.feature_names)):
        feature_range = []
  B* U! G8 r/ s. Z4 V! W  X        for j in range(len(dataset.data)):
; [0 A2 p4 c* }            if dataset.data[j] not in feature_range:
                feature_range.append(dataset.data[j])
4 k# a4 Q5 r' i( j' T- M& _+ T
) \- y- _5 q9 n- R' s3 N( |        spilt_h = 0.0
        for feature_value in feature_range:
, n" ?# e8 a( e9 w% [6 O* ?1 R+ L            subset = get_subset(dataset, dataset.feature_names, feature_value)
            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)
5 [: Y0 U+ ?/ F
        if best_gain <= base_h - spilt_h:
            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names

    return best_feature

# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
" `' q  H5 W5 v$ S4 D" M    target_range = {}
0 C2 \' i+ W" y8 B& E* p    best_target = None
& T5 g+ A( D# [    best_vote = 0

    for t in dataset.target:
        if t not in target_range.keys():
            target_range[t] = 1
! V0 b+ f5 D* r$ Q1 O8 l2 K( N- v' ]        else:
            target_range[t] += 1
: {' p, N8 q& |0 z8 @. q4 ]
    for t in target_range.keys():
        if target_range[t] > best_vote:
5 j9 m0 u) p# A2 W; W' H            best_vote = target_range[t]
            best_target = t

6 V; `$ S) r9 K8 {    return best_target
1 Q( ~; U* A8 @% l2 D8 x
% r( }+ d/ f: ^2 c" i, b- t# 返回测试的正确率
# predict_result: 预测标签列表, target_result: 实际标签列表
def accuracy_rate(predict_result, target_result):
& I* N' ^& s. O+ O    # print("Predict Result: ", predict_result)
    # print("Target Result:  ", target_result)
' C& ]3 @) |: y) U, g$ {/ ?9 N/ Y  U    accuracy_score = 0
9 Z! n6 h' _0 ]) ^    for i in range(len(predict_result)):
* f9 d9 w( {* o0 o# a8 ?& E        if predict_result == target_result:
            accuracy_score += 1
    return accuracy_score / len(predict_result)

# 决策树的节点结构
9 M/ G# [" E! S7 E/ xclass dt_node:
4 z! @# G$ K- }! m; f
" X( e% }% o- E; I    def __init__(self, content, is_leaf=False, parent=None):
        global nonce
: L! x7 R' E2 L; X7 u        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
        nonce += 1
        self.feature_name = None
        self.target_value = None
' C  p& @: j/ D3 v" g- O: q# {        self.vote_most = None # 记录当前节点最可能的标签
8 E4 M  v. |) l2 K        if not is_leaf:
/ }1 k9 d9 p4 l- \% Q) ?$ H3 o            self.feature_name = content # 非叶子节点的属性名
        else:
8 Z/ [3 W2 H2 g9 n2 I4 T0 j' c% T2 `            self.target_value = content # 叶子节点的标签

        self.parent = parent
0 v& b/ i6 C$ m; a  Z* q. C        self.child = {} # 以当前节点的属性对应的属性值作为键值

# 决策树模型
class dt_tree:
6 Q$ U( @4 Y# p
& f" K1 X8 v& H' V5 x. W    def __init__(self):
9 z0 y! u; Y  B# w2 C( H        self.tree = None # 决策树的根节点
        self.map_str = """
5 s/ ~: n# J! i2 Z: h# [# ~            digraph demo{
            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
            edge [fontname="Microsoft YaHei"];
            """ # 用于作图: pydotplus 格式的树图生成代码结构
3 u, e! k1 K( G1 s* C        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值

6 s7 _" j/ H' V  x9 \9 ^( |' {    # 训练模型, train_set: 训练集
/ F5 E6 O* R: |4 [. I2 v/ G! O, C3 P    def fit(self, train_set):
# n6 m5 c+ `* {. X* C9 F# m/ `
        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
9 c3 C+ y8 q/ C1 t+ \8 Q; \            return None

+ I+ D; ^' W9 I6 ?! ^. u        target_all_same = True
        for i in train_set.target:
. X5 }# t& s0 I& x1 }            if i != train_set.target[0]:
. g$ Q; Y# V$ V                target_all_same = False
                break

6 \4 G) u1 n! Q" u8 |        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
9 B. K9 R  L( Y5 s            node = dt_node(train_set.target[0], is_leaf=True)
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
! [* |( e  S8 B# L/ s- h' M- a  d. m                self.tree = node

2 J# |- @4 ^3 X$ p            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
  y8 v1 q" P3 ~- q% F, i            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
+ Y4 y" w4 Y* s        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
& l* T0 W! [2 X6 Z' ^            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
- D* g. V# m6 l2 E            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.color_dir[vote_most(train_set)] = color_set[0]
3 u( r# u( g" T                self.tree = node

            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
$ `' P* V* p8 U8 W; ^8 s            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"

. J9 W- S6 p- x( ]% ~            return node
        else: # 普通情况, 构建一个内容为属性的非叶子节点
# p; |0 c5 F0 R5 O6 w# P& q            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
+ S* A; s$ @$ h6 e. `) V5 h            best_feature_index = -1
6 J- L6 K' z8 u            for i in range(len(train_set.feature_names)):
" d* i7 [1 t+ m' A5 [9 l: A                if train_set.feature_names == best_feature:
. E$ B8 n$ i  H4 d                    best_feature_index = i
; w' I: C3 g5 S" o0 n, N                    break
6 ~- H4 P, A1 O& v$ Z! r, O8 y
            node = dt_node(best_feature)
$ ~1 e1 b& m0 n2 l  j1 i4 P# |. k            node.vote_most = vote_most(train_set)
            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
- b' a0 Z0 N' E                self.tree = node
2 r/ u# U; c$ K# l                # 用于作图, 初始化叶子节点可选颜色
0 D$ \/ c/ }8 x& d                for i in range(len(train_set.target)):
                    if train_set.target not in self.color_dir:
                        global color_i
                        self.color_dir[train_set.target] = color_set[color_i]
# i' E- Z3 k4 E% l1 @8 w" q2 k                        color_i += 1
                        color_i %= len(color_set)

            feature_range = [] # 获取该属性出现在数据集中的可选属性值
            for t in train_set.data:
8 n1 F0 {0 m0 n  t4 Y5 L                if t[best_feature_index] not in feature_range:
5 v% H7 u' ~) P: h* x                    feature_range.append(t[best_feature_index])

            # 用于做图, 创建一个内容为属性的非叶子节点
- j# u. d% N8 g5 t6 C            node_content = "属性：" + node.feature_name
) E( e! [2 [4 g/ d( u& [            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
- V" R! a& z. w. J! Q: Q
            for feature_value in feature_range:
                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
                if node.child[feature_value] == None:
6 r2 F! G3 k7 }4 ^                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
                node.child[feature_value].parent = node
& O; j, _9 |4 Q6 R
0 M5 {* N, c/ @) g, _                # 用于做图, 创建当前节点到所有子节点的连线
                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"
, T% r, \  L/ q  A' T
            # print("Rest Festure: ", train_set.feature_names)
; V$ c4 \4 c7 L. g            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
            # for feature_value in feature_range:
            #     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 = []
        for test in test_set.data:
) C0 Y1 C8 O: e. ~$ y7 {) V            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
$ q) F# Z1 u% I+ P, G            while node.target_value == None:
                feature_name_index = -1
) Y& k% y/ w9 z* ]                for i in range(len(test_set.feature_names)):
                    if test_set.feature_names == node.feature_name:
                        feature_name_index = i
                        break
3 Y, k3 }' O* d3 z- [! v  P  R% L                if test[feature_name_index] not in node.child.keys():
' X% W! ?$ m; H) o2 E" |                    break
/ f* ~6 u+ o9 @/ N6 J: e4 a                else:
                    node = node.child[test[feature_name_index]]
/ H$ B& c' p0 Y3 a" g( Y5 \
: E3 H4 {* S7 v" ~& s* t  f            if node.target_value == None:
7 R- Z9 O( e$ `- A9 Y                test_result.append(node.vote_most)
            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
                test_result.append(node.target_value)
4 p  l/ m: k* N" g
        return test_result

    # 输出树, 生成图片, path: 图片的位置
# I/ o$ L$ u9 Q) l    def show_tree(self, path="demo.png"):
        map = self.map_str + "}"
        print(map)
        graph = pdp.graph_from_dot_data(map)
6 C/ u2 N4 |" g, C  a* `1 f        graph.write_png(path)

# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
$ G1 g6 m' X+ z4 H/ b$ [! t& s7 C" l    c = dataset
    r = range(5, len(c.data) - 1, interval)
    rates = []
    for train_num in r:
        print(train_num)
+ O, v7 f! k& c: I, {% I' g        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:])
% ]* ~( @2 Z$ T! J+ S        dt = dt_tree()
        dt.fit(train_set)
: ^% f  Z6 N: b5 d! D        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))

    print(rates)
    plt.plot(r, rates)
    plt.ylabel(label)
& b1 n) h+ p1 d+ @. X    plt.show()
  C2 ~9 H  K. k8 T- W' r$ T
if __name__ == '__main__':

    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])
9 m7 n. C4 m  ^, d2 D    test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])

7 ^' D2 N0 |; c0 }8 K) x+ m    dt = dt_tree()  # 初始化决策树模型
. o2 i3 Q1 t# n0 p' C    dt.fit(train_set)  # 训练
    dt.show_tree("../image/demo.png") # 输出决策树图片
- M; ?4 i* \2 r# U. }; n    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧

+ P" k/ G6 u' c) G8 g: ~    # incremental_train_scale_test(load_car(), "car")
    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)



1
2
3
# v5 Y) H6 M. [- Z  m  D* i4
5
6
7
8
- |; m- O1 e4 j0 t, ?/ [. U$ I9
. |' s* s, k* n, L! Y10
* N# r/ y( t- x11
12
13
14
  h9 i8 B7 B( B; Y15
16
17
18
0 l) q7 d! L4 N4 l. y5 y19
20
21
22
& q- [+ c+ ^9 }7 q23
24
25
3 z; B* {, g+ I2 {' d  f7 z26
" I  Q7 Z8 ^# C27
28
6 h& Y! E' \7 @) G29
30
) W! n! y/ d' l7 x31
8 j; @/ R- r/ n5 G+ D1 Z- ~1 [1 N32
3 p) A! B' N4 B8 j33
* R* g3 u% O: p$ q6 G, T1 P4 |34
35
36
. }, y0 F& U. N. q# S  u1 T5 S37
38
* V% {6 A7 H! m/ T4 K6 Y- w39
( P* f# h; V( r) D! \- w40
41
42
43
/ {9 Y, _  ]# X- U" }4 l44
45
46
47
48
1 `9 v* K$ `7 X3 Z1 a' J9 F49
' \. f9 `4 y, E- l# V3 j: \50
51
52
! o! j2 {$ U$ e- s6 j5 B53
# }+ {: ^8 ^% R& `1 E5 |2 d" H  ~54
55
56
/ q, ^# g! q, c9 f+ d6 |57
58
' S# h& ?% K: W) }7 [59
60
2 N1 y4 z6 W- L. C% Z61
4 {! k/ q9 }( f7 ?2 C62
  I: M$ Y: H2 v6 x8 w" n. K9 L63
64
65
66
3 ~* P* u. ^5 w67
6 W, T5 i0 k' @3 @, m( ?" X1 i68
69
4 ~6 D. |! L; A% E3 F8 j( G: C% H' |70
0 X' I* }2 I' O- d3 A2 K71
6 w$ V; T) S  m( b" z7 o72
73
74
75
( K) q2 U1 E0 E76
77
/ v2 D& U/ B% n1 q# u9 d78
79
80
81
82
; ^5 Z0 @* `7 V0 W) v4 L% U83
84
85
: b1 [  k. X. `9 p6 @& V86
+ |6 R" t. W, C6 B87
! n7 E1 w0 l6 c# \88
89
90
( ~! [+ z/ [$ U91
92
93
9 R' l0 ]  i* v/ M* v94
95
96
97
0 p; k  B3 U4 |8 Q# f& Q98
: t( a6 q) i, d6 O+ D+ n99
0 o6 W5 M2 B* R! v0 @4 G% Y+ y  A100
/ F9 \: P, n# p4 t: q/ k/ G101
4 Y4 H4 i+ e7 N* M8 p% G' c, B102
. c) D3 ^. \- l; M2 b: k& h103
6 l8 R. M0 o. F  ~1 l( p104
9 y9 N% u/ w, n; y" B' p105
106
' ?2 G% j. i( U4 g: o107
108
  a# q. Y2 M7 b# t. q, H  k0 v109
  R# h( T2 o( f, M( p9 G7 x$ t110
2 y% t$ T+ N' ^9 ~. k8 n( s111
1 U. d9 c6 Q: _1 H7 c112
; A  S1 ?2 R7 Y7 d113
* y& i, g; k  ~0 [7 ]# R7 M0 i114
115
! U4 C  g. z, l+ y' m116
$ c* B. R2 N; u117
% s& ~' _% {. X0 p118
119
! ^; _$ o9 H# J- m# X4 ]0 V* M120
121
122
123
: U. O; Z+ Y! ^. U& s0 N2 y, x% z124
125
; `, Y' N9 ^6 w: H5 Z126
) ^2 ]( S8 S& g" H6 q5 G' ?9 r3 E. `127
( W+ O/ ], \0 ~3 F- C128
) r( J3 u3 a+ q- W" K129
130
( y6 u! O$ l% a% E- L8 p, I131
2 u* Q$ |$ b" F* n. y4 x7 v132
( a, M7 Q/ S6 e9 \7 x133
134
3 c! e& h3 j/ j( z0 `6 ~135
4 |3 ^# ?, [# p136
137
138
8 c4 n0 z+ T. [* r3 t139
! T: v8 G7 g9 ~- {# S5 W6 K) B+ ]8 f0 |' W140
141
3 ?3 Q, q8 l2 z# C4 |142
2 \, M0 N: i2 ^6 e9 W1 z) @6 [- U  }143
( _: R6 g1 r" ~& T  m0 J$ g144
  Q! E: S7 G! d0 Q, z145
146
147
148
! T" t. x! k7 ~; ^' w149
! v" Y; B! J, J) `( v3 ]3 o150
% i1 D6 r" G& B, z* i( @, x% ]8 o151
152
153
154
155
3 S: J7 M. y. x* V% H3 z* \156
157
158
159
160
161
162
, l' v- |. K5 \9 ^163
% U: P8 H( @+ j1 P  f164
165
! U5 r0 s  H+ @3 X166
167
168
, J$ K. z# _# L8 F8 X3 C2 ~9 K# b169
170
# L" {- ~7 p6 z  J7 X171
172
; w7 v2 u, W  `$ L3 l% O173
. B) D- |2 M5 Z/ g* @) T+ w174
175
176
177
; ]& J  u- t1 B8 U7 {2 Y178
/ _9 z. o4 g2 t; ~. P: O# v179
( m1 H. R* X" ^; S180
8 X5 [6 L3 Z' W. D6 U; ^181
( m* o; i! {  G# L. K% C& y182
. |. v* M/ T6 E$ d. {+ B183
184
185
$ k! g5 i% D) L6 S+ k1 s* s186
187
' s% K5 w. d1 b188
2 x2 X% v. Q0 o& D; ?, m: ]9 \% [$ n. b189
5 B- ?, p0 d. q1 x, v/ \/ K190
, J/ m- R9 W7 S191
! f  ]0 w+ ]; _* t* T5 {  W192
193
194
195
196
197
198
9 a7 M# F# p3 @- L6 V0 E/ {199
200
201
202
# I0 |" F6 J9 L" e203
. ]1 F* S2 M$ Y; y. ~204
: E. D2 U6 ?, k6 A$ f, @205
3 A- K+ D# x& o2 D4 _206
207
208
% r# r  T4 U# T% W. |209
210
211
$ U4 t0 Z! o- J9 k& u; L212
213
214
5 a: m# C4 M- X' f! i0 [- P$ R215
+ w0 I3 W2 h6 x/ V  p216
9 M6 j% U; [9 p7 x217
7 y) |, ]1 S2 X$ a) n! Z. N( T. f7 C218
219
- T# a* z' ?3 L220
2 I- T! b1 q2 m: q0 G221
222
223
224
' a; _8 n( t, X) P/ i# S225
226
227
228
229
230
4 D# g4 @8 _$ P- ^+ M231
232
) q0 k; I9 r) y3 u0 l233
234
235
/ y' B5 y- E% `  [, k! F1 q236
4 G: S6 Z- \6 L/ T237
238
239
240
2 }  }. W6 x) g2 X1 s241
242
$ X' Y; X( R! c! E# }243
244
245
; @; R! B3 P. Q; c. b( l# i- Y246
247
1 w6 X, Z; Q. m" m7 ~9 j# W248
$ c' ]/ J' A7 \' B0 w; ~249
250
2 r7 C! r, Q. q/ }1 f251
' i- y) ?, I" S, s& k252
9 a* N3 z; C5 t6 N253
254
255
5 p1 o0 e- T; Y- H+ \" n256
257
258
' r) G6 T4 Z9 ^2 m259
+ o, q7 i- `5 j& \; y4 b260
& `  C: Z$ Y, A6 Y7 @261
262
4 r* t+ p. r8 W7 s2 V# e263
  ]4 H8 B5 d" G' x) N7 S264
0 w; h( E, ^6 d# H6 a, P265
266
267
1 a" K8 |  g) Y" w  Y268
! J& B- A/ W+ X$ V5 A# F269
270
5 J6 j& I1 W" ]) i6 d271
272
3 s+ E! I' v0 F% F, O9 {1 t273
, E% o. _- m& K! J274
275
276
277
+ Z; {7 }, L! t" l& {( l278
2 T1 p- ], U( l" B8 [( ^  M279
6 U& x+ U1 D+ n7 }( d, g280
2 ?8 u  J, K' t+ b281
& n& s0 n" e/ Z/ m" |282
: z' [7 O1 S  _  D; r283
8 A: `: ^3 U; c; S- N# K. y1 E7 a284
285
286
0 h3 Y( v% v& Q% O2 T287
288
289
4 C5 @5 y/ m# B# R$ i& C0 S  t( R" `290
291
292
293
4 {# Q# _. O; [3 P/ I6 f294
3 k( V& x# a# ?' w# I, \9 a( c295
296
! X9 |! |" N; I9 X* h: ^0 ]( r297
298
  F! R8 q9 V: ^8 W5 a4 Q3 {299
300
301
" f2 @' e6 r2 e: P* l, l302
5 r, L; c4 E) q0 `- i0 y* D) u303
304
3 m/ V9 L6 Q: ^/ i- Q305
306
307
* E+ ]) E5 b3 y308
" ~8 p, m/ y$ b, }; H! }  b309
2 Z  u9 n! M, E; q310
311
312
9 g# t& r7 v, r7 a313
314
8 d5 Y) `8 r1 m  x315
4 T2 ]/ l% u2 H  C; S4 r316
317
318
319
4 v8 m9 b4 n# J' L320
321
- J; F/ }) l/ q- p" g  i; |322
  N. V0 d4 V+ o7 @323
324
) k7 ^/ i6 d; F; G% r( g325
326
7 h" J; H6 Q+ I! X9 G327
! a# V) ]' c; I) @' M' X1 G328
/ E0 B  W) U# Q+ F' ~329
7 R( A# v4 A7 K0 v* s! ]1 x8 G; T" _330
331



% Q0 k, A8 I3 g! H
+ v4 V% A  I6 |: l$ G
; P/ l, m  h4 A% P/ L# o





% H) b" q' Q2 `4 C
8 B( e  J. y$ b6 O, g& t————————————————
版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242