基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型
  C( T, q9 V: b4 z. n$ `& H6 ]
9 F: V, d% _1 Y6 B+ y决策树模型
; t; p$ z3 g8 s, o3 z目录
人工智能第五次实验报告 1
决策树模型 1
3 E9 Y0 }" m4 R一 、问题背景 1
' D. Y7 f8 \9 R6 l6 V+ G9 @1.1 监督学习简介 1
+ m( @5 p% e' R/ L4 k1.2 决策树简介 1
" Y3 v# E7 b. R' d" b二 、程序说明 3
4 ?3 D! V! Q6 s7 b1 ^2.1 数据载入 3
2.2 功能函数 3
2.3 决策树模型 4
7 C5 m9 Q; o4 C3 J三 、程序测试 5
3.1 数据集说明 5
8 D3 m! H/ e- P) ~$ I3.2 决策树生成和测试 6
3.3 学习曲线评估算法精度 7
四 、实验总结 8
! W! `' c# u3 K9 H/ ~/ j2 m附 录 - 程序代码 8
一 、问题背景
1.1监督学习简介
机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
' i$ a& J* h. [/ `5 _" @监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。

import numpy as np
6 C* n2 s  ], l! D8 P2 f. ffrom matplotlib import pyplot as plt
- _  h( m. Y# P) N7 kfrom math import log
import pandas as pd
, `3 q# Q! t  S) eimport pydotplus as pdp

"""
' X/ ]" p0 M* e- g6 j/ s/ j2 L19335286 郑有为
! l! h- P7 A7 e4 q6 X2 u人工智能作业 - 实现ID3决策树
9 z9 P9 G% O8 \1 n! w"""
2 t+ \# }: B& ~8 M8 g6 ^# J
! w% F8 }4 i( w2 X& c, V/ @0 Pnonce = 0  # 用来给节点一个全局ID
color_i = 0
+ T2 _0 `; e7 ^# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
8 M- I; c9 e5 ~! `1 I( Z, p  O* [* @color_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
  y7 W6 u6 k" ?2 D$ E; e
# 载入汽车数据, 判断顾客要不要买
- _* [# g' P9 v2 Gclass load_car:
# Q" Q  T9 C7 Z" }( y8 O/ `    # 在表格中,最后一列是分类结果
. M* w' Y' E1 }    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
. }' E) A) @' r; `: ?( S/ R6 T    # target: 目标分类值列表
/ u5 q/ s) e! v6 E+ F# t, r2 x    def __init__(self):
3 t' W$ _5 ^. _$ [6 @* Z* _2 J        df = pd.read_csv('../dataset/car/car_train.csv')
        labels = df.columns.values
: H( M' k. V  B- N        data_array = np.array(df[1:])
        self.feature_names = labels[0:-1]
        self.target_names = labels[-1]
( W' f) b  R4 ^. k" W4 z        self.data = data_array[0:,0:-1]
        self.target = data_array[0:,-1]

0 W/ P+ s/ W" y9 D8 v. W# 载入蘑菇数据, 鉴别蘑菇是否有毒
# x* K8 k# t' p! a  eclass load_mushroom:
  e' B; T  `9 a5 M0 w* {3 j) v, v* w    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
