强化学习——多臂老虎机问题（MAB）【附python代码】

一、问题描述

1.1 问题定义

  有一个用于 K 根拉杆的老虎机，每一根拉杆都对应一个关于奖励的概率分布 R 。每拉动一个拉杆，就可以从该拉杆的奖励概率分布中获得一个奖励 r 。在各拉杆的奖励概率分布未知的情况下，从头开始尝试，目标是在操作 T 次拉杆后获得尽可能高的累积奖励。

  由于奖励的概率分布是未知的，因此我们需要在“探索拉杆的获奖概率”和“根据经验选择获奖多的拉杆”中进行权衡。

【通俗易懂：有 K 个机器，你不知道每个机器的奖励概率分布，你只有 T 次机会选择机会，探索机器的奖励概率分布也算在 T 次内，然后尽可能获得最多的奖励。】

【示例：有 1 个 10 臂老虎机，你有 20 次选择机会，你可以花 10 次机会探索前 5 臂，根据获得的奖励，选择奖励期望最大的一个，剩下 10 次都选择最大的那 1 臂。（有可能奖励期望最大在没有探索的 5 臂中，也有可能在前 5 臂中，但是不是你选择的那个）】

1.2 形式化描述

  多臂老虎机问题可以表示为一个元组 $<A,R>$，其中：

• A 为动作集合，其中一个动作表示拉动一根拉杆，若多臂老虎机有 K 个拉杆，则动作空间就是集合 { a 1 , a 2 , . . . , a K } \{a_1,a_2,...,a_K\} {a1​,a2​,...,aK​}，用 $a_t\in A$ 表示任意一个动作；
• R 为概率分布，拉动每一根拉杆的动作 a 都对应一个奖励概率分布 $R(r|a)$，拉动不同拉杆的奖励分布通常是不同。

  假设每个时间步只能拉动 1 根拉杆，多臂老虎机的目标为最大化一段时间步 T 内累积的奖励：$max{\sum }_{t=1}^T{r}_t,r_t\sim R(\cdot |a_t)$。其中 $a_t$ 表示在第 t 时间步拉动某一拉杆的动作，$r_t$ 表示动作 $a_t$ 获得的奖励。

1.3 累积懊悔

  对于每一个动作 a ，我们定义其期望奖励为 $Q(a)=E_{r\sim R(\cdot |a)}[r]$ 。于是，至少存在一根拉杆，它的期望奖励不小于任意一根拉杆，将该最优期望奖励表示为 $Q^{\ast }={\max }_{a\in A}Q(a)$ 。

• 懊悔：当前动作 a 与最优拉杆期望奖励的差距，即 $R(a)=Q^{\ast }-Q(a)$
• 累积懊悔：操作 T 次拉杆后累积的懊悔总量，对于一次完整的 T 步决策 { a 1 , a 2 , . . . , a T } \{a_1,a_2,...,a_T\} {a1​,a2​,...,aT​} ，累积懊悔为：${\sigma }_R={\sum }_{t=1}^{T}R(a_t)$ 。

  所以求解 MAB 问题等价于最小化累积懊悔。

1.4 估计期望奖励

  为了知道拉动哪一根拉杆可以获得更高的奖励，所以我们需要估计这根拉杆的期望奖励。

算法流程：

对于 $\forall a\in A$ ，初始化计算器 $N(a)=0$ 和 期望奖励估值 $\hat{Q}(a)=0$
for $t=1\to T$ do
  选取某根拉杆，该动作记为 $a_t$
  得到奖励 $r_t$
  更新计数器：$N(a_t)+=1$
  更新期望奖励估值：$\hat{Q}(a_t)+=\frac{1}{N(a_t)}[r_t-\hat{Q}(a_t)]$

示例：

  编写一个拉杆为 10 的多臂老虎机。其中每个拉杆的奖励服从伯努利分布，即每次有 p 的概率获得奖励 1 ，有 1-p 的概率获得奖励 0 。【0 表示没有获奖，1 表示获奖。】

在 MAB 目录下新建 BernoulliBandit.py 文件

代码如下：

import numpy as np
import matplotlib.pyplot as plt


