基于Python实现的决策树模型

杨利霞

基于Python实现的决策树模型

9 y2 `" v4 Z. b% z决策树模型
( S8 {' S* v+ \$ I2 O* j& I目录
; N" R- n1 `9 R3 q( }8 n5 s" g8 g人工智能第五次实验报告 1
2 i+ _; t2 J1 e+ y0 O' F决策树模型 1
5 p8 `. k. m2 F一 、问题背景 1
6 Z# K) Y+ y2 [+ z$ P9 Y& }1.1 监督学习简介 1
4 X6 D& P  S4 ^( l- R* O! {* t1.2 决策树简介 1
4 k5 o, I$ G$ ]: U9 P二 、程序说明 3
" N( i) }# I; b, ^" x* h% D! ~2.1 数据载入 3
2.2 功能函数 3
2.3 决策树模型 4
三 、程序测试 5
) u: _5 A- z8 A1 c7 n+ ]6 r3.1 数据集说明 5
3.2 决策树生成和测试 6
; W* X5 r: x( I$ b1 n6 f* K9 r3.3 学习曲线评估算法精度 7
四 、实验总结 8
附 录 - 程序代码 8
一 、问题背景
+ M/ D; X$ u% G# A; ~2 @$ y+ s1.1监督学习简介
机器学习的形式包括无监督学习，强化学习，监督学习和半监督学习；学习任务有分类、聚类和回 归等。
$ w4 ^, ]; q9 ]: \监督学习通过观察“输入—输出”对，学习从输入到输出的映射函数。分类监督学习的训练集为标记 数据，本文转载自http://www.biyezuopin.vip/onews.asp?id=16720每一条数据有对应的”标签“，根据标签可以将数据集分为若干个类别。分类监督学习经训练集生 成一个学习模型，可以用来预测一条新数据的标签。
常见的监督学习模型有决策树、KNN算法、朴素贝叶斯和随机森林等。
5 |4 E; N9 K8 u! L. p1 I* u( ]/ r1.2决策树简介
决策树归纳是一类简单的机器学习形式，它表示为一个函数，以属性值向量作为输入，返回一个决策。
决策树的组成
( f' O6 y1 }9 I/ s: R5 L, x- P决策树由内节点上的属性值测试、分支上的属性值和叶子节点上的输出值组成。
. e$ J1 R/ A7 x3 Z' _4 y
0 [# E9 H4 j" K: A' u; Z" aimport numpy as np
1 u7 D; [+ w- T: A. P7 }9 P: bfrom matplotlib import pyplot as plt
from math import log
import pandas as pd
import pydotplus as pdp

# Y! }" I- c/ A. Q$ n  Q4 ?"""
7 V1 Q6 Q7 X( J) X% K; I19335286 郑有为
人工智能作业 - 实现ID3决策树
"""

# e! [* `2 s5 f8 n3 T% Ynonce = 0  # 用来给节点一个全局ID
6 f, O# G7 {5 F% H) \& n3 vcolor_i = 0
# 绘图时节点可选的颜色, 非叶子节点是蓝色的, 叶子节点根据分类被赋予不同的颜色
0 H# m1 j( ]/ Z2 o/ kcolor_set = ["#AAFFDD", "#DDAAFF", "#DDFFAA", "#FFAADD", "#FFDDAA"]
3 ^/ c/ E4 |6 i$ o# Y
# 载入汽车数据, 判断顾客要不要买
class load_car:
    # 在表格中,最后一列是分类结果
    # feature_names: 属性名列表
    # target_names: 标签(分类)名