8 s! `; w9 Z1 x+ F" z& S9 x4 t1 H    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self):
. J0 S5 h9 ]. z        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
        data_array = np.array(df)
- v0 {. e/ P; o1 g) S        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"]
        self.feature_names = labels[1:]
        self.target_names = labels[0]
( I! p3 h' h) E; m- F: I        self.data = data_array[0:,1:]
        self.target = data_array[0:,0]
' e! a) n5 N( x3 |, @. d- o
# 创建一个临时的子数据集, 在划分测试集和训练集时使用
# U2 y0 {9 D, Aclass new_dataset:
! c/ K" E$ t3 c    # feature_names: 属性名列表
    # target_names: 标签(分类)名
$ o2 c- c* @( C  q4 ~& q7 F* f) d, F/ [    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
& L! a2 @: X* Q: I- A  ?* g        self.feature_names = f_n
# y3 A% {6 e4 d9 z" _3 T        self.target_names = t_n
        self.data = d
* k1 p3 n& c1 r6 d, ^+ n        self.target = t
3 Y$ H2 ^& m8 c
# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
# target: 分类结果的列表, return: 信息熵
def get_h(target):
9 k. p( H+ s9 ^' [/ b) f6 J/ h    target_count = {}
    for i in range(len(target)):
        label = target
        if label not in target_count.keys():
: K  \2 n  S4 v0 L/ [            target_count[label] = 1.0
7 y5 \8 M+ j9 W! Y& K        else:
            target_count[label] += 1.0
; T$ Z$ r6 [& W8 i    h = 0.0
% Z" x$ |3 C$ B4 ?& E    for k in target_count:
        p = target_count[k] / len(target)
        h -= p * log(p, 2)
; A) v. w5 g" Y; K! T2 J/ y    return h

, _8 \" S. L  Q# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
  [+ y4 `; [' d  n* ?def get_subset(dataset, feature_name, feature_value):
    sub_data = []
    sub_target = []
    f_index = -1
  C$ r6 m- z3 d5 a9 P4 e    for i in range(len(dataset.feature_names)):
        if dataset.feature_names == feature_name:
            f_index = i
9 y! i2 i0 V6 N0 Y( T# M2 ?            break
5 U0 O8 w  T5 F
  k* {$ H. V7 k    for i in range(len(dataset.data)):
        if dataset.data[f_index] == feature_value:
1 S5 A  ^# x( q5 A( t            l = list(dataset.data[:f_index])
  v+ O2 N5 n% H6 i% j- O% @            l.extend(dataset.data[f_index+1:])
            sub_data.append(l)
            sub_target.append(dataset.target)
, ?' D7 ^) s" x* b' R) z
    sub_feature_names = list(dataset.feature_names[:f_index])
/ ~/ e6 _" h5 A! `8 y0 k* Y    sub_feature_names.extend(dataset.feature_names[f_index+1:])
- H; U6 y8 E: J& h6 P$ }    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)

( Q  |  ^% z" ]2 O: o) ]# 寻找并返回信息收益最大的属性划分
# 信息收益值划分该数据集前后的熵减
  {* b! t1 y' \6 @# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
def best_spilt(dataset):

& ]8 p4 ^6 n. x, p& j* X' a    base_h = get_h(dataset.target)
  Z( K9 F! b: p7 E7 X    best_gain = 0.0
    best_feature = None
    for i in range(len(dataset.feature_names)):
! M$ s! P# J8 p! P3 ?        feature_range = []
, u5 m1 L/ E0 N0 I+ n1 F* y        for j in range(len(dataset.data)):
            if dataset.data[j] not in feature_range:
                feature_range.append(dataset.data[j])
/ ]+ U" O- W% |
- o! W! T' z* o' @+ ^8 Y        spilt_h = 0.0
        for feature_value in feature_range:
0 O5 N% i; U- W            subset = get_subset(dataset, dataset.feature_names, feature_value)
: ?: b. t# \5 K! P) |+ B            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)

! v: a+ `: R0 ?0 H        if best_gain <= base_h - spilt_h:
            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names
7 S1 b- |4 d) H% l: [6 E5 ]
    return best_feature
7 D" f+ [6 Q- x2 M8 c
# 返回数据集中一个数据最可能的标签
1 I" G* h- r: jdef vote_most(dataset):
2 |! e; s+ `% Q( c& p3 Q    target_range = {}
$ a$ w1 N5 h. h7 @1 Z    best_target = None
' ~& H) C# Q4 N! T" C8 C! a! H    best_vote = 0

; r+ O$ _9 g) l) m    for t in dataset.target:
        if t not in target_range.keys():
) ?0 }4 d, J- z  K, y" J# i* t. c, ~3 v            target_range[t] = 1
        else:
% D8 |3 ]2 x7 O$ A) R/ c4 _            target_range[t] += 1

    for t in target_range.keys():
2 s! m$ x) T5 f5 u        if target_range[t] > best_vote:
            best_vote = target_range[t]
