基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型
, B& ?6 Z- [9 W1 o" Q1 l
决策树模型
# g6 L" o! Q, V1 L/ g) W8 v目录
* O0 x; R  W) `- B# ]: V1 k, {% N人工智能第五次实验报告 1
决策树模型 1
0 ?) S, G2 s' P+ {一 、问题背景 1
, D6 o. X; K9 Z: k  z# f1.1 监督学习简介 1
9 w$ s9 D7 \! I7 y- O( t( Q1.2 决策树简介 1
二 、程序说明 3
8 M$ n1 l$ f$ e/ s) h9 N- t( q+ X2.1 数据载入 3
2.2 功能函数 3
6 \/ j$ Z" z* e' M3 N, l+ ^2.3 决策树模型 4
三 、程序测试 5
3.1 数据集说明 5
# Y3 O) Y& W$ O  @3.2 决策树生成和测试 6
3.3 学习曲线评估算法精度 7
2 o8 K$ ?5 N4 B& ^3 a" C  ]' D四 、实验总结 8
附 录 - 程序代码 8
0 P  S' Q! \% Q" C9 f( i一 、问题背景
# z( p/ \( }& ^; t9 o3 ?" A  r9 Z1.1监督学习简介
机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
& t) ~$ G# \8 P* R- N. v- q监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
1.2决策树简介
  s$ e- i5 S8 J1 c+ b0 X决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
# R, u6 W# ]0 d9 t( T# a* L决策树的组成
决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
( M7 h1 C6 y1 d2 b; i' \7 G/ t# U" |
import numpy as np
from matplotlib import pyplot as plt
" f4 k0 o. o2 M, s: Ffrom math import log
import pandas as pd
2 ^0 q' U( R4 D% f3 e$ limport pydotplus as pdp
9 }3 z& S. s" u( t4 F
"""
19335286 郑有为
人工智能作业 - 实现ID3决策树
"""

nonce = 0  # 用来给节点一个全局ID
color_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
color_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
) R/ U4 p2 e3 R5 Q
# 载入汽车数据, 判断顾客要不要买
7 _2 Z1 g6 ^: g/ e9 t3 v) S* Z# {class load_car:
    # 在表格中,最后一列是分类结果
    # feature_names: 属性名列表
# D; O, [* K& l4 F: P! D    # target_names: 标签(分类)名
/ s% _* }% d  p4 N8 L% Q    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
$ w& M; f" I& W+ P/ B6 J; l) w  w9 U# T  z    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
        labels = df.columns.values
        data_array = np.array(df[1:])
2 y3 K+ y" P* P5 l" ?        self.feature_names = labels[0:-1]
        self.target_names = labels[-1]
! [& h% a' p/ H        self.data = data_array[0:,0:-1]
        self.target = data_array[0:,-1]

# 载入蘑菇数据, 鉴别蘑菇是否有毒
1 [- r& Z' U- b5 S; a* }; ^6 Bclass load_mushroom:
! ?2 h" q6 K- C3 E    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
1 J8 y$ @- X1 P    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
8 ]6 Z3 t% U: a% ^. g. q9 v    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/mushroom/agaricus-lepiota.data')
+ \4 D" z% y+ c& w$ {  A% U% y        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",
1 |" Q% Q0 z1 o& d: b$ B4 x                  "stalk-surface-below-ring", "stalk-color-above-ring", "stalk-color-below-ring",
8 G, v3 R" j, u: Y- l* {7 G0 M( ]                  "veil-type", "veil-color", "ring-number", "ring-type", "spore-print-color", "population", "habitat"]
% s' ~8 l7 j$ x3 P: k! R        self.feature_names = labels[1:]
! l6 Y9 k7 o' u) t" e" ?5 {3 H) E2 ^        self.target_names = labels[0]
+ ]6 e# p5 `* f! U        self.data = data_array[0:,1:]
2 O$ n5 S& r# G0 V& @& j        self.target = data_array[0:,0]