3 q9 l0 C7 C; K6 H" ]' g' u    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
! B3 `. U# e. }+ |    # target: 目标分类值列表
    def __init__(self):
        df = pd.read_csv('../dataset/car/car_train.csv')
        labels = df.columns.values
        data_array = np.array(df[1:])
        self.feature_names = labels[0:-1]
  w9 G  W, X2 S/ A  z6 w3 j        self.target_names = labels[-1]
4 ~0 |+ P, E* Z, p5 I0 l        self.data = data_array[0:,0:-1]
        self.target = data_array[0:,-1]
7 P, m2 G, N. w7 `( \; N: Y8 ?4 v! y
# 载入蘑菇数据, 鉴别蘑菇是否有毒
% Z7 I8 B( i7 R6 b  Tclass load_mushroom:
    # 在表格中, 第一列是分类结果: e 可食用; p 有毒.
' N0 `5 N' R- f9 A/ M6 i# `2 U    # feature_names: 属性名列表
0 `/ Y3 ]3 N' y    # target_names: 标签(分类)名
4 h$ S' N  z" \" A5 r    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
    # target: 目标分类值列表
1 L- j& v, I, b2 O1 Y    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",
                  "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:]
% P+ p+ b, F8 }. X        self.target_names = labels[0]
5 ^: ?, @; K# q. j8 i! D  l0 k        self.data = data_array[0:,1:]
) Y; H4 l$ B& `/ V5 f  B        self.target = data_array[0:,0]

9 @1 u4 u$ ]& `& d! t# 创建一个临时的子数据集, 在划分测试集和训练集时使用
$ F7 I8 ~6 z. Kclass new_dataset:
" P3 O: {, [% \7 y8 q    # feature_names: 属性名列表
    # target_names: 标签(分类)名
3 u/ B- X, r; p0 ~# s9 X    # data: 属性数据矩阵, 每行是一个数据, 每个数据是每个属性的对应值的列表
; G) l. }6 [& @8 u4 ?% D  C% d; l    # target: 目标分类值列表
    def __init__(self, f_n, t_n, d, t):
        self.feature_names = f_n
0 l  Z1 }' K  p% H        self.target_names = t_n
        self.data = d
        self.target = t
, \# m% H! E" Y
9 v3 H+ U  h5 v9 a3 n# 计算熵, 熵的数学公式为: $H(V) = - \sum_{k} P(v_k) \log_2 P(v_k)$
#        其中 P(v_k) 是随机变量 V 具有值 V_k 的概率
# target: 分类结果的列表, return: 信息熵
def get_h(target):
2 g  d$ Y' H" q    target_count = {}
    for i in range(len(target)):
        label = target
0 o* L% P5 S8 C" N# Z2 t, t$ K        if label not in target_count.keys():
' n1 |; m) T% ~( h+ ^' ?7 u            target_count[label] = 1.0
        else:
            target_count[label] += 1.0
    h = 0.0
    for k in target_count:
: Y$ G6 k; g; l9 l        p = target_count[k] / len(target)
( g) m! r) ~3 {8 k+ q8 F7 b        h -= p * log(p, 2)
, H" y( m) S, ]# Y- B& u2 r' s    return h

, q- s+ U6 _6 _# 取数据子集, 选择条件是原数据集中的属性 feature_name 值是否等于 feature_value
# 注: 选择后会从数据子集中删去 feature_name 属性对应的一列
def get_subset(dataset, feature_name, feature_value):
    sub_data = []
0 B- T* @, u% V3 |- d% I# C! H    sub_target = []
4 f; ^0 f( K7 g, P2 m9 e  O* I5 ~    f_index = -1
    for i in range(len(dataset.feature_names)):
- p/ E: F" c8 V3 m6 P8 ]        if dataset.feature_names == feature_name:
            f_index = i
            break

( E$ o$ y6 ~% s$ T' F    for i in range(len(dataset.data)):
; y4 j" }0 A3 @5 W        if dataset.data[f_index] == feature_value:
* K" q( W$ Z( J# W            l = list(dataset.data[:f_index])
* V8 y0 T* P, V            l.extend(dataset.data[f_index+1:])
            sub_data.append(l)
8 e( ]: m* A4 l* \+ |4 ~            sub_target.append(dataset.target)
/ f( y0 W' W; I4 ^
2 v  R& v9 ^! r' F6 i    sub_feature_names = list(dataset.feature_names[:f_index])
' x! o- B! c/ o: R" E/ o* l    sub_feature_names.extend(dataset.feature_names[f_index+1:])
0 C' \1 n3 Y0 I    return new_dataset(sub_feature_names, dataset.target_names, sub_data, sub_target)

# 寻找并返回信息收益最大的属性划分
# 信息收益值划分该数据集前后的熵减
# 计算公式为: Gain(A) = get_h(ori_target) - sum(|sub_target| / |ori_target| * get_h(sub_target))$
def best_spilt(dataset):

    base_h = get_h(dataset.target)
% l# {7 W3 ]: z    best_gain = 0.0
0 m3 W9 D* \; r/ h& r& t0 F    best_feature = None
5 A  [5 T8 y/ }( `- ]    for i in range(len(dataset.feature_names)):
2 D9 Y, }( B1 Z( e8 h2 z        feature_range = []
        for j in range(len(dataset.data)):
7 U, n& p: ~/ w* ]" p8 h- m( u7 w            if dataset.data[j] not in feature_range:
                feature_range.append(dataset.data[j])
9 |# P5 x2 v; U- ^
        spilt_h = 0.0
        for feature_value in feature_range:
            subset = get_subset(dataset, dataset.feature_names, feature_value)
3 |* B+ H' @. \+ X0 ~  n( o$ z# e            spilt_h += len(subset.target) / len(dataset.target) * get_h(subset.target)
& {9 f, n$ k4 B  I; Y
        if best_gain <= base_h - spilt_h:
2 x0 e7 W$ [! Z  }7 W% c  r; M" Z            best_gain = base_h - spilt_h
            best_feature = dataset.feature_names

; p! O2 T; f. {+ U) e4 Q. k9 g" C2 Y    return best_feature
! v0 p; s9 Q7 ]
# 返回数据集中一个数据最可能的标签
def vote_most(dataset):
    target_range = {}
% T. U) M; X" d& M0 Y    best_target = None
9 Q. E' @- J5 D7 a    best_vote = 0