! D6 F9 {  b5 A% G8 l            best_target = t

    return best_target
& r$ K1 \5 N4 N* k
# 返回测试的正确率
# predict_result: 预测标签列表, target_result: 实际标签列表
' q& F7 F7 p( s% q, bdef accuracy_rate(predict_result, target_result):
    # print("Predict Result: ", predict_result)
/ m5 K; n4 E" r# v    # print("Target Result:  ", target_result)
% O' t: G# s/ [+ }    accuracy_score = 0
    for i in range(len(predict_result)):
        if predict_result == target_result:
* k1 b% i% J7 [) x) b  S            accuracy_score += 1
    return accuracy_score / len(predict_result)

# 决策树的节点结构
2 f0 Z: C1 Q4 _3 Rclass dt_node:

    def __init__(self, content, is_leaf=False, parent=None):
        global nonce
* p. H' ~, g* I/ @: a        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
        nonce += 1
) k2 V" C5 {# u2 A0 g( l        self.feature_name = None
% B/ y) o0 j4 M3 S- `" G        self.target_value = None
) U0 w+ K( s5 Q2 P8 [; @        self.vote_most = None # 记录当前节点最可能的标签
: w, m4 }. }3 P/ |* [        if not is_leaf:
0 r$ T7 `/ n- E& B8 W            self.feature_name = content # 非叶子节点的属性名
        else:
* A/ W* T* N) ]( @6 q            self.target_value = content # 叶子节点的标签
) E, T& V5 U( z$ I  n, |
        self.parent = parent
& B9 ]. m* B+ o! P& p        self.child = {} # 以当前节点的属性对应的属性值作为键值
( G, B4 ^: Y+ ^" ]$ e: Q$ b0 v. ?" D
# 决策树模型
class dt_tree:

( V( \/ v% P' G+ o$ w    def __init__(self):
8 }( i4 c. i/ `2 w# n- H, V2 _        self.tree = None # 决策树的根节点
        self.map_str = """
6 _# A# A/ g' r; c% F            digraph demo{
            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
- r- g" Z, k0 J( B            edge [fontname="Microsoft YaHei"];
6 i% V  V5 X8 h2 Z! b+ Z            """ # 用于作图: pydotplus 格式的树图生成代码结构
1 n* S; I( V) W2 \8 O3 T* u        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值

    # 训练模型, train_set: 训练集
    def fit(self, train_set):
1 ?1 Z( t0 P, u6 |$ r6 ?; ]
8 H! \% G: ?. K0 d  t6 R        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
9 V& q* j! C. c1 Y( b4 g0 `" A* Z            return None
  {) p7 l5 ~9 r9 A* l
        target_all_same = True
0 H& A7 k' y4 A: C        for i in train_set.target:
  F+ I7 v! \3 x8 V; x/ x            if i != train_set.target[0]:
                target_all_same = False
                break
' Z" O9 @4 V- }9 `2 \
        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
& F) T0 `# H3 y% _: _            node = dt_node(train_set.target[0], is_leaf=True)
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
% g; Y% }1 ], i/ U1 l                self.tree = node

            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
  X+ y/ u* P" a( m: V3 X, l3 ^            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"
/ O  E2 b- B) J4 R0 G/ P
; c- {( V/ b1 o7 w2 F            return node
: t7 H, S! G4 z2 \, W: x+ a        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
- u# y$ B% h- g8 V            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
7 A. r- f, I; h' p            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
; R2 ], E* `  ]  r0 {/ O' K& a; M                self.color_dir[vote_most(train_set)] = color_set[0]
                self.tree = node
6 u1 y* u9 T  s% l' J2 J# E' i
% y( _% y; c2 D* L0 k7 N" j            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
4 s" k% m# v( s& g8 F/ [            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
& Q. t: o8 n  r, T5 B& r            for i in range(len(train_set.feature_names)):
; t6 |: M) E) ~; E                if train_set.feature_names == best_feature:
                    best_feature_index = i
                    break
) b  i3 Q9 Z5 r
            node = dt_node(best_feature)
