【算法】演员~评论家方法

2024-08-31 09:28
文章标签 算法 方法 演员 评论家

本文主要是介绍【算法】演员~评论家方法,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

一、引言

        演员-评论家算法(Actors-Critics Method)是一种用于并发编程中的同步机制,用于解决多线程环境下的资源竞争问题。与传统的锁和信号量等同步工具不同,演员-评论家方法采用更加灵活的协作策略。算法结合了策略梯度(Policy Gradient)和价值函数(Value Function)估计的强化学习方法。它包含两个主要组件:演员(Actor)和评论家(Critic)。演员负责根据当前策略选择动作,而评论家评估这些动作的好坏,并提供反馈来改进演员的策略。通过这种方式,演员-评论家算法能够在连续动作空间和复杂任务中表现出色。

二、算法原理

演员-评论家算法的核心思想是将参与者分为两类角色:

  • 演员(Actors):执行实际工作的线程,它们对共享资源进行操作。
  • 评论家(Critics):监控并评估演员行为的线程,它们不直接操作资源,但可以提供反馈以指导演员的行为。

算法的基本流程如下:

  • 演员尝试对共享资源进行操作。
  • 评论家评估操作的影响,并给出建议或直接干预。
  • 根据评论家的建议,演员决定是否继续操作或修改行为。

三、数据结构

演员-评论家算法中涉及的数据结构包括:

  • 共享资源:需要被多个线程访问和修改的数据。
  • 评论家反馈:评论家对演员操作的评估结果。
  • 状态表示:用于描述环境当前的状态。
  • 动作空间:定义了演员可以选择的所有可能动作。
  • 策略网络(演员):参数化为θ,输出给定状态下的动作概率分布。
  • 价值网络Q网络(评论家):参数化为w,评估当前状态或状态-动作对的价值。

四、算法使用场景

演员-评论家算法适用于:

  • 分布式系统:在分布式系统中协调不同节点的行为。
  • 实时系统:需要快速响应和动态调整策略的场景。
  • 多线程优化:在多线程环境中减少锁的使用,提高性能。

  • 机器人控制:优化机器人的动作策略。

  • 自动驾驶:学习驾驶策略和决策过程。

  • 游戏AI:训练游戏中的智能代理。
  • 资源管理:优化资源分配策略。
  • 连续动作空间:当动作空间是连续的,演员-评论家方法表现优越。
  • 高维状态空间:在复杂环境中,如机器人控制和游戏AI。
  • 需要高效学习的场景:在需要快速适应环境变化的任务中。

五、算法实现

使用Python实现的简单演员-评论家算法示例:

import numpy as np
import gym
import tensorflow as tfclass ActorCritic:def __init__(self, state_size, action_size):self.state_size = state_sizeself.action_size = action_sizeself.actor = self.build_actor()self.critic = self.build_critic()def build_actor(self):model = tf.keras.Sequential([tf.keras.layers.Dense(24, activation='relu', input_shape=(self.state_size,)),tf.keras.layers.Dense(self.action_size, activation='softmax')])model.compile(optimizer='adam', loss='categorical_crossentropy')return modeldef build_critic(self):model = tf.keras.Sequential([tf.keras.layers.Dense(24, activation='relu', input_shape=(self.state_size,)),tf.keras.layers.Dense(1, activation='linear')])model.compile(optimizer='adam', loss='mean_squared_error')return modeldef choose_action(self, state):state = state.reshape([1, self.state_size])probabilities = self.actor.predict(state).flatten()return np.random.choice(self.action_size, p=probabilities)def train(self, state, action, reward, next_state):state = state.reshape([1, self.state_size])next_state = next_state.reshape([1, self.state_size])target = reward + 0.99 * self.critic.predict(next_state)td_error = target - self.critic.predict(state)# Update actoraction_onehot = np.zeros(self.action_size)action_onehot[action] = 1self.actor.fit(state, action_onehot.reshape([1, self.action_size]), verbose=0)# Update criticself.critic.fit(state, target, verbose=0)# 使用示例
if __name__ == "__main__":env = gym.make('CartPole-v1')state_size = env.observation_space.shape[0]action_size = env.action_space.nagent = ActorCritic(state_size, action_size)for episode in range(1000):state = env.reset()done = Falsewhile not done:action = agent.choose_action(state)next_state, reward, done, _ = env.step(action)agent.train(state, action, reward, next_state)state = next_state

六、其他同类算法对比

