XD_MaoHai

强化学习丨时序差分算法TD(0)及相关编程仿真

一、算法简介

二、时序差分预测

2.1 算法介绍

2.2 算法应用：随机游走问题

2.3 TD(0)与MC的比较以及批量更新

三、Sarsa：同轨策略下的时序差分控制算法

3.1 算法介绍

3.2 算法应用：悬崖行走问题（Cliff Walking）

四、Q学习：离轨策略下的时序差分控制算法

4.1 算法介绍

4.2 算法应用

五、期望Sarsa

5.1 算法介绍

5.2 算法应用

5.3 三种控制算法之间的比较

六、最大化偏差与双学习

6.1 最大化偏差（Maximization Bias）

6.2 双学习（Double Learning）

参考文献与网址

一、算法简介

在上两篇文章中，笔者分别介绍了利用自举思想并需要完整环境知识的动态规划算法（DP），以及无需先验环境知识而仅根据经验来预测与决策的蒙特卡洛方法（MC），两者各有所长，若将DP自举的思想与MC无需构建环境模型的优势结合在一起，我们就得到了一种新的方法，也即是强化学习所有的思想中最核心、最新颖的思想——时序差分算法（Temporal Difference，TD）。

二、时序差分预测

2.1 算法介绍

所有强化学习的算法都会解决最基本的一个问题，那就是对某一策略 $\pi$ 下状态价值的预测，在无环境模型的情况下，如上篇文章讲到的MC算法，智能体是通过幕序列的训练来对访问状态的回报平均进行价值估计：

$V(S_{t}) = V(S_{t}) + \frac{1}{n}[G_{t}-V(S_{t})]$

这是一种无遗忘因子的估计方式，对于平稳问题较为有效，若要跟踪一个非平稳问题，我们可以将增量步长 $\frac{1}{n}$ 设置为常数 $\alpha$ ，估计公式变为：

$V(S_{t}) = V(S_{t}) + \alpha[G_{t}-V(S_{t})]$

这就是常量 $\alpha$ MC，在笔者的文章强化学习丨多臂老虎机相关算法的总结及其MATLAB仿真中中有提到，这是一种指数近因加权方式，也即引入了遗忘因子 $\alpha$ （也叫做增量步长），人为的使智能体对近阶段的学习更深刻些，从而跟踪非平稳问题。然而，对与上式而言，我们为了得到回报值 $G_{t}$ ，往往需要等到一幕结束，而对于一个较长的幕序列，甚至一个持续性任务，这种方式是不必要以及费时的。

在某一时刻我们可以得到此时刻的收益 $R_{t+1}$ ，为了得到此时刻的回报 $G_{t}$ ，我们不妨用下一状态的估计价值 $V(S_{t+1})$ 来替代下一时刻的回报值，再结合回报的递推公式可得到新的价值估计公式如下：

$V(S_{t}) = V(S_{t}) + \alpha[R_{t+1}+\gamma V(S_{t+1})-V(S_{t})]$

这就是时序差分预测算法的价值更新公式，有了该公式，我们就不难得到其算法流程：

时序差分预测算法TD(0)

Step1: 输入待评估的策略 $\pi$

Step2: 定义增量步长 $\alpha \in (0,1]$

Step3: 初始化状态价值函数为零向量

Step4: 遍历每幕：

初始化

生成幕的同时进行价值更新：