! @4 f% w" k' K( B; E            node.vote_most = vote_most(train_set)
% d+ R# O! ^! [' I1 G! r            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
7 H2 q, \* q, U/ p                self.tree = node
                # 用于作图, 初始化叶子节点可选颜色
                for i in range(len(train_set.target)):
' J) j. F7 K% ~7 u: B( X2 B                    if train_set.target not in self.color_dir:
2 a1 b! X+ b, m, I. e- k1 i                        global color_i
% g# U/ l' ]; l2 L3 R                        self.color_dir[train_set.target] = color_set[color_i]
                        color_i += 1
# X6 P; @2 r& o5 V0 B                        color_i %= len(color_set)
" h) w# m; \% B' B
2 ?# _/ c" i' R            feature_range = [] # 获取该属性出现在数据集中的可选属性值
5 s* [8 m/ i0 A, q4 s  ~  h            for t in train_set.data:
: F$ s1 m, |; a- P0 H1 }                if t[best_feature_index] not in feature_range:
0 |: b, r6 Y# r0 n                    feature_range.append(t[best_feature_index])
; e: z* ]9 m6 I- L+ ]
  J7 o8 N; O7 W. g            # 用于做图, 创建一个内容为属性的非叶子节点
            node_content = "属性：" + node.feature_name
# z2 P+ Z; d2 Q$ Z            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"

: R4 l: d0 X0 ]4 |. G' e& h            for feature_value in feature_range:
# }) @: T! o; ^0 L                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
                if node.child[feature_value] == None:
                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
& P. J9 L5 ]& n# d/ y                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
' h0 k) D4 ?, m& e4 W2 {                node.child[feature_value].parent = node
2 O4 `8 o, e' \: q
% t! k9 V+ U* k# R/ @  L4 C                # 用于做图, 创建当前节点到所有子节点的连线
0 ^2 Q6 |7 {+ g% v                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"
4 A+ F( V; q4 ?7 ]1 j1 y+ s5 D
* J+ p. l# o" Y6 G6 ^0 A1 w) A) c            # print("Rest Festure: ", train_set.feature_names)
            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
% z! p9 b; d9 L& A/ w/ h& q& }            # for feature_value in feature_range:
            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
; J2 D3 Q: e8 J: N0 m0 r            return node

+ g9 {* z: w/ D, s6 s" u    # 测试模型, 对测试集 test_set 进行预测
/ U% [: q, r. N1 s+ w1 b    def predict(self, test_set):
        test_result = []
' U+ O  I6 [+ w5 P7 T4 j2 ~        for test in test_set.data:
            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
            while node.target_value == None:
                feature_name_index = -1
2 t& S6 A6 G+ i: h                for i in range(len(test_set.feature_names)):
3 j6 r2 H5 O; K% |0 @9 F                    if test_set.feature_names == node.feature_name:
3 E$ ?% T4 D1 Y/ g9 M! [                        feature_name_index = i
                        break
                if test[feature_name_index] not in node.child.keys():
                    break
                else:
                    node = node.child[test[feature_name_index]]

" g- ?$ C, E# y5 {3 [0 n            if node.target_value == None:
7 v- n% [/ J& Q: L  U# X7 N                test_result.append(node.vote_most)
            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
( N. E; |0 V* D$ T- O                test_result.append(node.target_value)
" P) U% ~1 P4 F7 h' E1 k
        return test_result

    # 输出树, 生成图片, path: 图片的位置
! a% x3 B1 L1 Q3 H7 L    def show_tree(self, path="demo.png"):
        map = self.map_str + "}"
/ L0 X, U8 |) n. I+ J+ v  F$ `        print(map)
- V* N) K) V6 v" V        graph = pdp.graph_from_dot_data(map)
1 M8 D! ^1 J% b# Z' ?; v        graph.write_png(path)

# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
    c = dataset
# S: p; K- h0 K, I    r = range(5, len(c.data) - 1, interval)
    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])
        test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