与演员-评论家算法相比,其他并发控制算法包括:

  • 锁(Locks):通过互斥锁来保证同一时间只有一个线程访问资源。
  • 信号量(Semaphores):使用计数信号量来控制对资源的访问。
  • 监视器(Monitors):一种同步机制,允许线程在进入临界区前等待。
算法特点优势劣势
Q-Learning基于值的学习,使用 Q 表简单易懂,适用于离散动作空间不适用于高维状态空间,收敛速度慢
SARSA在线学习,使用当前策略更新 Q 值适应性强,能够处理非最优策略收敛速度慢,容易陷入局部最优
DQN使用深度学习进行 Q 值估计处理高维状态空间,具有较好的泛化能力训练不稳定,需要经验回放和目标网络
A3C异步并行学习,使用多个代理训练效率高,能够处理复杂环境实现复杂,需调试多个代理的同步
PPO采用剪切损失函数,保证策略更新稳定简单易实现,具有良好的性能训练速度可能较慢,超参数调节较为复杂

七、多语言代码实现

Java

import java.util.Random;public class ActorCritic {private double[] policy;  // Actor's policyprivate double[] valueFunction;  // Critic's value functionprivate double alpha = 0.01;  // Learning rate for policyprivate double beta = 0.01;  // Learning rate for value functionprivate Random random = new Random();public ActorCritic(int numActions) {policy = new double[numActions];valueFunction = new double[numActions];// Initialize policy and value functionfor (int i = 0; i < numActions; i++) {policy[i] = 1.0 / numActions;valueFunction[i] = 0.0;}}public int selectAction() {double p = random.nextDouble();double cumulativeProbability = 0.0;for (int i = 0; i < policy.length; i++) {cumulativeProbability += policy[i];if (p < cumulativeProbability) {return i;}}return policy.length - 1;}public void update(int action, double reward, double nextValue) {double tdError = reward + nextValue - valueFunction[action];valueFunction[action] += beta * tdError;policy[action] += alpha * tdError * (1 - policy[action]);// Normalize policydouble sum = 0.0;for (double p : policy) sum += p;for (int i = 0; i < policy.length; i++) policy[i] /= sum;}public static void main(String[] args) {// Example usageActorCritic ac = new ActorCritic(4);int action = ac.selectAction();ac.update(action, 1.0, 0.5);System.out.println("Selected action: " + action);}
}

Python

import numpy as npclass ActorCritic:def __init__(self, num_actions, alpha=0.01, beta=0.01):self.policy = np.ones(num_actions) / num_actionsself.value_function = np.zeros(num_actions)self.alpha = alphaself.beta = betadef select_action(self):return np.random.choice(len(self.policy), p=self.policy)def update(self, action, reward, next_value):td_error = reward + next_value - self.value_function[action]self.value_function[action] += self.beta * td_errorself.policy[action] += self.alpha * td_error * (1 - self.policy[action])self.policy /= np.sum(self.policy)# Example usage
ac = ActorCritic(4)
action = ac.select_action()
ac.update(action, 1.0, 0.5)
print(f"Selected action: {action}")

C++

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>class ActorCritic {
public:ActorCritic(int numActions, double alpha = 0.01, double beta = 0.01): alpha(alpha), beta(beta), policy(numActions, 1.0 / numActions), valueFunction(numActions, 0.0) {std::srand(std::time(0));}int selectAction() {double p = static_cast<double>(std::rand()) / RAND_MAX;double cumulativeProbability = 0.0;for (size_t i = 0; i < policy.size(); ++i) {cumulativeProbability += policy[i];if (p < cumulativeProbability) {return i;}}return policy.size() - 1;}void update(int action, double reward, double nextValue) {double tdError = reward + nextValue - valueFunction[action];valueFunction[action] += beta * tdError;policy[action] += alpha * tdError * (1 - policy[action]);double sum = 0.0;for (double p : policy) sum += p;for (double &p : policy) p /= sum;}private:double alpha;double beta;std::vector<double> policy;std::vector<double> valueFunction;
};int main() {ActorCritic ac(4);int action = ac.selectAction();ac.update(action, 1.0, 0.5);std::cout << "Selected action: " << action << std::endl;return 0;
}

Go

