基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

1 S& P# `: U! [, f  Z9 c决策树模型
目录
8 \6 D: U5 k. {& |7 L% Z- y5 T0 q人工智能第五次实验报告 1
决策树模型 1
- [  _* {9 I7 ]+ B& X3 O) y一 、问题背景 1
( E6 K" g3 v1 r1 U' z2 e1.1 监督学习简介 1
- i* R) G/ ^% b# j  i/ w1.2 决策树简介 1
' s, ]1 `# r  e5 h二 、程序说明 3
2.1 数据载入 3
2.2 功能函数 3
2.3 决策树模型 4
/ O! q1 D' I% b, ]8 E, F三 、程序测试 5
3.1 数据集说明 5
0 g' S- V, W- X1 r" |# ]5 C5 D3.2 决策树生成和测试 6
3.3 学习曲线评估算法精度 7
9 H! _% w# ?, G$ ]# I% A四 、实验总结 8
附 录 - 程序代码 8
一 、问题背景
1.1监督学习简介
机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
* q0 c9 Z2 D- z& P6 `. v0 p  I监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
' Z* }# `0 |* T, Z3 B- h- m常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
4 w" _  P' H9 }8 k8 A$ |1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
; Y+ Q! N) D! u3 m! T6 h决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。

import numpy as np
from matplotlib import pyplot as plt
2 O7 C7 p" s4 x) r5 s# \from math import log
import pandas as pd
( N5 u: A( u  H1 U  Dimport pydotplus as pdp
5 j3 Q' s9 a# k% X2 D; `4 a$ q
! p, r1 e% n0 z. D$ e# k' ~( V/ j"""
19335286 郑有为
# k) t: D  d5 r: Z7 d' G: _人工智能作业 - 实现ID3决策树
"""

nonce = 0  # 用来给节点一个全局ID
color_i = 0
% Q: l$ }( {& y4 g# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
) H* |/ X$ S. ~/ b8 }1 V6 }4 ^color_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
% q# |' G. c- O- i& d( f, r* S
# 载入汽车数据, 判断顾客要不要买
' S+ B" K$ c! T0 w3 Sclass load_car:
    # 在表格中,最后一列是分类结果
+ _) q" l! T, l  E) q0 e6 I6 ?    # feature_names: 属性名列表
6 q: X7 `) n0 N- q8 N    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self):
% r  w+ ^) _- N( e4 ]# }) Z- }        df = pd.read_csv('../dataset/car/car_train.csv')
        labels = df.columns.values
        data_array = np.array(df[1:])
) n! [' W# u. \        self.feature_names = labels[0:-1]
5 n- ~  U8 F4 i0 v7 j        self.target_names = labels[-1]
        self.data = data_array[0:,0:-1]
3 r1 e/ m8 a+ a5 n        self.target = data_array[0:,-1]

* g9 `4 n& [. @# 载入蘑菇数据, 鉴别蘑菇是否有毒
class load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
" B: l3 e+ |9 }6 C) B5 o        data_array = np.array(df)
# b$ g4 n( l/ K: 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",
. ^7 I; D. \+ w) z7 p' g4 S& C                  "stalk-surface-below-ring", "stalk-color-above-ring", "stalk-color-below-ring",
1 P& o& t, r/ V                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
0 v- i) h6 R9 M: ~& |) Z4 X        self.feature_names = labels[1:]
0 D. g5 {( p  b3 ^' L- A        self.target_names = labels[0]
) A( \8 p& W! V$ F* X$ q. q) G        self.data = data_array[0:,1:]
        self.target = data_array[0:,0]

# 创建一个临时的子数据集, 在划分测试集和训练集时使用
class new_dataset:
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
* [7 V$ c' b& n+ ^  s        self.feature_names = f_n
9 l: ?% N8 E$ U/ }2 Z8 q        self.target_names = t_n
        self.data = d
        self.target = t
( r7 t4 N( F  B* E4 M
# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
# target: 分类结果的列表, return: 信息熵
def get_h(target):
- \8 l3 ~0 R) j5 ?( N5 e0 E% t    target_count = {}
    for i in range(len(target)):
( P, S0 W" q$ A" [        label = target
- @: b, z+ {* e* p3 S1 P: u        if label not in target_count.keys():
            target_count[label] = 1.0
        else:
; `+ U& h" ~! ]3 s            target_count[label] += 1.0
$ v. |& k' j4 u/ I, n) T6 \    h = 0.0
    for k in target_count:
1 J$ }7 @( M* l  o" \        p = target_count[k] / len(target)
        h -= p * log(p, 2)
- E4 `0 Y3 \  p& a& Q! f    return h

( F/ p$ M0 r4 I$ m& J& T# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
def get_subset(dataset, feature_name, feature_value):
6 d2 U4 D- M* Y, q6 W( c3 a3 m* y    sub_data = []
- [( O* i1 g2 q; \/ o    sub_target = []
    f_index = -1
    for i in range(len(dataset.feature_names)):
        if dataset.feature_names == feature_name:
7 @5 T  e1 H' i            f_index = i
1 l+ ?, [$ i9 t0 A8 ]% \# m  u            break
7 ~9 Y; i. K1 {4 t
    for i in range(len(dataset.data)):
3 f0 K- x) \2 D; q) b        if dataset.data[f_index] == feature_value:
: l- U1 [( g/ W5 K! k            l = list(dataset.data[:f_index])
            l.extend(dataset.data[f_index+1:])
5 T' A# n; b$ L2 C3 H* J            sub_data.append(l)
5 O! A$ U* W0 W# H            sub_target.append(dataset.target)

    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)
- y0 ?" E, I) Y( \& z7 }
# 寻找并返回信息收益最大的属性划分
* G! I, @# Y! _# 信息收益值划分该数据集前后的熵减
8 d2 _3 t7 M0 e0 l5 e; m: Y# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
! J) E* {$ f- I. E- Jdef best_spilt(dataset):

    base_h = get_h(dataset.target)
    best_gain = 0.0
" g' r- t1 i7 V& Z) N) j* j    best_feature = None
: t$ K; l2 u4 n; ~. X' b    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:
+ u# W( z- b. _1 l" N( Q# e                feature_range.append(dataset.data[j])

+ }( b, H. A0 G3 |! b% S        spilt_h = 0.0
/ w( V, Q1 i- C& @        for feature_value in feature_range:
            subset = get_subset(dataset, dataset.feature_names, feature_value)
            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)

2 W# O2 V- {5 o0 y/ O        if best_gain <= base_h - spilt_h:
5 b8 z& G; f# _, r            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names

    return best_feature
5 r3 Q6 a: n+ S1 r/ v
3 w: k7 Z6 A% l5 W7 f# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
    target_range = {}
8 ^+ S9 L' k4 y) Q2 W7 m# q5 O( ^    best_target = None
    best_vote = 0
. t5 Z' ]# ]( T9 u& ^' p
    for t in dataset.target:
        if t not in target_range.keys():
* o+ g# @# K2 R6 n  C0 n" X            target_range[t] = 1
6 A# H9 ?1 a5 A) d! e        else:
            target_range[t] += 1

    for t in target_range.keys():
        if target_range[t] > best_vote:
            best_vote = target_range[t]
            best_target = t
4 q7 n" C" c/ b. M8 V% ]
' w5 S6 u' D; m% b% w9 f; `! y    return best_target
% R& w3 M' N8 J  `0 Z
, E. @( |. Z( g  N# 返回测试的正确率
# x: I, H" f4 z3 S# g# predict_result: 预测标签列表, target_result: 实际标签列表
def accuracy_rate(predict_result, target_result):
7 g# i7 ]( |! a+ L) R6 S    # print("Predict Result: ", predict_result)
    # print("Target Result:  ", target_result)
/ v4 C8 w& C$ F7 i% y2 _- ?# `9 Y7 ~    accuracy_score = 0
    for i in range(len(predict_result)):
' d) r9 i8 N0 x* ^        if predict_result == target_result:
            accuracy_score += 1
3 F- R9 f8 D6 h    return accuracy_score / len(predict_result)

4 W% w$ h& O2 O0 C+ F  e# 决策树的节点结构
0 I& s9 \8 ]) qclass dt_node:
3 E7 q9 O+ ~, f
  D3 b% p! D+ @$ C3 J% ^. `# Y    def __init__(self, content, is_leaf=False, parent=None):
        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
        nonce += 1
$ K: U, s; ]5 e' c$ m' G3 T        self.feature_name = None
        self.target_value = None
: `8 s( @4 ?! o% K2 \/ i/ V        self.vote_most = None # 记录当前节点最可能的标签
        if not is_leaf:
  ]5 ^: Q1 b! J  y6 b, Z) l            self.feature_name = content # 非叶子节点的属性名
        else:
            self.target_value = content # 叶子节点的标签

        self.parent = parent
3 G0 B+ n1 F$ I2 c2 ~' K( x1 u        self.child = {} # 以当前节点的属性对应的属性值作为键值

5 X0 P" y  U. i8 O7 s, i( F: I# 决策树模型
! g: U' L/ G' w5 \, I$ R6 q2 Lclass dt_tree:

' k% ^. x/ a8 l" E: Y: X$ ^. S3 w    def __init__(self):
+ P/ _. i( U! I; _0 D        self.tree = None # 决策树的根节点
% r) g3 P1 N  C        self.map_str = """
            digraph demo{
            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
            edge [fontname="Microsoft YaHei"];
* w, k. N: c" h* g            """ # 用于作图: pydotplus 格式的树图生成代码结构
; q3 U2 Y& ~+ `. Y8 m/ j3 Z        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值

    # 训练模型, train_set: 训练集
    def fit(self, train_set):
. h+ `& e8 \" E' L
3 m2 T3 Z; [- V5 _. e3 h4 q        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
            return None
: K+ G7 V% P5 L" z
& {, l6 `; f/ L' p        target_all_same = True
# Z) Z% K5 H' k3 D9 S/ [8 W        for i in train_set.target:
            if i != train_set.target[0]:
                target_all_same = False
                break
" X& Y' h- Q: v4 v
        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
+ ~+ ~. G- S, G- t1 O% k2 A( `            node = dt_node(train_set.target[0], is_leaf=True)
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
$ J8 I- k& S- K9 F0 X% v8 Z                self.tree = node

            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            node_content = "标签：" + str(node.target_value)
. h" w) b+ }. z. p: F$ ?- U7 P            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"

            return node
        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
8 [. \3 s& R) o, A                self.color_dir[vote_most(train_set)] = color_set[0]
7 V$ p: c6 T( J# d/ l' n                self.tree = node

' W0 _: p- y" s7 t, p- l            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            node_content = "标签：" + str(node.target_value)
% y; u' k) k8 G. M: s2 [            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"

            return node
        else: # 普通情况, 构建一个内容为属性的非叶子节点
1 e2 f5 P7 c# e# L/ S3 c            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
            best_feature_index = -1
            for i in range(len(train_set.feature_names)):
                if train_set.feature_names == best_feature:
                    best_feature_index = i
  p4 p/ ?" J) L  c- K                    break
8 T) X0 u* F- X6 h
            node = dt_node(best_feature)
5 X& O# O& s# ^6 }5 j& e            node.vote_most = vote_most(train_set)
4 Y8 H- i" l; y+ @            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
                self.tree = node
                # 用于作图, 初始化叶子节点可选颜色
! i  M5 P* l: ]3 K$ r  @3 }                for i in range(len(train_set.target)):
. R1 D5 y4 z$ I, `                    if train_set.target not in self.color_dir:
                        global color_i
6 i+ [  M0 o- L3 o: D                        self.color_dir[train_set.target] = color_set[color_i]
+ z2 a# E9 i2 t% p, D6 c                        color_i += 1
                        color_i %= len(color_set)

  {0 D; s7 [+ D4 P            feature_range = [] # 获取该属性出现在数据集中的可选属性值
$ B- K  X6 k' a3 g* B: P            for t in train_set.data:
; {; F/ e' U/ t* ^! }                if t[best_feature_index] not in feature_range:
7 q9 v6 e6 v" q4 w2 V* |                    feature_range.append(t[best_feature_index])

            # 用于做图, 创建一个内容为属性的非叶子节点
            node_content = "属性：" + node.feature_name
  I; l( \: G& i) I- g( U            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
# `! K% o6 J6 H9 {
. m" s& Y2 q/ f! Y; r            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:
                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
                node.child[feature_value].parent = node
3 |! r8 N+ @! y
                # 用于做图, 创建当前节点到所有子节点的连线
4 O+ b! D' I5 F! k3 d: N                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"

8 L  c- h1 n* Y* b" J6 b            # print("Rest Festure: ", train_set.feature_names)
            # 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)
- m, |. `$ g/ W( x" G( ~! n            return node

8 s$ K* J5 x' P8 U6 H- U    # 测试模型, 对测试集 test_set 进行预测
* V) B! P& k( A& O5 H+ H    def predict(self, test_set):
        test_result = []
        for test in test_set.data:
            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
            while node.target_value == None:
$ m0 n5 R) c+ p& U% T& Y                feature_name_index = -1
                for i in range(len(test_set.feature_names)):
$ C6 L: F! N( t6 z7 u                    if test_set.feature_names == node.feature_name:
9 C2 S7 b) Z4 k: B, U                        feature_name_index = i
                        break
                if test[feature_name_index] not in node.child.keys():
5 x) P8 ^% Q5 Q, ]                    break
                else:
                    node = node.child[test[feature_name_index]]
3 q1 C4 O1 G5 L/ T
" S9 @* M% h4 {  q            if node.target_value == None:
+ A9 A2 u( `+ y5 ^4 Q                test_result.append(node.vote_most)
. n+ ^5 y' j4 ^0 ?9 u            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
7 S8 |+ i$ e3 Z7 l5 T4 X                test_result.append(node.target_value)
" ~6 G  U& q# u) Z9 C
: j( S4 U& w. Z: o$ c8 k        return test_result
. T6 b* e( ?* R7 G
    # 输出树, 生成图片, path: 图片的位置
% y* b& o: F0 f1 }) x    def show_tree(self, path="demo.png"):
! i# A7 D5 y1 `2 t        map = self.map_str + "}"
4 B- j" e8 u! U" R6 A        print(map)
        graph = pdp.graph_from_dot_data(map)
/ A& M+ M% m, k1 f- X; t        graph.write_png(path)
) |4 V8 s2 Y( n8 \. z" ]# G, v
# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
    c = dataset
$ |. t4 k' p# o1 Y: O    r = range(5, len(c.data) - 1, interval)
    rates = []
2 C: L. b  a9 G3 N    for train_num in r:
        print(train_num)
. h, h0 B8 S  r        train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
, R9 ]! N. G1 \3 L7 |        test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
0 l6 m- z' J! Y. r        dt = dt_tree()
        dt.fit(train_set)
, i9 Z8 M1 o6 W7 J( p; E# T  C        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))
% ?2 \2 e5 J: a. M
    print(rates)
: F# N# _+ v6 C9 ^  h& v    plt.plot(r, rates)
0 I: c1 M0 s. L5 Z    plt.ylabel(label)
  C3 ~) |7 S/ ^6 x    plt.show()

  @' J" w8 d) ^$ fif __name__ == '__main__':
$ c0 v: ^# m2 {
2 q" s& V; L7 V" ^+ F/ w2 a    c = load_car()  # 载入汽车数据集
    # c = load_mushroom()  # 载入蘑菇数据集
' x: G# x: [2 z2 c- w    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
7 i, m! Z  e8 {1 g; W8 _    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:])
# ~; }+ k- l- ^; X: j
    dt = dt_tree()  # 初始化决策树模型
; h1 W* X( i/ r8 I7 Q! h$ X8 q    dt.fit(train_set)  # 训练
1 ?" T9 g1 O8 E& J' |    dt.show_tree("../image/demo.png") # 输出决策树图片
; n  r, F) d% H3 Y$ }) A! e    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧

    # incremental_train_scale_test(load_car(), "car")