" ]  ~. S# f7 ?7 S+ k- S        dt = dt_tree()
5 r% L4 H4 ?5 l1 u+ S: y! m7 k+ q+ l        dt.fit(train_set)
5 l, ?7 x0 [# X: ~& M' u        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))

, o3 Q! q- g# r- s8 }+ d6 v    print(rates)
    plt.plot(r, rates)
2 F9 a* ~2 w+ H8 d7 J" d9 C    plt.ylabel(label)
9 E+ z) @! s. |( i/ s    plt.show()

if __name__ == '__main__':

    c = load_car()  # 载入汽车数据集
    # c = load_mushroom()  # 载入蘑菇数据集
3 K) r0 L4 u+ J! W" l/ v    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
0 J+ k% \$ l+ A5 @% L    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:])
5 q9 C5 H: G0 B* l7 Y0 g% [( y' q- u
) ^( T$ @9 V# z0 p& s$ O' u    dt = dt_tree()  # 初始化决策树模型
  A  G& ?- q7 C! D3 i" j    dt.fit(train_set)  # 训练
    dt.show_tree("../image/demo.png") # 输出决策树图片
    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧

    # incremental_train_scale_test(load_car(), "car")
) F8 }$ T2 [" X$ h1 r" d' e    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)
2 m9 {/ d  C) O9 L! x' E4 E

) T; N; D6 u% E0 Z5 ~" G
" E% Z% w& a( H$ ~$ p: [6 C1
2
2 N% ?1 O# I" Q' F# o3
4
5
/ {, h% [2 N3 l% Q% F6
% u' g/ Q- U8 [5 X; ~( ]5 X# i' q7
8
9
# W2 E- F$ u/ ?10
11
12
13
14
15
2 O! C$ T6 V, B$ C* r, Z16
4 x% |# R1 @  L' q17
5 M6 Y) C' @% X: w- f4 W; P- y18
19
2 J# M" y. ~$ x  I- H( v2 e* Z20
21
22
+ `- L2 V2 C: d8 J- l6 M' r4 c7 l5 i23
. }% _  W. K- A: f7 Y' v) [24
% `9 t" ]! K, {& d25
26
27
28
) P% L$ I, b6 c$ ]# _) X29
30
31
32
33
: h5 V9 M4 D. ]. J+ I34
* [+ \7 A4 A4 v1 g35
36
37
/ b' L; ?& D- }1 e6 U& m9 m38
39
7 g2 Z; x! A  x2 ^9 W/ a1 `40
41
42
43
; e* h! n" ^$ U/ o, N, s* |44
45
8 a9 [$ h( X5 b, \46
  [' H1 W$ u$ ^0 Q7 K47
48
% ?$ g% M7 j# H! T49
1 J6 T3 |7 v$ s3 W' u6 u50
. c3 m: G. Q$ i; g3 h6 t1 H51
9 z6 _5 z5 I, j. Q52
53
9 Y' w2 Y, a  w& e) \54
1 i8 g! |6 c# E" o" z55
  r& `. ]0 x5 G6 g) q  m56
57
58
59
5 q) ?! d( ^0 `' [+ ^+ \, P60
- |: W9 r0 V( m- O& R" e+ e9 i61
1 v3 l5 x  ~0 f% O! m% o62
63
. m& r. t- q( s% T& I7 `64
# G& b, c# k, X65
66
/ c  E& _' o1 u  J; }6 U# L; x2 ~67
* D$ F9 R) N# A& ?68
  k" P3 `3 T: B6 Y69