package mainimport ("fmt""math/rand""time"
)type ActorCritic struct {policy         []float64valueFunction  []float64alpha, beta    float64
}func NewActorCritic(numActions int, alpha, beta float64) *ActorCritic {policy := make([]float64, numActions)valueFunction := make([]float64, numActions)for i := range policy {policy[i] = 1.0 / float64(numActions)}return &ActorCritic{policy, valueFunction, alpha, beta}
}func (ac *ActorCritic) SelectAction() int {p := rand.Float64()cumulativeProbability := 0.0for i, prob := range ac.policy {cumulativeProbability += probif p < cumulativeProbability {return i}}return len(ac.policy) - 1
}func (ac *ActorCritic) Update(action int, reward, nextValue float64) {tdError := reward + nextValue - ac.valueFunction[action]ac.valueFunction[action] += ac.beta * tdErrorac.policy[action] += ac.alpha * tdError * (1 - ac.policy[action])sum := 0.0for _, p := range ac.policy {sum += p}for i := range ac.policy {ac.policy[i] /= sum}
}func main() {rand.Seed(time.Now().UnixNano())ac := NewActorCritic(4, 0.01, 0.01)action := ac.SelectAction()ac.Update(action, 1.0, 0.5)fmt.Printf("Selected action: %d\n", action)
}

八、实际服务应用场景代码框架

应用场景

        开发一个智能机器人控制系统,使用演员-评论家方法来训练机器人在特定环境中移动。我们将使用 OpenAI Gym 作为环境,使用 Python 实现整个系统。

项目结构

robot_controller/
├── main.py
├── actor_critic.py
├── environment.py
└── requirements.txt

requirements.txt

gym
tensorflow
numpy

actor_critic.py

import numpy as np
import tensorflow as tfclass ActorCritic:def __init__(self, state_size, action_size):self.state_size = state_sizeself.action_size = action_sizeself.actor = self.build_actor()self.critic = self.build_critic()def build_actor(self):model = tf.keras.Sequential([tf.keras.layers.Dense(24, activation='relu', input_shape=(self.state_size,)),tf.keras.layers.Dense(self.action_size, activation='softmax')])model.compile(optimizer='adam', loss='categorical_crossentropy')return modeldef build_critic(self):model = tf.keras.Sequential([tf.keras.layers.Dense(24, activation='relu', input_shape=(self.state_size,)),tf.keras.layers.Dense(1, activation='linear')])model.compile(optimizer='adam', loss='mean_squared_error')return modeldef choose_action(self, state):state = state.reshape([1, self.state_size])probabilities = self.actor.predict(state).flatten()return np.random.choice(self.action_size, p=probabilities)def train(self, state, action, reward, next_state):state = state.reshape([1, self.state_size])next_state = next_state.reshape([1, self.state_size])target = reward + 0.99 * self.critic.predict(next_state)td_error = target - self.critic.predict(state)# Update actoraction_onehot = np.zeros(self.action_size)action_onehot[action] = 1self.actor.fit(state, action_onehot.reshape([1, self.action_size]), verbose=0)# Update criticself.critic.fit(state, target, verbose=0)

environment.py

import gymclass RobotEnvironment:def __init__(self):self.env = gym.make('CartPole-v1')def reset(self):return self.env.reset()def step(self, action):return self.env.step(action)def render(self):self.env.render()def close(self):self.env.close()

main.py

import numpy as np
from actor_critic import ActorCritic
from environment import RobotEnvironmentif __name__ == "__main__":env = RobotEnvironment()state_size = env.env.observation_space.shape[0]action_size = env.env.action_space.nagent = ActorCritic(state_size, action_size)for episode in range(1000):state = env.reset()done = Falsewhile not done:action = agent.choose_action(state)next_state, reward, done, _ = env.step(action)agent.train(state, action, reward, next_state)state = next_stateenv.render()env.close()

        演员-评论家方法是一种强大的强化学习算法,结合了策略和价值函数的优点,适用于多种复杂的环境。

这篇关于【算法】演员~评论家方法的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1123515

相关文章

不懂推荐算法也能设计推荐系统

本文以商业化应用推荐为例,告诉我们不懂推荐算法的产品,也能从产品侧出发, 设计出一款不错的推荐系统。 相信很多新手产品,看到算法二字,多是懵圈的。 什么排序算法、最短路径等都是相对传统的算法(注:传统是指科班出身的产品都会接触过)。但对于推荐算法,多数产品对着网上搜到的资源,都会无从下手。特别当某些推荐算法 和 “AI”扯上关系后,更是加大了理解的难度。 但,不了解推荐算法,就无法做推荐系

康拓展开(hash算法中会用到)