# 创建一个临时的子数据集, 在划分测试集和训练集时使用
, r4 ]1 H# B5 B6 ?; a- l! C! C! v+ uclass new_dataset:
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
" n( H$ x1 `, H    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
% V0 L3 A# |  {% K9 m        self.feature_names = f_n
        self.target_names = t_n
; C5 ^  ?$ R$ L( z2 p        self.data = d
4 @$ K# L2 \* k$ U! A) m4 w: P        self.target = t

# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
* q4 t, g5 J+ W6 |3 R1 g& M& f# q' ?; _#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
9 _$ q, S! ]6 |8 V, J- r# target: 分类结果的列表, return: 信息熵
- G9 }; b" ?3 d1 W; p: P; ?def get_h(target):
3 _+ l* w, j; \& c    target_count = {}
2 ^2 j" e* H$ o/ {4 Y# t" v- n3 Q/ y    for i in range(len(target)):
) t/ ^. y$ n# ^. m! @0 D        label = target
        if label not in target_count.keys():
. C( U& m3 a: X            target_count[label] = 1.0
7 S4 R4 @6 Y$ U; M) K8 `        else:
            target_count[label] += 1.0
2 ^6 O" L: C" d    h = 0.0
# b* r; _6 ~# {  k) s    for k in target_count:
        p = target_count[k] / len(target)
        h -= p * log(p, 2)
% {4 N8 ?) b/ J, n- M' w    return h

# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
+ h3 k2 ]* E: C9 i# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
! T! l6 o' X" {# ]- ^5 Vdef get_subset(dataset, feature_name, feature_value):
  [& H' S% V. R# E- p/ X    sub_data = []
0 Z/ g2 e. v7 |' W( F    sub_target = []
    f_index = -1
    for i in range(len(dataset.feature_names)):
        if dataset.feature_names == feature_name:
$ f' H) P) F- H            f_index = i
            break
7 C1 u+ C) {3 }' m% x: o& r( I: V4 x
    for i in range(len(dataset.data)):
        if dataset.data[f_index] == feature_value:
            l = list(dataset.data[:f_index])
            l.extend(dataset.data[f_index+1:])
  G6 m4 Z9 N+ `0 l: h0 k2 ?            sub_data.append(l)
            sub_target.append(dataset.target)
# N/ t4 `7 o3 A2 R; ?
5 ~6 Q' o8 g* n( M7 }+ }9 d2 L3 J    sub_feature_names = list(dataset.feature_names[:f_index])
0 X( q( `6 s: y' x) W    sub_feature_names.extend(dataset.feature_names[f_index+1:])
    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)

/ m7 q! P6 s% C, c+ d8 z: {# 寻找并返回信息收益最大的属性划分
# 信息收益值划分该数据集前后的熵减
# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
def best_spilt(dataset):

9 {. O& v6 `! k    base_h = get_h(dataset.target)
    best_gain = 0.0
! N% v; X' X, k0 ~" h2 i# ]+ C    best_feature = None
    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:
                feature_range.append(dataset.data[j])
- m1 I/ `- ]. r$ w4 l" E
        spilt_h = 0.0
9 W, |  B7 ]6 L" Q/ ^5 o' B+ R) |        for feature_value in feature_range:
1 X% c) n0 \5 e! `+ N7 W6 G            subset = get_subset(dataset, dataset.feature_names, feature_value)
            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)

6 n+ y/ e4 P: }- R/ o* n6 u        if best_gain <= base_h - spilt_h:
            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names