+ b2 \4 ?! ^+ y1 _4 p  T( M+ z    for t in dataset.target:
( C3 |4 a  ^9 c9 j9 R* w. O+ T        if t not in target_range.keys():
1 o# Q$ V8 _2 k+ h- q$ {            target_range[t] = 1
- S' Z' H7 I- N' c        else:
            target_range[t] += 1

4 }- i1 {7 U2 _& ^    for t in target_range.keys():
5 j# X' v8 [* S! s5 t8 X        if target_range[t] > best_vote:
9 V6 n7 B0 i/ R- i! B  U9 ?            best_vote = target_range[t]
            best_target = t

    return best_target
/ p, K1 p9 `) a5 C
# 返回测试的正确率
6 a. Y" j3 |! N# predict_result: 预测标签列表, target_result: 实际标签列表
3 ?3 \" B3 O  R3 g0 {; M& cdef accuracy_rate(predict_result, target_result):
    # print("Predict Result: ", predict_result)
    # print("Target Result:  ", target_result)
6 q4 g8 G7 p1 k; i3 c    accuracy_score = 0
% E7 J+ Z! z) O* ]( y    for i in range(len(predict_result)):
        if predict_result == target_result:
! @- A% }8 p8 `7 E9 s            accuracy_score += 1
) _. p, Y. j( i. y: B0 {% ^$ v0 x/ E    return accuracy_score / len(predict_result)

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

    def __init__(self, content, is_leaf=False, parent=None):
6 R! j% r6 r# V  b. s5 A% Y        global nonce
0 W+ ^6 j1 r! Z3 V; N- G        self.id = nonce # 为节点赋予一个全局ID, 目的是方便画图
        nonce += 1
) w3 A) w$ t. r) p0 [1 M% m        self.feature_name = None
1 S6 E) A1 o, {3 v- k# S" Z        self.target_value = None
        self.vote_most = None # 记录当前节点最可能的标签
        if not is_leaf:
# H7 ~7 P3 W' W0 ~" L* ]            self.feature_name = content # 非叶子节点的属性名
        else:
+ P% h4 o' j) B  j+ ]5 U& E. @            self.target_value = content # 叶子节点的标签

/ E( ~/ B# G( x6 Z7 @        self.parent = parent
1 G2 b% ~! n8 c7 Q        self.child = {} # 以当前节点的属性对应的属性值作为键值

% x/ E7 \4 l" A* c$ C7 C# 决策树模型
class dt_tree:

    def __init__(self):
        self.tree = None # 决策树的根节点
        self.map_str = """
            digraph demo{
0 T5 `4 Q% E/ Z1 @& y8 i. ^# S            node [shape=box, style="rounded", color="black", fontname="Microsoft YaHei"];
4 n3 \% @5 P" l* [            edge [fontname="Microsoft YaHei"];
8 Y$ X! R+ @% H. p            """ # 用于作图: pydotplus 格式的树图生成代码结构
        self.color_dir = {} # 用于作图: 叶子节点可选颜色, 以标签值为键值
" O8 ]& r! @3 w2 R% b0 L
    # 训练模型, train_set: 训练集
    def fit(self, train_set):
# Y. v5 [: k7 o6 T8 x2 i$ @0 Y1 S
        if len(train_set.target) <= 0:  # 如果测试集数据为空, 则返回空节点, 结束递归
* x9 d! @: w3 f0 `, R3 Z/ i            return None
: o4 \' |& ?' V
  F1 J# P$ }' U8 |  t7 F        target_all_same = True
        for i in train_set.target:
; k. m1 X+ X  k3 h* `! O1 A            if i != train_set.target[0]:
9 Z% J: l6 |0 q1 @8 ?                target_all_same = False
                break

        if target_all_same:  # 如果测试集数据中所有数据的标签相同, 则构造叶子节点, 结束递归
            node = dt_node(train_set.target[0], is_leaf=True)
# \" ~6 J* e7 Q' A# S* p            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
6 t5 @4 Q0 z  S) s4 m" E                self.tree = node

, ]3 E; n$ x1 B0 C6 D5 U! u$ l7 F            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
( e0 u9 P1 J/ o$ ^$ W% V9 r            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"
1 ~" H- ]0 ]6 b1 p3 S! X. x" |
' X& M  Y# D5 L- _            return node
        elif len(train_set.feature_names) == 0:  # 如果测试集待考虑属性为空, 则构造叶子节点, 结束递归
            node = dt_node(vote_most(train_set), is_leaf=True)  # 这里让叶子结点的标签为概率上最可能的标签
  D3 g4 d9 e2 N. p* @            if self.tree == None:  # 如果根节点为空,则让该节点成为根节点
                self.color_dir[vote_most(train_set)] = color_set[0]
# R' u9 o# d! A/ |1 T( H                self.tree = node
! M+ q+ [. m8 @+ @8 E" R
2 @- M+ ?- |0 t: @/ Q2 ]            # 用于作图, 更新 map_str 内容, 为树图增加一个内容为标签值的叶子节点
            node_content = "标签：" + str(node.target_value)
$ [( z& L9 q: s9 @            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"" + self.color_dir[node.target_value] + "\", style=filled]\n"
( O. e7 {. G( S5 S$ p2 b1 {/ R
            return node
        else: # 普通情况, 构建一个内容为属性的非叶子节点
            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
                    break
4 |: I) I6 W5 c) D1 x8 p. {8 P
            node = dt_node(best_feature)
            node.vote_most = vote_most(train_set)
            if self.tree == None: # 如果根节点为空,则让该节点成为根节点
                self.tree = node
                # 用于作图, 初始化叶子节点可选颜色
! H. U& I/ n0 J                for i in range(len(train_set.target)):
- F  K' |! l% R+ _: e" V0 E                    if train_set.target not in self.color_dir:
                        global color_i
  n7 _" c: \1 g2 \, f                        self.color_dir[train_set.target] = color_set[color_i]
                        color_i += 1
                        color_i %= len(color_set)

            feature_range = [] # 获取该属性出现在数据集中的可选属性值
: V; W8 |6 @. O8 r( g( H  p            for t in train_set.data:
- U9 V! v1 b& O& `- P                if t[best_feature_index] not in feature_range:
( R6 S% f. l/ ]& J* j9 R5 R7 @( f; Y( [                    feature_range.append(t[best_feature_index])

            # 用于做图, 创建一个内容为属性的非叶子节点
0 d8 K& V( s/ o4 Z- L2 h5 Z            node_content = "属性：" + node.feature_name
& h7 `' }+ |4 _1 E: o            self.map_str += "id" + str(node.id) + "[label=\"" + node_content + "\", fillcolor=\"#AADDFF\", style=filled]\n"
" X/ J& X2 P1 g+ {( _% S" \
            for feature_value in feature_range:
                subset = get_subset(train_set, best_feature, feature_value)  # 获取每一个子集
8 ~* |1 t& m( N% z                node.child[feature_value] = self.fit(subset)  # 递归调用 fit 函数生成子节点
$ G7 R0 ~+ Q; P. q( F/ H                if node.child[feature_value] == None:
5 k  n0 F% Y8 i, O+ h                    # 如果创建的子节点为空, 则创建一个叶子节点作为其子节点, 其中标签值为概率上最可能的标签
                    node.child[feature_value] = dt_node(vote_most(train_set), is_leaf=True)
$ |  b" [# T1 a2 D  {& I                node.child[feature_value].parent = node

% ~, {6 I$ t6 }# r# {                # 用于做图, 创建当前节点到所有子节点的连线
                self.map_str += "id" + str(node.id) + " -> " + "id" + str(node.child[feature_value].id) + "[label=\"" + str(feature_value) + "\"]\n"
+ u5 ?% Z+ x* C( B7 S
' O" W: k3 h$ u, {            # 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)
            return node
( |; i; t& B9 d" n
    # 测试模型, 对测试集 test_set 进行预测
( J9 I. P! N6 i6 X    def predict(self, test_set):
! h1 S5 S/ P( Q) X: J, ]        test_result = []
        for test in test_set.data:
- a5 z9 X+ V) @9 |3 B  p            node = self.tree # 从根节点一只往下找, 知道到达叶子节点
            while node.target_value == None:
  e6 M" \, h! T7 v                feature_name_index = -1
                for i in range(len(test_set.feature_names)):
: o5 B2 c9 D3 W5 `) C5 u% j$ I                    if test_set.feature_names == node.feature_name:
                        feature_name_index = i
                        break
                if test[feature_name_index] not in node.child.keys():
. \  e6 {& \  S. r4 k1 q! T6 e                    break
4 z, m' y# A: v9 ?  B                else:
) h+ b) q3 x" H! h$ J" ~8 _                    node = node.child[test[feature_name_index]]

            if node.target_value == None:
                test_result.append(node.vote_most)
: A, ^! {: A8 Q2 k( R' h            else: # 如果没有到达叶子节点, 则取最后到达节点概率上最可能的标签为目标值
  K6 Q, @. Z% Y/ \  j& r) P! M                test_result.append(node.target_value)
8 e/ g! R8 }2 x4 n7 r
        return test_result
  I; t' n5 l4 K
7 U! p& w4 c1 x) y9 Q7 c    # 输出树, 生成图片, path: 图片的位置
9 N% c( h% L$ q  \! O    def show_tree(self, path="demo.png"):
' w2 X' V, z0 Q0 W2 D+ L1 D        map = self.map_str + "}"
" s+ C9 w2 B' w5 D! b' F$ h+ @        print(map)
        graph = pdp.graph_from_dot_data(map)
% r0 O6 }9 l( q        graph.write_png(path)

0 \# o9 O) [9 q8 g% V+ m# 学习曲线评估算法精度 dataset: 数据练集, label: 纵轴的标签, interval: 测试规模递增的间隔
def incremental_train_scale_test(dataset, label, interval=1):
* a1 I) m1 A0 _' Y) ?/ j    c = dataset
) j  ]3 ]0 h" K    r = range(5, len(c.data) - 1, interval)
2 W8 S; D7 k( L7 V    rates = []
* }" U1 A7 L% F8 z% A    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])
/ w# Z4 b9 i% v+ C9 M; @8 h        test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])
( |2 E3 C% o, b, k, A        dt = dt_tree()
# X$ J' ?3 M) O% I( e        dt.fit(train_set)
8 ^0 d' a" ]$ j$ _5 x        rates.append(accuracy_rate(dt.predict(test_set), list(test_set.target)))

5 E1 V+ c6 w$ w4 d# d5 l1 n# q* h  |" Y    print(rates)
    plt.plot(r, rates)
) ?$ h7 ~! L* r$ x" E% t  J    plt.ylabel(label)
6 b* q/ C+ T8 O0 q1 J6 n4 f    plt.show()

) i2 t- p2 w# Q) r; iif __name__ == '__main__':

    c = load_car()  # 载入汽车数据集
    # c = load_mushroom()  # 载入蘑菇数据集
0 [+ x1 j6 q9 ~7 j* }3 T$ o    train_num = 1000 # 训练集规模(剩下的数据就放到测试集)
    train_set = new_dataset(c.feature_names, c.target_names, c.data[:train_num], c.target[:train_num])
9 P+ o6 y6 E) F- C8 G    test_set = new_dataset(c.feature_names, c.target_names, c.data[train_num:], c.target[train_num:])

    dt = dt_tree()  # 初始化决策树模型
: _" t- P' A! o7 F4 W# P% S) }  I    dt.fit(train_set)  # 训练
    dt.show_tree("../image/demo.png") # 输出决策树图片
    print(accuracy_rate(dt.predict(test_set), list(test_set.target))) # 进行测试, 并计算准确率吧
& r, @0 f" [( e0 K9 t# E$ V  Q, Y
    # incremental_train_scale_test(load_car(), "car")
    # incremental_train_scale_test(load_mushroom(), "mushroom", interval=20)
' u6 y& C1 w* I4 b" r. i
+ E: v/ L  r: g6 w7 L! }

+ R5 e' B1 M& s8 t% P1
" d- [9 a5 v0 D$ D! R! A6 B2
, _+ ^5 K5 R+ I) y* D" B* K9 U3
4
5
, L8 c" T, y0 J6
7
- r" t$ O  D: q& ^* j8
9
% R/ j$ v$ [* ^10
* T" j+ E; k/ ~2 S' q11
" j/ ?- g( C; `" C, H/ }12
13
14
4 J9 f' k% k  ~7 E) g15
16
17
( s, i9 c4 G  `3 l18
, t$ i# a& |: B! ]1 B7 V19
3 ?* O( Z- M+ Y1 a: C) S: F& l4 @20
5 I& G+ L" N2 x' u3 \21
22
23
) p$ Z7 k- ~: u/ T# ]24
25
1 D( n4 n. w# z& [5 o26
& c) N: i# ~$ l" c& t) @) {27
: g% S. A3 P" f! p4 V28
. f5 G6 e( d$ [4 U1 _29
- q. E% p' e# x% n  |6 t6 \30
  u* c2 ]! V3 ]8 Q6 e31
32
33
' `2 q1 d# c: I( \3 X, q34
35
1 V$ Z' q6 Z/ q% p' G36
$ F6 T' V- R0 f, k: |37
38
39
40
* J4 t4 m6 ]" {41
42
& K2 L/ y3 B& k43
44
45
46
" `9 G( Q* D5 _5 R$ \) p3 z47
48
, [$ V* f/ P1 F. b+ {9 p4 ~49
- T1 s2 D$ m% z50
51
: C3 E) K1 C4 o0 N9 X" ]52
. R4 q% G1 K1 F6 G2 v53
, G. W3 x* t1 N54
55
56
( U8 ]4 I+ K6 R( g9 Y- ^57
1 ^, f; E: [, v$ w6 c0 Z2 ~2 P! j58
59
60
61
1 v- E6 ~' `! e; Q8 q/ _1 @+ x62
( z# Z/ X: t$ B* f3 D63
64
65
66
67
68
8 |4 T% H" u6 k+ X* F6 C7 x$ u69
; P# j1 |8 y( j9 O% f! V6 O5 n70
- {. n+ ^4 p6 u; w  U! M1 z3 B71
72
73
* b0 z) @' r2 F74
# T" |& ?) W' y+ Q75
76
77
78
79
80
81
82
83
84
  Y- x3 p2 K2 b85
86
  `$ W- P* _. X4 W$ x1 c: h8 p87
! C* X* v- i* Q+ x! }3 y5 H88
89
90
8 r, ~; T' a4 d5 _; A7 Z91
92
93
, [: ^4 ]- d9 z9 t8 h% J. F" H94
5 y% i! |! ]. `4 w$ `3 y95
+ \( r8 q: ^4 r; S3 k# I96
97
' D: r2 U' D7 Q# d2 `7 @98
. n; K8 T( n$ g7 r3 ^- S9 {99
" ^" h# ~- ~  k$ Z4 P100
) W* ?) M/ @6 W) Q0 u& Q2 {101
4 ]9 f5 J( L: |/ F$ T102
103
( [' y: s' J+ s5 C7 I' R104
105
% ^6 X( x4 L' H! ]9 f106
107
108
% d, h4 j. o0 N3 w6 N9 v109
110
111
112
113
114
115
116
117
118
119
120
, d  Y" S9 r$ a) r) `121
122
123
124
9 L6 u5 }; W$ q4 Y: a125
126
127
' A2 G: l" W4 e. f. D128
  _0 U4 \7 q6 i! Y( p  c129
130
) V2 x" N) u& N5 u* r131
132
6 M/ V8 Q9 R0 x133
* D1 u' w8 V% r1 O8 y/ `134
, W! X" L) S0 Y; x. b( t* e135
136
137
138
( T, k. o% c2 M+ I1 ]139
140
. g. _  `* b" B* o141
7 ^1 I$ b  c/ T$ _/ ]6 [6 G142
143
/ {$ I5 i  C1 |% B$ |  d144
0 f- z0 p5 K3 I5 r& s; u: u145
146
, i5 b8 [% Q: ]6 K9 [$ s. A147
' p) |- A" J. K' K- L0 R$ l* z148
; Z8 a  ~/ g) i( i$ I; [8 v149
* B; U/ d# a* \- r$ v" w! M150
2 n3 e+ F+ e/ [151
; r# c& ~' K6 I% r9 ^3 M152
. D2 w& `5 L1 _' h153
; N' _1 c- u7 p% h; |: I. z154
8 R' h3 _, k. u7 `155
8 Q4 X" P9 _6 p0 `& r# \4 d) i156
3 G* b  l$ l4 T# I- t157
158
159
7 R' y+ Y% h/ a7 i4 _160
( u" K" y$ E  M. q, |161
162
8 P8 f( k! S6 P163
164
165
166
6 F7 ]2 O. U, F! s167
168
# r0 Q9 F9 v/ R: i: z& g# |! b0 K9 N169
170
/ o/ l% l& P# J4 j171
* l9 e9 I5 a/ r: t172
6 N6 l2 G- J! {7 }  _3 h' |( x173
174
175
2 s9 L1 V' m7 R176
177
178
179
4 B3 }  r0 N" o3 P8 V1 F180
181
. s& i+ |5 J: Q, s( K" I0 h5 L182
7 A3 G3 m/ t0 @; S183
6 u; Y, r# A% W1 ]184
185
186
187
188
189
7 e! E1 D3 _7 b  _190
191
192
. P% s+ M( q; U3 P: U7 r193
194
195
* ?/ ~) ]" q1 l* P  S* p196
% H9 s- U. b# }( o4 T. D! S1 C197
198
199
200
201
202
) V: I8 o4 \' }# u203
204
; ]: b  k3 \" S$ p205
206
; T$ G& O+ E9 X0 o% o4 P207
8 X5 C* z+ \) k0 ]208
209
2 s# i# A( i' t0 w( B) O9 Q8 T210
211
* C* S' j. _8 }! D212
) Z2 V: L2 A$ ]. i# s213
& y2 l- B) T# ^$ C( z' d214
' G: a3 J3 v% j215
216
217
218
219
220
; w, u& S) a1 R, x, N5 ]4 A, q221
  z# O9 U8 \' ^. G7 }+ E$ s222
6 w. w+ j; e9 V. e. M8 }. V223
$ F7 V! r; i4 e& i& l2 k224
225
) a' g! {, _1 p9 l- k4 m+ F3 A226
: p( |# K: I) f227
2 e- M& p; N6 i0 F" y' N228
0 ?- G8 t- s& s; l8 F229
230
231
232
. ]. J# [0 t0 f, I& C! y4 X! V9 l* W: d1 B233
" h- ]) b3 K3 r2 V' n234
! I$ G$ y* x- ]1 v235
) I' t7 O& n4 i) y2 g2 m1 E: w. e236
0 j# `5 q: P2 g0 G5 _+ D237
238
/ f! R3 `9 D9 O" x* V239
240
241
8 ~" ~1 j& d& m# S/ H' n242
243
244
+ _- e* q  a$ M' S5 a& L$ D' d245
246
$ j4 Y' V* R" @. J; o/ N* K247
# `1 Y; `$ ~7 F$ e8 g248
% J  y5 V) V! v4 A249
250
- n2 ]% o( `' e3 ~251
, T9 N9 J+ {+ H4 \+ l  Q4 j/ p252
253
254
7 z2 D0 f/ K* j, ^' g$ K255
256
: J4 O  K+ E* D6 o8 X0 E2 x257
258
0 }" h6 i; d/ O8 Q6 {6 C0 }259
260
261
262
# D% G, x/ P( f% D7 w. @263
" c+ \  `" U8 h; [5 X8 Y264
265
; ?0 @( f* d* R0 H! w7 j266
( e2 k7 t2 w( \9 s9 F( {, H: C267
" k) x6 A) e9 I  f268
, X5 }8 f& r, R+ n) c269
270
& p8 Y- Y5 k) E* H& P8 H271
272
273
274
6 T/ {" T- ?/ H% F4 ?8 d275
1 a9 A, @& }: u& A0 z276
4 F; Z3 v; I" f5 M2 n4 Y277
278
279
& J* {/ r  ~1 a6 U5 `7 O280
1 Z9 P+ y  \1 o4 H* Z$ G281
282
) C) ^1 T! J+ f2 s: g0 ?) `3 }283
7 K+ k% I' a+ d  v% S; s( b284
2 a% p" W1 b% f% P- Q( {285
286
287
& [" b- l$ G3 ?& e# W( ?288
289
290
% p: W# B! a$ `7 ?: F+ u7 @291
# T5 `7 E" u  y6 O6 A7 x0 L+ ]292
+ l: }  G9 K) m0 @  [293
* k9 |( P0 a& ~3 ]4 A- {! Q294
0 [% }2 B3 b* ^" Q7 n8 M295
296
297
298
299
; @- i; k3 J: y8 S& S' K6 \300
301
/ r( Z9 R# H. T9 g302
/ s+ J- |+ f( ?1 a1 b303
" \3 e4 m5 p. K# g+ p0 c0 [, ]% g9 y" R304
305
306
307
9 D( `0 c" Y& }4 P! C. R308
309
5 _7 _$ W$ S; c' j4 E1 f310
2 N: {: k8 ]6 Y7 _" B311
& ~$ I3 B* v9 A9 R: o* j1 Q312
1 e( W" D4 z+ J0 a$ r# @313
# }$ G2 z2 W; E; `9 z314
315
7 i' ^- b; y5 r! j4 h+ \316
8 g7 O" k! a4 p2 z7 o& n317
, R% `& J) Y% T* q9 |+ S, R318
319
, `( w2 u3 G% J9 r: V" g. q# V320
321
/ `6 {" w* R1 ^6 b322
2 t$ I- U7 W- [9 Y; o$ N: C323
324
2 d, D: N! `; r. p: b325
7 N( }: d6 P7 a$ k# x326
327
* s, t0 x* ^2 i, @7 R( w+ i328
1 R( H5 t& n8 ^6 G2 o( C* q329
330
2 n) m6 \" z2 Z  p  |$ E331

7 \- g' S  w$ J7 h( F* r- x
% b' o; r& r, @. k3 `
6 T* P! W4 _4 v9 t  T2 y


! k0 g; L5 b5 j  f0 ^- u: d9 v

) ~3 m' [: C; W' w7 z3 d) X# l

5 q0 {+ g4 M% T

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


% ?3 x1 |4 j4 \( }8 k1 g$ B1 C