康拓展开是一个全排列到一个自然数的双射(也就是某个全排列与某个自然数一一对应) 公式: X=a[n]*(n-1)!+a[n-1]*(n-2)!+...+a[i]*(i-1)!+...+a[1]*0! 其中,a[i]为整数,并且0<=a[i]<i,1<=i<=n。(a[i]在不同应用中的含义不同); 典型应用: 计算当前排列在所有由小到大全排列中的顺序,也就是说求当前排列是第

csu 1446 Problem J Modified LCS (扩展欧几里得算法的简单应用)

这是一道扩展欧几里得算法的简单应用题,这题是在湖南多校训练赛中队友ac的一道题,在比赛之后请教了队友,然后自己把它a掉 这也是自己独自做扩展欧几里得算法的题目 题意:把题意转变下就变成了:求d1*x - d2*y = f2 - f1的解,很明显用exgcd来解 下面介绍一下exgcd的一些知识点:求ax + by = c的解 一、首先求ax + by = gcd(a,b)的解 这个

综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

LntonAIServer视频质量诊断功能中的抖动检测是一个专门针对视频稳定性进行分析的功能。抖动通常是指视频帧之间的不必要运动,这种运动可能是由于摄像机的移动、传输中的错误或编解码问题导致的。抖动检测对于确保视频内容的平滑性和观看体验至关重要。 优势 1. 提高图像质量 - 清晰度提升:减少抖动,提高图像的清晰度和细节表现力,使得监控画面更加真实可信。 - 细节增强:在低光条件下,抖

【数据结构】——原来排序算法搞懂这些就行,轻松拿捏

前言:快速排序的实现最重要的是找基准值,下面让我们来了解如何实现找基准值 基准值的注释:在快排的过程中,每一次我们要取一个元素作为枢纽值,以这个数字来将序列划分为两部分。 在此我们采用三数取中法,也就是取左端、中间、右端三个数,然后进行排序,将中间数作为枢纽值。 快速排序实现主框架: //快速排序 void QuickSort(int* arr, int left, int rig

【C++】_list常用方法解析及模拟实现

相信自己的力量,只要对自己始终保持信心,尽自己最大努力去完成任何事,就算事情最终结果是失败了,努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一:什么是list? •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二:list常用接口 •🌰1.默认成员函数 🔥构造函数(⭐) 🔥析构函数 •🌰2.list对象

浅谈主机加固,六种有效的主机加固方法

在数字化时代,数据的价值不言而喻,但随之而来的安全威胁也日益严峻。从勒索病毒到内部泄露,企业的数据安全面临着前所未有的挑战。为了应对这些挑战,一种全新的主机加固解决方案应运而生。 MCK主机加固解决方案,采用先进的安全容器中间件技术,构建起一套内核级的纵深立体防护体系。这一体系突破了传统安全防护的局限,即使在管理员权限被恶意利用的情况下,也能确保服务器的安全稳定运行。 普适主机加固措施:

webm怎么转换成mp4?这几种方法超多人在用!

webm怎么转换成mp4?WebM作为一种新兴的视频编码格式,近年来逐渐进入大众视野,其背后承载着诸多优势,但同时也伴随着不容忽视的局限性,首要挑战在于其兼容性边界,尽管WebM已广泛适应于众多网站与软件平台,但在特定应用环境或老旧设备上,其兼容难题依旧凸显,为用户体验带来不便,再者,WebM格式的非普适性也体现在编辑流程上,由于它并非行业内的通用标准,编辑过程中可能会遭遇格式不兼容的障碍,导致操

poj 3974 and hdu 3068 最长回文串的O(n)解法(Manacher算法)

求一段字符串中的最长回文串。 因为数据量比较大,用原来的O(n^2)会爆。 小白上的O(n^2)解法代码:TLE啦~ #include<stdio.h>#include<string.h>const int Maxn = 1000000;char s[Maxn];int main(){char e[] = {"END"};while(scanf("%s", s) != EO

透彻!驯服大型语言模型(LLMs)的五种方法,及具体方法选择思路

引言 随着时间的发展,大型语言模型不再停留在演示阶段而是逐步面向生产系统的应用,随着人们期望的不断增加,目标也发生了巨大的变化。在短短的几个月的时间里,人们对大模型的认识已经从对其zero-shot能力感到惊讶,转变为考虑改进模型质量、提高模型可用性。 「大语言模型(LLMs)其实就是利用高容量的模型架构(例如Transformer)对海量的、多种多样的数据分布进行建模得到,它包含了大量的先验