class BernoulliBandit:
    """伯努利多臂老虎机，输入 K 表示拉杆个数"""

    def __init__(self, K):
        self.probs = np.random.uniform(size=K)  # 随机生成 K 个 0-1 的数，表示每个拉杆的获奖概率
        self.best_idx = np.argmax(self.probs)  # 获奖概率最大的拉杆
        self.best_prob = self.probs[self.best_idx]  # 最大的获奖概率
        self.K=K

    def step(self, k):
        if np.random.rand() < self.probs[k]:
            return 1
        else:
            return 0


np.random.seed(1)
K = 10
bandit = BernoulliBandit(K)
print("随机生成了一个 %d 臂的伯努利多臂老虎机" % K)
print("获奖概率最大的拉杆为 %d 号，其获奖概率为 %.4f" % (bandit.best_idx, bandit.best_prob))

运行结果如下：

D:\RL\MAB\.venv\Scripts\python.exe D:\RL\MAB\BernoulliBandit.py 
随机生成了一个10臂的伯努利多臂老虎机
获奖概率最大的拉杆为1 号，其获奖概率为0.7203

进程已结束，退出代码为 0

  接下来编写 Solver 基础类来解决 MAB 问题。具体的解决策略由每个继承 Solver 的类来实现。

  新建 Solver.py 文件，文件代码如下：

import numpy as np


class Solver:
    """多臂老虎机解决方案抽象类"""

    def __init__(self, bandit):
        self.bandit = bandit
        self.counts = np.zeros(self.bandit.K) # 每根拉杆的尝试次数
        self.regret = 0 # 当前步的累积懊悔
        self.actions = []   # 记录每一步的动作
        self.regrets = []   # 记录每一步的累积懊悔

    def update_regret(self, k):
        # 记录累积懊悔并保存，k为本次动作选择的拉杆的编号
        self.regret += self.bandit.best_prob - self.bandit.probs[k]
        self.regrets.append(self.regret)

    def run_one_step(self):
        # 返回当前动作选择的拉杆，由具体的策略实现
        raise NotImplementedError

    def run(self, num_steps):
        # 运行一定次数，num_steps为总运行次数
        for _ in range(num_steps):
            k = self.run_one_step()
            self.counts[k] += 1
            self.actions.append(k)
            self.update_regret(k)

配置 numpy 和 matplotlib 模块：

访问文章：配置 numpy 和 matplotlib 模块

二、解决方法

2.1 ϵ-贪婪算法

  完全贪婪算法就是在每一刻都采取期望奖励估值最大的动作，这就是纯粹的利用，没有探索。而 ε-贪婪算法则是在其基础上添加了噪声，每次以 1-ε 的概率选择以往经验中期望奖励估值最大的那根拉杆【利用】，以 ε 的概率随机选择一根拉杆【探索】，公式如下：