9 u- X6 h+ p6 U9 [
2 h% C# I! F5 {. C    return best_feature

# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
    target_range = {}
8 G  m0 v1 [1 {8 Y9 F: S  i9 v    best_target = None
: Y  l6 f% C( _1 g" [- I    best_vote = 0

    for t in dataset.target:
        if t not in target_range.keys():
            target_range[t] = 1
        else:
( h& W6 E1 `( L  z            target_range[t] += 1
5 N# v- m8 z- }1 d1 y3 l+ Z+ E
    for t in target_range.keys():
% t. \, b4 L: J6 `        if target_range[t] > best_vote:
$ l. Z8 V8 y. Y            best_vote = target_range[t]
            best_target = t
6 `- _& c% k' m
8 A! n: ]9 n3 w$ b6 ~) w    return best_target

# 返回测试的正确率
( x* t! e/ r8 J. r# predict_result: 预测标签列表, target_result: 实际标签列表
8 \/ B6 [' C( W, |def accuracy_rate(predict_result, target_result):
+ d+ b1 E" C5 X9 R  \/ F, H7 G    # print("Predict Result: ", predict_result)
    # print("Target Result:  ", target_result)
  {+ S0 q& r, F6 l7 F- g+ e    accuracy_score = 0
8 s& R: D) o) V  g& j    for i in range(len(predict_result)):
( f' x- [/ `5 L  K2 k( W        if predict_result == target_result:
6 r1 C: n: C! o4 x: k            accuracy_score += 1
    return accuracy_score / len(predict_result)

# 决策树的节点结构
class dt_node:
0 p; h. J. H2 ]* L; ?/ j: a  s
0 k( r" z8 Y! M    def __init__(self, content, is_leaf=False, parent=None):
' u3 U' y& n: w! r2 \! F" Q        global nonce
        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
        nonce += 1
        self.feature_name = None
        self.target_value = None
2 g7 ?7 z: B) G5 Q        self.vote_most = None # 记录当前节点最可能的标签
        if not is_leaf:
            self.feature_name = content # 非叶子节点的属性名
        else:
            self.target_value = content # 叶子节点的标签
$ w( G  n9 y  `! D$ _; ]' |
  n! P5 i" `. ~$ h; J0 I        self.parent = parent
6 J! z* q; i$ U( d        self.child = {} # 以当前节点的属性对应的属性值作为键值
& ~! ?9 g) A* D' U# m
# 决策树模型
class dt_tree:

9 u9 ]% _/ X) T% n( Y( f- N    def __init__(self):
( ?! q( q# h. P6 f+ s        self.tree = None # 决策树的根节点
        self.map_str = """
0 E0 I+ X; g* k3 D" z0 ?            digraph demo{
/ S! u: J4 y% D! w9 i6 T" n" ~            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
            edge [fontname="Microsoft YaHei"];
            """ # 用于作图: pydotplus 格式的树图生成代码结构
        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值

3 S# s) @4 l: i3 t9 V    # 训练模型, train_set: 训练集
+ w. O: m' i  j    def fit(self, train_set):

8 d) G  Q4 |9 e  [( x( h$ D* Y        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
6 `8 i! t9 }5 C4 S- ?" s            return None

        target_all_same = True
' @6 V# B/ J% k) m6 B9 }  e. G8 e        for i in train_set.target:
            if i != train_set.target[0]:
                target_all_same = False
                break

        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
            node = dt_node(train_set.target[0], is_leaf=True)
3 p1 L0 `$ [. ^. a- g, O9 `% u            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.tree = node

" O0 ]; Z8 a1 R1 A  v" g; h7 X            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
, g9 _8 v- g+ s1 O' `5 \2 ]- f            node_content = "标签：" + str(node.target_value)
( v! O# ]8 w7 s7 Z, \" p& p7 l1 Q            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
0 j& g4 G4 w. g3 f
6 t# ]8 M; V8 `            return node
7 s8 e+ u' i5 G6 \5 c+ ^        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
4 v7 Q- Y6 t) O# d2 J            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.color_dir[vote_most(train_set)] = color_set[0]
! F  O* x& O4 O: L- ^0 s0 K                self.tree = node

6 ?7 ^+ z$ D& {/ N            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
: c% L1 D; J1 h0 o. [$ x" n            node_content = "标签：" + str(node.target_value)
9 C. Y+ o/ V- m( f+ {! d" C            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
0 ~1 E# P7 ]! b+ M8 Y
            return node
6 U+ B: e8 `. B0 Y1 X' `7 Z' k        else: # 普通情况, 构建一个内容为属性的非叶子节点
8 _( k/ k2 P% e+ s. s            best_feature = best_spilt(train_set) # 寻找最优划分属性, 作为该结点的值
            best_feature_index = -1
7 @  w, `6 P8 m( \5 a5 L% U) R            for i in range(len(train_set.feature_names)):
                if train_set.feature_names == best_feature:
5 C6 p5 ^- k+ \$ E. {+ L3 K                    best_feature_index = i
) E5 c$ ]$ h$ I* B                    break
2 r, a% k( o' b3 r( q
. Y: |" K4 J( I( l3 c, A% `7 T( \; A            node = dt_node(best_feature)
+ A* b+ I/ R; X; d) q( y& g! l2 }            node.vote_most = vote_most(train_set)
7 ]7 d" e: j# t$ h  A& v            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
                self.tree = node
5 Z9 T/ j  u/ t1 p. O" l, x) g+ G+ m" g                # 用于作图, 初始化叶子节点可选颜色
                for i in range(len(train_set.target)):
                    if train_set.target not in self.color_dir:
                        global color_i
/ Z8 y; I% H( C+ l                        self.color_dir[train_set.target] = color_set[color_i]
                        color_i += 1
* v* N! i# r0 d( z+ }0 u6 V                        color_i %= len(color_set)
5 B/ r6 C/ h4 M& Q
+ U$ ~8 H- t+ |$ J: `            feature_range = [] # 获取该属性出现在数据集中的可选属性值
0 E2 V5 U6 |, {* t# J. X            for t in train_set.data:
+ V; B* W. ?8 U                if t[best_feature_index] not in feature_range:
, I1 N' C: d) `+ m" y! [/ \                    feature_range.append(t[best_feature_index])

            # 用于做图, 创建一个内容为属性的非叶子节点
9 g' S8 F6 f; s0 g# ~& r2 i& Z            node_content = "属性：" + node.feature_name
            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
4 l4 {: Z4 ?2 n" e* p; R1 l5 W6 }
7 i: ~( B2 _5 l6 ?            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:
% i: N$ p, Q0 W2 E1 }! o                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
                node.child[feature_value].parent = node

                # 用于做图, 创建当前节点到所有子节点的连线
! e2 |+ q6 Y8 ^6 H) @3 z5 H                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"

6 \  a4 V3 x' e8 ^. ]            # 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:
' S9 y6 P6 P5 Y( i& L            #     print("Child[", feature_value, "]: ", node.child[feature_value].feature_name, node.child[feature_value].target_value)
            return node
4 o& m2 Q( t8 T5 z+ {+ |9 w
& [6 p. K* m3 i* B# X    # 测试模型, 对测试集 test_set 进行预测
    def predict(self, test_set):
        test_result = []
- D. D% D" O1 N/ O+ K- X        for test in test_set.data:
/ S8 h. v( P0 H' J! N$ h            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
            while node.target_value == None:
$ w9 B# @8 p6 j3 Z7 D                feature_name_index = -1
/ B6 E$ m3 b) Q$ V$ }; q                for i in range(len(test_set.feature_names)):
                    if test_set.feature_names == node.feature_name:
                        feature_name_index = i
                        break
                if test[feature_name_index] not in node.child.keys():
* a) h" o) I* `7 ]4 v                    break
                else:
                    node = node.child[test[feature_name_index]]

5 b+ w' a7 Q: L! u4 d            if node.target_value == None:
* P- o2 t, T1 _8 |- f5 U                test_result.append(node.vote_most)
            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
* D9 `% [6 W: Y! A8 K                test_result.append(node.target_value)
; |) d4 O" B$ k; a5 {2 e* W! Q
        return test_result

: r0 a/ m# R% V    # 输出树, 生成图片, path: 图片的位置
" \; h: Z& h+ f    def show_tree(self, path="demo.png"):
# l: _$ O0 k- {6 S$ m        map = self.map_str + "}"
0 R% \, O$ F5 D; l2 ?  L5 m2 e        print(map)
; D. c& S+ l( I: S: u        graph = pdp.graph_from_dot_data(map)
  k7 t6 k. I( U1 F; a! Q        graph.write_png(path)
  [6 E8 d# w! f  S# q) @. U- Z. s" o
# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
& |1 b# b- A/ ?( D1 ?def incremental_train_scale_test(dataset, label, interval=1):
    c = dataset
4 c& {: e1 C) Y8 ^2 g! D% k$ {    r = range(5, len(c.data) - 1, interval)
    rates = []
; h8 k/ N1 v' ~6 K8 S( V$ M    for train_num in r:
- J* m7 w! h9 r' Y  z. y; |8 K9 e% ]        print(train_num)
. T# W6 Z( _9 F$ P2 a  N        train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
2 x) Y( n/ m3 V" p        test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
        dt = dt_tree()
        dt.fit(train_set)
1 Z) y/ V0 m1 @" L        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))

    print(rates)
( t* Z  H2 q. T4 N( b7 r0 f    plt.plot(r, rates)
+ l" n# P; a1 \# f- x! l) w# y& K    plt.ylabel(label)
0 T: i+ z) b* z    plt.show()

if __name__ == '__main__':
9 g& t6 M4 n- q+ z1 O) i% \, v* x
! x; D1 z# C! L) l8 K& w    c = load_car()  # 载入汽车数据集
    # c = load_mushroom()  # 载入蘑菇数据集
+ _2 y  Z( M: `  z9 o' X# w1 s    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
5 \# f* F' U3 K& R. n    train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
- a' X+ S+ u& l: U' R4 _. J    test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
) x: M$ C+ Q9 F' |* m8 |
# g& @* E$ n  V1 L8 _  C. L; e    dt = dt_tree()  # 初始化决策树模型
6 j, s# K; B) D& C8 L. p    dt.fit(train_set)  # 训练
9 t4 T: F  f6 L! }$ i+ O5 y( w# m" |2 ?    dt.show_tree("../image/demo.png") # 输出决策树图片
    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧

    # incremental_train_scale_test(load_car(), "car")
    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)
6 {6 D) M( G0 M1 R; k7 b

9 e# M# b% ~/ i( N  O
$ U8 _$ k, F/ G: m2 s4 h/ {- K$ D1
2
8 I' b# s: d4 ~9 z3
4
) P2 ?+ U) h# k8 V" r5
0 u# M- ~  }) a* O" V7 Z* P! H. J6
7
2 R4 E+ Y: g. R  T! A2 L: O' @8
& ~9 E" @. z. i  t7 F+ G9 Y* B9
10
. u9 O4 I% P( D- q) N7 M6 `( d11
12
+ i' J& X7 B5 h6 T13
& R9 F' m/ A- x* U4 U8 d, @14
15
9 L6 D6 o$ Q% {" z/ P16
. \% a0 Q: b; c$ z8 `17
18
6 i7 D/ B/ m6 t19
# H& \, g7 d$ }' f; M5 k6 ?* I20
4 D5 S' |* G3 Y3 ?$ }# l21
22
23
24
2 I& o7 S& F+ x: j  k( [- K25
3 |8 H* I- ?9 {! N' O9 S26
7 a/ E8 ~3 T) f  a/ Z4 ]27
28
6 v! l$ c1 a$ y; U: V1 Y9 q29
30
$ y$ _3 H  m8 N: X8 S31
32
1 c- O" `1 e. H33
! G% j* Q+ `* G9 h8 L$ O8 V* g34
3 A4 M. C* P' M0 X* k35
36
# L& L- D/ S- Z2 k37
& j+ i. v5 i9 Y3 }1 Y38
39
40
* G+ Z: c$ j2 \5 W41
' P$ m. b! j' n" b42
3 g( m, D: P+ f: }8 ^+ V" X& h1 c1 Q43
: @- m8 X. v) \% Q$ X6 U& m44
45
46
, l# ]& l, A5 O' V% _- F! w! ?47
48
49
50
: h8 b4 {5 H! `# _) l51
, ~2 m& p. w9 U52
9 h# L3 w% }" a: b5 t* f+ w53
2 B. @4 u& W1 v( K9 o& Q& U54
* S3 y8 [4 r( m4 L55
  \$ S) w7 ]6 ^( P% h56
57
! u% ?0 `: a7 b  J  t58
% b: K6 C+ V( k+ \59
; k& l  y6 M6 l0 a/ O60
61
62
& _, k( `2 A  F63
64
65
$ }" Z( k7 {3 T6 e66
67
68
3 X* C6 h& ?1 \7 d( R69
70
+ `: H, s( U0 L) l+ [71
72
73
74
# M# _) R- x' e9 i) c75
76
77
. e( d7 H( k9 C4 X78
79
3 r4 l8 j  X* \& h" Q6 A( e80
81
; M8 Z6 o/ B) C5 N! c% p2 p82
9 c# N( L& f% t( L, ^6 L9 e1 w83
  M: O# T$ X' g& E7 }5 S& y4 z! v84
4 a( \; z3 W9 J9 g+ \( b85
86
87
88
  Q0 f* P) c$ g) z2 d89
90
9 [3 z" c' A$ A9 b, ~- X91
92
93
: {  r/ W0 R' l+ y) l94
95
96
97
98
99
8 ?0 N' t( X3 Y* z1 o: R100
* S. H7 z( b0 S8 J; A8 p101
- Y, C% X; i; X# J* X: w+ O% t102
' a0 w) F! e$ I# P# c9 q103
# M9 t5 e; i. x  z! [104
6 {1 R/ @; {! `% G- l* A$ l+ Y105
106
# g% N* h; }" ^, p9 J107
- C1 L' f- G6 Z# t( I108
109
110
8 G# I* U$ \- ?/ @7 U111
112
; P1 _( d; Q* [9 U8 @113
114
115
+ H1 K' O. A: n9 ?+ H* t116
, @$ j) z8 B0 Z$ }117
118
119
120
121
122
123
124
125
+ }# ?% ^* h! Q% E4 _- k126
127
9 H3 s7 v' [/ h4 p8 d2 `4 b128
129
130
131
$ b( m- J( e( X5 |! R! L9 {8 ~132
+ \2 _' j. C. \& z133
134
135
136
. e, R- D/ b8 l) i( n% }  }' X137
138
/ L, |* W( V1 v( k139
140
3 b+ ]/ g* t! |" t0 n& z141
142
143
8 E* U) }8 Y6 u, I( }5 Z# y144
5 v0 F* s0 c/ V, b8 n4 s145
. d7 K. L2 k6 q+ D. k8 u" P146
8 ^, p  ]9 |" H" P147
148
149
150
151
& r+ y* Y* v: ?7 M9 d5 C1 D9 d152
" K  @$ J5 h  Q" |3 {; W153
: c$ l4 n' Y* v* [1 s154
1 y% v4 Z2 j- X; g  \8 w, Y155
156
2 ^2 \2 o/ i, l. |  M! N157
% ~0 }' {$ U( K6 `5 U& |158
! ^9 c8 i2 n" k) e* C( I159
9 d$ U3 L7 x3 e. t3 \+ q" k  I4 G160
161
4 E" o: e4 h# @' F3 S162
163
$ I4 _5 l9 p7 N6 F+ T( _% ?; d164
165
166
167
168
( d" g' x' X' O8 L" h) |* M169
170
5 d- f$ N) s: b( `! K+ H  t$ W171
- m: a# F9 v) E5 Y& g172
/ V' G% D  ]% [, c7 l. d173
174
175
8 K5 x! {% O+ \9 a5 e176
+ @7 E/ w+ a; F8 f; Q! F' |177
) d: k" X; e: [( j178
' |6 f& I, ^7 c8 D179
180
181
6 K6 I% k4 L* r$ _0 V182
  e+ s  I7 q# u5 L: h; G% F. i183
: p3 |$ C- N& V1 r; a) U/ O( t184
185
3 T/ x2 w3 t1 x+ H  z186
187
188
! v; D2 N& ~) B189
190
191
2 v% R* [! ^" h3 a  X8 `) B: w192
. Y- |! ?* M' |  u3 ?193
194
3 c; ?  s4 V8 l2 T195
196
197
198
199
; K7 N9 a! W1 k200
* h$ n) ^& u. u+ o' ^) k201
6 `; _2 K. f* v/ u& `/ Q202
/ e5 b4 l* d$ C# g! _* X1 t203
3 |# M" i' S* ^0 J204
1 I' ~& A- h! {205
5 B) r( D1 P6 y2 X6 U6 F* f0 u, h206
207
208
  |. R8 p* D; j. l  f/ o209
210
211
. W/ q5 a, s7 _. k8 y2 X212
213
6 l6 w- c  b0 c/ t214
( a4 G' O( m& c( b215
216
6 m  ^* k* M) q! `217
2 C# s3 f5 Y4 P2 D) a" Q# R* H218
219
220
221
222
223
8 }+ F9 s4 P( ?/ N1 ~224
3 w! K: P- _  ]6 T225
226
, x: b; L" f0 P) U: R9 b227
# }4 o9 z7 Y8 b' V4 z6 d8 Q/ b228
, `7 e/ R9 t3 n, U, _229
230
231
6 F( ^1 Y! e# y: c& W$ j" X* x232
233
234
" i  Q: _* A1 [$ E7 S; u4 S235
236
  u( @+ n! x/ d0 ^+ O237
, G$ d5 \4 K% q238
239
8 ?6 w2 [4 d7 p: k0 F$ @3 @; s240
241
8 m- l! K3 g& H2 J6 H7 w242
8 S9 z0 {) k( T9 f7 F243
244
245
246
% D% P& U' u. N247
248
249
250
% ^  w, c! s8 U4 R251
252
( D: s' h2 l. Z9 L7 b6 T. t& _253
$ w$ j9 v% Y" ^254
$ ~9 R& U2 D. Z5 L. I6 x+ ]255
256
, g. y  u% V+ W1 m3 M9 [3 x257
258
259
$ h6 ~9 p/ h+ M2 Z! R260
261
" P7 W- L! {; u262
9 H) L5 i; d/ u$ p9 z0 U263
264
: U1 G% h5 ?/ A265
266
267
1 Q; B  f( F9 n. \268
3 l2 H% g; j: y0 F: M6 _, [8 [269
3 ?+ w  W7 S6 R+ i5 M) z0 Z270
271
; q5 S9 |9 R+ B" _272
273
274
; d. h* [* `" S- a* U$ u( F275
276
277
278
: O5 O9 Q4 @2 ?4 S8 C& ?2 _279
280
281
282
) k/ \+ X' _6 C2 t: F- r/ I) E283
1 q" `( b- l3 t  c3 d, c" L284
285
286
287
288
289
290
' A4 V+ r. C& C291
292
% ]4 F# c8 v, j: I! _2 _5 }293
' Q& A/ J3 `& m5 G6 Z/ ?! a294
295
296
297
298
" a8 K+ a' K6 E# X299
300
; g0 U; {! D  \$ D% X301
302
303
304
305
5 Y2 U1 I8 e  t! _7 {8 g! U& n306
307
308
309
310
! V7 o& t" I' J0 C- @9 r311
, H8 B+ k1 b7 r. c" n1 D312
313
314
315
316
0 b  X2 H0 k) q' X% t% C317
8 L6 P( _% h- g2 S/ C& P: l# a318
% k( ]" T' W# M* k  ?1 w8 C319
320
2 z$ O/ G0 ~! }9 `321
1 c" P2 @9 w, O* v5 M$ ^( w) ~. Y322
323
324
+ X. g6 I& a& ?6 p$ o& r325
' m; a  B  V& Z& x326
' q0 j" G7 m# v. H: p' Y0 v  R327
328
. @( T6 ^9 i$ D329
330
, ]- _' V. s; J" S) Y+ |! b" k2 [7 y  G331





4 e$ y! i. ]# D8 ?  N
7 N( D' E, a& K( O3 {# B7 O2 `
- A  z# R) u4 {3 l


  @& W9 c! c0 U5 h, a5 _8 H

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