1 P9 F& N, p0 \! G5 S    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)
( Q2 }! U& u/ l

: A& j, @* e) ^" {  p% P6 X
! _3 \+ i/ L/ P9 w7 }1
- ?: ]  m! H% d4 `% v' i9 V2
3
4
% ~  a2 Z2 Z/ F: X5
6
# H- F) i7 E$ f$ L, S7
4 ]6 o1 e5 r7 m6 E, }8 o$ j8
) X2 J. ~: z6 i4 l2 n) J. {6 [9
  t. e6 S( A+ a* g10
11
12
- ?: r) h/ A. G! x: c% |13
  G+ @) T1 A6 m% O, P% p14
  N9 l; F4 ^1 [7 W! R: V15
, D& Q& C2 w4 o, s16
$ O" W' w9 X6 B4 G# _17
- ^5 T, [$ H/ s4 V% `5 N& R! N* R0 H18
19
20
21
9 Y* F; j2 a/ \22
, V0 _( ?4 L' X9 ?) ^23
24
7 _5 V" ~# G8 U2 G4 ?) ]25
1 C/ S6 _0 ~3 X# C! A26
$ _8 Y. J4 r/ x# L* g27
/ S5 }7 X9 U8 b- P4 Z. q28
29
+ a0 j9 g, t1 X$ @8 a# L/ ~30
31
32
33
34
35
, H2 o9 H) U: U( U& y' I+ H( F36
7 J( T  g3 L6 j; V37
, Z: ^7 N; q# [8 h9 Y+ Z0 Z38
3 ^) R- D4 l$ Z% D' h3 l1 P39
, r( f& {3 M/ G2 ^+ G  I40
41
! s9 C3 b/ ~7 ^/ G- E42
43
44
* l5 ]: Q( }2 f+ _0 ]! j1 t45
! y6 l* W, t9 H/ d# ?0 P% p, W9 i46
3 ^8 y  y0 }/ L& z- M, `47
0 ?) o6 r9 G+ I  @48
49
3 a: G7 B+ m" ^6 Z) p, }5 c50
- Z& I2 s) S1 ~- u9 V( N3 w51
52
53
54
% Z* l9 x+ ~* d' u* P$ G55
: O3 X" e' W9 w! f* n0 p: _56
57
58
. {: t9 I4 P3 F59
9 P+ }- v5 H# t+ w: Z% s- U1 R60
61
62
/ b/ B$ i/ m% A63
64
65
66
- @: H6 [! \  _! Y, \67
0 C6 A! {  [$ r6 Y. T" P68
. x  _8 q6 E5 m& B69
7 ^; L" A/ b3 ^! V6 L# q6 z- m  L" `70
' h" b0 X5 \* n- B71
! f! v+ y0 J) R7 U2 f' D72
73
74
75
4 D# |. j7 N0 e3 \76
77
0 c) J; t2 O  O7 l78
: Q( T. V! @# ~2 u5 |" \79
0 Z3 r! L6 U# N# O80
$ I3 J) W% }' F, O; c# @1 o81
$ @3 i% [% @  d. s. u4 k82
83
84
85
$ E! m/ H$ _: @5 U86
87
8 s1 ^- L/ R$ b7 d7 {88
89
90
2 O4 `7 l* Q$ Q: b4 Q91
92
& J$ Y) r. W4 U. O) z, N+ J0 v# K93
0 y# K6 A9 y5 z( ?, ?5 {/ `( A94
7 e& a5 v0 ^6 f95
: X( W4 c; t( N3 y: F+ `; N+ N96
97
98
8 Y3 e9 _) G4 p99
" P4 `  F! x. ?+ M6 g100
101
102
8 b4 D+ V! A2 t5 k1 a103
" p7 F9 w' c/ ~+ Z6 O; s104
  I; m  P2 G. a# v" n6 ]1 \' m105
106
107
/ E4 G. a7 b) F- Y% ]108
; c$ |9 ]. F: A- z# a! L109
5 O: R6 l- |0 E# f110
111
112
113
114
" _, J/ B% A/ `4 L6 M4 E+ y. }115
116
117
118
6 Y( E# Q6 x# w, a7 Z$ N119
( j$ `# X  R% t. [$ h+ o8 y6 G  A120
/ i, V1 P* l/ e" W) W( e. `. N& T121
122
/ G" S* |" w1 S+ V! g1 X5 j123
9 R$ d4 T' a* h# u124
125
126
0 g/ z* V5 f3 ~$ h' A127
128
5 {7 b6 m5 A$ |* {, c5 U  t129
" a3 j+ l- f6 Y. |$ K7 |5 y/ u% O0 C130
) ~" W8 @7 h2 A. Y131
132
133
+ J+ [  {* P% X3 Y134
0 R# E5 q2 [- D+ _$ a0 s+ A2 V* W8 f135
# X& T7 ]' a1 {136
137
138
139
140
141
* f1 v% I3 }" A# O$ m; g: K5 d142
143
8 `4 b$ \* ]# D" ~$ D144
145
' j0 a. ^$ U6 M/ {" s) }' W) q146
( v% ]: n3 ]  o& V, V3 n147
148
5 u$ M+ v& ]# f4 `2 C* O$ k8 F+ U149
150
: g# t. j) K3 G! w9 [151
152
% H- J' r& p  r0 f153
) _" O* c4 \) c# t' c4 w1 G. O154
$ G% G3 ^/ p" m$ W  B- r155
156
157
% w: X) `! q  ^* ]158
159
160
161
% U: a/ S) b; G162
163
164
165
  X  {' T2 D, R7 N1 F166
167
168
169
170
  ?0 R' i: g$ Y5 y171
( U' C5 C! m9 h7 S  H172
% X; E: w7 v% [5 N8 h# F173
+ i# t: ~7 ~' L1 n. }; A174
. S" a0 n" Z/ T6 c  H$ K175
+ n+ s4 U& ~7 L/ {  v# g& w6 m6 P176
177
178
179
180
. |9 {) `  ~7 O( V181
182
183
: Y! `, y  M1 D1 C9 C184
185
$ m$ y$ K2 V) p5 G186
187
1 D4 Q3 W, E% X! f/ s2 M* |188
7 E# r+ G& r6 W1 m# m5 h& f189
190
191
8 Z# f" T8 c- z9 d3 b192
193
! G- ?7 H/ E  g1 r6 I) {8 [/ n194
195
! f$ k/ `4 F) D! @. Y196
; T* ?! n5 s. A( L- ]5 C/ l197
& N8 g4 O- `$ _  x198
199
200
: h6 X' q. v. S201
202
. |9 @7 l1 `7 `203
204
0 K& ~1 x# |0 p# \  A* e5 f205
206
. y$ X* y: w; K: ^6 m2 b207
8 p4 y, Y: I; h/ N; R8 T/ d208
! W/ K6 s5 |2 U5 T3 {209
210
211
212
  P/ K+ q6 K* q, J* j5 y. _5 b213
214
2 [1 `$ Q/ }$ T4 J( T  Z5 Y1 O215
216
217
" ~: S6 p* a4 q, Q. D  l218
219
220
5 l* X5 y$ g  L9 [' R221
8 u8 V' O4 g  V- D4 J) y222
, F: ^/ k8 |3 w- S4 _223
: ?$ h- i- L9 E' B2 K224
225
" ]) \4 Z( S1 P  F+ u  N9 x, e7 K226
227
. e# \( [+ \2 Y1 N) S- f: j9 U' \228
229
7 {% ~" l( M  _230
) @5 f* \7 l# K4 U# c7 p231
232
7 r6 k7 Q. {8 P9 d+ @6 ^233
234
8 h. l0 t1 l' ?$ p5 S/ c" g0 S* c235
" e. s) d8 [, ~6 ]% ^6 A3 A236
237
238
& w5 `# g2 i  I7 ]' I239
3 K( _+ E. K" A* u% Y7 H' l240
' w2 m3 c  N: L$ J. n' }4 ]4 H241
) |, [! B# ], f5 A( B+ A242
243
244
: y5 w% x3 a6 d3 J% ^: U' q$ b, \245
246
6 n9 G0 F& z8 d" t3 u5 |/ p) o& e247
" ]7 Q% Q6 X; K3 q$ S248
: i1 P) k& p$ k5 t249
250
251
252
8 P- x2 t8 O" s) N' I" s253
254
  K) B; p0 s4 E: K5 X9 U# ~, f, B255
256
/ N( Z3 ~, t" Q$ f! b257
258
259
260
' E, X3 m) W1 B: |" _4 N261
- g7 f7 `8 C; M( g) U262
$ I4 [1 o* f# q+ I8 ]263
- l. h; _% N) s1 u264
  u* M6 J* G6 Y) x& ^3 V; d1 v8 s7 g. L265
266
0 S* H  g+ c2 W" H# f/ j% S. f267
! T4 ?; j/ B4 h7 S7 C) v& E4 h268
  c5 u$ {3 S! D; g5 \% H# t! M: W269
270
271
5 ~, Y/ T' R" _! W% I272
273
274
275
276
277
278
2 F5 P  Q" W% ^' L( ]279
6 s9 {- j8 N" k; K) I5 q# N280
281
( v% y( v" P& L4 n7 E8 [282
283
284
& S5 |3 r* P0 q# q3 Z1 M- o/ Q285
. U3 m0 f' E  \0 ~. ^286
287
' Y* i5 A& U" P, ~9 U( M288
  J- c6 S* J* e: X) P2 H. T6 C289
290
291
, c3 x* g# {3 q  z  R1 z3 s292
293
) u, t% c! v( C1 K, b! u294
295
4 P1 S+ Y& ^$ a% `- u! n, \296
297
298
299
300
301
0 W+ {, _. K( w# O: u9 ^302
303
5 Y$ ~& a2 s6 _, N  Q' A304
' t3 |  W0 ~/ L305
+ p+ }8 u) |( o7 ~9 E4 `( ?306
3 f/ u8 f( |# U( H0 Z307
7 s' N& P# g! s8 H# L/ i0 o! A308
' Y( S/ \* \, W7 f+ T309
7 b* Z# j4 Z" C310
311
312
0 ~' ?: w$ E; a5 x( w/ ?313
314
! l/ I. U. F# s) b% M315
7 [4 e! x! @* y+ F; ]9 d316
6 ]$ \3 b) N4 S8 C317
318
319
320
1 Z$ F& m( T7 C4 k321
322
9 V. m- _5 t4 \+ q6 C" d323
9 H( X6 V+ C% a  X3 a. K324
325
326
0 S- K) g& e* u; C3 Y% S: l327
328
329
+ G8 Y% D) z4 I330
331
, W" E5 g% a/ }9 G



" N- T7 \1 q, b( S$ w

7 C# @' Q% i( O4 T, R+ W8 M

, i3 b" e: F& T5 I  k
9 f7 h- u8 O7 P( Q  D$ ?
1 Y  ^4 t. ~9 d6 G
% ?* L) ], Z; _3 ~8 V- R
————————————————
8 O4 M: n  w, ?" w) _2 X9 S版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242
, u* C7 J4 q: {* `1 l, k$ S
5 @; Y; I$ _. s1 Q+ d% ^8 ?2 e' c
1 A0 Z5 V7 y- L* x/ T$ a9 _2 m