根据策略 $\pi$ 选择动作并执行，观测到 $R,S^{'}$

$V(S)=V(S)+\alpha[R+\gamma V(S^{'}) - V(S)]$

$S = S^{'}$

若为终止状态则终止本幕，开始访问下一幕

通过上述式子可以看出，在预测算法中，MC方法是将回报 $G_{t}$ 的估计值作为学习目标，而TD算法则是将 $R+\gamma V(S^{'})$ 的估计值作为学习目标。上面流程中提到的TD(0)的括号里的数值就是该TD算法下， $S_{t}$ 的估计值 $V(S_{t})$ 与更好的估计 $R+\gamma V(S^{'})$ 之间的误差，表示为：

$\delta_{t}=R_{t+1}+\gamma V(S_{t+1}) - V(S_{t})$

如果价值函数数组在一幕内没有变化（指幕的生成过程中），例如在MC算法中就是如此，则MC误差可写为TD误差之和，由于篇幅有限以及推导过程较易，这里直接给出下式，具体过程见Sutton的《强化学习》的式（6.6）：

$G_{t}-V({S_{t}}) = \sum_{k=t}^{T-1}\gamma^{t-1}\delta_{k}$

当价值函数数组在一幕内发生变化时，例如TD（0）的情况下被不断更新，不妨用 $V^{*}$ 表示未更新的价值，表示已经更新的价值，则MC误差依然可表示为TD误差之和，推导如下：

$\begin{align*} G_{t}-V(S_{t}) &= R_{t+1}+\gamma G_{t+1}-V(S_{t})+\gamma V^{*}(S_{t+1})-\gamma V^{*}(S_{t+1})\\ &=(R_{t+1}+\gamma V^{*}(S_{t+1})-V^{*}(S_{t}))+\gamma(G_{t+1}-V^{*}(S_{t+1}))-(V(S_{t})-V^{*}(S_{t}))\\ &=\delta_{t}+\gamma[G_{t+1}-V(S_{t+1})+(V(S_{t+1})-V^{*}(S_{t+1}))]-\alpha \delta_{t}\\ &=(1-\alpha)\delta_{t}+\gamma\alpha\delta_{t+1} +\gamma[G_{t+1}-V(S_{t+1})]\\ &=(1-\alpha)\delta_{t}+\gamma\alpha\delta_{t+1} +\gamma[(1-\alpha)\delta_{t+1}+\gamma\alpha\delta_{t+2}+\gamma(G_{t+1}-V(S_{t+1})) ]\\ &=(1-\alpha)\delta_{t}+\gamma\delta_{t+1}+\gamma^{2}\alpha\delta_{t+2}+\gamma^{2}(G_{t+1}-V(S_{t+1}))\\ &=(1-\alpha)\delta_{t}+\gamma\delta_{t+1}+\gamma^{2}\delta_{t+2}+\cdots+\gamma^{T-t-1}\delta_{T-1}+\gamma^{T-t}(G_{T}-V(S_{T}))\\ &=-\alpha\delta_{t}+\sum_{k=t}^{T-1}\gamma^{k-t}\delta_{k} \end{align*}$

可见，当增量步长 $\alpha$ 较小时，可用前式近似替代上式。

2.2 算法应用：随机游走问题

随机游走问题

存在一个状态转移路径如下：

所有幕都是从中心状态C开始，在每个时刻以相同的概率向左或向右移动一个状态，左侧和右侧的两个实心方框为终止状态，当终止于右侧方框时会有+1的收益，除此之外每次动作的收益均为0，假设该任务无折扣，估计该策略下（随机向左向右移动）各状态的价值。

因为该任务无折扣，所以不难发现每个状态的真实价值是从该状态开始终止与最右侧的概率，由于该问题模型比较简单，环境模型比较容易构建，因此可以很容易的列出该问题的贝尔曼方程并进行求解得到，状态A~E的真实价值分别为： $\frac{1}{6},\frac{2}{6},\frac{3}{6},\frac{4}{6},\frac{5}{6}$ 。如果采用TD(0)算法，根据上述算法流程也不难可以编写出该问题的TD(0)算法求解的代码：

# Algorithm: Temporal Difference——Policy Evaluation
# Project  :Random Walking
# Author   : XD_MaoHai
# Reference: Jabes
# Date     : 2021/11/18


# 导入库函数
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
# 设置进度条
from tqdm import tqdm


# 初始化A-E的状态价值为0.5，右侧终点值为1，左侧终点值为0
# VALUES = [左侧终点 A B C D E 右侧终点]
VALUES = np.zeros(7)
VALUES[1:6] = 0.5
VALUES[6] = 1
# 各个状态真实价值
VALUES_TRUE = np.zeros(7)
VALUES_TRUE[1:7] = np.arange(1, 7)/6.0
# 定义向左向右走的动作
ACTION_LEFT = 0
ACTION_RIGHT = 1
# 状态转移收益为0
REWARD = 0


# 时序差分算法
def temporal_difference(values, alpha=0.1, batch_updating=False):
    """
    values: 状态价值矩阵
    alpha : 增量步长
    batch_updating: 是否批量更新
    return: 返回本幕序列
    """
    # 起始状态为C
    state = 3
    # 定义轨迹列表
    trajectory = [state]
    # 定义收益列表
    rewards = [0]
    # 生成幕序列
    while True:
        old_state = state
        # 以0.5的概率随机选择向左向右走
        if np.random.binomial(1, 0.5) == ACTION_LEFT:
            state -= 1
        else:
            state += 1
        # 更新轨迹列表
        trajectory.append(state)
        # 若非批量更新
        if not batch_updating:
            # TD更新
            values[old_state] += alpha * (REWARD + values[state] - values[old_state])
        # 判断该幕是否终止
        if state == 6 or state == 0:
            break
        rewards.append(REWARD)
    return trajectory, rewards



# 主函数
if __name__ == '__main__':
    # 在以下幕次序画图
    episodes = [0, 1, 10, 100]
    # 初始化价值矩阵
    current_values = np.copy(VALUES)
    plt.figure(1)
    # 开始迭代
    for i in range(episodes[-1] + 1):
        if i in episodes:
            plt.plot(current_values, label=str(i) + 'episodes')
        temporal_difference(current_values)
    plt.plot(VALUES_TRUE, label='True values')
    plt.xlabel('State')
    plt.ylabel('Values')
    plt.legend()

运行程序后可得到各幕数量下状态估计价值函数如下：

其中紫线表示真实状态价值，可见随着训练幕数的增多，各状态价值渐渐趋近真实价值。

2.3 TD(0)与MC的比较以及批量更新

上面已经提到，TD(0)算法优于MC的一个地方就是其利用了自举的思想，不需要等到幕结束就可以根据下一状态价值进行本时刻状态价值估计，并且该算法已经被理论证明，对于任何固定的策略 $\pi$ ，如果增量步长 $\alpha$ 选择一个足够小的常数，那么它的均值就能收敛到真实价值 $v_{\pi}$ 。

虽然TD(0)与MC都具有收敛性，但遗憾的是，目前两者的收敛速度还没能从数学角度上进行比较证明，但在实践中，对于类似上面随机游走问题的随机任务，TD方法通常比常量 $\alpha$ MC方法收敛的快，为比较两者在随机游走问题中的收敛速度，在上述代码段中添加常量 $\alpha$ MC方法求解的代码以及计算均方根误差（Root Mean Squared Error,RMSE）的代码:

# 蒙特卡洛算法(每次访问)
def monte_carlo(values, alpha=0.1, batch_updating=False):
    """
    values: 状态价值矩阵
    alpha : 增量步长
    batch_updating: 是否批量更新
    return: 返回本幕序列
    """
    # 起始状态为C
    state = 3
    # 定义轨迹列表
    trajectory = [state]
    # 生成幕序列
    while True:
        old_state = state
        # 以0.5的概率随机选择向左向右走
        if np.random.binomial(1, 0.5) == ACTION_LEFT:
            state -= 1
        else:
            state += 1
        # 更新轨迹列表
        trajectory.append(state)
        # 判断该幕是否终止
        if state == 6:
            reward = 1.0
            break
        elif state == 0:
            reward = 0.0
            break
    # 若非批量更新
    if not batch_updating:
        for state_ in trajectory[:-1]:
            # MC更新
            values[state_] += alpha * (reward - values[state_])
    return trajectory, [reward] * (len(trajectory) - 1)


# 计算平均经验均方根误差
def rms_error():
    # 设置TD与MC的增量步长参数
    td_alphas = [0.15, 0.1, 0.05]
    mc_alphas = [0.01, 0.02, 0.03, 0.04]
    # 设定幕数量
    episodes = 100
    # 设定遍历次数
    runs = 100
    # 计算每个alpha下的均方根误差
    for i, alpha in enumerate(td_alphas + mc_alphas):
        total_errors = np.zeros(episodes + 1)
        if i < len(td_alphas):
            method = 'TD'
            linestyle = 'solid'
        else:
            method = 'MC'
            linestyle = 'dashdot'
        # runs次独立迭代运算
        for r in tqdm(range(runs)):
            errors = []
            current_values = np.copy(VALUES)
            # 基于episodes个幕迭代
            for i in range(0, episodes + 1):
                # 计算A~E几个价值估计的均方根误差
                errors.append(np.sqrt(np.sum(np.power(VALUES_TRUE[1:6] - current_values[1:6], 2)) / 5.0))
                if method == 'TD':
                    temporal_difference(current_values, alpha=alpha)
                else:
                    monte_carlo(current_values, alpha=alpha)
            total_errors += np.asarray(errors)
        total_errors /= runs
        plt.plot(total_errors, linestyle=linestyle, label=method + ', alpha = %.02f' % (alpha))
    plt.xlabel('Episodes')
    plt.ylabel('RMSE')
    plt.legend()

之后在主函数进行调用即可：

# 计算均方根误差
    plt.figure(2)
    rms_error()

得到两种算法，不同增量步长 $\alpha$ 下均方根误差随幕数增长的变化曲线如下：

可见，在该问题中，TD方法要比MC方法表现的好。

通过，TD(0)的价值更新公式可以看出，该算法是利用单次时刻的误差 $\delta_{t}$ 进行价值更新的，如果现在训练幕数或是时间步长有限，为了避免单次误差的随机性，我们不妨将每个时刻该状态价值估计的偏差进行记录求和，在所有的幕训练结束后再利用这些偏差和进行价值更新，这样就相当于对偏差做了一次期望（但并未平均），这样的更新方法就叫做批量更新。

同样，MC算法也可以利用批量更新的方式进行求解，但是，在选择的步长参数 $\alpha$ 足够小的情况下，TD(0)可以确定的收敛到与 $\alpha$ 无关的唯一结果，而常数 $\alpha$ MC方法在相同条件下也能确定的收敛，但是会收敛到不同的结果。

为比较批量更新方法下，TD(0)与MC的收敛速度，现在上面随机游走问题的代码段中添加批量更新代码部分：

# 批量更新
def batch_updating(method, episodes, alpha):
    # 设定遍历次数
    runs = 100
    # 初始化均方根误差矩阵
    total_errors = np.zeros(episodes)
    # runs次独立迭代运算
    for r in tqdm(range(0, runs)):
        # 初始化状态价值
        current_values = np.copy(VALUES)
        # 初始化当前幕数量下的均方根误差列表
        errors = []
        # 定义当前记录的所有幕
        trajectories = []
        # 定义当前记录的幕对应的收益序列
        rewards = []
        # 基于episodes个幕迭代
        for ep in range(episodes):
            # 选择当前算法:TD or MC
            if method == 'TD':
                trajectory_, rewards_ = temporal_difference(current_values, alpha=alpha, batch_updating=True)
            else:
                trajectory_, rewards_ = monte_carlo(current_values, alpha=alpha, batch_updating=True)
            # 记录幕序列和收益序列
            trajectories.append(trajectory_)
            rewards.append(rewards_)
            # 批量更新直至状态价值收敛到一定阈值
            while True:
                # 初始化误差列表
                updates = np.zeros(7)
                # 遍历
                for trajectory_, rewards_ in zip(trajectories, rewards):
                    for i in range(0, len(trajectory_) - 1):
                        if method == 'TD':
                            updates[trajectory_[i]] += rewards_[i] + current_values[trajectory_[i+1]] - current_values[trajectory_[i]]
                        else:
                            updates[trajectory_[i]] += rewards_[i] - current_values[trajectory_[i]]
                updates *= alpha
                # 批量更新
                current_values += updates
                # 当满足收敛精度（1e-3）时
                if np.sum(np.abs(updates)) < 1e-3:
                    break
            # 计算均方根误差
            errors.append(np.sqrt(np.sum(np.power(current_values[1:6] - VALUES_TRUE[1:6], 2)) / 5.0))
        total_errors += np.asarray(errors)
    total_errors /= runs
    return total_errors

之后在主函数中进行调用绘图即可：

# 批量更新下TD与MC比较
    td_rmse = batch_updating('TD', episodes=episodes[-1], alpha=0.001)
    mc_rmse = batch_updating('MC', episodes=episodes[-1], alpha=0.001)
    # 绘图
    plt.figure(3)
    plt.plot(td_rmse, label='TD')
    plt.plot(mc_rmse, label='MC')
    plt.xlabel('Episodes')
    plt.ylabel('RMSE')
    plt.legend()

运行程序可得到批量更新方法下，TD(0)与MC方法均方根误差随幕数的增长而变化的曲线：

可见，批量TD方法比批量MC方法表现的要好。

其实，这种TD(0)的最优性也不难理解，通过对批量TD(0)与批量MC两种算法的原理可以得知，由于没有自举特性而全然依赖样本序列，批量MC算法总是在找出最小化训练集上均方误差的估计，相当于仅对回报统计量进行期望估计；而由于偏差求和的操作，批量TD(0)的算法暗含了对MDP环境模型参数的估计，比如下个时刻状态的转移概率以及相应的收益期望，也就是说批量TD(0)总是在找出符合MDP模型的最大似然参数估计，并且等价于假设潜在过程参数的估计是确定性的而非近似的，这种估计就叫做确定性等价估计，这也解释了在与预测回报相关的任务中该方法的优越性。

虽然非批量TD(0)并不能达到确定性估计，但它大致朝着这些方向在更新，因此它可能比常数 $\alpha$ MC方法更快。

三、Sarsa:同轨策略下的时序差分控制算法

解决完预测问题，接下来就要解决控制问题。在上篇文章中，笔者介绍了MC算法的同轨和离轨两种控制方法，同样TD(0)算法也具有此两种方法，同时仍然遵循广义策略迭代（GPI）的模式，以下先对同轨策略下的TD(0)算法做一介绍。

3.1 算法介绍

在没有环境模型的情况下，为了找到最优策略，我们需要参照的是动作价值函数，同状态价值函数的更新公式类似，TD(0)算法下动作价值函数更新公式如下：

$Q(S_{t},A_{t})=Q(S_{t},A_{t})+\alpha[R_{t+1}+\gamma Q(S_{t+1},A_{t+1})-Q(S_{t},A_{t})]$

由于上式涉及两个时刻状态-动作二元组函数以及一个时刻的收益，因此同轨策略下的时序差分控制算法又叫做Sarsa算法。利用上式可解决GPI中的策略评估问题，而对于策略改进，我们依旧采用选择贪婪动作的改进方法，但是在同轨策略下，为了增加试探概率，我们需要采用 $\epsilon$ -软性策略，该策略说明可参笔者上篇文章强化学习丨蒙特卡洛方法及关于“二十一点”游戏的编程仿真的3.2.1部分。

另外，为了防止策略稳定时智能体还在以 $\epsilon$ 的概率盲目试探，不妨使得该探测概率随训练幕数的增长而递减，由此得到Sarsa算法流程如下：

Sarsa算法

Step1: 输入增量步长 $\alpha \in (0,1]$

Step2: 初始化状态-动作价值函数为零向量

Step3: 对每幕循环：

                 $\epsilon = 1/num_{ep}$ , $num_{ep}$ 为当前共训练的幕数

初始化S

使用 $\epsilon$ -贪心策略在出选择

                生成幕的同时进行价值更新：

                        执行，观测到 $R,S^{'}$

                        使用 $\epsilon$ -贪心策略在 $S^{'}$ 出选择 $A^{'}$

                          $Q(S,A)=Q(S,A)+\alpha[R+\gamma Q(S^{*},A)-Q(S,A)]$

                         $S=S^{'},A=A^{'}$

                        若为终止状态则终止本幕，开始访问下一幕

3.2 算法应用：悬崖行走问题（Cliff Walking）

悬崖行走问题（Cliff Walking）

存在如下图的一个网格世界，包含起点和目标状态，在每个方格处可执行上下左右这些常见的动作，掉下悬崖会（Cliff）得到-100的收益并把智能体送回起点，其它的转移得到的收益都是-1。

现寻求一条最短路径使得智能体能安全到达终点。

基于上述Sarsa算法流程，不难对该问题进行编程求解。首先载入需要用到的库：

# Algorithm: Temporal Difference——Sarsa
# Project  : Cliff Walking
# Author   : XD_MaoHai
# Reference: Stan Fu
# Date     : 2021/11/19

import sys
import gym
import numpy as np
import random
from collections import defaultdict, deque
import matplotlib.pyplot as plt

编写更新动作价值的函数（该函数是为了使程序结构更为清晰有条理，当然也可以直接在Sarsa迭代过程中直接进行价值更新）：

# 更新状态-动作价值表
def update_Q(alpha, gamma, Q, state, action, reward, next_state=None, next_action=None):
    """
    alpha: 增量步长
    gamma: 折扣因子
    Q: 状态-动作价值表
    state: 当前状态
    action:当前动作
    reward:回报
    next_state:下个状态
    next_action:下个动作
    return:返回更新的Q
    """
    # 当前状态-动作价值
    current_Q = Q[state][action]
    # 下个时刻状态-动作价值
    next_Q = Q[next_state][next_action] if next_state is not None else 0
    # 学习对象
    target = reward + gamma * next_Q
    # 更新
    new_Q = current_Q + alpha * (target - current_Q)
    return new_Q

编写 $\epsilon$ -贪心策略函数：

# ε-贪心策略
def epsilon_greedy(Q, state, nA, epsilon):
    """
    Q: 状态-动作价值表
    state: 当前状态
    nA:动作数
    epsilon:探索概率
    return:返回选择的动作
    """
    # 如果随机数大于epsilon则选择贪心动作
    if random.random() > epsilon:
        return np.argmax(Q[state])
    else:
        return random.choice(np.arange(nA))

编写 Sarsa算法的函数：

# Sarsa算法
def sarsa(env, num_episodes, alpha, gamma=1.0):
    """
    env: 游戏环境
    num_episodes:总的训练幕数
    alpha: 增量步长
    gamma: 折扣因子
    return:预测的状态价值
    """
    # 环境总的可选动作数
    nA = env.action_space.n
    # 初始化状态-动作价值表
    Q = defaultdict(lambda: np.zeros(nA))
    # 建立关于单幕总收益的双向队列
    tmp_scores = deque()
    # 建立关于平均收益的双向队列
    avg_scores = deque(maxlen=num_episodes)
    # 开始训练迭代
    for each_episode in range(1,num_episodes+1):
        # 进度显示
        print("Episode {}/{}".format(each_episode, num_episodes), end="\r")
        sys.stdout.flush()
        # 初始化单幕总收益
        scores = 0
        # 环境重置
        state = env.reset()
        # 设置逐渐递减的epsilon
        epsilon = 1.0 / each_episode
        # 选择动作
        action = epsilon_greedy(Q, state, nA, epsilon)
        # 单幕训练
        while True:
            # 执行动作
            next_state, reward, done, info = env.step(action)
            # 更新单幕收益和
            scores += reward
            # 如果幕结束则更新Q后记录本幕收益和
            if done:
                Q[state][action] = update_Q(alpha, gamma, Q, state, action, reward)
                tmp_scores.append(scores)
                break
            # 更新动作、状态和Q
            next_action = epsilon_greedy(Q, next_state, nA, epsilon)
            Q[state][action] = update_Q(alpha, gamma, Q, state, action, reward, next_state, next_action)
            state = next_state
            action = next_action
        # 更新平均收益和
        avg_scores.append(np.mean(tmp_scores))
    # 绘图
    plt.plot(np.asarray(avg_scores))
    plt.xlabel('Episode')
    plt.ylabel('Average Reward Sum')
    plt.show()
    return Q

最后在主函数中选择gym库中的CliffWalking-v0环境，并进行Sarsa函数调用以及绘图：

# 主函数
if __name__ == '__main__':
    # 载入环境
    env = gym.make('CliffWalking-v0')
    # 输出动作空间和观测空间
    print("Action space:{}".format(env.action_space.n))
    print("Observation space:{}".format(env.observation_space.n))
    # 训练智能体得到最优动作价值函数
    Q_opt = sarsa(env, 20000, .01)
    print(Q_opt.items())
    # 输出最优策略
    policy_opt = np.array([np.argmax(Q_opt[key]) if key in Q_opt else -1 for key in np.arange(48)]).reshape(4, 12)
    print("\nOptimal Policy (UP = 0, RIGHT = 1, DOWN = 2, LEFT = 3, No Action = -1):")
    print(policy_opt)
    # 绘制估计的最优状态价值函数
    V_opt = ([np.max(Q_opt[key]) if key in Q_opt else 0 for key in np.arange(48)])
    plot_values(V_opt)

其中绘制状态价值函数图的函数plot_values的代码如下：

# Author   : Stan Fu
# 绘制状态价值图形函数
def plot_values(V):
    # 重装V
    V = np.reshape(V, (4, 12))
    # 绘图
    fig = plt.figure(figsize=(15, 5))
    ax = fig.add_subplot(111)
    im = ax.imshow(V, cmap='cool')
    for (j, i), label in np.ndenumerate(V):
        ax.text(i, j, np.round(label, 3), ha='center', va='center', fontsize=14)
    plt.tick_params(bottom='off', left='off', labelbottom='off', labelleft='off')
    plt.title('Optimal State Value Function')
    plt.show()

运行程序，可得到训练20000幕后最优状态价值函数如下：

其中黑线就是最后学习的最优路径，这与我们的直观认知一致。同时还得到随着幕数的增长，每幕的平均收益和曲线如下：

可见，每幕的平均收益和得到了较快的收敛。

四、Q学习：离轨策略下的时序差分控制算法

4.1 算法介绍

现在考虑另一种算法，仍用 $\epsilon$ -贪心策略生成幕序列（行为策略），但利用绝对贪心动作价值含函数进行价值更新，如下：

$Q(S_{t},A_{t})=Q(S_{t},A_{t})+\alpha[R_{t+1}+\gamma \underset{a}{max} Q(S_{t+1},a)-Q(S_{t},A_{t})]$

对比上式和Sarsa算法价值更新公式可知，上式没有选择与行为策略，也即 $\epsilon$ -贪心策略产生的相同的后继状态-动作价值进行更新，而是直接选择了贪心动作，并将之视为学习目标，而与行动策略无关，因此这种更新方式是一种离轨策略，这种方法又叫做Q学习（Q Learning）。

有了价值更新公式，这里仿照Sarsa算法可以得到Q学习的算法流程图如下：

Q-Learning算法

Step1: 输入增量步长 $\alpha \in (0,1]$

Step2: 初始化状态-动作价值函数为零向量

Step3: 对每幕循环：

                 $\epsilon = 1/num_{ep}$ , $num_{ep}$ 为当前共训练的幕数

初始化S

                生成幕的同时进行价值更新：

                        使用 $\epsilon$ -贪心策略在出选择

                        执行，观测到 $R,S^{'}$

                          $Q(S,A)=Q(S,A)+\alpha[R+\gamma \underset{a}{max} Q(S^{*},a)-Q(S,A)]$

                         $S=S^{'}$

                        若为终止状态则终止本幕，开始访问下一幕

4.2 算法应用

这里依然用悬崖游走的问题对Q-Learning算法进行实例分析，依据上述算法流程，首先对价值更新函数进行更改如下:

# 下个时刻状态-动作价值
    next_Q = np.max(Q[next_state]) if next_state is not None else 0

其次将sarsa()函数替换为Q_learning()函数：

# Q_learning算法
def Q_learning(env, num_episodes, alpha, gamma=1.0):
    """
    env: 游戏环境
    num_episodes:总的训练幕数
    alpha: 增量步长
    gamma: 折扣因子
    return:返回最优状态价值函数
    """
    # 环境总的可选动作数
    nA = env.action_space.n
    # 初始化状态-动作价值表
    Q = defaultdict(lambda: np.zeros(nA))
    # 建立关于单幕总收益的双向队列
    tmp_scores = deque()
    # 建立关于平均收益的双向队列
    avg_scores = deque(maxlen=num_episodes)
    # 开始训练迭代
    for each_episode in range(1, num_episodes+1):
        # 进度显示
        print("Episode {}/{}".format(each_episode, num_episodes), end="\r")
        sys.stdout.flush()
        # 初始化单幕总收益
        scores = 0
        # 环境重置
        state = env.reset()
        # 设置逐渐递减的epsilon
        epsilon = 1.0 / each_episode
        # 单幕训练
        while True:
            # 选择动作
            action = epsilon_greedy(Q, state, nA, epsilon)
            # 执行动作
            next_state, reward, done, info = env.step(action)
            # 更新单幕收益和
            scores += reward
            # 如果幕结束则更新Q后记录本幕收益和
            if done:
                Q[state][action] = update_Q(alpha, gamma, Q, state, action, reward)
                tmp_scores.append(scores)
                break
            # 更新状态和Q
            Q[state][action] = update_Q(alpha, gamma, Q, state, action, reward, next_state)
            state = next_state
        # 更新平均收益和
        avg_scores.append(np.mean(tmp_scores))
    # 绘图
    plt.plot(np.asarray(avg_scores))
    plt.xlabel('Episode')
    plt.ylabel('Average Reward Sum')
    plt.show()
    return Q

最后在主函数中调用该函数并绘图即可，运行程序，可得到训练20000幕后最优状态价值函数如下：

同时还得到随着幕数的增长，每幕的平均收益和曲线如下：

可见上述结果均与Sarsa算法结果基本一致。

五、期望Sarsa

5.1 算法介绍

上文已经介绍，Sarsa算法是利用 $\epsilon$ -贪心策略产生的动作价值进行价值更新，而Q-Learning算法则是利用绝对贪心动作进行价值更新，现在我们将两者融合，即利用 $\epsilon$ -贪心策略下次时刻动作价值的期望做为学习目标进行价值更新，公式如下：

$\begin{aligned} Q(S_{t},A_{t})&=Q(S_{t},A_{t})+\alpha[R_{t+1}+\gamma E[Q(S_{t+1},A_{t+1})|S_{t+1}] -Q(S_{t},A_{t})]\\ &=Q(S_{t},A_{t})+\alpha[R_{t+1}+\gamma \sum_{a}\pi(a|S_{t+1})Q(S_{t+1},a) -Q(S_{t},A_{t})] \end{aligned}$

上述公式虽然计算复杂，但是利用求期望的方式消除了因为随机选择 $A_{t+1}$ 所带来的方差，因此这种方法又叫做期望Sarsa，可以看出当上式中策略 $\pi$ 为绝对贪心策略时，期望Sarsa就退化成了Q学习方法。仿照上述算法可列出该算法流程如下：

期望Sarsa算法

Step1: 输入增量步长 $\alpha \in (0,1]$ 与探索概率 $\epsilon \in (0,1]$

Step2: 初始化状态-动作价值函数为零向量

Step3: 对每幕循环：

初始化S

                生成幕的同时进行价值更新：

使用 $\epsilon$ -贪心策略在出选择

                        执行，观测到 $R,S^{'}$

$Q(S,A)=Q(S,A)+\alpha[R+\gamma \sum_{a}\pi(a|S^{*})Q(S^{*},a) -Q(S,A)]$

                         $S=S^{'}$

                        若为终止状态则终止本幕，开始访问下一幕

5.2 算法应用

依然用悬崖游走问题对期望Sarsa算法做实例分析，首先更改价值更新函数：

# 更新状态-动作价值表
def update_Q(alpha, gamma, Q, state, action, reward, next_state=None):
    """
    alpha: 增量步长
    gamma: 折扣因子
    Q: 状态-动作价值表
    state: 当前状态
    action:当前动作
    reward:回报
    next_state:下个状态
    next_action:下个动作
    return:返回更新的Q
    """
    # 当前状态-动作价值
    current_Q = Q[state][action]
    # 下个时刻状态-动作价值
    next_Q = np.max(Q[next_state]) if next_state is not None else 0
    # 学习对象
    target = reward + gamma * next_Q
    # 更新
    new_Q = current_Q + alpha * (target - current_Q)
    return new_Q

其次将Q_learning()函数替换为expected_sarsa()函数：

# 期望Sarsa算法
def expected_sarsa(env, num_episodes, alpha, gamma=1.0):
    """
    env: 游戏环境
    num_episodes:总的训练幕数
    alpha: 增量步长
    gamma: 折扣因子
    return:返回最优状态价值函数
    """
    # 环境总的可选动作数
    nA = env.action_space.n
    # 初始化状态-动作价值表
    Q = defaultdict(lambda: np.zeros(nA))
    # 建立关于单幕总收益的双向队列
    tmp_scores = deque()
    # 建立关于平均收益的双向队列
    avg_scores = deque(maxlen=num_episodes)
    # 开始训练迭代
    for each_episode in range(1, num_episodes+1):
        # 进度显示
        print("Episode {}/{}".format(each_episode, num_episodes), end="\r")
        sys.stdout.flush()
        # 初始化单幕总收益
        scores = 0
        # 环境重置
        state = env.reset()
        # 设置epsilon
        epsilon = 0.005
        # 单幕训练
        while True:
            # 选择动作
            action = epsilon_greedy(Q, state, nA, epsilon)
            # 执行动作
            next_state, reward, done, info = env.step(action)
            # 更新单幕收益和
            scores += reward
            # 更新Q
            Q[state][action] = update_Q(alpha, gamma, nA, epsilon, Q, state, action, reward, next_state)
            # 如果幕结束则更新Q后记录本幕收益和
            if done:
                tmp_scores.append(scores)
                break
            # 更新状态
            state = next_state
        # 更新平均收益和
        avg_scores.append(np.mean(tmp_scores))
    # 绘图
    plt.plot(np.asarray(avg_scores))
    plt.xlabel('Episode')
    plt.ylabel('Average Reward Sum')
    plt.show()
    return Q

最后在主函数中调用该函数并绘图即可，运行程序，可得到训练20000幕后最优状态价值函数如下：

同时还得到随着幕数的增长，每幕的平均收益和曲线如下：

所得图像也均与上述算法结果一致。

5.3 三种控制算法之间的比较

上述三种算法最重要的区别就是价值更新公式的不同，为比较三种算法的性能，此处引用Sutton书中的一个比较图如下：

这是悬崖行走问题三种方法的长期性能和短期性能曲线，上图中横轴为增量步长 $\alpha$ ，纵轴是每幕的平均收益和。可以看出，期望Sarsa保持了Sarsa优于Q学习的显著优势，同时在短期和长期表现中期望Sarsa也均显著胜于Sarsa。而对于Sarsa算法而言，其仅在 $\alpha$ 较小时能够有良好的长期表现。

六、最大化偏差与双学习

6.1 最大化偏差（Maximization Bias）

注意到我们在上面讲述的控制算法中，都包含了最大化的操作，也即是贪心算法，也就是根据所有动作价值的最大值来进行价值更新，然而，当这些动作的回报服从一定的分布或是单纯的噪声时，这种贪心的做法往往会使得价值估计变大，由此产生的一个正偏差叫做最大化偏差。我们用下面一个经典的例子对其进行解释：

最大化偏差的例子

考虑下面一个MDP过程：

这个MDP有两个非终止节点A和B，每幕从A开始，每步随机选择向左向右的动作，直至到达两侧方框表示的终止状态。由B达到左侧终止状态对应有N个动作，同时每次都会得到一个服从均值为-0.1、方差为1.0的正态分布的收益，其余状态转移收益为0，求状态转移的最优路径。

这是一个非常简单而直观的问题，由于由B达到左侧终止状态，各动作收益的均值为-0.1且同分布，因此最优路径一定会是由A向右达到右侧终止状态。但是利用Q学习算法得到的智能体选择由A向左移动的概率曲线如下：

上图中黄线表示Q学习算法策略稳定下智能体选择由A向左移动的概率，该值为0.05是使用 $\epsilon=0.1$ 的 $\epsilon$ -贪心策略选择动作而引起的最低向左运动的概率（ $\frac{\epsilon}{|A|}=\frac{\epsilon}{2}=0.05$ ）。

从上图可以看到，虽然Q学习算法学习曲线最后慢慢趋近最优学习曲线，但是在开始时，也即训练幕数较低时，由于由B达到左侧终止状态的N个动作价值的样本量不够，其价值还得不到收敛，而此时价值更新选择的是N个动作中此刻价值最大的价值函数，因此会使得对A向左移动的价值函数估计偏高，从而选择左移动的概率变大，这就是最大化偏差带来的影响。

但当样本数量慢慢增多时，由B达到左侧终止状态的N个动作价值得到收敛，从A向左移动的价值函数也会慢慢收敛，选择左移动的概率慢慢变小。

6.2 双学习（Double Learning）

为了解决开始时样本数量过少且选择贪心算法带来的最大化偏差问题，不妨引入两个动作价值函数表 $Q_{1}$ 与 $Q_{2}$ ，每步价值更新依然选择贪心动作，但是等概率的从其中一个Q表选择贪心动作:

$A^{*}=\underset{a}{argmax}\ Q(S_{t+1},a)$

而从另外一个表中选择该动作对应的Q值进行价值更新:

$Q(S_{t},A_{t})=Q(S_{t},A_{t})+\alpha[R_{t+1}+\gamma Q_{the\_other}(S_{t+1},A^{*})-Q(S_{t},A_{t})]$

这样一来就消除了变量分布产生的随机性所带来了估计误差，这种方法就叫做双学习，对于Q学习的双学习算法叫做双Q学习算法，依据上式可得其算法流程如下：

双Q学习算法

Step1: 输入增量步长 $\alpha \in (0,1]$ 与探索概率 $\epsilon \in (0,1]$

Step2: 初始化 $Q_{1}(S,A)$ 与 $Q_{2}(S,A)$ 为零向量

Step3: 对每幕循环：

初始化

  生成幕的同时进行价值更新：

基于 $Q_{1}+Q_{2}$ 之和，使用 $\epsilon$ -贪心策略在出选择

                        执行，观测到 $R,S^{'}$

以0.5的概率执行：

   $Q_{1}(S,A)=Q_{1}(S,A)+\alpha[R+\gamma Q_{2}(S^{'},\underset{a}{argmax}Q_{1}(S^{'},a))-Q_{1}(S,A)]$

或者执行：

    $Q_{2}(S,A)=Q_{2}(S,A)+\alpha[R+\gamma Q_{1}(S^{'},\underset{a}{argmax}Q_{2}(S^{'},a))-Q_{2}(S,A)]$

                            $S=S^{'}$

                        若为终止状态则终止本幕，开始访问下一幕

利用该算法对上面的那个MDP过程进行求解，并与Q学习算法学习曲线对比得：

上述算法的代码可参下面链接，这里由于本文篇幅有限就不再贴了：

阿亮算法：解剖[强化学习]Double Learning本质并对比Q-Learning与期望Sarsahttps://zhuanlan.zhihu.com/p/269870048 通过上图可以看出，双Q学习并没有受到最大化偏差的影响，从训练开始就一致趋近并最终收敛于最优学习曲线，可见该算法在此类问题中的优越性。

参考文献与网址

[1] Sutton R , Barto A . Reinforcement Learning:An Introduction Second Edition

[2] 强化学习基础篇（十九）TD与MC在随机游走问题应用

[3] 强化学习之时序差分学习

[4] 强化学习（五） - 时序差分学习(Temporal-Difference Learning)及其实例----Sarsa算法, Q学习, 期望Sarsa算法

[5] 解剖[强化学习]Double Learning本质并对比Q-Learning与期望Sarsa

你可能感兴趣的:(强化学习,算法,python,强化学习,机器学习)

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
python os.environ 江湖偌大 python 深度学习
os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
Python中os.environ基本介绍及使用方法鹤冲天Pro #Python python 服务器开发语言
文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
Pyecharts数据可视化大屏：打造沉浸式数据分析体验我的运维人生信息可视化数据分析数据挖掘运维开发技术共享
Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
Goolge earth studio 进阶4——路径修改与平滑陟彼高冈yu Google earth studio 进阶教程旅游
如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
Python教程：一文了解使用Python处理XPath 旦莫 Python进阶 python 开发语言
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 python os.environ
>>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
基于社交网络算法优化的二维最大熵图像分割智能算法研学社（Jack旭）智能优化算法应用图像分割算法 php 开发语言
智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
使用Faiss进行高效相似度搜索 llzwxh888 faiss python
在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
python是什么意思中文-在python中%是什么意思编程大乐趣
Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
python八股文面试题分享及解析(1) Shawn________ python
#1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
121. 买卖股票的最佳时机薄荷糖的味道_fb40
给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
Python快速入门 —— 第三节：类与对象孤华暗香 Python快速入门 python 开发语言
第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
pyecharts——绘制柱形图折线图 2224070247 信息可视化 python java 数据可视化
一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
Python 实现图片裁剪（附代码） | Python工具剑客阿良_ALiang
前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
python os 环境变量 CV矿工 python 开发语言 numpy
环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
Python爬虫解析工具之xpath使用详解 eqa11 python 爬虫开发语言
文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
Faiss：高效相似性搜索与聚类的利器网络·魚大数据 faiss
Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
数字里的世界17期：2021年全球10大顶级数据中心，中国移动榜首张三叨
你知道吗？2016年，全球的数据中心共计用电4160亿千瓦时，比整个英国的发电量还多40％！前言每天，我们都会创造超过250万TB的数据。并且随着物联网（IOT）的不断普及，这一数据将持续增长。如此庞大的数据被存储在被称为“数据中心”的专用设施中。虽然最早的数据中心建于20世纪40年代，但直到1997-2000年的互联网泡沫期间才逐渐成为主流。当前人类的技术，比如人工智能和机器学习，已经将我们推向
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
《Python数据分析实战终极指南》 xjt921122 python 数据分析开发语言
对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insert into select 主键自增 mybatis delete返回值 mybatis insert返回主键 mybatis insert返回对象 mybatis plus insert返回主键 mybatis plus 插入生成id
前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
Python中深拷贝与浅拷贝的区别 yuxiaoyu.
转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
jvm调优总结（从基本概念到深度优化） oloz java jvm jdk 虚拟机应用服务器
JVM参数详解：http://www.cnblogs.com/redcreen/archive/2011/05/04/2037057.html Java虚拟机中，数据类型可以分为两类：基本类型和引用类型。基本类型的变量保存原始值，即：他代表的值就是数值本身；而引用类型的变量保存引用值。“引用值”代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。
【Scala十六】Scala核心十：柯里化函数 bit1129 scala
本篇文章重点说明什么是函数柯里化，这个语法现象的背后动机是什么，有什么样的应用场景，以及与部分应用函数(Partial Applied Function)之间的联系 1. 什么是柯里化函数 A way to write functions with multiple parameter lists. For instance def f(x: Int)(y: Int) is a
HashMap dalan_123 java
HashMap在java中对很多人来说都是熟的；基于hash表的map接口的非同步实现。允许使用null和null键；同时不能保证元素的顺序；也就是从来都不保证其中的元素的顺序恒久不变。 1、数据结构在java中，最基本的数据结构无外乎：数组和引用（指针），所有的数据结构都可以用这两个来构造，HashMap也不例外，归根到底HashMap就是一个链表散列的数据
Java Swing如何实时刷新JTextArea，以显示刚才加append的内容周凡杨 java 更新 swing JTextArea
在代码中执行完textArea.append("message")后，如果你想让这个更新立刻显示在界面上而不是等swing的主线程返回后刷新，我们一般会在该语句后调用textArea.invalidate()和textArea.repaint()。问题是这个方法并不能有任何效果，textArea的内容没有任何变化，这或许是swing的一个bug，有一个笨拙的办法可以实现
servlet或struts的Action处理ajax请求 g21121 servlet
其实处理ajax的请求非常简单，直接看代码就行了： //如果用的是struts //HttpServletResponse response = ServletActionContext.getResponse(); // 设置输出为文字流 response.setContentType("text/plain"); // 设置字符集 res
FineReport的公式编辑框的语法简介老A不折腾 finereport 公式总结
FINEREPORT用到公式的地方非常多，单元格（以=开头的便被解析为公式），条件显示，数据字典，报表填报属性值定义，图表标题，轴定义，页眉页脚，甚至单元格的其他属性中的鼠标悬浮提示内容都可以写公式。简单的说下自己感觉的公式要注意的几个地方： 1.if语句语法刚接触感觉比较奇怪，if(条件式子,值1,值2)，if可以嵌套，if(条件式子1，值1，if(条件式子2，值2，值3)
linux mysql 数据库乱码的解决办法墙头上一根草 linux mysql 数据库乱码
linux 上mysql数据库区分大小写的配置 lower_case_table_names=1 1-不区分大小写 0-区分大小写修改/etc/my.cnf 具体的修改内容如下: [client] default-character-set=utf8 [mysqld] datadir=/var/lib/mysql socket=/va
我的spring学习笔记6-ApplicationContext实例化的参数兼容思想 aijuans Spring 3
ApplicationContext能读取多个Bean定义文件，方法是： ApplicationContext appContext = new ClassPathXmlApplicationContext（ new String[]｛“bean-config1.xml”，“bean-config2.xml”，“bean-config3.xml”，“bean-config4.xml
mysql 基准测试之sysbench annan211 基准测试 mysql基准测试 MySQL测试 sysbench
1 执行如下命令，安装sysbench-0.5： tar xzvf sysbench-0.5.tar.gz cd sysbench-0.5 chmod +x autogen.sh ./autogen.sh ./configure --with-mysql --with-mysql-includes=/usr/local/mysql
sql的复杂查询使用案列与技巧百合不是茶 oracle sql 函数数据分页合并查询
本片博客使用的数据库表是oracle中的scott用户表; ------------------- 自然连接查询查询 smith 的上司(两种方法) &
深入学习Thread类 bijian1013 java thread 多线程 java多线程
一．线程的名字下面来看一下Thread类的name属性，它的类型是String。它其实就是线程的名字。在Thread类中，有String getName()和void setName(String)两个方法用来设置和获取这个属性的值。同时，Thr
JSON串转换成Map以及如何转换到对应的数据类型 bijian1013 java fastjson net.sf.json
在实际开发中，难免会碰到JSON串转换成Map的情况，下面来看看这方面的实例。另外，由于fastjson只支持JDK1.5及以上版本，因此在JDK1.4的项目中可以采用net.sf.json来处理。一.fastjson实例 JsonUtil.java package com.study; impor
【RPC框架HttpInvoker一】HttpInvoker：Spring自带RPC框架 bit1129 spring
HttpInvoker是Spring原生的RPC调用框架，HttpInvoker同Burlap和Hessian一样，提供了一致的服务Exporter以及客户端的服务代理工厂Bean，这篇文章主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成在【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中
【Mahout二】基于Mahout CBayes算法的20newsgroup的脚本分析 bit1129 Mahout
#!/bin/bash # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information re
nginx三种获取用户真实ip的方法 ronin47
随着nginx的迅速崛起，越来越多公司将apache更换成nginx. 同时也越来越多人使用nginx作为负载均衡, 并且代理前面可能还加上了CDN加速，但是随之也遇到一个问题：nginx如何获取用户的真实IP地址,如果后端是apache,请跳转到<apache获取用户真实IP地址>，如果是后端真实服务器是nginx，那么继续往下看。实例环境：用户IP 120.22.11.11
java-判断二叉树是不是平衡 bylijinnan java
参考了 http://zhedahht.blog.163.com/blog/static/25411174201142733927831/ 但是用java来实现有一个问题。由于Java无法像C那样“传递参数的地址，函数返回时能得到参数的值”，唯有新建一个辅助类：AuxClass import ljn.help.*; public class BalancedBTree {
BeanUtils.copyProperties VS PropertyUtils.copyProperties 诸葛不亮 PropertyUtils BeanUtils
BeanUtils.copyProperties VS PropertyUtils.copyProperties 作为两个bean属性copy的工具类，他们被广泛使用，同时也很容易误用，给人造成困然；比如：昨天发现同事在使用BeanUtils.copyProperties copy有integer类型属性的bean时，没有考虑到会将null转换为0，而后面的业
[金融与信息安全]最简单的数据结构最安全 comsci 数据结构
现在最流行的数据库的数据存储文件都具有复杂的文件头格式，用操作系统的记事本软件是无法正常浏览的，这样的情况会有什么问题呢？从信息安全的角度来看，如果我们数据库系统仅仅把这种格式的数据文件做异地备份，如果相同版本的所有数据库管理系统都同时被攻击，那么
vi区段删除 Cwind linux vi 区段删除
区段删除是编辑和分析一些冗长的配置文件或日志文件时比较常用的操作。简记下vi区段删除要点备忘。 vi概述引文中并未将末行模式单独列为一种模式。单不单列并不重要，能区分命令模式与末行模式即可。 vi区段删除步骤： 1. 在末行模式下使用:set nu显示行号非必须，随光标移动vi右下角也会显示行号，能够正确找到并记录删除开始行
清除tomcat缓存的方法总结 dashuaifu tomcat 缓存
用tomcat容器，大家可能会发现这样的问题，修改jsp文件后，但用IE打开依然是以前的Jsp的页面。出现这种现象的原因主要是tomcat缓存的原因。解决办法如下: 在jsp文件头加上 <meta http-equiv="Expires" content="0"> <meta http-equiv="kiben&qu
不要盲目的在项目中使用LESS CSS dcj3sjt126com Web less
　如果你还不知道LESS CSS是什么东西，可以看一下这篇文章，是我一朋友写给新人看的《CSS——LESS》　　不可否认，LESS CSS是个强大的工具，它弥补了css没有变量、无法运算等一些“先天缺陷”，但它似乎给我一种错觉，就是为了功能而实现功能。　　比如它的引用功能 ? .rounded_corners{
[入门]更上一层楼 dcj3sjt126com PHP yii2
更上一层楼通篇阅读完整个“入门”部分，你就完成了一个完整 Yii 应用的创建。在此过程中你学到了如何实现一些常用功能，例如通过 HTML 表单从用户那获取数据，从数据库中获取数据并以分页形式显示。你还学到了如何通过 Gii 去自动生成代码。使用 Gii 生成代码把 Web 开发中多数繁杂的过程转化为仅仅填写几个表单就行。本章将介绍一些有助于更好使用 Yii 的资源：
Apache HttpClient使用详解 eksliang httpclient http协议
Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会
zxing二维码扫描功能 gundumw100 android zxing
经常要用到二维码扫描功能现给出示例代码 import com.google.zxing.WriterException; import com.zxing.activity.CaptureActivity; import com.zxing.encoding.EncodingHandler; import android.app.Activity; import an
纯HTML+CSS带说明的黄色导航菜单 ini html Web html5 css hovertree
HoverTree带说明的CSS菜单:纯HTML+CSS结构链接带说明的黄色导航在线体验效果：http://hovertree.com/texiao/css/1.htm代码如下,保存到HTML文件可以看到效果： <!DOCTYPE html > <html > <head> <title>HoverTree
fastjson初始化对性能的影响 kane_xie fastjson 序列化
之前在项目中序列化是用thrift，性能一般，而且需要用编译器生成新的类，在序列化和反序列化的时候感觉很繁琐，因此想转到json阵营。对比了jackson，gson等框架之后，决定用fastjson，为什么呢，因为看名字感觉很快。。。网上的说法： fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发。
基于Mybatis封装的增删改查实现通用自动化sql mengqingyu DAO
1.基于map或javaBean的增删改查可实现不写dao接口和实现类以及xml，有效的提高开发速度。 2.支持自定义注解包括主键生成、列重复验证、列名、表名等 3.支持批量插入、批量更新、批量删除 <bean id="dynamicSqlSessionTemplate" class="com.mqy.mybatis.support.Dynamic
js控制input输入框的方法封装(数字，中文，字母，浮点数等) qifeifei javascript js
在项目开发的时候，经常有一些输入框，控制输入的格式，而不是等输入好了再去检查格式，格式错了就报错，体验不好。 /** 数字，中文，字母,浮点数(+/-/.) 类型输入限制，只要在input标签上加上 jInput="number,chinese,alphabet,floating" 备注：floating属性只能单独用*/ funct
java 计时器应用 tangqi609567707 java timer
mport java.util.TimerTask; import java.util.Calendar; public class MyTask extends TimerTask { private static final int
erlang输出调用栈信息 wudixiaotie erlang
在erlang otp的开发中，如果调用第三方的应用，会有有些错误会不打印栈信息，因为有可能第三方应用会catch然后输出自己的错误信息，所以对排查bug有很大的阻碍，这样就要求我们自己打印调用的栈信息。用这个函数：erlang:process_display (self (), backtrace).需要注意这个函数只会输出到标准错误输出。也可以用这个函数：erlang:get_s