$$a_t=\{\begin{array}{l}arg\underset{a\in A}{\max }\hat{Q}，采样概率：1-ϵ\\ 从A中随机选择，采样概率：ϵ\end{array}$$

  随着探索次数不断的增多，对各个动作的奖励估计越来越准确，所以没必要继续花费大力气进行探索。所以我们可以让 ε 随着时间衰减，但是不会到 0 。因为基于有限步观测的完全贪婪算法仍然是一个局部信息的贪婪算法，永远离最优解有一个固定的差距。

项目结构：

新建 EpsilonGreedy.py 文件，文件代码如下：

import numpy as np

from Solver import Solver


class EpsilonGreedy(Solver):
    def __init__(self,bandit,epsilon=0.01,init_prob=1.0):
        super(EpsilonGreedy,self).__init__(bandit)
        self.epsilon = epsilon
        self.estimates=np.array([init_prob]*self.bandit.K)

    def run_one_step(self):
        if np.random.random()<self.epsilon:
            k=np.random.randint(0,self.bandit.K)
        else:
            k=np.argmax(self.estimates)
        r=self.bandit.step(k)
        self.estimates[k]+=1./(self.counts[k]+1)*(r-self.estimates[k])
        return k

在新建 Main.py 文件，文件代码如下：

import numpy as np
from matplotlib import pyplot as plt

from BernoulliBandit import bandit
from EpsilonGreedy import EpsilonGreedy


def plot_results(solvers, solver_names):
    """输出解决方法的累积懊悔变化图"""
    for idx, solver in enumerate(solvers):
        time_list = range(len(solver.regrets))
        plt.plot(time_list, solver.regrets, label=solver_names[idx])
    plt.xlabel('Time Step')
    plt.ylabel('Cumulative regrets')
    plt.title('%d-arm bandit' % solvers[0].bandit.K)
    plt.legend()
    plt.show()


np.random.seed(1)
epsilon_greedy_solver = EpsilonGreedy(bandit, epsilon=0.01)
epsilon_greedy_solver.run(5000)
print('epsilon-贪婪算法的累积懊悔为：', epsilon_greedy_solver.regret)
plot_results([epsilon_greedy_solver], ["EpsilonGreedy"])

运行 Main.py 文件，结果如下：

随机生成了一个 10 臂的伯努利多臂老虎机
获奖概率最大的拉杆为 1 号，其获奖概率为 0.7203
epsilon-贪婪算法的累积懊悔为： 25.526630933945313

  接下来尝试不同 ε 取值的结果：

修改 Main.py 代码如下：

import numpy as np
from matplotlib import pyplot as plt

from BernoulliBandit import bandit
from EpsilonGreedy import EpsilonGreedy


def plot_results(solvers, solver_names):
    """输出解决方法的累积懊悔变化图"""
    for idx, solver in enumerate(solvers):
        time_list = range(len(solver.regrets))
        plt.plot(time_list, solver.regrets, label=solver_names[idx])
    plt.xlabel('Time Step')
    plt.ylabel('Cumulative regrets')
    plt.title('%d-arm bandit' % solvers[0].bandit.K)
    plt.legend()
    plt.show()


# np.random.seed(1)
# epsilon_greedy_solver = EpsilonGreedy(bandit, epsilon=0.01)
# epsilon_greedy_solver.run(5000)
# print('epsilon-贪婪算法的累积懊悔为：', epsilon_greedy_solver.regret)
# plot_results([epsilon_greedy_solver], ["EpsilonGreedy"])

np.random.seed(0)
epsilons = [1e-4, 0.01, 0.1, 0.25, 0.5]
epsilon_greedy_solver_list = [EpsilonGreedy(bandit, epsilon=e) for e in epsilons]
epsilon_greedy_solver_names = ['epsilon={}'.format(e) for e in epsilons]
for epsilon_greedy_solver in epsilon_greedy_solver_list:
    epsilon_greedy_solver.run(5000)

plot_results(epsilon_greedy_solver_list, epsilon_greedy_solver_names)

运行 Main.py 文件，结果如下：

随机种子为 0 的结果很完美，但是选择随机种子为 1 的话，这是实验结果：

但是将时间步扩大为 50000，实验结果又变回来了

  接下来尝试 ε 随着时间反比例衰减，公式为：${ϵ}_t=\frac{1}{t}$

修改 EpsilonGreedy.py 文件，文件代码如下：

import numpy as np

from Solver import Solver


class EpsilonGreedy(Solver):
    def __init__(self, bandit, epsilon=0.01, init_prob=1.0):
        super(EpsilonGreedy, self).__init__(bandit)
        self.epsilon = epsilon
        self.estimates = np.array([init_prob] * self.bandit.K)

    def run_one_step(self):
        if np.random.random() < self.epsilon:
            k = np.random.randint(0, self.bandit.K)
        else:
            k = np.argmax(self.estimates)
        r = self.bandit.step(k)
        self.estimates[k] += 1. / (self.counts[k] + 1) * (r - self.estimates[k])
        return k


class DecayingEpsilonGreedy(Solver):
    def __init__(self, bandit, init_prob=1.0):
        super(DecayingEpsilonGreedy, self).__init__(bandit)
        self.estimates = np.array([init_prob] * self.bandit.K)
        self.total_count = 0

    def run_one_step(self):
        self.total_count += 1
        if np.random.random() < 1 / self.total_count:
            k = np.random.randint(0, self.bandit.K)
        else:
            k = np.argmax(self.estimates)
        r = self.bandit.step(k)
        self.estimates[k] = 1. / (self.counts[k] + 1) * (r - self.estimates[k])

        return k

修改 Main.py 文件，文件代码如下：

import numpy as np
from matplotlib import pyplot as plt

from BernoulliBandit import bandit
from EpsilonGreedy import EpsilonGreedy, DecayingEpsilonGreedy


def plot_results(solvers, solver_names):
    """输出解决方法的累积懊悔变化图"""
    for idx, solver in enumerate(solvers):
        time_list = range(len(solver.regrets))
        plt.plot(time_list, solver.regrets, label=solver_names[idx])
    plt.xlabel('Time Step')
    plt.ylabel('Cumulative regrets')
    plt.title('%d-arm bandit' % solvers[0].bandit.K)
    plt.legend()
    plt.show()


# np.random.seed(1)
# epsilon_greedy_solver = EpsilonGreedy(bandit, epsilon=0.01)
# epsilon_greedy_solver.run(5000)
# print('epsilon-贪婪算法的累积懊悔为：', epsilon_greedy_solver.regret)
# plot_results([epsilon_greedy_solver], ["EpsilonGreedy"])


# np.random.seed(1)
# epsilons = [1e-4, 0.01, 0.1, 0.25, 0.5]
# epsilon_greedy_solver_list = [EpsilonGreedy(bandit, epsilon=e) for e in epsilons]
# epsilon_greedy_solver_names = ['epsilon={}'.format(e) for e in epsilons]
# for epsilon_greedy_solver in epsilon_greedy_solver_list:
#     epsilon_greedy_solver.run(50000)
# plot_results(epsilon_greedy_solver_list, epsilon_greedy_solver_names)


np.random.seed(1)
decaying_epsilon_greedy_solver = DecayingEpsilonGreedy(bandit)
decaying_epsilon_greedy_solver.run(5000)
print('epsilon 反比衰减的贪婪算法的累积懊悔为：', decaying_epsilon_greedy_solver.regret)
plot_results([decaying_epsilon_greedy_solver], ["DecayingEpsilonGreedy"])

运行 Main.py 文件，结果如下：

D:\RL\MAB\.venv\Scripts\python.exe D:\RL\MAB\Main.py 
随机生成了一个 10 臂的伯努利多臂老虎机
获奖概率最大的拉杆为 1 号，其获奖概率为 0.7203
epsilon 反比衰减的贪婪算法的累积懊悔为： 10.114334931260183

进程已结束，退出代码为 0

这是扩大时间步至 50000 的结果：

  从实验结果可以发现，反比例衰减的 ε-贪婪算法可以使得累积懊悔与时间步的关系变为次线性，这明显优于固定 ε 值的 ε-贪婪算法。

2.2 上置信界算法

  对于多臂老虎机来说，一根拉杆的探索次数较少，它的不确定性就很高。不确定越高，它具有的探索价值就越大。为此，引入不确定性度量 U(a) ，它随着一个动作被尝试次数的增加而减少。【说白了就是新鲜感】

  上置信界（UCB）算法是一种经典的基于不确定性的策略算法，其思想是基于霍夫丁不等式。在霍夫丁不等式中，令 $X_1,X_2,...,X_n$ 为 n 个独立同分布的随机变量，取值范围为 [0,1] ，其经验期望为 $\bar{x}=\frac{1}{n}{\sum }_{j=1}^n{X}_j$ ，则有 $$P(E[X]\ge \bar{x}+u)\le e^{-2n{u}^2}$$

  将霍夫丁不等式运用到多臂老虎机问题中。$\hat{Q}$ 代入 $\bar{x}$，不等式中 $u=\hat{U}(a_t)$ 代表不确定性度量。给定一个概率 $p=e^{-2N(a_t)U(a_t{)}^2}$ ，根据上述不等式，$Q(a_t)<\hat{Q}(a_t)+\hat{U}(a_t)$ 至少以概率 $1-p$ 成立，当 p 很小时，$Q(a_t)<\hat{Q}(a_t)+\hat{U}(a_t)$ 就以很大概率成立，所以 $\hat{Q}(a_t)+\hat{U}(a_t)$ 就是期望奖励上界。

  根据 $p=e^{-2N(a_t)U(a_t{)}^2}$ 得知 $\hat{U}(a_t)=\sqrt{\frac{-\log p}{2N(a_t)}}$ ，其中 $N(a_t)$ 是该拉杆的已经拉动的次数。确定概率 p 就可以计算 $\hat{U}(a_t)$ 。

  在实际编程中，令 $p=\frac{1}{t}$ ；令 $\hat{U}(a_t)=\sqrt{\frac{-\log p}{2(N(a_t)+1)}}$ ，以免出现分母为 0 的情况；令 $a_t=argma{x}_{a\in A}[\hat{Q}(a)+c\cdot \hat{U}(a)]$ ，用系数 c 来控制不确定性比重。

新建 UCB.py 文件，文件代码如下：

import numpy as np

from Solver import Solver


class UCB(Solver):
    def __init__(self, bandit, c, init_prob=1.0):
        super(UCB, self).__init__(bandit)
        self.total_count = 0
        self.estimates = np.array([init_prob] * self.bandit.K)
        self.c = c

    def run_one_step(self):
        self.total_count += 1
        ucb = self.estimates + self.c * np.sqrt(np.log(self.total_count) / (2 * (self.counts + 1)))  # 计算上置信界
        k = np.argmax(ucb)
        r = self.bandit.step(k)
        self.estimates[k] += 1. / (self.counts[k] + 1) * (r - self.estimates[k])
        return k

修改 Main.py 文件，文件代码如下：

import numpy as np
from matplotlib import pyplot as plt

from BernoulliBandit import bandit
from EpsilonGreedy import EpsilonGreedy, DecayingEpsilonGreedy
from UCB import UCB


def plot_results(solvers, solver_names):
    """输出解决方法的累积懊悔变化图"""
    for idx, solver in enumerate(solvers):
        time_list = range(len(solver.regrets))
        plt.plot(time_list, solver.regrets, label=solver_names[idx])
    plt.xlabel('Time Step')
    plt.ylabel('Cumulative regrets')
    plt.title('%d-arm bandit' % solvers[0].bandit.K)
    plt.legend()
    plt.show()


def apply_epsilon_greedy_1():
    np.random.seed(1)
    epsilon_greedy_solver = EpsilonGreedy(bandit, epsilon=0.01)
    epsilon_greedy_solver.run(5000)
    print('epsilon-贪婪算法的累积懊悔为：', epsilon_greedy_solver.regret)
    plot_results([epsilon_greedy_solver], ["EpsilonGreedy"])


def apply_epsilon_greedy_2():
    np.random.seed(1)
    epsilons = [1e-4, 0.01, 0.1, 0.25, 0.5]
    epsilon_greedy_solver_list = [EpsilonGreedy(bandit, epsilon=e) for e in epsilons]
    epsilon_greedy_solver_names = ['epsilon={}'.format(e) for e in epsilons]
    for epsilon_greedy_solver in epsilon_greedy_solver_list:
        epsilon_greedy_solver.run(50000)
    plot_results(epsilon_greedy_solver_list, epsilon_greedy_solver_names)


def apply_decaying_epsilon_greedy():
    np.random.seed(1)
    decaying_epsilon_greedy_solver = DecayingEpsilonGreedy(bandit)
    decaying_epsilon_greedy_solver.run(50000)
    print('epsilon 反比衰减的贪婪算法的累积懊悔为：', decaying_epsilon_greedy_solver.regret)
    plot_results([decaying_epsilon_greedy_solver], ["DecayingEpsilonGreedy"])


def apply_UCB():
    np.random.seed(1)
    c = 1  # 不确定性比重
    UCB_solver = UCB(bandit, c)
    UCB_solver.run(5000)
    print('上置信界算法累积懊悔为：', UCB_solver.regret)
    plot_results([UCB_solver], ["UCB"])

apply_UCB()

运行 Main.py 文件，结果如下：

D:\RL\MAB\.venv\Scripts\python.exe D:\RL\MAB\Main.py 
随机生成了一个 10 臂的伯努利多臂老虎机
获奖概率最大的拉杆为 1 号，其获奖概率为 0.7203
上置信界算法累积懊悔为： 70.45281214197854

进程已结束，退出代码为 0

2.3 汤普森采样算法

  MAB问题还有一种经典算法——汤普森采样，先假设每个拉杆的奖励服从特定的概率分布，然后根据每个拉杆的期望奖励来进行选择。但是计算所有拉杆的期望奖励的代价比较高，所以该算法使用采样的方式，即根据当前每个动作 a 的奖励概率分布进行一轮采样，得到一组拉杆的奖励样本，再选择样本中奖励最大的动作。【汤普森采样是一种计算所有拉杆的最高奖励概率的蒙特卡洛采样方法】

  在实际中，通常用 Beta 分布对当前每个动作的奖励概率分布进行建模。具体来说，若某拉杆被选择了 k 次，其中 $m_1$ 次奖励为 1，$m_2$ 次奖励为 0，则该拉杆服从参数为 $(m_1+1,m_2+1)$ Beta 分布。

新建 ThompsonSampling.py 文件，文件代码如下：

import numpy as np

from Solver import Solver


class ThompsonSampling(Solver):
    def __init__(self, bandit):
        super(ThompsonSampling, self).__init__(bandit)
        self._a = np.ones(self.bandit.K)
        self._b = np.ones(self.bandit.K)

    def run_one_step(self):
        samples = np.random.beta(self._a, self._b)
        k = np.argmax(samples)
        r = self.bandit.step(k)
        self._a[k] += r
        self._b[k] += (1 - r)
        return k

修改 Main.py 文件，文件代码如下：

import numpy as np
from matplotlib import pyplot as plt

from BernoulliBandit import bandit
from EpsilonGreedy import EpsilonGreedy, DecayingEpsilonGreedy
from ThompsonSampling import ThompsonSampling
from UCB import UCB


def plot_results(solvers, solver_names):
    """输出解决方法的累积懊悔变化图"""
    for idx, solver in enumerate(solvers):
        time_list = range(len(solver.regrets))
        plt.plot(time_list, solver.regrets, label=solver_names[idx])
    plt.xlabel('Time Step')
    plt.ylabel('Cumulative regrets')
    plt.title('%d-arm bandit' % solvers[0].bandit.K)
    plt.legend()
    plt.show()


def apply_epsilon_greedy_1():
    np.random.seed(1)
    epsilon_greedy_solver = EpsilonGreedy(bandit, epsilon=0.01)
    epsilon_greedy_solver.run(5000)
    print('epsilon-贪婪算法的累积懊悔为：', epsilon_greedy_solver.regret)
    plot_results([epsilon_greedy_solver], ["EpsilonGreedy"])


def apply_epsilon_greedy_2():
    np.random.seed(1)
    epsilons = [1e-4, 0.01, 0.1, 0.25, 0.5]
    epsilon_greedy_solver_list = [EpsilonGreedy(bandit, epsilon=e) for e in epsilons]
    epsilon_greedy_solver_names = ['epsilon={}'.format(e) for e in epsilons]
    for epsilon_greedy_solver in epsilon_greedy_solver_list:
        epsilon_greedy_solver.run(50000)
    plot_results(epsilon_greedy_solver_list, epsilon_greedy_solver_names)


def apply_decaying_epsilon_greedy():
    np.random.seed(1)
    decaying_epsilon_greedy_solver = DecayingEpsilonGreedy(bandit)
    decaying_epsilon_greedy_solver.run(50000)
    print('epsilon 反比衰减的贪婪算法的累积懊悔为：', decaying_epsilon_greedy_solver.regret)
    plot_results([decaying_epsilon_greedy_solver], ["DecayingEpsilonGreedy"])


def apply_UCB():
    np.random.seed(1)
    c = 1  # 不确定性比重
    UCB_solver = UCB(bandit, c)
    UCB_solver.run(5000)
    print('上置信界算法累积懊悔为：', UCB_solver.regret)
    plot_results([UCB_solver], ["UCB"])


def apply_thompson_sampling():
    np.random.seed(1)
    thompson_sampling_solver = ThompsonSampling(bandit)
    thompson_sampling_solver.run(5000)
    print('汤普森采样算法累积懊悔为：', thompson_sampling_solver.regret)
    plot_results([thompson_sampling_solver], ["ThompsonSampling"])

apply_thompson_sampling()

运行 Main.py 文件，结果如下：

D:\RL\MAB\.venv\Scripts\python.exe D:\RL\MAB\Main.py 
随机生成了一个 10 臂的伯努利多臂老虎机
获奖概率最大的拉杆为 1 号，其获奖概率为 0.7203
汤普森采样算法累积懊悔为： 57.19161964443925

进程已结束，退出代码为 0

2.4 小结

算法	累积懊悔与时间步的关系
ε-贪婪算法	线性
ε-衰减贪婪算法	次线性（对数）
上置信界算法	次线性（对数）
汤普森采样算法	次线性（对数）

原文地址：https://blog.csdn.net/yyh520025/article/details/140497612

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！