精华内容
下载资源
问答
  • 梯度下降法 梯度上升法 深层加固学习介绍— 19 (DEEP REINFORCEMENT LEARNING EXPLAINED — 19) This is a new post devoted to Policy-Gradient Methods, in the “Deep Reinforcement Learning Explained” series...

    梯度下降法 梯度上升法

    深层加固学习介绍— 19 (DEEP REINFORCEMENT LEARNING EXPLAINED — 19)

    This is a new post devoted to Policy-Gradient Methods, in the Deep Reinforcement Learning Explained series. Policy-Gradient methods are a subclass of Policy-Based methods that estimate an optimal policy’s weights through gradient ascent.

    这是 深度强化学习解释 系列中专门讨论策略梯度方法的新文章。 策略梯度方法是基于策略的方法的子类,该方法通过梯度上升来估计最佳策略的权重

    Image for post
    Summary of approaches in Reinforcement Learning presented until know in this series. The classification is based on whether we want to model the value or the policy (source: https://torres.ai)
    本文介绍了强化学习的方法摘要,直到本系列为止为止。 分类基于我们是要对值还是策略进行建模(来源: https : //torres.ai )

    Intuitively, gradient ascent begins with an initial guess for the value of policy’s weights that maximizes the expected return, then, the algorithm evaluates the gradient at that point that indicates the direction of the steepest increase of the function of expected return, and so we can make a small step in that direction. We hope that we end up at a new value of policy’s weights for which the value of the expected return function is a little bit larger. The algorithm then repeats this process of evaluating the gradient and taking steps until it considers that it is eventually reached the maximum expected return.

    直观地讲,梯度上升首先是对使期望收益最大化的保单权重值的初始猜测,然后,算法在该点处评估梯度,该梯度指示期望收益函数的最大增加方向,因此我们可以朝这个方向迈出一小步。 我们希望最终得到一个新的政策权重值,期望收益函数的值会更大。 然后,该算法重复此评估梯度并采取步骤的过程,直到它认为最终达到最大预期收益为止。

    Although we have coded a deterministic policy in the previous post, Policy-based methods can learn either stochastic or deterministic policies. With a stochastic policy, our neural network’s output is an action vector that represents a probability distribution (rather than returning a single deterministic action). The policy we will follow is selecting an action from this probability distribution. This means that if our agent ends up in the same state twice, we may not end up taking the same action every time.

    尽管我们在上一篇文章中已经编码了确定性策略,但是基于策略的方法可以学习随机策略或确定性策略。 使用随机策略,我们的神经网络的输出是一个表示概率分布的作用向量(而不是返回单个确定性作用)。 我们将遵循的策略是从该概率分布中选择一个动作。 这意味着,如果我们的代理两次处于相同状态,则可能不会每次都采取相同的操作。

    The key idea underlying policy gradients is reinforcing good actions: to push up the probabilities of actions that lead to higher return, and push down the probabilities of actions that lead to a lower return, until you arrive at the optimal policy. The policy gradient method will iteratively amend the policy network weights (with smooth updates) to make state-action pairs that resulted in positive return more likely, and make state-action pairs that resulted in negative return less likely.

    政策梯度背后的关键思想是加强良好的行动:提高导致较高回报的行动的可能性,并降低导致较低回报的行动的可能性,直到您获得最佳策略为止。 策略梯度方法将迭代地修改策略网络权重(平滑更新),以使产生正收益的状态-动作对更有可能,而使产生负收益的状态-动作对更不可能。

    From this post on, we will begin to enter into a more rigorous definition at a mathematical level of everything that we are presenting since it will be good for us to understand the most advanced algorithms. We will start describing the primary form of the REINFORCE algorithm ( original paper), the fundamental policy gradient algorithm on which nearly all the advanced policy gradient algorithms are based.

    从这篇文章开始,我们将开始在数学上对我们所呈现的所有事物进行更严格的定义,因为这对我们理解最先进的算法将是一件好事。 我们将开始描述REINFORCE算法的主要形式( 原始论文 ),这是基本策略梯度算法,几乎所有高级策略梯度算法都基于该基本策略梯度算法。

    数学定义 (Mathematical definitions)

    弹道 (Trajectory)

    The first thing we need to define is a trajectory, just a state-action sequence without keeping track of the rewards:

    我们需要定义的第一件事是一条轨迹 ,只是一个状态-动作序列,而没有跟踪奖励:

    Image for post

    A trajectory is a little bit more flexible than an episode because there are no restrictions on its length; it can correspond to a full episode or just a part of an episode.

    轨迹比情节稍微灵活一点,因为它的长度没有限制。 它可以对应于整集或部分集。

    We denote the length with a capital H, where H stands for Horizon, and we represent a trajectory with τ:

    我们用大写字母H表示长度,其中H表示Horizo​​n ,并且用τ表示轨迹:

    Image for post

    The method is built upon trajectories instead of episodes because maximizing expected return over trajectories (instead of episodes) lets the method search for optimal policies for both episodic and continuing tasks.

    该方法建立在轨迹而不是情节的基础上,因为最大化轨迹的预期收益(而不是情节)可以使该方法针对情景任务和连续任务搜索最佳策略。

    Although for the vast majority of episodic tasks, where a reward is only delivered at the end of the episode, it only makes sense just to use the full episode as a trajectory; otherwise, we don’t have enough reward information to meaningfully estimate the expected return.

    尽管对于大多数情节任务而言,奖励仅在情节结束时才提供,但仅将整个情节用作轨迹才有意义; 否则,我们没有足够的奖励信息来有意义地估计预期收益。

    返回轨迹 (Return of a trajectory)

    We denote the return for a trajectory τ with R(τ), and it is calculated as the sum reward from that trajectory τ:

    我们用R(τ)表示轨迹τ收益 并计算为该轨迹τ的总奖励

    Image for post

    预期收益 (Expected return)

    Remember that the goal of this algorithm is to find the weights θ of the neural network that maximize expected return that we denote by U(θ) and can be defined as:

    请记住,该算法的目标是找到使期望回报最大化的神经网络权重θ ,我们用U(θ)表示,可以定义为:

    Image for post

    To see how it corresponds to the expected return, note that we have expressed the return R(τ) as a function of the trajectory τ. Then, we calculate the weighted average, where the weights are given by P(τ;θ), the probability of each possible trajectory, of all possible values that the return R(τ) can take. Note that probability depends on the weights θ in the neural network because θ defines the policy used to select the actions in the trajectory, which also plays a role in determining the states that the agent observes.

    要查看它与预期收益如何对应,请注意,我们已将收益R ( τ )表示为轨迹τ的函数。 然后,我们计算加权平均值,其中权重为 P( τ ; θ ),即返回R ( τ )可以取的所有可能值的每个可能轨迹的概率。 请注意,概率取决于神经网络中的权重θ ,因为θ定义了用于选择轨迹中动作的策略,这在确定代理观察到的状态时也起着作用。

    渐变上升 (Gradient ascent)

    As we already introduced, one way to determine the value of θ that maximizes U(θ) function is through gradient ascent.

    正如我们已经介绍的那样,确定使U(θ)函数最大化的θ值的一种方法是通过梯度上升

    Gradient ascent is closely related to gradient descent, where the differences are that gradient descent is designed to find the minimum of a function (steps in the direction of the negative gradient), whereas gradient ascent will find the maximum (steps in the direction of the gradient).

    梯度上升梯度下降密切相关,区别在于梯度下降被设计为找到函数的最小值 (向负梯度的方向步进) ,而梯度上升将找到最大值(负梯度的方向步进)。 渐变)

    Equivalent to Hill Climbing algorithm presented in the previous Post, intuitively we can visualize that the gradient ascent draws up a strategy to reach the highest point of a hill, U(θ), just iteratively taking small steps in the direction of the gradient:

    等效于上一篇文章中介绍的Hill Climbing算法,直观地我们可以直观地看到,梯度上升拟定了一种策略来达到山的最高点U(θ) ,只是在梯度方向上逐步采取了一些小步骤:

    Image for post
    source: https://torres.ai
    来源: https : //torres.ai

    Mathematically, our update step for gradient ascent can be expressed as:

    从数学上讲,我们对梯度上升的更新步骤可以表示为:

    Image for post

    where α is the step size that is generally allowed to decay over time (equivalent to the learning rate decay in deep learning). Once we know how to calculate or estimate this gradient, we can repeatedly apply this update step, in the hopes that θ converges to the value that maximizes U(θ).

    其中α是通常允许随时间衰减的步长(相当于深度学习中的学习速率衰减 )。 一旦知道了如何计算或估计该梯度,就可以重复应用此更新步骤,以期θ收敛到使U ( θ )最大化的值。

    抽样与估算 (Sampling and estimate)

    To apply this method, we will need to be able to calculate the gradient ∇​U(θ); however, we won’t be able to calculate the exact value of the gradient since that is computationally too expensive because, to calculate the gradient exactly, we’ll have to consider every possible trajectory, becoming an intractable problem in most cases.

    为了应用这种方法,我们将需要能够计算梯度∇U(θ); 但是,我们将无法计算梯度的确切值,因为这在计算上过于昂贵,因为要精确计算梯度,我们将必须考虑所有可能的轨迹,这在大多数情况下会成为棘手的问题。

    Instead of doing this, the method samples a few trajectories using the policy and then use those trajectories only to estimate the gradient. This is equivalent to the approach of Monte Carlo presented in Post 13 of this series, and for this reason, method REINFORCE is also known as Monte Carlo Policy Gradients.

    代替执行此操作,该方法使用策略对一些轨迹进行采样,然后仅将这些轨迹用于估计梯度。 这等效于本系列文章后13中介绍的蒙特卡洛方法,因此,REINFORCE方法也称为蒙特卡洛政策梯度。

    伪码 (Pseudocode)

    In summary, the described method is a loop that has three steps:

    总之,所描述的方法是一个包含三个步骤的循环:

    1. Collect trajectories

      收集轨迹
    2. Use the trajectories to estimate the gradient

      使用轨迹估计坡度
    3. Update the weights of the policy

      更新政策的权重

    The pseudocode that describes in more detail the behavior of this method can be written as:

    更详细地描述此方法的行为的伪代码可以写为:

    Image for post

    梯度估算公式 (Gradient estimation formula)

    As the reader can see in the equation of step 2 in the pseudocode, to estimate the gradient (which we will refer to as g hat for simplicity), the method uses these m trajectories collected in step 1. Let’s look a bit more closely at this equation. To understand it, we begin by making some simplifying assumptions, for example, assuming that we only have a single trajectory (m=1) that corresponds to a full episode. Then the equation for the gradient estimation looks like this:

    正如读者在伪代码的步骤2的方程式中所看到的那样,为了估计梯度(为简单起见,我们将其称为g hat),该方法使用了在步骤1中收集的这m条轨迹。让我们更仔细地看一下这个方程式。 为了理解它,我们首先进行一些简化的假设,例如,假设我们只有一个与整个情节相对应的单个轨迹( m = 1)。 然后,用于梯度估计的公式如下所示:

    Image for post

    Remember that R(τ) is just the cumulative reward from the trajectory τ, the only one trajectory in this simplified example. Assume that the reward signal and the sample play we are working with gives the Agent a reward of positive one (R(τ)=+1) if we won the game and a reward of negative one (R(τ)=-1) if we lost. In the other hand, the term

    请记住, R ( τ )只是轨迹τ的累积奖励在此简化示例中轨迹τ是唯一的一条轨迹。 假设我们正在使用的奖励信号和示例游戏给Agent带来了正数的奖励( R ( τ )= + 1)(如果我们赢了游戏),而负数的奖励( R ( τ )=-1)。如果我们输了。 另一方面,术语

    Image for post

    looks at the probability that the Agent selects action at from state st in time step t. Remember that π with the subscript θ refers to the policy which is parameterized by θ. Then, the full expression takes the gradient of the log of that probability is

    着眼于概率代理选择国家行动 ST在时间步长 。 请记住,带有下标θ的 π 表示θ参数化的策略。 然后,完整表达式采用该概率的对的梯度

    Image for post

    This will tell us how we should change the weights of the policy θ if we want to increase the log probability of selecting action at from state st. Specifically, suppose we nudge the policy weights by taking a small step in the direction of this gradient. In that case, it will increase the log probability of selecting the action from that state, and if we step in the opposite direction will decrease the log probability.

    这将告诉我们,我们应该如何改变政策θ的权重,如果我们希望增加国家选择动作的概率 具体来说,假设我们朝这个梯度的方向走了一小步,就可以轻推政策权重。 在那种情况下,它将增加从该状态选择动作的对概率,而如果我们朝相反的方向迈进,则将降低对数概率。

    The following equation will do all of these updates all at once for each state-action pair, at and st, at each time step t in the only trajectory:

    下面的方程式将在唯一轨迹的每个时间步t处的每个状态动作对at和st一次完成所有这些更新:

    Image for post

    To see this behavior, assume that the Agent won the episode. Then, R(τ) is just a positive one (+1), and what the sum does is add up all the gradient directions we should step in to increase the log probability of selecting each state-action pair. That’s equivalent to just taking H+1 simultaneous steps where each step corresponds to a state-action pair in the trajectory.

    要查看此行为,请假定特工赢得了该集。 然后, R ( τ )只是一个正数(+1),总和就是将所有我们应该介入的梯度方向加起来,以增加选择每个状态-动作对的对概率。 这等效于仅同时执行H + 1个步骤,其中每个步骤对应于轨迹中的状态-动作对。

    In the opposite, if the Agent lost, R(τ) becomes a negative one, which ensures that instead of stepping in the direction of the steepest increase of the log probabilities, the method steps in the direction of the steepest decrease.

    相反,如果Agent丢失,则R ( τ )变为负数,这确保了方法不是朝对数概率的最陡峭增加的方向步进,而是朝着最陡峭的减小方向步进。

    Well, remember that this explanation was for a simplified example. In the general equation, you will notice that it is almost identical. We now need to add contributions from multiple trajectories (with the sum) and add a scaling factor that’s inversely proportional to the number of trajectories:

    好吧,请记住,这种解释只是为了简化示例。 在一般等式中,您会注意到它几乎是相同的。 现在,我们需要添加来自多个轨迹(总和)的贡献,并添加与轨迹数量成反比的缩放因子:

    Image for post

    If the reader wants to learn how to derive the equation that approximates the gradient, it can be found in the Post’s Appendix. However, this derivation can be safely skipped.

    如果读者想学习如何推导近似梯度的方程,可以在《 邮报》附录中找到 。 但是,可以安全地跳过此推导。

    为什么要优化对数概率而不是概率 (Why optimize log probability instead of probability)

    In Gradient methods where we can formulate some probability 𝑝 which should be maximized, we would actually optimize the log probability log𝑝 instead of the probability for some parameters 𝜃.

    在梯度方法中,我们可以制定应最大化的概率,,实际上,我们将优化对数概率log𝑝而不是某些参数the的概率。

    The reason is that generally, work better to optimize log𝑝(𝑥) than 𝑝(𝑥) due to the gradient of log𝑝(𝑥) is generally more well-scaled. Remember that probabilities are bounded by 0 and 1 by definition, so the range of values that the optimizer can operate over is limited and small.

    原因是通常,由于log𝑝(𝑥)的梯度通常更易于缩放 ,因此比log(𝑥)更好地优化log𝑝(𝑥)。 请记住,根据定义,概率受0和1限制,因此优化器可以操作的值的范围有限且很小。

    In this case, sometimes probabilities may be extremely tiny or very close to 1, and this runs into numerical issues when optimizing on a computer with limited numerical precision. If we instead use a surrogate objective, namely log p (natural logarithm), we have an objective that has a larger “dynamic range” than raw probability space, since the log of probability space ranges from (-∞,0), and this makes the log probability easier to compute.

    在这种情况下,有时概率可能极小或非常接近1,并且在数值精度有限的计算机上进行优化时会遇到数值问题。 如果我们改用替代目标,即log p (自然对数),则我们的目标“动态范围”比原始概率空间大,因为概率空间的对数范围为(-∞,0),并且使对数概率更易于计算。

    编码加强 (Coding REINFORCE)

    After describing the method mathematically, in this section, we will explore an implementation of the REINFORCE to solve OpenAI Gym’s Cartpole environment. To help the reader understand the essential parts, we implemented the simplified example where each trajectory corresponds to a full episode, and we collect only one (m=1) trajectory.

    在数学上描述了方法之后,在本节中,我们将探索REINFORCE的实现以解决OpenAI Gym的Cartpole环境 。 为了帮助读者理解基本部分,我们实施了简化示例,其中每个轨迹对应一个完整的情节,并且我们仅收集一个( m = 1)轨迹。

    The entire code of this post can be found on GitHub and can be run as a Colab google notebook using this link.

    这篇文章完整代码可以在GitHub上找到也可以使用此链接作为Colab谷歌笔记本运行

    Acknowledgments: The code presented in this post has been inspired by the REINFORCEMENT implementation shared at Udacity GitHub.

    致谢:这篇文章中介绍的代码是受Udacity GitHub上共享的REINFORCEMENT实现的启发。

    First, we will import all necessary packages with the following lines of code:

    首先,我们将使用以下代码行导入所有必需的软件包:

    import gymimport numpy as npfrom collections import dequeimport matplotlib.pyplot as pltimport torch
    torch.manual_seed(0) # set random seedimport torch.nn as nnimport torch.nn.functional as Fimport torch.optim as optimfrom torch.distributions import Categorical

    And also the OpenAI Gym’s Cartpole Environment:

    还有OpenAI Gym的Cartpole环境:

    env = gym.make('CartPole-v0')

    Next in the code, we define the policy π (and initialize it with random weights):

    接下来,在代码中,我们定义策略π(并使用随机权重对其进行初始化):

    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")class Policy(nn.Module):def __init__(self, s_size=4, h_size=16, a_size=2):
    super(Policy, self).__init__()
    self.fc1 = nn.Linear(s_size, h_size)
    self.fc2 = nn.Linear(h_size, a_size) def forward(self, x):
    x = F.relu(self.fc1(x))
    x = self.fc2(x)return F.softmax(x, dim=1)def act(self, state):
    state = torch.from_numpy(state).float()
    .unsqueeze(0).to(device)
    probs = self.forward(state).cpu()
    m = Categorical(probs)
    action = m.sample()return action.item(), m.log_prob(action)

    Two convolutional layers make the policy neural network:

    两个卷积层构成了策略神经网络:

    Policy(
    (fc1): Linear(in_features=4, out_features=16, bias=True)
    (fc2): Linear(in_features=16, out_features=2, bias=True)
    )

    The code to train REINFORCE is similar to the code of Hill-Climbing method already described in the previous post:

    到列车加强代码类似于已经描述的爬山方法的代码以前的帖子

    policy = Policy().to(device)
    optimizer = optim.Adam(policy.parameters(), lr=1e-2)def reinforce(n_episodes=10000, max_t=1000, gamma=1.0):
    scores_deque = deque(maxlen=100)
    scores = []for i_episode in range(1, n_episodes+1):
    saved_log_probs = []
    rewards = []
    state = env.reset()for t in range(max_t):
    action, log_prob = policy.act(state)
    saved_log_probs.append(log_prob)
    state, reward, done, _ = env.step(action)
    rewards.append(reward)if done:break
    scores_deque.append(sum(rewards))
    scores.append(sum(rewards))
    discounts = [gamma**i for i in range(len(rewards)+1)]
    R = sum([a*b for a,b in zip(discounts, rewards)])
    policy_loss = []for log_prob in saved_log_probs:
    policy_loss.append(-log_prob * R)
    policy_loss = torch.cat(policy_loss).sum()
    optimizer.zero_grad()
    policy_loss.backward()
    optimizer.step()if i_episode % 100 == 0:
    print('Episode {}\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_deque)))if np.mean(scores_deque)>=195.0:
    print('Environment solved in {:d} episodes!\tAverage
    Score: {:.2f}'.format(i_episode-100,
    np.mean(scores_deque)))breakreturn scoresscores = reinforce()
    Image for post

    We can plot the scores obtained in each episode during training:

    我们可以标出训练期间每个情节中获得的分数:

    fig = plt.figure()
    plt.plot(np.arange(1, len(scores)+1), scores)
    plt.ylabel('Score')
    plt.xlabel('Episode #')
    plt.show()
    Image for post

    We render how the Agent applies the policy with the following code:

    我们使用以下代码来呈现代理如何应用策略:

    def watch_agent():
    env = gym.make('CartPole-v0')
    state = env.reset()
    rewards = []
    img = plt.imshow(env.render(mode='rgb_array'))for t in range(2000):
    action, _ = policy.act(state)
    img.set_data(env.render(mode='rgb_array'))
    plt.axis('off')
    display.display(plt.gcf())
    display.clear_output(wait=True)
    state, reward, done, _ = env.step(action)
    rewards.append(reward)if done:
    print("Reward:", sum([r for r in rewards]))break
    env.close()watch_agent()
    Image for post

    If you run the code in the Colab you will be able to see how the Agent handles the cart pole with a dynamic image.

    如果您在Colab中运行代码,您将能够看到代理如何处理带有动态图像的手推车。

    接下来是什么? (What is next?)

    In this post, we have explained in detail the REINFORCE algorithm, and we have coded it. However, can REINFORCE be improved? In the following Post, we will go over ways to improve the REINFORCE algorithm. All of the improvements will be utilized and implemented in the PPO algorithm. See you in the next post!

    在这篇文章中,我们详细解释了REINFORCE算法,并对其进行了编码。 但是,REINFORCE是否可以改善? 在下面的文章中,我们将探讨改进REINFORCE算法的方法。 所有改进将在PPO算法中使用和实现。 下篇再见!

    附录:如何推导梯度方程 (APPENDIX: How to derive the gradient equation)

    This appendix is a mathematical demonstration of the equation that approximate the gradient, presenting how to derive the gradient ∇​U(θ):

    本附录是方程近似的梯度,呈现如何导出梯度∇U(θ)的数学示范:

    Image for post

    方法 (Approach)

    First, we will start writing the gradient as the expected value

    首先,我们将开始将梯度写为期望值

    Image for post

    and from here, it becomes much easier to express the final formula that articulates its approximation with the empirical estimate with a sample-based average of m trajectories under the policy.

    从这里开始,用该策略在m个轨迹的基于样本的平均数下,用经验估计值表达表达其近似值的最终公式变得容易得多。

    It is common to refer to this gradient as the likelihood ratio policy gradient, keystone to the method that performs a (stochastic) gradient ascent over the policy parameter space to find a local optimum of U(θ).

    通常将此梯度称为似然比策略梯度,这是在策略参数空间上执行(随机)梯度上升以找到U(θ)局部最优值的方法的基石。

    似然比政策梯度 (Likelihood Ratio Policy Gradient)

    In order to obtain the likelihood ratio policy gradient, we start from

    为了获得似然比策略梯度,我们从

    Image for post

    and taken the gradient of both sides we obtain a first expression of its value:

    并采用双方的渐变,我们得到其值的第一个表达式:

    Image for post

    We can then get this formula and rewrite the gradient of the sum as the sum of the gradients

    然后,我们可以获取此公式并将总和的梯度重写为梯度的总和

    Image for post

    If we multiply every term in the sum by this factor

    如果我们将总和中的每一项乘以这个因子

    Image for post

    which is perfectly allowed because this fraction is equal to one, we have this expression

    这是完全允许的,因为这个分数等于1,我们有这个表达式

    Image for post

    and with a simple rearrangement of the terms, we obtain

    并通过简单地重新排列术语,我们获得

    Image for post

    Now, if we consider the chain rule, and the fact that the gradient of the log of a function is always equal to the gradient of the function, divided by the function

    现在,如果考虑链式规则,以及函数对数的斜率始终等于函数的斜率除以函数的事实

    Image for post

    we obtain the expected formula for the likelihood ratio policy gradient

    我们获得似然比策略梯度的期望公式

    Image for post

    Once we have written the gradient as an expected value in this way, it becomes much easier to estimate.

    通过这种方式将梯度写为期望值后,估计起来就容易得多了。

    抽样与估算 (Sampling and estimate)

    We already introduced that we won’t be able to calculate the exact value of the gradient ∇​U(θ) since that is computationally too expensive, because to calculate the gradient exactly, we’ll have to consider every possible trajectory, becoming an intractable problem in most cases. Instead of doing this, the method samples a few trajectories using the policy and then use those trajectories only to estimate the gradient.

    我们已经介绍了,我们将不能够计算梯度∇U(θ),因为这是计算过于昂贵的精确值,因为精确地计算梯度,我们必须要考虑每一个可能的轨迹,成为在大多数情况下都是棘手的问题。 代替执行此操作,该方法使用策略对一些轨迹进行采样,然后仅将这些轨迹用于估计梯度。

    For doing that, we can approximate the likelihood ratio policy gradient with a sample-based average, as shown below:

    为此,我们可以使用基于样本的平均值来近似似然比策略梯度,如下所示:

    Image for post

    The best way to proceed to get the desired expression for the likelihood ratio policy gradient is to simplify

    继续为似然比策略梯度获得所需表达式的最佳方法是简化

    Image for post

    We will start with unrolling the expression of the probability of a trajectory taking into account the action-selection probabilities from the policy

    我们将从考虑策略中的动作选择概率展开轨迹概率的表达开始

    Image for post

    and take the gradient of both sides we obtain a first expression of the its value:

    并取两边的梯度,我们得到其值的第一个表达式:

    Image for post

    Then, because the log of a product is equal to the sum of the logs, we obtain the following expression:

    然后,由于一个产品的对数等于该对数的总和,因此我们获得以下表达式:

    Image for post

    Because the gradient of the sum can be written as the sum of gradients, this is equal to

    因为总和的梯度可以写成梯度的总和,所以等于

    Image for post

    The first component of this expression

    此表达式的第一部分

    Image for post

    has no dependence on θ, so

    θ无关

    Image for post

    and this implies that

    这意味着

    Image for post

    Finally, because we can rewrite the gradient of the sum as the sum of gradients, we obtain the desired function

    最后,因为我们可以将和的梯度重写为梯度的和,所以我们获得了所需的函数

    Image for post

    And from here, replacing the previous calculation in the formula that approximate the likelihood ratio policy gradient with a sample-based average

    然后从此处开始,用基于样本的平均值替换近似似然比策略梯度的公式中的先前计算

    Image for post

    we obtain the final equation to estimate the gradient

    我们得到最终方程来估计梯度

    Image for post

    翻译自: https://towardsdatascience.com/policy-gradient-methods-104c783251e0

    梯度下降法 梯度上升法

    展开全文
  • 最小二乘法+牛顿法+拟牛顿法+梯度下降法+梯度上升法+共轭梯度法 最小二乘法+牛顿法+拟牛顿法+梯度下降法+梯度上升法+共轭梯度法 上述几种方法,除了最小二乘法是直接使用公式取得之外,另外几种方法都是...

    最小二乘法+牛顿法+拟牛顿法+梯度下降法+梯度上升法+共轭梯度法

     

    最小二乘法+牛顿法+拟牛顿法+梯度下降法+梯度上升法+共轭梯度法

    上述几种方法,除了最小二乘法是直接使用公式取得之外,另外几种方法都是使用迭代法进行求解。

    梯度下降法主要沿着负梯度方向进行更新,只引入了一阶导数。

    牛顿法则将一阶导数和二阶导数相结合进行参数的迭代更新,但是其二阶导数矩阵涉及到海瑟矩阵求逆,复杂度较高,因此基于牛顿法之上,出现了拟牛顿法,其主要思想是构造一个新的矩阵来近似替代海瑟矩阵的逆,这样可以避免牛顿法中的复杂的海瑟矩阵求逆操作。

    本质上来说,牛顿法是二阶收敛,而梯度下降是一阶收敛,所以牛顿法收敛更快,但是每次迭代的时间,牛顿法比梯度下降时间长。牛顿法就是用一个二次曲面去拟合你当前所处位置的局部曲面,而梯度下降法使用一个平面去拟合当前的局部曲面,所有牛顿法的下降路径会更简单,更符合最优路径。

    共轭梯度法基于梯度下降中的负梯度方向之外,引入了共轭向量,可以使收敛更快。

    牛顿法是二阶优化方法,拟牛顿法和共轭梯度法一般叫做1.5阶优化方法,梯度下降法及其变形则是一阶优化方法。

    几个数学概念

    1) 梯度(一阶导数)

    考虑一座在 (x1, x2) 点高度是 f(x1, x2) 的山。那么,某一点的梯度方向是在该点坡度最陡的方向,而梯度的大小告诉我们坡度到底有多陡。注意,梯度也可以告诉我们不在最快变化方向的其他方向的变化速度(二维情况下,按照梯度方向倾斜的圆在平面上投影成一个椭圆)。对于一个含有 n 个变量的标量函数,即函数输入一个 n 维 的向量,输出一个数值,梯度可以定义为:

     

    2) Hesse 矩阵(二阶导数)

    Hesse 矩阵常被应用于牛顿法解决的大规模优化问题(后面会介绍),主要形式如下:

    当 f(x) 为二次函数时,梯度以及 Hesse 矩阵很容易求得。二次函数可以写成下列形式:

    其中 x为列向量,A 是 n 阶对称矩阵,b 是 n 维列向量, c 是常数。f(x) 梯度是 Ax+b, Hesse 矩阵等于 A。

     

    3) Jacobi 矩阵

    Jacobi 矩阵实际上是向量值函数的梯度矩阵,假设F:Rn→Rm 是一个从n维欧氏空间转换到m维欧氏空间的函数。这个函数由m个实函数组成:

    。这些函数的偏导数(如果存在)可以组成一个m行n列的矩阵(m by n),这就是所谓的雅可比矩阵

    总结一下,

    a) 如果 f(x) 是一个标量函数,那么雅克比矩阵是一个向量,等于 f(x) 的梯度, Hesse 矩阵是一个二维矩阵。如果 f(x) 是一个向量值函数,那么Jacobi 矩阵是一个二维矩阵,Hesse 矩阵是一个三维矩阵。

    b) 梯度是 Jacobian 矩阵的特例,梯度的 jacobian 矩阵就是 Hesse 矩阵(一阶偏导与二阶偏导的关系)。

    梯度下降法(Gradient Descent)

    梯度下降法是最早最简单,也是最为常用的最优化方法。梯度下降法实现简单,

    当目标函数是凸函数时,梯度下降法的解是全局解。一般情况下,其解不保证是全局最优解,梯度下降法的速度也未必是最快的。

    梯度下降法的优化思想是用当前位置负梯度方向作为搜索方向,因为该方向为当前位置的最快下降方向,所以也被称为是”最速下降法“。最速下降法越接近目标值,步长越小,前进越慢。

    梯度下降法的搜索迭代示意图如下图所示:

    梯度下降法的缺点:

      (1)靠近极小值时收敛速度减慢,如下图所示;

      (2)直线搜索时可能会产生一些问题;

      (3)可能会“之字形”地下降。

    1)批量梯度下降法(Batch Gradient Descent,BGD)

    2)随机梯度下降(Stochastic Gradient Descent,SGD)

    批量梯度下降法和随机梯度下降法比较:

    当样本个数m很大的时候,随机梯度下降迭代一次的速度要远高于批量梯度下降方法。两者的关系可以这样理解:随机梯度下降方法以损失很小的一部分精确度和增加一定数量的迭代次数为代价,换取了总体的优化效率的提升。增加的迭代次数远远小于样本的数量。

    对批量梯度下降法和随机梯度下降法的总结:

    批量梯度下降---最小化所有训练样本的损失函数,使得最终求解的是全局的最优解,即求解的参数是使得风险函数最小,但是对于大规模样本问题效率低下。

    随机梯度下降---最小化每条样本的损失函数,虽然不是每次迭代得到的损失函数都向着全局最优方向, 但是大的整体的方向是向全局最优解的,最终的结果往往是在全局最优解附近,适用于大规模训练样本情况。

    牛顿法和拟牛顿法(Newton's method & Quasi-Newton Methods)

      1)牛顿法(Newton's method)

      牛顿法是一种在实数域和复数域上近似求解方程的方法。方法使用函数(x)的泰勒级数的前面几项来寻找方程(x) = 0的根。牛顿法最大的特点就在于它的收敛速度很快

    关于牛顿法和梯度下降法的效率对比:

      从本质上去看,牛顿法是二阶收敛,梯度下降是一阶收敛,所以牛顿法就更快。如果更通俗地说的话,比如你想找一条最短的路径走到一个盆地的最底部,梯度下降法每次只从你当前所处位置选一个坡度最大的方向走一步,牛顿法在选择方向时,不仅会考虑坡度是否够大,还会考虑你走了一步之后,坡度是否会变得更大。所以,可以说牛顿法比梯度下降法看得更远一点,能更快地走到最底部。(牛顿法目光更加长远,所以少走弯路;相对而言,梯度下降法只考虑了局部的最优,没有全局思想。)

      根据wiki上的解释,从几何上说,牛顿法就是用一个二次曲面去拟合你当前所处位置的局部曲面,而梯度下降法是用一个平面去拟合当前的局部曲面,通常情况下,二次曲面的拟合会比平面更好,所以牛顿法选择的下降路径会更符合真实的最优下降路径。

     

    注:红色的牛顿法的迭代路径,绿色的是梯度下降法的迭代路径。

    牛顿法的优缺点总结:

      优点:二阶收敛,收敛速度快;

      缺点:牛顿法是一种迭代算法,每一步都需要求解目标函数的Hessian矩阵的逆矩阵,计算比较复杂;

                       一定要有正定逆矩阵,极值点导数为零才有解,可能得不到结果。

    2)拟牛顿法(Quasi-Newton Methods)

      拟牛顿法是求解非线性优化问题最有效的方法之一,于20世纪50年代由美国Argonne国家实验室的物理学家W.C.Davidon所提出来。Davidon设计的这种算法在当时看来是非线性优化领域最具创造性的发明之一。不久R. Fletcher和M. J. D. Powell证实了这种新的算法远比其他方法快速和可靠,使得非线性优化这门学科在一夜之间突飞猛进。

      拟牛顿法的本质思想是改善牛顿法每次需要求解复杂的Hessian矩阵的逆矩阵的缺陷,它使用正定矩阵来近似Hessian矩阵的逆,从而简化了运算的复杂度。拟牛顿法和最速下降法一样只要求每一步迭代时知道目标函数的梯度。通过测量梯度的变化,构造一个目标函数的模型使之足以产生超线性收敛性。这类方法大大优于最速下降法,尤其对于困难的问题。另外,因为拟牛顿法不需要二阶导数的信息,所以有时比牛顿法更为有效。如今,优化软件中包含了大量的拟牛顿算法用来解决无约束,约束,和大规模的优化问题。

    共轭梯度法(Conjugate Gradient)

    共轭梯度法是介于最速下降法与牛顿法之间的一个方法,它仅需利用一阶导数信息,但克服了最速下降法收敛慢的缺点,又避免了牛顿法需要存储和计算Hesse矩阵并求逆的缺点,共轭梯度法不仅是解决大型线性方程组最有用的方法之一,也是解大型非线性最优化最有效的算法之一 在各种优化算法中,共轭梯度法是非常重要的一种。其优点是所需存储量小,具有步收敛性,稳定性高,而且不需要任何外来参数。

    [优化方法] 梯度下降法、最小二乘法、牛顿法、拟牛顿法、共轭梯度法

    梯度下降法是指参数不断沿着负梯度方向不断更新,直到最小值,其形象化表示如下图:

    批量梯度下降、随机梯度下降、小批量梯度下降

    最小二乘法,又叫做最小平方法,它通过最小化误差的平方和寻找数据的最佳函数匹配,思想比较简单,最小二乘法可以求出参数的解析解。下面仍然以线性回归为例说明最小二乘法的计算过程。

    1. 相比较于梯度下降,不需要选择步长。
    2. 如果样本量不大,且存在解析解,则最小二乘法是更好的选择。但是如果样本量很大,则求逆矩阵复杂度比较高,此时选择梯度下降更好。
    3. 计算速度很快。

    牛顿法一般有两个用途,一种是用于求方程的根,一种是用来求最值。下面将就这两个问题分开讨论。

      牛顿法是一种在实数域和复数域上近似求解方程的方法。方法使用函数(x)的泰勒级数的前面几项来寻找方程(x) = 0的根。牛顿法最大的特点就在于它的收敛速度很快

    牛顿法求方程的根

    牛顿法解方程的根的思想是利用泰勒公式的前几项来不断逼近f(x)=0 的根。f(x) f(x)泰勒公式的一阶展开式为:

    牛顿法求最值

    利用导数为0的f(x)点来,结合边界值,求取最大值或者最小值

    1. 相比较于梯度下降法,梯度下降法只引入了一阶导数信息,而牛顿法引入了二阶导数信息;
    2. 收敛速度快,但是需要计算海瑟矩阵的逆矩阵,计算较复杂;

    拟牛顿法:

    在牛顿法中,海瑟矩阵的逆需要计算,这一过程非常耗时,。。。。。主要包括DFP(Davidon-Fletcher-Powell)算法、BFGS(Broyden-Fletcher-Goldfarb-Shanno)算法和Broyden算法。

    1. 改善了牛顿法求海瑟矩阵的逆矩阵的计算复杂的缺陷,使用正定矩阵来近似海瑟矩阵的逆,简化了计算复杂度。

    共轭梯度法

    共轭梯度法是求解线性方程组的一种很有效的方法,当然也可以通过改进适用于非线性方程组,但是这里讲线性方程组的情况。

    共轭梯度法也是一个迭代求解的算法。它在梯度下降法的基础上进行了改良,梯度下降法的所有参数更新的方向是负梯度方向。在共轭梯度中,初始点的下降方向仍然是负梯度方,但后面的迭代方向是该点的负梯度方向和前一次迭代方向(共轭方向)形成的凸锥中的一个方向(大概就是两个方向的线性组合),这可以避免梯度下降的“锯齿”现象,如下图所示:

    绿色线条表示梯度下降的曲线,红色线条表示共轭梯度法下降的曲线。因为梯度下降法总是沿着负梯度方向进行一维搜索,所以相邻的迭代方向是正交的,所以会出现“锯齿”现象,而且刚开始下降很多,后来下降速度越来越慢。而共轭梯度法相当于每次搜索一个方向,但是搜索一步到位,不会出现“锯齿”现象。

    1. 克服了最速下降法收敛慢的缺点
    2. 避免了牛顿法需要存储计算海瑟矩阵并求逆矩阵的缺点
    3. 所需存储量小,可快速收敛,稳定性高,不需要参数,可避免梯度下降的“锯齿”现象。

    六、总结

    上述几种方法,除了最小二乘法是直接使用公式取得之外,另外几种方法都是使用迭代法进行求解。

    梯度下降法主要沿着负梯度方向进行更新,只引入了一阶导数。

    牛顿法则将一阶导数和二阶导数相结合进行参数的迭代更新,但是其二阶导数矩阵涉及到海瑟矩阵求逆,复杂度较高,因此基于牛顿法之上,出现了拟牛顿法,其主要思想是构造一个新的矩阵来近似替代海瑟矩阵的逆,这样可以避免牛顿法中的复杂的海瑟矩阵求逆操作。

    本质上来说,牛顿法是二阶收敛,而梯度下降是一阶收敛,所以牛顿法收敛更快,但是每次迭代的时间,牛顿法比梯度下降时间长。牛顿法就是用一个二次曲面去拟合你当前所处位置的局部曲面,而梯度下降法使用一个平面去拟合当前的局部曲面,所有牛顿法的下降路径会更简单,更符合最优路径。

    共轭梯度法基于梯度下降中的负梯度方向之外,引入了共轭向量,可以使收敛更快。

    牛顿法是二阶优化方法,拟牛顿法和共轭梯度法一般叫做1.5阶优化方法,梯度下降法及其变形则是一阶优化方法。

     

     

    参考:[优化方法] 梯度下降法、最小二乘法、牛顿法、拟牛顿法、共轭梯度法

    参考:常用的优化算法:梯度下降法,牛顿法,拟牛顿法,共轭梯度法

    参考:批量梯度下降(BGD)、随机梯度下降(SGD)以及小批量梯度下降(MBGD)的理解

    参考:梯度下降(Gradient Descent)小结

    参考:常见的几种最优化方法(梯度下降法、牛顿法、拟牛顿法、共轭梯度法等)

    参考:牛顿法-维基百科

    参考:梯度下降法和共轭梯度法有何异同?

    参考:共轭梯度法计算回归

    参考:共轭梯度法(Conjugate Gradient Method)

    参考:Second Order Optimization Algorithms I

    展开全文
  • 实现基于梯度上升法的PCA 参考bobo老师的机器学习课程,进行总结回顾 目录 基于梯度上升法的PCA原理 实现基于梯度上升法实现的PCA 用自制数据集验证手写的PCA 基于梯度上升法的PCA原理 PCA(Principal Component ...

    实现基于梯度上升法的PCA

    参考bobo老师的机器学习课程,进行总结回顾

    目录

    • 基于梯度上升法的PCA原理
    • 实现基于梯度上升法实现的PCA
    • 用自制数据集验证手写的PCA

    基于梯度上升法的PCA原理

    PCA(Principal Component Analysis):主成分分析
    可以用于数据降维,重新确定数据所在的空间的基,保留k个方差最大的基。

    故我们要找到令数据方差最大的基
    即寻找使样本空间上所有的点映射到这个轴后的方差最大Var(x)=1mi=1m(xixˉ)2Var(x) = \frac{1}{m}\sum\limits_{i=1}^m(x_i-\bar x)^2

    为了方便计算方差,我们会先对数据进行去均值(demean)处理,这样再计算投影点的方差时,无需再减去均值

    故我们需要寻找一个轴的方向 w = (w1,w2,…,wn)
    使得样本映射到w后,方差最大
    Var(Xproject)=1mi=1mXproject(i)2Var(X_{project}) = \frac{1}{m}\sum\limits_{i=1}^m||X_{project}^{(i)}||^2
    若令w的膜为1
    则上式=1mi=1mX(i)w2\frac{1}{m}\sum\limits_{i=1}^m||X^{(i)}\cdot w||^2

    故这是一个最优化问题,寻找w,令Var最大
    可以采用梯度上升法,对w进行求解


    maxwVar(Xproject)=1mi=1mX(i)w2\max\limits_{w} Var(X_{project}) = \frac{1}{m}\sum\limits_{i=1}^m||X^{(i)}\cdot w||^2
    对w求梯度

    这个可以展开,方便进行求解
    上式为1mi=1m(j=1nXj(i)wj)2\frac{1}{m}\sum\limits_{i=1}^m \big( \sum\limits_{j=1}^n X_j^{(i)}w_j\big)^2
    对其中的wjw_j求导为
    2mi=1m((j=1nXj(i)wj)Xj(i))\frac{2}{m}\sum\limits_{i=1}^m \Big((\sum\limits_{j=1}^n X_j^{(i)}w_j)X^{(i)}_j \Big)

    进行向量化后
    w的导数为2mXT(Xw)\frac{2}{m}X^T(Xw)
    故通过梯度上升法,可以确定出第一个主成分


    求出第一个主成分以后,如何求出下一个主成分?

    数据在第一个主成分上的分量上去掉在新数据上的第一主成分
    再进行上述梯度上升法,找到w


    高维数据如何映射为低维数据?
    Xk=XWTX_k = X W^T

    低维数据如何映射到高维数据?
    Xm=XkWX_m = X_k W

    实现基于梯度上升法实现的PCA

    import numpy as np
    class PCA_gradient():
        
        def __init__(self,n_component):
            self.n_component = n_component
            self.W = None #把基竖着写(和上述的原理不同之处)
        
        def fit(self,X):
            """获得数据集X的前n个主成分"""
            def demean(X):
                return X-X.mean(axis=0)
            
            def f(X,w):
                return np.sum(X.dot(w)**2)/len(X)
            
            def d_f(X,w):
                return X.T.dot(X.dot(w))*2/len(X)
            
            def debug_d_f(X,w,epsilon=1e-4):
                res = np.empty(len(w))
                for i in range(len(w)):
                    w1 = w.copy()
                    w1[i] += epsilon
                    w2 = w.copy()
                    w2[i] -= epsilon
                    res[i] = (f(X,w1) - f(X,w2))/(2*epsilon)
                return res
            
            def direction(w):
                return w/np.linalg.norm(w)
            
            def find_first_component(df,X,inital_w,eta=0.01,itertion=int(1e4),E=1e-12):
                w = inital_w
                w = direction(w)
                for _ in range(itertion):
                    w_old = w.copy()
                    w += eta * df(X,w)
                    w = direction(w)
                    if abs(f(X,w) - f(X,w_old))<E:
                        break
                print(w)
                return w
            
            assert self.n_component <= X.shape[1],"the num of dimension reduction feature must be less"
            
            X = demean(X)
            self.W = np.empty((self.n_component,X.shape[1]))
            for i in range(self.n_component):
                inital_w = np.random.random(X.shape[1])
                self.W[i] = find_first_component(d_f,X,inital_w)
                X = X - (X.dot(self.W[i])).reshape(-1,1)*self.W[i]
            
            self.W = self.W.T
        
        def transform(self,X_new):
            return X_new.dot(self.W)
        
        def reversetransform(self,X_new):
            return X_new.dot(self.W.T) 
    

    用自制数据集验证手写的PCA

    import numpy as np
    X = np.empty(shape=(100,2))
    X[:,0] = np.random.uniform(0,100,size=100)
    X[:,1] = X[:,0]*0.75 + 3 + np.random.normal(0,10,size=100)
    
    import matplotlib.pyplot as plt
    plt.scatter(X[:,0],X[:,1])
    
    pca = PCA_gradient(n_component=2)
    pca.fit(X)
    
    [0.77510722 0.63182972]
    [ 0.63182975 -0.7751072 ]
    
    pca.W
    
    array([[ 0.77510722,  0.63182975],
           [ 0.63182972, -0.7751072 ]])
    
    w1 = pca.W[:,0]
    w2 = pca.W[:,1]
    plt.figure(figsize=(5,5))
    plt.scatter(X[:,0],X[:,1])
    plt.plot([0,150*w1[0]],[0,150*w1[1]])
    plt.plot([60,60*w2[0]+60,60-60*w2[0]],[0,60*w2[1],-60*w2[1]])
    plt.xlim([0,100])
    plt.ylim([0,100])
    
    (0, 100)
    

    在这里插入图片描述

    pca = PCA_gradient(n_component=1)
    pca.fit(X)
    X_k = pca.transform(X)
    X_m = pca.reversetransform(X_k)
    
    [0.77510722 0.63182972]
    
    plt.scatter(X[:,0],X[:,1],alpha=0.5)
    plt.scatter(X_m[:,0],X_m[:,1],alpha=0.5)
    

    在这里插入图片描述
    验证无误~

    展开全文
  • 梯度下降 梯度下降来说,在神经网络中用到,最小化误差的一种优化方法。用梯度下降求函数f(x)=-2x^2+4x+5的极小值。

    梯度下降法

    梯度下降法来说,在神经网络中用到,最小化误差的一种优化方法。用梯度下降法求函数f(x)=2x^2+4x+5的极小值。
    在这里插入图片描述
    在此函数中,(-2,-1)区间,对任意一点xi,导数都为负数;
    在此函数中,(-1, 0)区间,对任意一点xi,导数都为正数;
    这样,在梯度下降中,公式 在这里插入图片描述就容易解释了,在(-2,-1)区间,导数在这里插入图片描述为负数,更新的在这里插入图片描述在增大,一直向最低点逼近;同样在(-1,-2)区间,导数在这里插入图片描述为正数,更新的在这里插入图片描述在减小,一直向最低点逼近。
    代码如下:

    # -*- coding: utf-8 -*-
    # @Time : 2019/12/18 17:06
    # @Author : Zhanghui
    
    import matplotlib.pyplot as plt
    import  numpy as np
    """
    梯度下降算法
    求函数f(x)=2x^2+4x+5的最小值
    """
    # 函数导数
    def Derivatives(old):
        return -4*old+4
    
    #梯度上升算法
    def GradientAscent():
        xcord = []  #保存x坐标
        ycord = []  #保存y坐标
        xnew = 0    #梯度算法的初始值
        alpha = 0.01 # 学习速率(一般根据经验和具体需要设置)
        maxCycle = 100 #学习次数
        for k in range(maxCycle):
            xold = xnew
            xnew = xold + alpha *Derivatives(xold) #梯度上升公式
            xcord.append(xnew)
            ycord.append(2*np.square(xnew) + 4*xnew+5)
        return xcord,ycord #返回每一次学习完后的x,y值
    
    #画图
    def plotFig(xcord,ycord):
        fig = plt.figure()
        ax = fig.add_subplot(111)
        ax.scatter(xcord, ycord, s=4, c='red', marker='s', alpha=.5) #绘制每次学习后x,y值
        x = np.arange(-2,0,0.01)
        y = 2*np.square(x) + 4*x+5
        ax.plot(x,y)            #绘制-2x^2+4x+5 函数
        plt.title('BestFit')  # 绘制title
        plt.xlabel('X')
        plt.ylabel('Y')  # 绘制label
        plt.show()
    
    if __name__== '__main__':
        xcord, ycord = GradientAscent()
        plotFig(xcord,ycord)
    

    梯度上升法

    在梯度上升法是在逻辑回归中求概率最大值,即求最大似然函数的最大值用到的方法,求函数f(x)=-2x^2+4x+5的极大值为例。
    在这里插入图片描述
    在此函数中,(0,1)区间,对任意一点xi,导数都为正数;
    在此函数中,(1, 2)区间,对任意一点xi,导数都为负数;
    这样,在梯度下降中,公式 在这里插入图片描述就容易解释了,在(0,1)区间,导数在这里插入图片描述为正数,更新的在这里插入图片描述在增大,一直向最高点逼近;同样在(1,2)区间,导数在这里插入图片描述为负数,更新的在这里插入图片描述在减小,一直向最高点逼近。
    代码示例:

    # -*- coding: utf-8 -*-
    # @Time : 2019/12/18 17:06
    # @Author : Zhanghui
    
    import matplotlib.pyplot as plt
    import  numpy as np
    """
    梯度上升算法
    求函数f(x)=-2x^2+4x+5的最大值
    """
    # 函数导数
    def Derivatives(old):
        return -4*old+4
    
    #梯度上升算法
    def GradientAscent():
        xcord = []  #保存x坐标
        ycord = []  #保存y坐标
        xnew = 0    #梯度算法的初始值
        alpha = 0.01 # 学习速率(一般根据经验和具体需要设置)
        maxCycle = 100 #学习次数
        for k in range(maxCycle):
            xold = xnew
            xnew = xold + alpha *Derivatives(xold) #梯度上升公式
            xcord.append(xnew)
            ycord.append(-2*np.square(xnew) + 4*xnew+5)
        return xcord,ycord #返回每一次学习完后的x,y值
    
    #画图
    def plotFig(xcord,ycord):
        fig = plt.figure()
        ax = fig.add_subplot(111)
        ax.scatter(xcord, ycord, s=4, c='red', marker='s', alpha=.5) #绘制每次学习后x,y值
        x = np.arange(0,2,0.01)
        y = -2*np.square(x) + 4*x+5
        ax.plot(x,y)            #绘制-2x^2+4x+5 函数
        plt.title('BestFit')  # 绘制title
        plt.xlabel('X')
        plt.ylabel('Y')  # 绘制label
        plt.show()
    
    if __name__== '__main__':
        xcord, ycord = GradientAscent()
        plotFig(xcord,ycord)

    反向推理,就能明白梯度上升为什么是加梯度,而梯度下降是减梯度。

    展开全文
  • 梯度上升用来求函数的最大值,梯度下降用来求函数的最小值。 转载于:https://www.cnblogs.com/bafenqingnian/p/8706747.html
  • 梯度上升法,梯度下降法

    万次阅读 2015-08-29 09:59:56
    梯度下降的思想:假设现在要求上图中函数f(x)的最小值,先选择一个初始点,下一个点的产生是沿着梯度直线方向(本函数求最小值是沿着梯度负方向,若求最大值则沿着梯度方向)为什么叫梯度上升和梯度下降呢?...
  • 其中为第i组数据的independent variable,为第i组数据的dependent variable,为系数向量。 最小二乘法,如上所示。...此时使用梯度下降法或者梯度上升法我们仅仅把数字输入,进行简单的计算即可
  • 回忆一下,我们要想求出一个目标函数的最大值,我们就可以使用梯度上升法来解决。   这篇博客主要就是来推导一下梯度上升法解决 PCA 问题相应的公式。 推导过程   在这里,我们的目标就是:   这里我们不再...
  • PCA与梯度上升法1 什么是PCA2 使用梯度上升法求解PCA问题3 求数据的主成分PCA4 求数据的前n个主成分5 高维数据映射为低纬数据6 scikit-learn中的PCA7 试手MNIST数据集8 使用PCA对数据进行降噪9 人脸识别与特征脸 ...
  • 使用梯度上升法解决主成分分析问题
  • 【机器学习】Logistic回归的梯度上升法
  • 上篇讲的是PCA基于矩阵操作方法的实现,本文讲的是基于梯度上升法实现的PCA。 PCA之梯度上升法PCA原理主成分分析PCA均值归零(demean)映射轴和方差梯度上升法代码实现单个主成分分析多个主成分分析 PCA原理 假设...
  • 主成分分析法:主要作用是降维 疑似右侧比较好? 第三种降维方式: 问题:?????...方差:描述样本整体分布的疏密的指标,方差越大,样本之间越稀疏;...使用梯度上升法解决PCA问题: ...
  • 1.梯度上升法def gradascent(datamatin,classlabels): datamat=mat(datamatin) labelmat=mat(classlabels).transpose() m,n=shape(datamat) alpha=0.001 maxcycles=500 weights=ones((n,1))
  • 7-2 使用梯度上升法求解PCA问题 7-3 求数据的主成分PCA demean 梯度上升法 使用极端数据集测试 7-1 什么是PCA 降维后 同理去掉特征一,降维则为 那个方案更好呢,右边的,在x轴上点集间距离大,有...
  • 本文接着上一篇《Logistic回归分类----梯度上升法》,升级为随机梯度上升法。同理,《机器学习实战》一书改编而来,测试数据依然保存在网盘上,https://pan.baidu.com/s/1qY9jFsg。相比梯度上升算法,随机梯度上升...
  • 教你用梯度上升法解决N皇后问题 一、最陡梯度上升法1.先上代码#ifndef GA #define GA #include #include using namespace std; class queen { private: int size; int eva_now; int *list; void init() { for...
  • PCA梯度上升法

    2020-07-22 15:21:04
    其中,初始化的w向量不能为零向量(虽然在昨天学的梯度下降中是可以的) 三、不能使用StanderdScaler标准化变量,因为PCA求主成分的时候是想求一个轴,使样本映射上去的时候方差最大,但标准化之后方差就唯一了,...
  • Python3入门机器学习 5.2 使用梯度上升法求解PCA问题
  • 在一元一次函数中,函数的斜率可以代表函数在 ...梯度上升法更新系数的公式: ,我们已经知道其中 为 变化的方向, α 则为每次在这个方向走的步长,也成为学习率。 梯度下降法更新系数的公式:
  • 1 什么是PCA 主成分分析: ●一个非监督的机器学习算法 ●主要用于数据的降维。通过降维,可以发现更便于人类理解的特征 ●其他应用:可视化;去噪 2 使用梯度上升法求解PCA问题 ...
  • 梯度上升法(定义函数) In [ 99 ] : def f ( w , X ) : . . . : return np . sum ( ( X . dot ( w ) ** 2 ) ) / len ( X ) In [ 100 ] : def df_math ( w , X ) : . . . : return X...
  • 利用梯度公式 $\nabla f = \frac{2}{m}·X^T(Xw)$ 的梯度上升法实际上是批量梯度上升法(还有随机梯度上升法和小批量梯度上升法,本文不涉及)。 梯度上升法求主成分 求第一主成分 首先定义一组有两个特征的数据集 $X...
  • 方案:梯度上升法优化效用函数,找到其最大值时对应的主成分 w ; 效用函数中,向量 w 是变量; 在最终要求取降维后的数据集时,w 是参数;  1)推导梯度求解公式 变形一   变形二   ...
  • 一、什么是PCA 主成分分析 Principal Component Analysis 一个非监督学的学习算法 主要用于数据的降维 通过降维,可以发现更便于人类理解的特征 其他应用:可视化;...二、使用梯度上升法求解PC...
  • 非监督学习,没有y的信息 还可以写成这样 向量化!
  • 目录7-1 什么是PCA 降维后 同理去掉特征一,降维则为 那个方案更好呢...方差样本的疏密 所有的样本减去整体样本的均值 dmean后式子化简为这样 X是向量,demean后为零 w是单位方向向量 主成分分析有很强的数学原理...
  • http://sbp810050504.blog.51cto.com/2799422/1608064/这个网址解释了多维空间的sigmoid函数与梯度上升算法的原理,大家可以参考一下。 from numpy import * def loadDataSet():#读数据 dataMat = [] labelMat = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 610
精华内容 244
关键字:

梯度上升法