精华内容
下载资源
问答
  • 强化学习算法

    万次阅读 2018-03-04 22:15:03
    强化学习算法是机器学习大家族中的一类,使用强化学习能够让机器学着如何在环境中拿到高分表现出优秀的成绩,而这些成绩背后所付出的努力,是不断的试错,不断尝试,累加经验,学习经验。 强化学习是一个大家族,...

    https://blog.csdn.net/AMDS123/article/details/70197796总结的不错。

    强化学习算法是机器学习大家族中的一类,使用强化学习能够让机器学着如何在环境中拿到高分表现出优秀的成绩,而这些成绩背后所付出的努力,是不断的试错,不断尝试,累加经验,学习经验。

    强化学习是一个大家族,包括许多中算法,比如通过行为的价值来选去特定行为的方法,抱括使用表格学习的q learning,sarsa,使用神经网络学习的deep q network,还有直接输出行为的policy gradients ,有或者了解所处的环境,想象出一个虚拟的环境病虫虚拟环境中学习等。

    强化学习算法包括 Q-learning、sarsa、deep Q Network、policy Gradient、Actor Critic等等

    当前机器学习算法有三种:监督学习、无监督学习和强化学习(RL);

    RL是在尝试的过程中学习到在特定的情境下选择哪种行动可以得到最大的回报。在很多场景中,当前的行动不仅会影响当前的rewards,还会影响之后的状态和一系列的rewards。RL最重要的3个特定在于:(1):基本是一种闭环的形式;(2)不会直接指示选择哪种行动(actions);一系列的actions和奖励信号(reward signals)都会影响之后较长时间。

    RL与有监督学习、无监督学习的比较;

    (1)有监督学习是从一个已经有标记的训练集中学习,训练集中每个样本的的特征可以视为是对该sitiuation的描述,而其label可以视为是应该执行的正确的action,但是有监督的学习不能学习交互的情景,因为在交互的问题中期望行为的样例是非常不实际的,agent智能从自己的经历(experience)中进行学习,而experience中采取的行为并不一定是最优的,这是RL就是非常合适的,因为RL不是利用正确的行为进行指导,而是利用已有的训练信息来对行为进行评价。

    (2)因为RL利用的并不是采取正确行动的experience,从这点看和无监督学习的确有些相像,但是还是不一样,无监督学习的目的可以说是从一堆未标记样本中发现隐藏的结构,而RL的目的是最大化reward signal。

    (3)总的来说,RL与其它机器学习算法 不同地方在于:其中没有监督者,只有一个reward信号,反馈是延迟的,不是立即生成的;时间在RL中具有重要意义;agent的行为会影响之后的一系列data。

    RL采用的是边获得样例边学习的方式,在获得样例之后更新自己的模型,利用当前的模型来指导下一步的行动,下一步的行动获得reward之后再更新模型,不断迭代重复直到模型收敛。在这个过程中,非常重要的一点在于“在已有当前模型的情况下,如果选择下一步的行动才对完善当前的模型最有利”,这就涉及到了RL中的两个非常重要的概念:探索(exploration)和开发(exploitation),exploration是指选择之前未执行过的actions,从而探索更多的可能性;exploitation是指选择已执行过的actions,从而对已知的actions的模型进行完善。

    举一个简单的例子,f(x)在一个未知的[a,b]的连续函数,现在让你选择一个x使得f(x)取最大值,规则是你可以通过自己给定的x来查看其所对应的f(x),假如通过[a,0]之间的几次尝试,你会发现在x1附近的时候值较大,于是你想通过在x1附近不断的尝试和逼近来寻找这个可能的最大值,这个就成为开发(exploition),但是在[0,b]之间是个未探索过的领域,这是选择这一部分就称为是exploration,如果不尽兴exploration也许只会找到局部最优的极值。exploration和exploition在RL中同等重要,如何在探索(exploration)和开发(exploition)之间权衡是RL中的一个重要问题和挑战。

    在RL中,agents是具有明确的目标的,所有的agents都能感知自己的环境,并根据目标来指导自己的行为,因此RL的另一个特点是他将agents和与其交互的不确定的环境为是一个完整的问题,在RL中有四个非常重要的概念:

    (1)规则(policy)

    policy定义了agents在特定的时间特定的环境下的行为方式,可以视为是从环境状态到行为的映射;

    展开全文
  • 【强化学习】什么是强化学习算法

    千次阅读 多人点赞 2019-02-26 20:56:56
    【强化学习】什么强化学习算法?一、强化学习解决什么问题?二、强化学习如何解决问题?2.1、强化学习的基本框架2.2、强化学习系统的要素2.3、强化学习与监督学习的区别2.4、强化学习与非监督学习的区别三、强化学习...


    本博文通过参考《深入浅出强化学习原理入门》的第一章与《Reinforcement Learning: An Introduction》的Chapter 1部分和知乎专栏,解释什么是强化学习算法。

    一、强化学习解决什么问题?

    强化学习的经典应用案例有:非线性二级摆系统(非线性控制问题)、棋类游戏、机器人学习站立和走路、无人驾驶、机器翻译、人机对话 等。概括来说,强化学习所能解决的问题为序贯决策问题,就是需要连续不断做出决策,才能实现最终目标的问题。强化学习与其它的机器学习方法相比,专注于从交互中进行以目标为导向的学习。

    二、强化学习如何解决问题?

    强化学习主要是学习What to do(在当前情况下该如何选择动作),就是如何将情况(situations)与动作(actions)对应起来,以达到最大化的数值奖励信号。

    2.1、强化学习的基本框架

    强化学习的基本框架如下图所示,强化学习的主体一般被称为agent,其与environment互动以达到某种目的。所有强化学习的agent有明确的目标,能够感知全部或者部分environment,并且选择action执行来影响environment。除此之外,还要假设在最开始,agent需要在对于所面对的environment一无所知的情况下采取行动。
    强化学习框架
    强化学习的三个特征:(1)强化学习是一个闭环问题。(2)没有直接对该如何选择action的指示,需要试探搜索去发现哪个动作会产生最大的数值奖励。(3)动作不光会影响直接的奖励,还会影响接下来的环境状态。

    2.2、强化学习系统的要素

    一个强化学习系统一般包括如下的几个要素:
    (1)policy(策略)
    policy是从感知到的environment的state到在这些state下要执行的action的映射。这对应于心理学中stimulus-response rules or associations(应激-反应规则或关联)。在一些情况下,policy可以是简单的函数或者是查表。而在别的情况下,可能会需要更多的计算,例如暴力搜索。policy是强化学习agent的核心,因为一个policy便可以单独决定agent的行为。另外,policy也可能是随机的。
    (2)reward signal(奖励信号)
    reward signal定义了强化学习问题的目标(goal)。在每个时间步内,environment给agent发送一个奖励值。agent唯一的目标便是在长时间运行中最大化接收到的总的reward。reward signal定义了一件事对于agent来说是好是坏。任一时刻发送给agent的reward取决于agent当前的action以及当前environment的state。agent影响reward signal的唯一方式就是通过action直接影响reward,或者通过改变environment的state间接影响。reward signal是改变policy的首要基础。如果一个policy选择了低reward的action,则之后在同样情况下,policy可能会改为选其他的action。总的来说,reward signal可能是environment state和采取的action的函数(也可以带有随机性)。
    (3)value function(值函数)
    reward signal表示的是在直接感受下哪个是好的。而value function则是表示从长期来看,什么是好的。也就是state的value(价值)是一个agent从当前state开始,在未来期望累积的总的reward。reward定义的是环境state直接的好处,而value是state长期的好处,考虑了之后可能会出现的state以及这些state下的reward。例如一个state可能会产生一个低的reward,但是有着高的value,因为跟着它的通常是一些会产生高reward的state。反之亦然。

    reward是首要的,而value是其次的,因为没有reward就没有value。但是当我们做决策并对决策进行评估时,更关注的是value。对于action的选择是基于value来判断的。我们追寻的是带来最高value的state而不是最高的reward,因为这些action从长远上来讲会获得最多的reward。但不幸的是,决定value要比决定reward难得多。reward是由environment直接给出的,但是value是需要对agent的整个执行时间内的状况进行观察,以此对value进行估计和重估计。事实上,强化学习算法中最重要的部分就是如何有效地估计value。
    (4)model of the environment(环境模型)
    model of the environment是用来模拟真实environment的行径的,或者说是对environment会如何表现的推断。例如,给定一个state和action,这个model会预测因此产生的下一state和下一reward。model一般用在planning(规划)里,可以在真正执行之前通过考虑未来的可能情况来决定一系列动作。利用model和planning用来解决强化学习问题的方法被称为model-based方法,作为更简单的model-free方法的对照。model-free方法主要是指通过trial-and-error(试错)学习,是planning的对立。(就是planning不需要直接执行action与真实的environment互动,可以对environment建模,然后自己跟这个environment模型互动。这样就叫planning)

    2.3、强化学习与监督学习的区别

    监督学习需要的是标签数据,通过训练获得模型来推断那些不在训练集中的样本的标签应该是什么,监督学习的主要目的是总结概括。强化学习需要的是带有回报的交互数据,agent需要通过从自己的经验中学习如何使自己的利益最大化。

    2.4、强化学习与非监督学习的区别

    非监督学习一般是寻找未标注数据中同一类的结构信息,而强化学习专注于为agent实现reward最大化。

    三、强化学习实例

    3.1、训练Tic-Tac-Toe游戏玩家的强化学习理解

    Tic-Tac-Toe(井字棋)游戏:两名玩家轮流在一个三乘三的棋盘上比赛。 一个玩家画X和另一个玩家画O,直到一个玩家通过在水平,垂直或对角线上连续放置三个标记来获胜(下图表示画X的玩家获胜)。如果整个表都被填满了而没有人获胜,那么比赛就是平局。 由于一个比较熟练的玩家可以保证不败,我们假设我们的对手并不是一个完美的玩家,有时他会下错地方。我们认为输和平局对我们来说是一样坏的,我们该如何构建一个玩家,其能够发现对手的不完美并且学习如何最大化自己获胜的可能性?
    在这里插入图片描述
    本博文介绍基于value function的强化学习来训练tic-tac-toe游戏玩家的方法。首先对这个游戏每个可能的state建立一个数表,每个数都是从这个state开始获胜概率的最新估计。我们把这个估计看做这个state的value。若State A有比B更高的value,说明A比B好,也就是当前估计下,从state A开始获胜的概率比从B开始大。

    假设我们是下X的,那么所有有三个X在一行(一列,斜对角)的state的获胜概率是1,所有三个O在一行(一列,斜对角)或者填满(平局)的state的获胜概率是0,其余所有state的初始概率是0.5,代表我们猜测我们有一半几率获胜。

    强化学习训练过程中,需要权衡Exploration 和 Exploitation的平衡关系(参考资料4),下面的Tic-Tac-Toe游戏的python代码利用的是greedgreed and εgreed\varepsilon - greed 的方法。与对手玩多轮游戏。为了选择下一步该下在哪,我们检测了我们每一个可能的落子之后产生的state,在表中查询他们当前的value。一般情况下,我们是greedy的,也就是选择那些会导致有最高value的state的地方落子,也就是有最高获胜可能性的地方。偶尔,我们会在其他位置里随机选一个落子。这种叫exploratory(试探性的)的落子,因为这能让我们去经历之前没见过的state。

    在玩这个游戏的过程中,不停改变这些state的value,尽可能让它们更准确地估计获胜概率。每一次落子之后,将之前state的value向之后state的value靠近。ss表示落子之前的state,ss'表示落子之后的state,V(S)V\left( S \right)表示ss对应的value,对于V(S)V\left( S \right)的更新可以写为:

    V(S)V(S)+α[V(S)V(S)]V\left( S \right) \leftarrow V\left( S \right) + \alpha \left[ {V\left( {S'} \right) - V\left( S \right)} \right]

    α\alpha为步长,是一个小的分数,影响学习率。这种更新规则被称作temporal-difference(时间差分)学习方法。因为其更新是基于两个不同时间对value的估计之差V(S)V(S){V\left( {S'} \right) - V\left( S \right)}的。
    如果步长参数随着时间适当减小,对于任意固定的对手,这个方法是可以收敛到每个state下我们真实的获胜概率的。更进一步地,我们所选择的落子的地方(除了exploratory的选择)事实上都是对抗对手最优的选择。也就是说,这种方法能够收敛到最优的policy。

    强化学习可以应用于系统的高阶和低阶。虽然井字游戏的玩家只学习了游戏的基本动作,但没有什么能阻止强化学习在更高的层次上进行,在这个层次上,每个动作“可能本身就是一种精心设计的解决问题方法的应用”。在分层学习系统中,强化学习可以在多个层次上同时进行。

    3.2、训练Tic-Tac-Toe游戏玩家的python代码

    import numpy as np
    import pickle
    
    BOARD_ROWS = 3   ##棋盘行数
    BOARD_COLS = 3   ##棋盘列数
    BOARD_SIZE = BOARD_ROWS * BOARD_COLS
    
    class State:  
        def __init__(self):
            # the board is represented by an n * n array,
            # 1 represents a chessman of the player who moves first,
            # -1 represents a chessman of another player
            # 0 represents an empty position
            self.data = np.zeros((BOARD_ROWS, BOARD_COLS))
            self.winner = None
            self.hash_val = None
            self.end = None
    
        # compute the hash value for one state, it's unique
        def hash(self):
            '''计算棋盘不同state对应的hash值
            '''
            if self.hash_val is None:
                self.hash_val = 0
                for i in self.data.reshape(BOARD_ROWS * BOARD_COLS):
                    if i == -1:
                        i = 2
                    self.hash_val = self.hash_val * 3 + i
            return int(self.hash_val)
    
        # check whether a player has won the game, or it's a tie(监测是否有玩家获胜或平局)
        def is_end(self):
            if self.end is not None:
                return self.end
            results = []
            # check row
            for i in range(0, BOARD_ROWS):
                results.append(np.sum(self.data[i, :]))
            # check columns
            for i in range(0, BOARD_COLS):
                results.append(np.sum(self.data[:, i]))
    
            # check diagonals
            results.append(0)
            for i in range(0, BOARD_ROWS):
                results[-1] += self.data[i, i]
            results.append(0)
            for i in range(0, BOARD_ROWS):
                results[-1] += self.data[i, BOARD_ROWS - 1 - i]
    
            for result in results:
                if result == 3:
                    self.winner = 1
                    self.end = True
                    return self.end
                if result == -3:
                    self.winner = -1
                    self.end = True
                    return self.end
    
            # whether it's a tie(当棋盘下满还没有胜负,则游戏为平局)
            sum = np.sum(np.abs(self.data))
            if sum == BOARD_ROWS * BOARD_COLS:
                self.winner = 0
                self.end = True
                return self.end
    
            # game is still going on
            self.end = False
            return self.end
    
        # @symbol: 1 or -1
        # put chessman symbol in position (i, j)
        def next_state(self, i, j, symbol):
            new_state = State()
            new_state.data = np.copy(self.data)
            new_state.data[i, j] = symbol
            return new_state
    
        # print the board
        def print(self):
            for i in range(0, BOARD_ROWS):
                print('-------------')
                out = '| '
                for j in range(0, BOARD_COLS):
                    if self.data[i, j] == 1:
                        token = '*'
                    if self.data[i, j] == 0:
                        token = '0'
                    if self.data[i, j] == -1:
                        token = 'x'
                    out += token + ' | '
                print(out)
            print('-------------')
    
    def get_all_states_impl(current_state, current_symbol, all_states):
        for i in range(0, BOARD_ROWS):
            for j in range(0, BOARD_COLS):
                if current_state.data[i][j] == 0:
                    newState = current_state.next_state(i, j, current_symbol)
                    newHash = newState.hash()
                    if newHash not in all_states.keys():
                        isEnd = newState.is_end()
                        all_states[newHash] = (newState, isEnd)
                        if not isEnd:
                            get_all_states_impl(newState, -current_symbol, all_states)
    
    def get_all_states():
        current_symbol = 1
        current_state = State()
        all_states = dict()
        all_states[current_state.hash()] = (current_state, current_state.is_end())
        get_all_states_impl(current_state, current_symbol, all_states)
        return all_states
    
    # all possible board configurations
    all_states = get_all_states()
    
    class Judger:
        # @player1: the player who will move first, its chessman will be 1
        # @player2: another player with a chessman -1
        # @feedback: if True, both players will receive rewards when game is end
        def __init__(self, player1, player2):
            self.p1 = player1
            self.p2 = player2
            self.current_player = None
            self.p1_symbol = 1
            self.p2_symbol = -1
            self.p1.set_symbol(self.p1_symbol)
            self.p2.set_symbol(self.p2_symbol)
            self.current_state = State()
    
        def reset(self):
            self.p1.reset()
            self.p2.reset()
    
        def alternate(self):
            while True:
                yield self.p1
                yield self.p2
    
        # @print: if True, print each board during the game
        def play(self, print=False):
            alternator = self.alternate()
            self.reset()
            current_state = State()
            self.p1.set_state(current_state)
            self.p2.set_state(current_state)
            while True:
                player = next(alternator)
                if print:
                    current_state.print()
                [i, j, symbol] = player.act()
                next_state_hash = current_state.next_state(i, j, symbol).hash()
                current_state, is_end = all_states[next_state_hash]
                self.p1.set_state(current_state)
                self.p2.set_state(current_state)
                if is_end:
                    if print:
                        current_state.print()
                    return current_state.winner
    
    # AI player
    class Player:
        # @step_size: the step size to update estimations
        # @epsilon: the probability to explore
        def __init__(self, step_size=0.1, epsilon=0.1):
            self.estimations = dict()
            self.step_size = step_size
            self.epsilon = epsilon
            self.states = []
            self.greedy = []
    
        def reset(self):
            self.states = []
            self.greedy = []
    
        def set_state(self, state):
            self.states.append(state)
            self.greedy.append(True)
    
        def set_symbol(self, symbol):
            self.symbol = symbol
            for hash_val in all_states.keys():
                (state, is_end) = all_states[hash_val]
                if is_end:
                    if state.winner == self.symbol:
                        self.estimations[hash_val] = 1.0
                    elif state.winner == 0:
                        # we need to distinguish between a tie and a lose
                        self.estimations[hash_val] = 0.5
                    else:
                        self.estimations[hash_val] = 0
                else:
                    self.estimations[hash_val] = 0.5
    
        # update value estimation
        def backup(self):
            # for debug
            # print('player trajectory')
            # for state in self.states:
            #     state.print()
    
            self.states = [state.hash() for state in self.states]
    
            for i in reversed(range(len(self.states) - 1)):
                state = self.states[i]
                td_error = self.greedy[i] * (self.estimations[self.states[i + 1]] - self.estimations[state])
                self.estimations[state] += self.step_size * td_error
    
        # choose an action based on the state
        def act(self):
            state = self.states[-1]
            next_states = []
            next_positions = []
            for i in range(BOARD_ROWS):
                for j in range(BOARD_COLS):
                    if state.data[i, j] == 0:
                        next_positions.append([i, j])
                        next_states.append(state.next_state(i, j, self.symbol).hash())
    
            if np.random.rand() < self.epsilon:
                action = next_positions[np.random.randint(len(next_positions))]
                action.append(self.symbol)
                self.greedy[-1] = False
                return action
    
            values = []
            for hash, pos in zip(next_states, next_positions):
                values.append((self.estimations[hash], pos))
            np.random.shuffle(values)
            values.sort(key=lambda x: x[0], reverse=True)
            action = values[0][1]
            action.append(self.symbol)
            return action
    
        def save_policy(self):
            with open('policy_%s.bin' % ('first' if self.symbol == 1 else 'second'), 'wb') as f:
                pickle.dump(self.estimations, f)
    
        def load_policy(self):
            with open('policy_%s.bin' % ('first' if self.symbol == 1 else 'second'), 'rb') as f:
                self.estimations = pickle.load(f)
    
    # human interface
    # input a number to put a chessman
    # | q | w | e |
    # | a | s | d |
    # | z | x | c |
    class HumanPlayer:
        def __init__(self, **kwargs):
            self.symbol = None
            self.keys = ['q', 'w', 'e', 'a', 's', 'd', 'z', 'x', 'c']
            self.state = None
            return
    
        def reset(self):
            return
    
        def set_state(self, state):
            self.state = state
    
        def set_symbol(self, symbol):
            self.symbol = symbol
            return
    
        def backup(self, _):
            return
    
        def act(self):
            self.state.print()
            key = input("Input your position:")
            data = self.keys.index(key)
            i = data // int(BOARD_COLS)
            j = data % BOARD_COLS
            return (i, j, self.symbol)
    
    def train(epochs):
        player1 = Player(epsilon=0.01)
        player2 = Player(epsilon=0.01)
        judger = Judger(player1, player2)
        player1_win = 0.0
        player2_win = 0.0
        for i in range(1, epochs + 1):
            winner = judger.play(print=False)
            if winner == 1:
                player1_win += 1
            if winner == -1:
                player2_win += 1
            print('Epoch %d, player 1 win %.02f, player 2 win %.02f' % (i, player1_win / i, player2_win / i))
            player1.backup()
            player2.backup()
            judger.reset()
        player1.save_policy()
        player2.save_policy()
    
    def compete(turns):
        player1 = Player(epsilon=0)
        player2 = Player(epsilon=0)
        judger = Judger(player1, player2)
        player1.load_policy()
        player2.load_policy()
        player1_win = 0.0
        player2_win = 0.0
        for i in range(0, turns):
            winner = judger.play()
            if winner == 1:
                player1_win += 1
            if winner == -1:
                player2_win += 1
            judger.reset()
        print('%d turns, player 1 win %.02f, player 2 win %.02f' % (turns, player1_win / turns, player2_win / turns))
    
    # The game is a zero sum game. If both players are playing with an optimal strategy, every game will end in a tie.
    # So we test whether the AI can guarantee at least a tie if it goes second.
    def play():
        while True:
            player1 = HumanPlayer()
            player2 = Player(epsilon=0)
            judger = Judger(player1, player2)
            player2.load_policy()
            winner = judger.play()
            if winner == player2.symbol:
                print("You lose!")
            elif winner == player1.symbol:
                print("You win!")
            else:
                print("It is a tie!")
    
    if __name__ == '__main__':
        ##两个AI玩家进行强化学习训练
        train(int(1e5))
        ##两个AI玩家进行强化学习测试
        compete(int(1e3))
        ##human玩家与AI玩家比赛
        play()
    

    参考资料

    1、《深入浅出强化学习原理入门》
    2、《Reinforcement Learning: An Introduction》
    3、https://zhuanlan.zhihu.com/p/50347818
    4、https://blog.csdn.net/LagrangeSK/article/details/81010195

    展开全文
  • 强化学习算法的总结

    千次阅读 2020-04-21 20:15:44
    强化学习算法依据马尔科夫的决策过程主要分为两大类,分别是基于模型的强化学习算法(动态规划法等)和无模型的强化学习算法(蒙特卡洛算法等)。这些强化学习算法的核心思想是学习者通过自身的不断学习最终使得整个...

    强化学习算法依据马尔科夫的决策过程主要分为两大类,分别是基于模型的强化学习算法(动态规划法等)无模型的强化学习算法(蒙特卡洛算法等)。这些强化学习算法的核心思想是学习者通过自身的不断学习最终使得整个学习过程中获得的奖惩值达到最大(既通过行为选择,最终获得最优策略)。
    行为选择的方主要有两种方法:
    (1)贪婪算法:即通过选择某一行为使得获得的行为值函数达到做大,如果最大的值不唯一,则从中进行随机选择,即。
    (2)-贪婪方法:-贪婪方法改善了贪婪算法存在的不足,因为贪婪算法每次选择行为,都要选当前的行为值函数达到最大的行为,但是这样会使得选择的行为的种类较少,就会出现良好总可能性,第一种会很快使得状态值函数收敛,第二种情况则会可能使得状态值函数一直不会收敛(虽然第二种情况的可能性较小,但是仍然是有一些不足),所以可以采取-贪婪方法。这种方法有两种选择行为的规则,第一种规则是随机等概率地从可选的行为中选择其中一种,第二种规则贪婪方法相同。-贪婪方法的具体实现方式为:每隔一段时间就会对两种规则进行选择,第一种规则发生的概率为(通常为一个很小的数值),第二种规则发生的概率为,且该规则只对一次的行为选择有效。剩余的时间都将采用第二种规则。
    获得最优策略的方式主要有三种:策略迭代,值迭代和策略搜索
    策略迭代和值迭代又属于基于值函数估计的方法(当状态空间和动作空间都是离散的且不能太大,值函数可以用一张表格来表示,也叫表格型强化学习算法)或者基于值函数逼近的方法(当状态空间维数很大或者状态空间为连续空间时)。策略迭代和值迭代又都包括策略评估和策略改进两个过程。两者的不同在于:策略迭代是等到策略评估所获得的状态值函数收敛之后才采用贪婪算法进行策略的改进(就是在所有获得的状态值函数里,选择产生最大Q(s,a)的).该方法交替进行,一个完成另一个开始。值迭代不需要等到策略评估所获得的值函数全部收敛,而是策略评估一次之后,就采用贪婪算法进行策略改进。而策略搜索属于基于策略逼近的算法。在无模型的强化学习算法中,三种最优策略的方法,每一个方法又细分为在线(同策略的Sarsa算法等)和离线(Qlearning算法等)两种形式。如图(1)和(2)所示。
    (1)强化学习算法的分类
    (2)强化学习算法的分类
    时间差分法
    时间差分法是无模型的强化学习算法,它结合了蒙特卡洛算法和动态规划方法。是一种基于经验学习并且以估值更新值函数的强化学习算法。具体结合了蒙特卡洛算法的基于试验的的思路和动态规划方法中的自举的方法从而形成了自己独特的更新状态值函数的方法。包括TD(0),TD(1),…TD(n),Q学习算法和Sarsa等算法。TD(1)算法为用下一时刻的状态值函数更新当前的状态值函数,TD(2)用后继的第二状态值函数更新当前的状态值函数。以此类推TD(n)算法用后继的第n个状态值函数来更新当前的状态值函数。因此通过类比可知TD(0)是随走随更新。
    Sarsa算法:为在线(同策略)的强化学习算法。既在策略评估的过程中行动策略和评估策略都是-贪婪策略。如图(3).
    (3)Sarsa算法
    Qlearning算法:为离线(异策略)的强化学习算法。既在策略评估的过程中它的行动策略为-贪婪策略,评估策略为贪婪策略如图(4)所示。
    (4)Q学习算法

    展开全文
  • 强化学习算法实现自动炒股

    千次阅读 2020-06-29 10:08:55
    强化学习算法自动炒股 本文利用强化学习算法 PG,来对股票市场的指数进行交易研究 感兴趣的朋友可以在这个基础上导入其他市场的数据,添加 observation 的维度(本文仅使用了“当天收盘价”和“与前一天收盘价的差值...

    强化学习算法自动炒股

    本文利用强化学习算法 PG,来对股票市场的指数进行交易研究

    感兴趣的朋友可以在这个基础上导入其他市场的数据,添加 observation 的维度(本文仅使用了“当天收盘价”和“与前一天收盘价的差值”两个维度)

    操作 action 设置了 2 个维度 :short 和 long

    添加多个维度的数据,再对多个股票进行算法训练,一定会使得该模型更具有鲁棒性,希望大家多多尝试

    百度深度学习算法库 PARL ,以及搭建股票测试环境的 gym-anytrading 网址附在下面,用起来感觉不错的可以去 github 上给她们点 star

    环境依赖

    paddlepaddle

    parl,网址:https://github.com/PaddlePaddle/PARL

    gym

    gym-anytrading,网址:https://github.com/AminHP/gym-anytrading

    提醒:

    数据和方法皆来源于网络,无法保证有效性,仅供学习和研究!

    代码实现:

    github 地址:https://github.com/Ryan906k9/stock_pg

    展开全文
  • pytorch实现强化学习算法 这段时间一直在看莫凡python关于强化学习的教程,因为教程都是tensorflow写的,tensorflow用的少,所以用pytorch替换了其中的网络部分 莫凡的教程结合了代码、图示讲解,比较通俗一些,...
  • Policy Gradients 深度强化学习算法实现流程详解前言一、PG深度强化学习算法的产生动机?二、算法原理三.算法实现流程总结 前言 基于Policy Gradients(策略梯度法,后文简称PG)的深度强化学习方法,思想上与基于Q...
  • 在前面的章节里,我们已经学习了基于值函数的强化学习算法,他的核心思想是利用当前的策略ππ\pi与环境进行交互,得到数据之后,利用得到的信息来更新值函数,得到一个新的值函数之后,我们可以利用这个值函数产生...
  • 如何判断强化学习算法是否收敛 1. 策略熵 对于随机性策略(PPO等)可以用策略熵来表示策略是否“确定”。在训练过程中随着策略提升,策略变得越来越确定,此时熵应该是随着逐渐降低的,熵曲线趋于平缓。 2. loss...
  • 强化学习算法分类及发展趋势

    千次阅读 2019-03-31 21:56:03
    已有的强化学习算法种类繁多,一般可按下列几个标准来分类。 (1)根据强化学习算法是否依赖模型可以分为基于模型的强化学习算法和无模型的强化学习算法。这两类算法的共同点是通过与环境交互获得数据,不同点是...
  • 【新智元导读】知乎专栏强化学习大讲堂作者郭宪博士开讲《强化学习从入门到进阶》,我们为您节选了其中的第二节《基于gym和tensorflow的强化学习算法实现》,希望对您有所帮助。同时,由郭宪博士等担任授课教师的...
  • 这是基于模型的强化学习算法,也就是说都是已知的。为这么可以用动态规划来求解强化学习的最优策略,是因为动态规划问题的最优解可通过寻找子问题的最优解来得到问题的最优解。并且可以找到子问题状态之间的递推关系...
  • SAC即SoftActor-Critic(柔性致动/评价),它是一种基于off-policy和最大熵的深度强化学习算法,其由伯克利和谷歌大脑的研究人员提出。作为目前高效的model-free算法,SAC是深度强化学习中对于连续动作控制的又一...
  • 深度强化学习(二)强化学习算法的分类

    万次阅读 多人点赞 2019-06-17 16:18:21
    对于强化学习的分类,主要参考了莫烦大佬的视频和OpenAI的Spinning Up的介绍。 一、Model-Free和Model-Based两大类 上图是Spinning Up中的分类图。对于model的理解就是强化学习中的环境。根据是否去学习环境来...
  • 一图看懂DQN(Deep Q-Network)深度强化学习算法 ) DQN简介 DQN是一种深度学习和强化学习结合的算法,提出的动机是传统的强化学习算法Q-learning中的Q_table存储空间有限,而现实世界甚至是虚拟世界中的状态是接近无限...
  • 摘要 互联网泡沫,大数据的驱动下,机器学习以及人工智能领域在后台的...本文就机器学习中的强化学习算法随便聊一聊。 马尔科夫决策过程Markov Decision Process(MDP) 感谢马尔科夫,我们才能在状态之间游刃
  • 其中,机器狗是如何运用ModelArts平台进行云端协同利用强化学习算法进行路径切换的呢,以下慢慢道来。 第一条路径中有火焰,是一条危险路径 机器狗自主决策后生成第二条路径,绕开火焰行动 首先,机器狗将...
  • 使用Gym库+keras实现强化学习算法

    千次阅读 2019-12-11 16:17:03
    【题目】使用Gym库+keras实现强化学习算法 一、Gym库介绍与使用 gym 介绍 二、例子 Keras深度强化学习-- Policy Network与DQN实现 相关资源: Paper: Policy Gradient:Policy gradient methods for ...
  • 这篇文章是我在知乎上写的,由于里面有大量公式,所以如何移植过来的话需要手动编辑格式,太麻烦了。。。。我就直接贴个链接,想看的可以点进去看: PyTorch 学习笔记(十二):强化学习算法之DQN及其变种 ...
  • 多智能体强化学习背景知识为什么提出多智能体DDPG(MADDPG)?学习MADDPG算法的先验知识?Q-LearningDQNSPGDPGDDPG由DDPG算法到MADDPG算法?MADDPG算法的巧妙之处? 为什么提出多智能体DDPG(MADDPG)? 多智能体...
  • 来源:新智元本文约1300字,建议阅读5分钟。本文为你介绍一个用PyTorch实现了17种深度强化学习算法的教程和代码库,帮助大家在实践中理解深度RL算法。[ 导读 ]深...
  • PPO-强化学习算法

    千次阅读 2020-01-22 20:46:42
    PPO是一个on-policy算法 PPO能用于离散或者连续的动作空间 Spinningup的PPO支持用MPI并行 Key Equations PPO-clip更新策略通过: θ k + 1 = arg ⁡ max ⁡ θ E s , a ∼ π θ k [ L ( s , a , θ k , ...
  •   model-free的强化学习算法已经在Atari游戏上取得了巨大成功,但是与人类选手相比,model-free的强化学习算法需要的交互数据往往大地多。其根本原因在于人类选手能够很容易学习到游戏的大概运行规律,从而进行...
  • 强化学习算法已经有各种实现平台,譬如基于tensorflow的OpenAI Baselines,rllib,基于Pytorch的 PyTorch DRL ,rlpyt。最新推荐一个轻量快速实现的RL框架,由清华大学的本科生推出,相比于之前的RL平台,有一下几点...
  • 首先,如果你是为了追求一个非常高的强化学习效果,也就是flappy bird的分数,那么建议出门右拐选择DQN,但是如果你是为了通过一个项目,想详细了解Qleaning的原理,以及如何建立一个强化学习的模型,那么你来对地方...
  • 强化学习算法:AC系列详解

    千次阅读 2020-03-21 17:02:14
    A3C的优点: 强化学习算法不稳定很大程度上是由于强化学习得到一连串的数据之间具有相关性,只有打破只有的相关性才能得到一个稳定的算法。前面了解到的DQN就是使用了经验池的方法来打破数据时间的相关性,通过从...
  • 并行强化学习算法:A2C/A3C

    千次阅读 2020-06-02 07:07:09
    AsynchronousAdvantageActor-Critic是一种异步的基于优势函数的Actor-Critic并行学习算法。 Actor指需要学习的policy π,Critic指需要学习的Value Function。
  • 【数据猿导读】 《深入浅出强化学习:原理入门》试图从最简单的解决马尔科夫决策过程的动态规划算法,一路讲解到最前沿的深度强化学习算法(Deep Q Network,DQN),单刀直入,全无枝枝蔓蔓之感。不仅解释数学原理...
  • 强化学习算法伪代码对比

    千次阅读 2020-03-29 22:14:30
    Value-Based Q-learning: 1、在迭代模型时Q-learning算法目标值的计算是选取下一状态最大的动作价值 2、下一状态的动作选取使用的是e-...1、在迭代模型时Q-learning算法目标值的计算是选取e-greedy算法产生的下...
  • 深度强化学习算法比较

    千次阅读 2019-08-05 20:10:14
    通过价值选行为 Q-learning 、Sarsa、 Deep Q ...想象环境并从中学习 Model based RL 基于概率(Policy-Based RL) policy Gradients 基于价值(Value-Based RL) Q-learning 、Sarsa 基于概率: 感官...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,647
精华内容 22,258
关键字:

强化学习算法