; p7 j) |: u0 Y8 J  i70
( w/ T3 O9 m: v% y5 Z71
72
$ {  Z& Z' X6 V" i2 n73
& |  a' D* B1 r& C74
) D4 O7 x% j. j/ p6 l75
  d9 W# c4 I" B* t) M76
1 u$ u0 x" `. \2 W+ C5 G7 v* q77
. z5 ]! |% t3 X% U4 G, k8 g78
79
80
81
- b6 y/ [9 ?# _1 k6 Z+ g" V1 N82
/ L7 p2 j! M/ |) Y0 T: J! f$ |+ A$ e83
84
. k! O+ G1 C7 w9 t85
86
87
88
/ l# D( k8 T1 z5 @' M+ b* t  h89
! B3 c% j* A6 V  [2 s90
+ r# I8 n+ C$ {2 A91
' @0 i4 A- @1 n# `% }5 C& Q92
' i: Y" v; ?. @' [. ^- @93
9 P' ]) V$ Q2 M94
$ \% P" r0 ^( _+ R; |5 O+ Y) Y95
96
. f: U" Q5 P/ ^! [9 l97
0 b. N% V2 a! w8 o: ~! f0 |98
99
100
101
102
103
104
7 Y/ H3 U  n& n$ X105
106
4 `0 ]# l1 H  @0 u* E; u+ F7 T107
% _$ h; x- s/ \2 C9 @7 }+ [/ l$ k108
109
110
111
112
113
' I, {& g) X4 b# n# E114
- ?* _7 m) N* l% `0 f1 t1 C115
6 e" q( u$ T- u: `2 c116
117
118
119
120
121
122
! r  ], j" W; P& o5 n6 L  Q123
, _3 H- q; v+ V0 F+ T124
125
7 j" ^) t# z" l* Y+ L4 w126
2 \' a5 H% z3 r3 x; D, c* B9 a: e127
; G6 I, \% |+ y& [' P2 S128
129
130
131
& W9 D4 x! o+ _3 P4 C0 h5 [132
0 K3 [% E2 v8 U5 ?133
! ~) y6 e8 a: O  V/ ?$ v$ M134
135
136
137
138
139
140
" K/ ^6 g" \' Q/ I# O$ J$ B141
+ t1 N0 U  r# o7 P+ J2 {9 @142
143
$ f4 W, S1 z1 {144
- A0 z' v7 h) q. m' L) |145
146
147
148
! B. Q0 `5 L' K* i% i. C- _149
150
151
* f9 A. \# e  _. k152
+ X* k4 A. U1 k153
154
9 @4 ~2 V3 a4 a155
156
157
158
: I7 Q; Y6 o: i$ a( n# |7 M159
160
161
6 \8 [2 {; R3 I' |" Q  |/ N5 n162
163
164
165
& D% M* \. D" g0 C. s4 Q7 |. [3 l' `166
. ~, ~2 a# a2 O( I6 Z" |# }# i) D167
168
8 T: M& O. p% @4 ?169
& Y4 i! r3 C' c1 K  M170
' Q2 f" L9 j' t& m# |171
172
173
174
4 |  ~# Y7 H: E/ O8 E9 U5 W175
176
! M" ]: }1 o* m; W7 k4 B+ z177
1 s6 O  D! u) [- N- z178
179
180
181
( N: k3 m1 D% Q5 J6 h182
183
( \5 U( u5 z; {/ q- a184
185
! M2 K$ [6 `" U! L& t3 k, a- A: b186
! l8 F  m6 H1 H; X9 W187
/ C4 K" L; A4 |/ Q( |; p188
$ l- w$ b; C8 ^# H6 I% v' B/ A" M189
- v/ d6 e9 x' u* j190
- r: _- u8 F1 f; A( E) l+ H191
8 B" H2 M# p' A; S% O192
193
194
195
2 N- w; Z1 {- j. s# f: F5 h196
197
198
199
) _/ ?3 g$ w. K6 N200
' ^$ p  X4 f. @201
, Z! @0 k8 ?) Q6 d' D202
* F3 t6 K  D! J203
0 M$ X8 E* A# B1 _. p/ K0 W204
- @9 M) |- z. M5 @$ X205
206
  K+ L+ p' G) D( q) L207
, y2 }, e4 A3 h208
209
: m6 Q1 e/ d/ {1 i8 a210
211
4 ?" Q5 j9 N, S$ I% I% _" y: H% k212
! h! p% B5 I. K# R213
214
4 u" d& n0 l% h4 O1 J1 |215
/ G6 n5 O* r* p) l- o$ Q216
; F4 E+ q- O0 m. m  V217
1 I! k2 @$ g; D218
219
220
" U) L, p+ y! M221
! p" y3 ]% s1 m+ o9 y8 S9 l222
223
224
225
226
% |* R: |- Z& ?9 p- L227
# H$ Z6 r, ^. ~* T) F228
3 c- F9 ~) R% `9 n9 Z) E) H229
  b( \: R4 k  A230
231
232
233
234
235
8 `0 i0 z% w; w- V. [2 w& n* H, C236
6 s; ?0 E! X. L237
238
  d9 l& z. b' a! e4 D( o# |5 P- Q6 P239
3 I7 }) Y; G/ m  }% G) [1 d240
, v3 `$ m$ r& x# a6 L9 _241
242
243
244
6 \1 a$ d# Q3 d' t4 R245
% O/ b6 M4 Z4 O: a' Q) \/ G246
247
3 Y& s4 }- R2 g' v' J7 U# E248
! c! x) S# s! d. @1 B' z249
8 y$ s: k/ o$ D2 q, p3 C0 q' A0 f250
! K$ v6 r' Q9 @6 `0 u8 k7 w' _251
252
! T6 l- _+ b) f) W9 N( ?5 X$ v1 i253
$ Q; r7 T  W0 t7 J7 B254
255
256
& Z! j& U# u0 B( _' c0 l257
258
259
1 f! ]; Q# `! l. [260
261
262
263
264
0 `. n) h: q; w. {4 n265
266
. c# I5 h6 s) C8 I* l5 X; i3 ]267
+ w2 Z1 Y  i- X8 {" C268
269
+ G% \+ y" i) z" B  [: J0 F) y9 i$ |270
& ?2 b5 q4 R* b' ^$ M. m+ z271
; x7 q5 x) t- j+ p272
273
3 j* B. t; x  C/ E. i9 g7 I274
/ @4 X0 p& g5 @( x( B* k) ]275
276
! X% {' S" l) G. ]277
# C: h# {% M* v( ]278
279
280
281
0 f5 j9 {. N4 X, m6 b' ?* b9 _282
4 L, z0 O6 Y4 q& H! Z; G; M283
, s8 E" n/ l( z% q9 E; z+ n284
0 j- L3 E2 U2 e- V7 u285
2 e8 J0 A0 W  i/ j. \5 r- j286
+ z; d$ _2 L% S6 N287
1 v( b& {& [. V288
" N- W# N9 J9 i6 {289
290
291
- _" I6 _7 G! K292
, q# c; R5 A8 a8 v1 z5 x, R- F293
294
295
# X5 E( L/ r7 M0 W# A) p296
297
$ \1 d3 N8 ]* R298
299
300
) V0 V: X  k3 ~0 m. A1 p: z& R6 X301
302
303
% `0 i7 g6 c- g0 w304
. I1 }7 V2 W# ?  g5 t% ~305
) a2 y1 m; K/ q6 P2 J& ?% u306
307
308
309
  n' X# v$ B6 n7 R, @/ l310
4 x  ]$ O" u( m9 l: z; j* o! n$ k311
4 P5 e2 s: T' }3 O  u6 S312
8 f% g7 \6 t; u# J- b3 {$ `- T313
2 S- d* r4 y. a3 s. \+ |4 i314
+ r' A' p5 g$ A7 j1 }* Q/ h315
# d& f1 ]5 V" p316
317
318
319
6 r5 i8 i. r0 P8 Y! N8 e8 H6 k320
4 _5 c3 o8 _. \& P$ y9 f321
322
323
* j& z) B: D. f+ Z% e8 Y2 L4 G324
/ l) _- O2 j5 b* _325
326
' o5 @; i# v$ v3 B: y; z  m  c+ N1 |+ W327
328
329
330
1 M; L6 M8 O; s331
& M7 d9 Y  R2 m% G9 C
) z8 _4 c% s* s- `- I

6 }+ W- I) t8 U3 D" a& J8 S
4 i- o0 K4 |$ n, X




# K- A( z1 F0 g


* W' `! R% u% I- L! n————————————————
8 k9 W0 G% d# m6 S版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242

3 m- c2 o1 n/ k  p) |
2 A5 f: V+ v/ Z+ R" W