【论文翻译】ACTOR-MIMIC :DEEP MULTITASK AND TRANSFER REINFORCEMENT LEARNING

  • Abstract:

    • 在多个环境中行动并且将学会的知识进行迁移,是智能体的一个重要技能。为此,我们定义了一种新的“多任务和迁移学习”方法,使智能体能够学习如何同时处理多个任务,然后将其知识推广到新的领域。这种方法被称为“Actor-Mimic”,利用深度强化学习技术和模型压缩技术,来学习一个单一的策略网络:在几位专家老师的指导下,学习如何在一系列不同的任务中行动。我们随后证明了:学习到的表征,能够在没有专家指导的情况下,泛化到新的任务,同时加快了在新环境下的学习。我们的方法通常可以应用于广泛的领域,本文我们使用Atari games作为测试环境来演示我们的方法。
  •  1 INTRODUCTION

  •  3 ACTOR-MIMIC

    • 3.1 POLICY REGRESSION OBJECTIVE

      • 给定一组游戏S1,...,SN,我们的第一个目标就是:得到一个多任务策略网络,能玩这些游戏的时候表现的接近于专家水平。为了训练这个多任务网络,我们使用多个专家DQN E1....,EN,这些专家DQN是特定于任务的。此时,我们把“guidance”定义为通用策略的q-network和专家的q-network之间的均方误差。由于不同游戏之间的专家q-network的输出值可能很不一样,相差范围较大,此时我们发现很难直接从专家的q-network当中蒸馏知识。于是我们的替代方案是: 对q-network的输出进行softmax操作,从而限制一下输出的范围,这样在训练时候更加稳定。直观地说,我们可以从迫使学生更多地关注专家在每个状态下选择的动作的角度来看待使用softmax,因为在每个状态下,状态的准确值本身是多少显得不太重要。我们称之为:“Actor-Mimic”。特别是,我们的技术首先通过Q值输出Boltzmann分布,将每个专家DQN转换为策略网络。
      •                    
      • 其中τ是一个温度参数, AEi 是 专家所使用的动作空间。我们定义策略网络的学习目标是:专家网络的策略和多任务网络的策略之间的交叉熵:
      • 其中 πAMN(ajs;θ) 是多任务策略,与多任务自己学习Q-network作为目标相比,我们现在有一个稳定的监控训练信号(专家网络输出)来指导多任务网络。
      • 在实际采样样本的时候,可以从专家策略采样也可以从多任务策略采样,都可以收敛。采用的方法是epislon-greedy策略。
    •  3.2 FEATURE REGRESSION OBJECTIVE

      • 我们可以通过这样的方式来得到专家网络的指引。
      • 记 hAMN(s) 为AMN网络输出层的前一个隐含层激励。 记 hEi(s) 为 专家网络输出层的前一个隐含层激励。
      • 接下来我们使用一个网络 fi 来拟合:从 hAMN(s) 到 hEi(s)的映射。并用下面的损失更新fi网络。
      • 当优化这个目标函数的时候,误差被反向传播到 fi网络 和 AMN网络 的所有层。通过这种方式,强行逼迫AMN网络计算出可以预测 专家特征 的 特征。这样做的理由是:如果我们能从一个多任务网络预测到所有专家特征,那么专家特征的信息都会被包含在里面。对每个专家网络,都使用不同的特征预测网络,这种做法,可以解决这个问题:“不同的专家特征具有不同的维度”。通过实验我们发现,这种设计方法的主要好处是:它可以提高迁移学习在某些目标任务中的表现。
    • 3.3 ACTOR-MIMIC OBJECTIVE

      • 结合之前定义的各种优化目标,总的优化目标可以定义为:
      • 其中,β是一个超参数,用来控制两个目标之间的相对权重。直观地说,我们可以把policy regression objective看作是:老师告诉学生应该如何行动。而feature regression objective 类似于:老师告诉学生为什么要这样做(模仿专家的思维过程)。
    • 3.4 TRANSFERING KNOWLEDGE: ACTOR-MIMIC AS PRETRAINING

      • 现在我们已经会了如何把学习多任务策略,接下来我们可以把任务迁移到新的目标当中。想要迁移到新任务,需要先删除最后一个softmax层。然后,我们使用AMN的权重装载进DQN网络进行训练,该DQN将在新的目标任务上进行训练。
  • 4 CONVERGENCE PROPERTIES OF ACTOR-MIMIC

    • agent采取episilon-greedy策略,通用策略的状态是K维向量,Q网络是一个KxA的矩阵。动作空间是A维度。输出的动作分布就是:Q值 的 softmax。
    • 4.1 STOCHASTIC STATIONARY POLICY

    • 4.2 STOCHASTIC ADAPTIVE POLICY

    •  

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
很抱歉,我并不是一个能够直接编写代码的AI,但我可以提供一些参考资料和指导。 首先,你需要了解SAC算法的原理和实现细节,建议先阅读一遍论文并理解其中的数学公式和推导过程。接着,你需要熟悉TensorFlow的使用方法,包括搭建神经网络、定义损失函数、优化器等等。 在开始编写代码之前,你需要准备好SAC算法所需的环境和数据集,包括强化学习环境和训练数据。可以选择使用OpenAI Gym等开源强化学习库或自己构建环境。对于数据集,可以使用Replay Buffer等经典技术进行采样和存储。 下面是一个简化版的SAC算法的TensorFlow实现代码,仅供参考: ```python import tensorflow as tf import numpy as np # 定义神经网络 class Critic(tf.keras.Model): def __init__(self, state_dim, action_dim): super(Critic, self).__init__() self.state_layer = tf.keras.layers.Dense(64, activation='relu') self.action_layer = tf.keras.layers.Dense(64, activation='relu') self.concat_layer = tf.keras.layers.Concatenate() self.q_layer = tf.keras.layers.Dense(1, activation=None) def call(self, inputs): state, action = inputs state = self.state_layer(state) action = self.action_layer(action) inputs = self.concat_layer([state, action]) q_value = self.q_layer(inputs) return q_value class Actor(tf.keras.Model): def __init__(self, state_dim, action_dim): super(Actor, self).__init__() self.state_layer = tf.keras.layers.Dense(64, activation='relu') self.mean_layer = tf.keras.layers.Dense(action_dim, activation=None) self.std_layer = tf.keras.layers.Dense(action_dim, activation=None) def call(self, inputs): state = self.state_layer(inputs) mean = self.mean_layer(state) std = tf.exp(self.std_layer(state)) dist = tfp.distributions.Normal(mean, std) action = dist.sample() return action # 定义SAC算法 class SACAgent: def __init__(self, state_dim, action_dim, gamma=0.99, alpha=0.2, tau=0.005): self.gamma = gamma self.alpha = alpha self.tau = tau self.actor = Actor(state_dim, action_dim) self.critic1 = Critic(state_dim, action_dim) self.critic2 = Critic(state_dim, action_dim) self.target_critic1 = Critic(state_dim, action_dim) self.target_critic2 = Critic(state_dim, action_dim) self.actor_optimizer = tf.keras.optimizers.Adam(learning_rate=3e-4) self.critic_optimizer = tf.keras.optimizers.Adam(learning_rate=3e-4) self.update_target_networks() def update_target_networks(self): self.target_critic1.set_weights(self.critic1.get_weights()) self.target_critic2.set_weights(self.critic2.get_weights()) def get_action(self, state): state = tf.expand_dims(tf.convert_to_tensor(state), 0) action = self.actor(state) return action.numpy()[0] def train(self, state_batch, action_batch, reward_batch, next_state_batch, done_batch): state_batch = tf.convert_to_tensor(state_batch, dtype=tf.float32) action_batch = tf.convert_to_tensor(action_batch, dtype=tf.float32) reward_batch = tf.convert_to_tensor(reward_batch, dtype=tf.float32) next_state_batch = tf.convert_to_tensor(next_state_batch, dtype=tf.float32) done_batch = tf.convert_to_tensor(done_batch, dtype=tf.float32) next_action_batch = self.actor(next_state_batch) next_q1_batch = self.target_critic1([next_state_batch, next_action_batch]) next_q2_batch = self.target_critic2([next_state_batch, next_action_batch]) next_q_batch = tf.minimum(next_q1_batch, next_q2_batch) target_q_batch = reward_batch + self.gamma * (1 - done_batch) * (next_q_batch - self.alpha * tf.math.log(next_action_batch.prob(action_batch) + 1e-8)) with tf.GradientTape() as tape: q1_batch = self.critic1([state_batch, action_batch]) critic1_loss = tf.reduce_mean(tf.square(q1_batch - target_q_batch)) critic1_grads = tape.gradient(critic1_loss, self.critic1.trainable_variables) self.critic_optimizer.apply_gradients(zip(critic1_grads, self.critic1.trainable_variables)) with tf.GradientTape() as tape: q2_batch = self.critic2([state_batch, action_batch]) critic2_loss = tf.reduce_mean(tf.square(q2_batch - target_q_batch)) critic2_grads = tape.gradient(critic2_loss, self.critic2.trainable_variables) self.critic_optimizer.apply_gradients(zip(critic2_grads, self.critic2.trainable_variables)) with tf.GradientTape() as tape: new_action_batch = self.actor(state_batch) new_q1_batch = self.critic1([state_batch, new_action_batch]) actor_loss = tf.reduce_mean(self.alpha * tf.math.log(new_action_batch.prob(new_action_batch) + 1e-8) - new_q1_batch) actor_grads = tape.gradient(actor_loss, self.actor.trainable_variables) self.actor_optimizer.apply_gradients(zip(actor_grads, self.actor.trainable_variables)) self.update_target_networks() # 训练SAC算法 env = gym.make('Pendulum-v0') agent = SACAgent(env.observation_space.shape[0], env.action_space.shape[0]) replay_buffer = [] for episode in range(1000): state = env.reset() done = False total_reward = 0 while not done: action = agent.get_action(state) next_state, reward, done, _ = env.step(action) replay_buffer.append((state, action, reward, next_state, done)) state = next_state total_reward += reward if len(replay_buffer) > 128: batch = random.sample(replay_buffer, 128) state_batch, action_batch, reward_batch, next_state_batch, done_batch = map(np.array, zip(*batch)) agent.train(state_batch, action_batch, reward_batch, next_state_batch, done_batch) print('Episode:', episode, 'Total reward:', total_reward) ``` 请注意,此代码仅为简化版的SAC算法实现,只包含基本的神经网络定义、损失函数和优化器,还需要根据具体情况进行调整和优化,例如添加正则化、批归一化等技术,以提高算法的性能和稳定性。此外,还需要考虑如何处理连续动作空间、离散动作空间等不同情况,以及如何设置超参数等问题。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值