基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型
( d$ k7 `5 H; s6 a$ Y" w
决策树模型
目录
% w5 r3 W$ A. }, w$ e人工智能第五次实验报告 1
; _) Y' c# h# Y' ?  n- U决策树模型 1
一 、问题背景 1
1.1 监督学习简介 1
1.2 决策树简介 1
7 s3 {: a" s/ o& U4 G: t二 、程序说明 3
$ }( B$ R6 q, K0 q5 C2.1 数据载入 3
; f- x0 t( x$ F: d. b3 U. i2.2 功能函数 3
2.3 决策树模型 4
1 X5 G( w% |2 m/ r  Y3 ^2 N三 、程序测试 5
0 ^+ g7 {( ?' }( F$ y3.1 数据集说明 5
! ]1 h' B2 q  x* Z# m2 G: p3.2 决策树生成和测试 6
3.3 学习曲线评估算法精度 7
四 、实验总结 8
附 录 - 程序代码 8
% U5 H( a8 X+ w& W2 j一 、问题背景
1.1监督学习简介
机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
+ x0 p9 {& \8 x% d常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
& @$ v) I& ^! r; `& J0 z1.2决策树简介
) x5 K' E9 s# ]) g' {. G' F决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
8 K4 W9 C- x* _& I决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。

import numpy as np
; R" ]  G5 R! p: E/ V& @8 @from matplotlib import pyplot as plt
7 R: I4 s* `, h2 sfrom math import log
import pandas as pd
import pydotplus as pdp
0 |. d- u/ I8 ^9 f
7 F( W' _4 W! ^1 m# h1 R- Q"""
/ J5 s! f: f7 D* j1 E6 J19335286 郑有为
9 V! k, X3 z! C5 l5 i8 m& E人工智能作业 - 实现ID3决策树
"""
; u" D6 J) c# o. [; z
nonce = 0  # 用来给节点一个全局ID
: |4 R* K5 @- b5 L; o# ucolor_i = 0
/ W; I7 a+ K8 s, Z- M5 J# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
! t  H! ~: I! N! Ecolor_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]

; h1 m$ n% M# B: \4 Y* x# 载入汽车数据, 判断顾客要不要买
class load_car:
    # 在表格中,最后一列是分类结果
    # feature_names: 属性名列表
( B- E2 r: J/ b/ \    # target_names: 标签(分类)名
$ Q- O. D* a/ J6 p    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
        labels = df.columns.values
( h$ Z, s2 {6 i        data_array = np.array(df[1:])
/ A2 ]( y4 m4 i  B        self.feature_names = labels[0:-1]
  e# f6 x2 Y) I+ E7 l# R3 Y2 Q        self.target_names = labels[-1]
# h! ~7 B0 }0 j! W2 d, h6 c$ m        self.data = data_array[0:,0:-1]
8 q3 z1 |3 z- c  H; I        self.target = data_array[0:,-1]

& I$ `! [, P* X! y1 u8 a/ D. T# 载入蘑菇数据, 鉴别蘑菇是否有毒
class load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
7 n2 ]; h/ e+ ?+ T! |) [( p1 S/ w- T    # feature_names: 属性名列表
    # target_names: 标签(分类)名
6 T- G* F9 I# n# w( n    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
( v4 s! O$ t6 p$ D    # target: 目标分类值列表
3 f; W4 k: K6 ?8 {/ L3 R+ W    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",
+ t3 z1 j6 R' B# t                  "stalk-surface-below-ring", "stalk-color-above-ring", "stalk-color-below-ring",
* {4 p; \8 e7 _$ N7 v) A                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
        self.feature_names = labels[1:]
        self.target_names = labels[0]
7 z* L& g  V( D" L        self.data = data_array[0:,1:]
4 Z; D( n# Q& B% K" w        self.target = data_array[0:,0]
$ F7 t2 x; ]& {  j6 z8 H2 S2 z
# v# R9 n# P9 v/ M: m4 H# 创建一个临时的子数据集, 在划分测试集和训练集时使用
; ~' B# X6 {: W* |" i7 Vclass new_dataset:
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
3 q  d$ ?# _% t, R0 f+ O/ W9 b9 @    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
" ~  S* Y) c! t5 v$ W1 y    # target: 目标分类值列表
# j) ^& h! H6 y3 B/ X1 v    def __init__(self, f_n, t_n, d, t):
        self.feature_names = f_n
: |2 P: s. c4 }" i6 F9 t) v        self.target_names = t_n
        self.data = d
        self.target = t
& d4 ?! f0 X. h
5 `. t" m! c+ z8 L$ h# I& v7 T0 U# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
# target: 分类结果的列表, return: 信息熵
8 c, v* j6 }" x$ H) pdef get_h(target):
    target_count = {}
) H3 {& ^* {) Q3 Y' A- N    for i in range(len(target)):
        label = target
        if label not in target_count.keys():
6 c" t) J) b% Z# d$ w( ^/ V            target_count[label] = 1.0
        else:
            target_count[label] += 1.0
& y; f+ K5 r! K, w5 y    h = 0.0
1 F! y8 @; F& L' n9 f    for k in target_count:
        p = target_count[k] / len(target)
' Q3 M3 X+ N2 Q) Z5 g        h -= p * log(p, 2)
    return h
; u" ~. ~, S( I
# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
def get_subset(dataset, feature_name, feature_value):
    sub_data = []
3 v2 p; q# a0 n8 ~0 k- }8 T    sub_target = []
8 Q: u1 R; t, K' x    f_index = -1
    for i in range(len(dataset.feature_names)):
+ n- v9 y1 _. u: P, F* h0 B4 H- Y        if dataset.feature_names == feature_name:
            f_index = i
& k/ o+ l7 G1 U0 c7 c9 r            break

# O6 n) P; |# A- e) _/ Z* _    for i in range(len(dataset.data)):
! l0 I3 x8 A0 r: `: X: Z) [* N        if dataset.data[f_index] == feature_value:
6 `0 L6 {7 [1 l+ n" @6 v3 {            l = list(dataset.data[:f_index])
( B4 ^; N8 n9 ?. A- s; V& S1 ^! Q            l.extend(dataset.data[f_index+1:])
            sub_data.append(l)
2 G) A  I1 l  \0 w2 N* T# l            sub_target.append(dataset.target)

    sub_feature_names = list(dataset.feature_names[:f_index])
- _( h$ E% B! B, @    sub_feature_names.extend(dataset.feature_names[f_index+1:])
, d1 s* U  d- G& c4 ^! t    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)

# 寻找并返回信息收益最大的属性划分
0 X9 ~9 u- w7 ]9 |2 Y; W! g, w7 J# 信息收益值划分该数据集前后的熵减
; x' c$ v8 R1 v- N& f! r' R# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
def best_spilt(dataset):
) F& D3 n8 l1 O# ]% i
    base_h = get_h(dataset.target)
9 l% t: }+ [, s3 {- V' t& T    best_gain = 0.0
' w" u% p7 k5 g1 Z$ f( J; ?9 O    best_feature = None
# F. {6 M# ]; E/ k; f9 O    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:
0 l( Y' e/ @/ ^, O2 r1 y* [) O$ N* U                feature_range.append(dataset.data[j])

0 ^' [) M% d, s: C4 ?        spilt_h = 0.0
        for feature_value in feature_range:
0 {9 B7 N8 v2 b- F3 |            subset = get_subset(dataset, dataset.feature_names, feature_value)
5 i; S2 M' t6 H6 u0 Y            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
3 b- _' D( F8 y- R* @6 E            best_feature = dataset.feature_names
( R1 U4 ^2 T0 X1 m  Y% M
, C3 Z: `- Q# u( h    return best_feature
% b$ ?% {' y. v1 n- F, \2 @% Z, ?
# 返回数据集中一个数据最可能的标签
: ^* K3 E7 {2 p0 A/ idef vote_most(dataset):
) z: Y4 p7 n) O- y. H    target_range = {}
    best_target = None
    best_vote = 0

# ^& n* t. d" @1 P, k9 \# f) E/ N2 P( j    for t in dataset.target:
        if t not in target_range.keys():
            target_range[t] = 1
        else:
5 Q, N# n+ C$ t' j& d' B3 }3 h) w            target_range[t] += 1
+ }2 ]' r5 g8 j9 V
    for t in target_range.keys():
$ [) Z( k& _, |        if target_range[t] > best_vote:
            best_vote = target_range[t]
  I8 D0 c- ^: Z* E1 j* |$ a  D$ @            best_target = t
" i+ c7 P9 A  y
    return best_target
' K9 f" z+ m! u$ V1 ?( g
# 返回测试的正确率
( E5 t  z- T. q$ a" d6 H# predict_result: 预测标签列表, target_result: 实际标签列表
def accuracy_rate(predict_result, target_result):
6 o) }5 @. y" I: U  o  e1 m+ \! d    # print("Predict Result: ", predict_result)
    # print("Target Result:  ", target_result)
0 \! T8 I+ X  a+ K1 [6 f* S    accuracy_score = 0
    for i in range(len(predict_result)):
        if predict_result == target_result:
2 e5 z% a% u2 M! [7 J8 S4 u4 l            accuracy_score += 1
- S4 q" Y3 m- @  `$ T    return accuracy_score / len(predict_result)

# 决策树的节点结构
class dt_node:

    def __init__(self, content, is_leaf=False, parent=None):
        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
4 a3 l. t: A+ t. \2 Z        nonce += 1
; k" J, _6 I7 ^: o+ N3 t6 j        self.feature_name = None
/ Z- f) [- M8 x5 Z        self.target_value = None
6 I7 A  o2 o) g3 e        self.vote_most = None # 记录当前节点最可能的标签
( g) y" s( J: o% z  _8 }  U4 }        if not is_leaf:
            self.feature_name = content # 非叶子节点的属性名
        else:
            self.target_value = content # 叶子节点的标签
3 }$ e4 S9 |+ s' z* G
) L+ t' W3 |2 d* L        self.parent = parent
        self.child = {} # 以当前节点的属性对应的属性值作为键值

# 决策树模型
. |5 I& L' x; i1 {, }5 N& j" iclass dt_tree:
! V( D. |2 S4 U2 j% `4 S) w$ e
; o: D2 O8 w6 `: l% ]; [5 W    def __init__(self):
3 l+ D/ r% L1 R" M) L        self.tree = None # 决策树的根节点
0 U. @3 J2 v: x8 j9 _        self.map_str = """
: a1 v" C8 f% W            digraph demo{
0 R  Y7 w- M$ @; k& S  ~- M1 s3 w* C1 C            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
            edge [fontname="Microsoft YaHei"];
            """ # 用于作图: pydotplus 格式的树图生成代码结构
        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值

    # 训练模型, train_set: 训练集
    def fit(self, train_set):
, {6 M  D& i* p
        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
- v9 J: b: a& X1 r8 A, S            return None

/ W, T5 Y. @. p' z        target_all_same = True
% g! k6 m! z3 r9 g3 t( U5 n        for i in train_set.target:
            if i != train_set.target[0]:
4 ]' ^8 y" R- g! [                target_all_same = False
                break

        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
9 i4 P, Y( \1 C6 ^! f            node = dt_node(train_set.target[0], is_leaf=True)
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
: c* F0 r( b6 B& e( u9 J' x                self.tree = node
1 O- {: j5 b8 Z' p
            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            node_content = "标签：" + str(node.target_value)
( E& y! B' H( H0 R* G5 _            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
. `$ ~/ p3 J7 I) _2 @! \
            return node
+ b/ ]: G# Q* p        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
( t. ?1 `" F1 t9 }7 q" @# Y            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
9 ~3 s$ p. |* a% W+ i# K) L            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.color_dir[vote_most(train_set)] = color_set[0]
! A0 ^& X; w; `, ^. T7 i                self.tree = node

, {4 Y' l' m/ t, I& ]* C            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            node_content = "标签：" + str(node.target_value)
& h; Q; c2 R% Y! g% _            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
7 u0 B9 R; @9 W
+ W: J, `; U% S5 a  j9 J. A            return node
        else: # 普通情况, 构建一个内容为属性的非叶子节点
            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
            best_feature_index = -1
% R6 B7 A% y7 j' f4 z0 p            for i in range(len(train_set.feature_names)):
                if train_set.feature_names == best_feature:
' k0 I4 x2 f( Q. m& z                    best_feature_index = i
! `$ e9 {' l% H! i& z0 x" o                    break
- w8 c6 ?8 \- J
" ~7 S# [/ b7 U4 ^3 v# A            node = dt_node(best_feature)
            node.vote_most = vote_most(train_set)
            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
                self.tree = node
& H. B. z, u0 l3 `/ S                # 用于作图, 初始化叶子节点可选颜色
                for i in range(len(train_set.target)):
                    if train_set.target not in self.color_dir:
2 `# L( f% }9 t. J, q                        global color_i
. h* H0 Q9 W9 Y( b& S! u                        self.color_dir[train_set.target] = color_set[color_i]
' u! @  U. E" Q6 [                        color_i += 1
5 q, \& G0 C3 s4 X6 u2 S- o+ y6 [                        color_i %= len(color_set)
$ E9 E1 c8 z  y
: U, s  V: s( e" }& d            feature_range = [] # 获取该属性出现在数据集中的可选属性值
            for t in train_set.data:
" j( {# \+ Z2 O/ [+ F1 S                if t[best_feature_index] not in feature_range:
& X) M/ W5 \: |" }9 n                    feature_range.append(t[best_feature_index])
+ D+ }8 ]& b4 O; a$ k% W
            # 用于做图, 创建一个内容为属性的非叶子节点
. S2 s" S3 ?" A' }- N            node_content = "属性：" + node.feature_name
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
/ O! I/ k# ^6 H4 N" F
( C6 |4 _3 q& d7 o            for feature_value in feature_range:
                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
4 {2 X, g' O. @! R! Q                if node.child[feature_value] == None:
                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
0 G5 X5 Y- l: F9 S                node.child[feature_value].parent = node
0 p; o8 z& s! P1 H' e' Z# P
0 v9 L0 b1 r; {+ T                # 用于做图, 创建当前节点到所有子节点的连线
7 I0 R7 o# _- Y                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"
5 d( B/ N# f) y- [) o! T4 Z
            # print("Rest Festure: ", train_set.feature_names)
2 g7 G7 |! J2 P9 `7 |3 b+ ^            # print("Best Feature: ", best_feature_index, best_feature, "Feature Range: ", feature_range)
            # for feature_value in feature_range:
: D3 w1 i9 k0 i; _' G6 W            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
0 x' `6 i  N/ Q4 J            return node
# P% N  m1 S- q( C( N! T8 w/ U  [
    # 测试模型, 对测试集 test_set 进行预测
    def predict(self, test_set):
        test_result = []
1 A: Z5 |# ?, f0 f* {        for test in test_set.data:
            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
8 P6 V: Y# }+ u) ~  [6 C$ |            while node.target_value == None:
8 G" L3 B8 t- ]) I: D7 p                feature_name_index = -1
                for i in range(len(test_set.feature_names)):
                    if test_set.feature_names == node.feature_name:
                        feature_name_index = i
; c& W) q; V1 }0 t+ R" E  h                        break
- H" L3 i& W9 E6 o% l0 Y; x                if test[feature_name_index] not in node.child.keys():
                    break
! w( H$ s! @* I- r1 O; A                else:
7 z0 f6 d1 Y5 k+ d8 y' |                    node = node.child[test[feature_name_index]]
4 R0 t6 ?( t, b, G$ _2 t, e
8 ^+ f/ x3 O6 q. H9 J! l- Z            if node.target_value == None:
+ A$ H. e0 M3 m; I                test_result.append(node.vote_most)
( U! h3 q% j$ }            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
                test_result.append(node.target_value)

9 ]2 Y0 ?- N! M. j4 y        return test_result
' t) e1 _( d+ p) o3 L, L
: ?" x: Z! |; G    # 输出树, 生成图片, path: 图片的位置
    def show_tree(self, path="demo.png"):
        map = self.map_str + "}"
        print(map)
        graph = pdp.graph_from_dot_data(map)
( A, C# s0 H9 B: J4 N  a: y+ o        graph.write_png(path)

: \$ ?3 j; M/ s" ^# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
8 @; s) u8 V: ?" ^    c = dataset
- {' E8 g5 K( q0 J$ H9 |7 Y! n5 G    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:])
        dt = dt_tree()
( N6 @/ J) ]) d7 m        dt.fit(train_set)
        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))
: w7 O6 o- E3 Q$ f" p+ i
( g. \; X( Y7 [2 h# h4 L8 @& ^    print(rates)
, [* E1 ~' R- a8 p5 J! t    plt.plot(r, rates)
. d8 I1 K8 J1 [- d8 ^. u    plt.ylabel(label)
- z# o2 x! {8 C, B9 K    plt.show()
$ E. V( {. N, |, P* E5 K* R& k: X
7 D1 M/ L' O# }3 pif __name__ == '__main__':

    c = load_car()  # 载入汽车数据集
    # c = load_mushroom()  # 载入蘑菇数据集
    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
) T: `0 c  C. _  i' |    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:])

. ?  d# m; D6 W7 C2 T6 P& t    dt = dt_tree()  # 初始化决策树模型
8 k; \$ T3 j# N    dt.fit(train_set)  # 训练
2 q) f% j$ j7 q    dt.show_tree("../image/demo.png") # 输出决策树图片
: V8 s  m% `4 X7 z    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧
9 X: l' o7 g3 @& _1 P; M! c2 k
! [+ E/ S5 `% o- k# K3 [    # incremental_train_scale_test(load_car(), "car")
    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)
% _, b6 F# ?# j8 l& ]2 m
. W0 f0 Z- m0 B% _

! u. C  _* P/ d: e' _7 ]6 L1
! \2 u* N" t6 O. ?" [2
' \6 v0 ^- t, N% }- K3
( k9 t& w% n- _: O7 ^8 b4
5
6 |/ j' b9 g1 M0 ?6
5 C  Q" R# V4 x; g- U; ]; c$ H  \6 A7
: b6 c  r+ M2 W2 h0 }9 Y8
1 @+ b7 l4 |8 j, a: t6 i7 I4 ]) K9
7 ]  {/ v& T0 l2 o/ Y( \9 L) G' A5 R10
11
12
. @$ g! j! {+ N) w( O1 a13
14
, r6 t) O! k; K& p. N. N4 C15
% I7 M$ U' T% h4 r7 N, L, X$ t16
17
18
/ F# P8 y& A- M2 w6 R4 `9 E  d19
2 I0 j4 _% f2 |9 ~  r20
21
22
23
* g5 J: o1 k8 X1 [24
25
26
2 k' I9 M: O- j/ i/ {27
5 V! t( u$ u9 J2 q9 _28
29
30
, ?: v; A' p# z9 H# o, z31
32
33
- W* R& t# K, T$ V" C8 c3 m- `3 v% W' j34
35
7 ?5 b5 J$ t/ I0 \4 e/ {" Q7 W36
5 t. f% X+ T- o0 f1 B( a5 H8 p; U37
8 h8 D1 q% D( \0 ]/ ]# t8 `$ ~# E38
" v6 `7 `$ @* [* ~, K39
40
' {/ c* ?7 b0 R4 Q, X$ r' \41
2 e" q' |3 i+ B6 a) h5 B42
% o6 z' G. {- f, _& b% d/ B43
44
45
: X2 j* m& g) U! I, s9 H46
$ {$ H( C! R( y$ ?6 o; ]! R( o+ F0 K47
. ?7 P' \& I8 C- d48
6 T( m; E" O/ a! V  Z5 ]49
50
51
8 G) m  k# J5 _  N# t4 M52
53
* t. S; C5 w0 V# _: g7 C) N0 K; V54
2 T" D( q. W% b  k3 l; ~0 F# C55
56
57
$ T+ F0 i5 X; |& l! I/ j58
59
60
) Y; r. p& S. R. n61
62
- @$ M" {! g/ a2 Z63
9 L9 x* U& _* [: f64
65
66
67
68
69
& w: [6 l  f- y$ G( m+ Z70
0 A. U/ X/ Y- ~. `( N4 v  o, B3 I71
- }; u" c2 f+ p$ w; a& U0 e72
73
* h0 T% H* V' }74
75
76
77
: Z( \! v. O* ~1 ~/ t/ Q78
: ^0 k6 U' V$ @79
80
81
, [: c9 a& L$ t$ u( l* ]% C82
83
84
85
86
# t4 `$ @$ V% T# t9 M, V87
88
89
90
91
92
. R& m2 X. y7 i, \- D93
94
95
4 S$ H/ r! L/ C) f$ l2 w2 r1 A96
: C% N, e0 @% j6 p8 l. |! M97
98
( G/ h0 T9 i+ b0 l. K  G9 X99
' q9 w( P. ~9 p! O% {% t/ K100
101
- D, d) u! [2 [0 J  S- }: L; [102
/ s1 [# o# q: t/ @% Z( I103
0 U2 S5 O# G8 T1 C104
6 P) w3 d6 s" w4 g/ C; G105
106
107
' z3 A1 C; A' [+ g4 u- u+ C) |9 S108
109
' z, n7 L2 L1 e3 |% [110
* m; S+ ?+ s" o$ w$ K7 O+ l111
112
+ Q7 o- w" ~  Q0 m113
114
115
+ h9 o6 Z6 @: _" Q$ @2 u0 m116
117
118
( a, T7 o. s. U, o! c  b119
  u- b" R, W$ F* u! n120
( K- S4 O! t& E+ Q0 Q- ~121
122
123
9 j; R; E# i- _' X3 s% Z. Y9 B. _124
125
126
  D1 C7 {, C+ m8 L! q& l7 M: v127
7 q$ t# U' K9 }0 \0 `; P128
129
: W: v- P4 o8 X' p2 R; e5 R130
7 ]1 V# `3 e& q) j/ U" ~" t131
132
133
134
9 c. A1 q- D- E2 e( V135
136
137
138
) B( y% R5 d: w8 J+ j" N$ c139
  i# c$ V5 O. t140
141
9 t& F; w" N" \- R# S5 o142
143
144
145
, S- I( K. Y  Z9 C) V+ d1 V) E$ D146
147
148
; [* J0 H- H" u149
150
2 @6 }9 r1 x) x3 x8 c4 `% u% Q1 G151
$ u+ B; z0 G8 D$ B2 @1 O  W: y152
. n2 M+ L. s4 d153
154
155
156
157
6 b4 B- C* {* C$ v; Y0 s( n158
5 G6 O5 i' {7 q/ I) ]159
; P% @8 b: w: x2 ^# m160
& X& f; Q3 T8 h4 R8 \161
162
163
164
165
( i; n, ]. c# J4 I/ p- i5 j166
167
168
, x# E( s, i/ r; F8 c3 y8 i6 s& r7 K* d169
170
9 A$ h) F; @, q2 L/ _171
172
0 \$ [( r; e: Q8 k173
174
175
+ P8 V1 }! G7 D) ~' g* r' i176
177
- Q6 x/ q% P4 {6 D) k6 J178
179
9 c, K5 `! g, q/ ]6 p180
181
182
183
+ [7 p1 T0 f4 `184
1 a3 q. _4 r1 j# Z- s: h/ c; Y185
186
187
4 D5 C9 R- J7 u* n188
189
190
191
: ?/ I5 o( j: v! \2 s9 z192
5 R- G0 `% q" J193
3 Z( [  K# P0 W194
195
196
6 L, \! Y- d, W- g7 _' s* Z$ L197
198
199
200
: ]$ A3 Y3 Z* w7 E& K( U8 P  L201
202
- K( r" F8 u& |# H% d4 N3 f203
% z/ ~" c$ f7 x204
205
- l( g+ B; s5 s5 Q/ u0 o& E206
207
208
209
% C2 o1 @, @) s* b210
& b9 U  V) l" \211
212
/ @% N* J0 _  B* E& r213
214
215
: m$ q# l/ C! J7 d( s$ N. ]216
3 _# Q+ p" a0 A7 ]+ J217
218
219
220
. C, n9 R. l3 @& r$ e221
+ p: W1 m1 M' E222
223
224
225
226
227
1 l8 p, U; s, ?# l, a228
229
230
) z! C3 O; H0 p' ~2 A* H" k231
% V& h" e) L2 z232
+ [) T  ?* P) Y- B233
+ M* w6 d6 z3 V2 s234
235
/ G# `2 \8 b& o+ d; c3 X236
3 [8 a1 R/ A! j+ t2 j9 `237
6 T4 v4 h8 Y+ V6 l) u238
239
4 w) K; O* ~( y( I4 V& S0 A( X1 s240
/ M! Q0 u( X# ]9 b5 T7 b0 W241
242
243
0 \/ D/ ^& r' B8 B5 R9 I) i8 ^244
245
2 B' A9 Y/ a" Q) G) P1 b246
0 q: u" i/ O) n: u( F. c" Z$ k3 i247
248
249
& \5 x9 x' E' N) x250
251
, O3 y# i9 A0 l2 k3 }4 w2 [252
& x; Q4 Y3 F6 {253
; ~* t3 S* |9 r/ \6 a3 b254
255
256
$ c; B( v7 l. `) Z7 @257
258
* w& M% e; _! Y! S2 J+ q# n259
2 I1 o' G; _/ R7 g/ H) m4 I260
261
262
* [; c+ H* a( ~8 G9 w: X5 K% C' P& n( _263
- X4 l3 P: k% h: D0 q* V264
265
; K3 H2 G- C: ?; Y266
267
9 V) k9 l5 Q, D  \% ?268
269
# [' c' d! h% \  w; y9 p2 s) Q270
271
9 \% G0 y7 y" P4 \" t" j* \9 a272
  t/ a. H0 h8 N7 I$ D' f' m& A2 a273
, `1 D) i  H: e- X274
6 X3 A( r& b1 g4 L4 A: o* H* z275
276
/ f" j- s  `' ^5 M1 g* w277
278
0 N8 ~# o" l/ J$ a/ W279
+ v6 Q% P% S5 C& l5 x280
8 K# f  o8 T% \& W" I7 d281
282
283
284
! m6 s) ^2 |! U( w285
286
/ G0 c4 [2 |7 T" w/ P1 }287
288
: c# a9 H9 o; }: J8 W$ x# i5 p289
, o1 V2 B* Z$ _290
$ `- o8 ]* m3 e% x8 Y291
292
293
- _0 J0 t9 d1 Y+ b8 H3 v* V6 T" P294
295
296
297
298
8 f9 m" v  y* |299
300
% L" @1 b+ [; j; t4 X301
302
303
304
" e- y# U6 T* t305
6 }# U5 X' ]6 U; h* p$ {306
307
308
" G0 k1 {5 R9 l+ O& h309
310
311
312
. g# T% r2 \  q" m9 ^! B5 n5 D313
314
5 L$ _3 Q% r# {315
- i+ E% b! y% _. ~2 q316
317
318
& u  N9 i3 G1 z1 e: ~8 {) \5 w319
320
321
322
. m1 l; \. T$ z4 c0 y5 u323
. p' {# c3 `) K4 _, ^324
325
326
% S" f- n7 ?2 m, Z8 _327
328
329
330
331

7 o9 p0 i/ d4 P& f% I0 ~
3 G* _# I" b3 A8 f! a; r- x6 U0 C  J% A
. `, ]: A. y& c
3 V& n9 c; K7 C9 h

) W: L( }, z- R9 _

! K) v3 V7 s& Z6 @7 C
, c7 a/ u. U( y3 x

6 U) w& C- i; m+ |) ]0 R
1 U, E8 P: m0 S————————————————
0 F9 x9 p( e$ c版权声明：本文为CSDN博主「biyezuopin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sheziqiong/article/details/126803242
8 v' H  q- h7 x' u) j