精华内容
下载资源
问答
  • 对可分系统,不同于传统的分解协调算法,DCMACOA选用各子系统间的关联变量为协调变量,借助于多Agent及生物免疫的进化思想,对各子系统优化及系统协调采用了多Agent免疫优化方法,优化搜索算子主要包括:邻域克隆...
  • 该模型采用分布检测、分布响应的模式,通过多agent技术的思想建立系统总体结构,给出了模型的各个组成部分,并对结构中各种agent与中心控制台的功能设计进行了分析。同时,为了提高中心控制台的融合性能,设计了一种...
  • 针对多Agent协作强化学习中存在的行为和状态维数灾问题,以及行为选择上存在多个均衡解,为了收敛到最佳均衡解需要搜索策略空间和协调策略选择问题,提出了一种新颖的基于量子理论和蚁群算法的多Agent协作学习算法。...
  • 论文研究-基于多Agent的交通运输枢纽虚拟组织信息集成框架.pdf, 面对动态、快速、多变的市场环境 ,虚拟企业开始出现并得以快速发展 ,传统的交通运输枢纽有了新的要求 ....
  • 从电子政务的发展趋势出发,在语义网技术的基础上,采用XML/...在上述基础上,结合多agent技术构建了基于语义和多agent的电子政务协同工作模型,以支持政务服务的协同工作,为建立一个虚拟的一站式服务平台奠定基础。
  • 针对标准的遗传算法在任务分配中收敛速度慢的问题, 对多agent系统中的任务分配进行形式化描述的基础上, 融合模拟退火算法的优化思想, 提出了一种基于模拟退火遗传算法的任务分配方法, 详细阐述了该算法的基本思想和...
  • 先把我做出来的效果给大家看看:CS188之多Agent协作程序示意https://www.zhihu.com/video/1207811737292251136然后,贴代码,编程思想在注释里面,有想了解的同学自己看吧!# myAgents.py # --------------- # ...

    先把我做出来的效果给大家看看:

    cdb2454256b72eb24880e5af846bb344.png
    CS188之多Agent协作程序示意https://www.zhihu.com/video/1207811737292251136

    然后,贴代码,编程思想在注释里面,有想了解的同学自己看吧!

    # myAgents.py
    # ---------------
    # Licensing Information:  You are free to use or extend these projects for
    # educational purposes provided that (1) you do not distribute or publish
    # solutions, (2) you retain this notice, and (3) you provide clear
    # attribution to UC Berkeley, including a link to http://ai.berkeley.edu.
    #
    # Attribution Information: The Pacman AI projects were developed at UC Berkeley.
    # The core projects and autograders were primarily created by John DeNero
    # (denero@cs.berkeley.edu) and Dan Klein (klein@cs.berkeley.edu).
    # Student side autograding was added by Brad Miller, Nick Hay, and
    # Pieter Abbeel (pabbeel@cs.berkeley.edu).
    
    from game import Agent
    from searchProblems import PositionSearchProblem
    
    import util
    import time
    import search
    
    """
    IMPORTANT
    `agent` defines which agent you will use. By default, it is set to ClosestDotAgent,
    but when you're ready to test your own agent, replace it with MyAgent
    """
    def createAgents(num_pacmen, agent='MyAgent'):
        return [eval(agent)(index=i) for i in range(num_pacmen)]
    
    class MyAgent(Agent):
        """
        Implementation of your agent.
        """
        # 为了能够在多个吃豆人之间共享信息,必须创建类变量
        # pacmanAmount表示一共有多少个吃豆人
        pacmanAmount = 0
        # chasingGoal表示哪些豆豆已经被设定为目标,其他的吃豆人可以不用管了
        chasingGoal = []
        
        def getAction(self, state):
            """
            Returns the next action the agent will take
            """
    
            "*** YOUR CODE HERE ***"
            # 如果通过之前的计算,确认该豆豆的任务都已经完成了,为了节约计算资源,直接停止该豆豆
            if self.isFinished:
                return Directions.STOP
            else:
                # 如果行动序列中已经没有接下来的步骤,那么就要生成新的行动序列
                if len(self.actions) == 0:
                    actions = search.bfs(CoopFoodSearchProblem(state, self.index))
                    self.actions = actions
                    # print(actions)
                # 只要行动序列不为空,就把第一个行动返回出去,并更新行动序列
                if len(self.actions) > 0:
                    nextAction = self.actions[0]
                    del self.actions[0]
                    return nextAction
                # 如果行动序列中已经没有后续步骤了,那么就认为该豆豆的任务都完成了
                else:
                    self.isFinished = True
                    return Directions.STOP
    
        def initialize(self):
            """
            Intialize anything you want to here. This function is called
            when the agent is first created. If you don't need to use it, then
            leave it blank
            """
    
            "*** YOUR CODE HERE"
            # 初始化一些吃豆人的信息
            # isFinished表示吃豆人是不是已经完成了自己的任务,初始为False
            self.isFinished = False
            # actions表示目前正在执行的行动序列,初始为一个空列表
            self.actions = []
            # 吃豆人总数+1
            MyAgent.pacmanAmount += 1
    
    """
    Put any other SearchProblems or search methods below. You may also import classes/methods in
    search.py and searchProblems.py. (ClosestDotAgent as an example below)
    """
    
    class ClosestDotAgent(Agent):
    
        def findPathToClosestDot(self, gameState):
            """
            Returns a path (a list of actions) to the closest dot, starting from
            gameState.
            """
            # Here are some useful elements of the startState
            startPosition = gameState.getPacmanPosition(self.index)
            food = gameState.getFood()
            walls = gameState.getWalls()
            problem = AnyFoodSearchProblem(gameState, self.index)
    
            "*** YOUR CODE HERE ***"
            # 直接调用我们现成的BFS算法进行问题求解,找最近的豆豆
            return search.bfs(problem)
    
        def getAction(self, state):
            return self.findPathToClosestDot(state)[0]
    
    class AnyFoodSearchProblem(PositionSearchProblem):
        """
        A search problem for finding a path to any food.
    
        This search problem is just like the PositionSearchProblem, but has a
        different goal test, which you need to fill in below.  The state space and
        successor function do not need to be changed.
    
        The class definition above, AnyFoodSearchProblem(PositionSearchProblem),
        inherits the methods of the PositionSearchProblem.
    
        You can use this search problem to help you fill in the findPathToClosestDot
        method.
        """
    
        def __init__(self, gameState, agentIndex):
            "Stores information from the gameState.  You don't need to change this."
            # Store the food for later reference
            self.food = gameState.getFood()
    
            # Store info for the PositionSearchProblem (no need to change this)
            self.walls = gameState.getWalls()
            self.startState = gameState.getPacmanPosition(agentIndex)
            self.costFn = lambda x: 1
            self._visited, self._visitedlist, self._expanded = {}, [], 0 # DO NOT CHANGE
    
        def isGoalState(self, state):
            """
            The state is Pacman's position. Fill this in with a goal test that will
            complete the problem definition.
            """
            x,y = state
    
            "*** YOUR CODE HERE ***"
            # self.food是一个用0和1表示的关于豆豆的矩阵,0和1可以直接被当做逻辑值返回
            return self.food[x][y]
    
    # 为了描述这个合作吃豆豆的问题,我重新定义了一个新的问题类
    class CoopFoodSearchProblem(PositionSearchProblem):
        '''
        版权声明:这个类是Shaohua Yuan原创的,Jing Xue进行了注释和改进
        '''
        def __init__(self, gameState, agentIndex):
            "Stores information from the gameState.  You don't need to change this."
            # Store the food for later reference
            self.food = gameState.getFood()
    
            # Store info for the PositionSearchProblem (no need to change this)
            self.walls = gameState.getWalls()
            self.startState = gameState.getPacmanPosition(agentIndex)
            self.costFn = lambda x: 1
            self._visited, self._visitedlist, self._expanded = {}, [], 0 # DO NOT CHANGE
    
            # 为了提升每个吃豆人的工作效率,我们把所有的豆豆平均分给每个吃豆人
            self.agentIndex = agentIndex
            self.foodAll = self.food.asList()
            # 这个变量用于存放分给每个吃豆人的豆豆的总数
            avgFood = len(self.foodAll) // MyAgent.pacmanAmount + 1
            # 接下来用分片操作完成平均分配
            self.foodByAgent = self.foodAll[agentIndex*avgFood : (agentIndex+1)*avgFood]
            
        def isGoalState(self, state):
            # 这个分支用于解决吃到最后,吃豆人比豆豆多的情况
            if len(self.foodAll) <= MyAgent.pacmanAmount:
                return state in self.foodAll
            # 接着我们判断当前位置如果有豆豆的情况
            if state in self.foodAll:
                # 如果豆豆在自己的目标任务中,且还没有被别的吃豆人设置为目标
                if (state in self.foodByAgent) and (state not in MyAgent.chasingGoal):
                    MyAgent.chasingGoal.append(state)
                    return True
                # 如果豆豆离自己非常近,并且没有被别的吃豆人设定为目标的话,执行此分支
                elif (util.manhattanDistance(state, self.startState) <= (1+self.agentIndex)*(1+self.agentIndex)) 
                  and (state not in MyAgent.chasingGoal):
                    MyAgent.chasingGoal.append(state)
                    return True
                # 最后的分支用来处理一些不知道的情况,以找到自己任务中的豆豆作为目标
                else:
                    return state in self.foodByAgent
            else:
                return False

    最后是GitHub地址:

    GitHub地址github.com
    展开全文
  • jq设置页面分辨率自适应,核心思想: function resize() { //window.screen.display=3; if(window.screen.display == 2) { resizeCenter();//居中模式,垂直填充 } else if(window.screen.display == 3) { ...
  • 结合具体实例“热虫实验”,解释了Swarm在人工世界环境下进行计算机仿真模拟的基本思想,探讨了Swarm的主要概念和系统结构;进而以Java语言为例介绍了面向对象思想用于Swarm编程的基本情况,并对Swarm所提供的软件...
  • 虚拟现实的实时交互得到了越来越广泛地应用,...在对分布式渲染原理研究分析的基础上,依据设计模式的思想,设计了一种基于Sort-First结构的实时分布式渲染框架和同步机制,并在实践中应用OGRE图形引擎实现了该系统。
  • 供电企业管理信息系统的建设是适应社会发展的需要,基于分布式人工智能的Agent思想和技术为建立系统提供了新的解决方案。以多Agent为背景,提出了适合供电企业的层次系统结构,在实际的使用中得到很好的验证。
  • 以往对智能Agent的社会思维属性的研究,是将Agent的社会性划分到某社会层次进行研究,或者是在个体思维模型中加入某种社会思维状态。然而,智能Agent任何时候都是通过承担社会角色而发挥其作用的,而且一旦承担了...
  • Mean Field Multi-Agent Reinforcement Learning

    千次阅读 2018-10-16 17:16:03
    这是18 ICML的文章,文中的证明推理很,主要借鉴一下思想。 文章首先阐述了以前的一些找Nash平衡等方法对于大规模agent合作或者对抗的计算量要求很大。因此提出了这个算法。 首先介绍了Stochastic Game的环境: ...

    这是18 ICML的文章,文中的证明推理很多,主要借鉴一下思想。

    文章首先阐述了以前的一些找Nash平衡等方法对于大规模agent合作或者对抗的计算量要求很大。因此提出了这个算法。

    首先介绍了Stochastic Game的环境

    第一个参数是状态空间,随后的N个参数是agent i的动作空间,在随后是agent i 的奖励函数,p是转移函数,y是折扣因子

    每个agent j 根据自己的策略选择动作,其中是agent j 在动作空间上的概率分布。

    表示joint policy,在这个joint policy下,agent j 的 value function可以写成:

    agent j 的Q function可以写成:

    所以value function又可以被Q表示为

    随后是Nash Q-learning

    每个agent的目标学习一个最优的策略去maximize他们的value function,对于agent j 取最优的policy 取决于 joint policy。

    因此在Stochastic game 中Nash 平衡被描述为:

    在Nash平衡中每个agent把自己最好的respones反馈给其他的agent,因此给出了一个Nash policy 的value function

    因此此时我们可以使用Nash value function重写Q function:

    其中

    随后开始介绍Mean Field MARL:

    首先为了解决所有的agent不能都同时策略的进行行为并同时更新标准Q function这一问题。

    我们重构了Q function:

    是 j 附近的agent。这里不同的N(j)要根据不同的环境,有区别的取设置

    这样就有效的降低了整体的复杂度。

    随后是Mean Field Approximation:(这一阶比较趋紧与证明)

    我们根据1971年提出的mean field theory可以用于拟合

    这里我们考虑离散的动作空间,同时我们把agent j 的aj使用one hot 编码:,随后我们根据agent j的邻居agents计算 mean action 平均动作,随后我们把每个邻居agent k的的one hot  action ak全部用 的加和表示:

    其中,可以被解释为agent j的附近agents动作的经验分布。

    随后是对Qj的推到:

    最后的结论很重要也就是最后近似等于

    我们可以看下面这个图来近似:

    此时Q函数的更新函数可以写为:

    此时agent j的mean field 的value function 可以写成:

    接着我们给出了计算每个agent j 的最好策略的迭代过程,其中mean action 

    ,eq(11) 随后policy 根据mean action更改:

    eq(12)

    为了区分与Nash平衡,我们标记mean field,Q function:

    。随后开始证明mean field会像Nash 平衡一样收敛

    MFQ:

    loss function :

    也就是说yj是Q target计算出来的,是Q est计算出来的

    伪代码:

    MFAC:

    他的所有实验都是共享网络的,也就是一个Target Net 一个Est Net,然后每个agent之间唯一的不同点就是mean action的影响,不然只要这个agent在这个位置,那么他就会做出确定的动作,而不会考取其他agent的动作。

     

     

     

     

     

     

     

     

    展开全文
  • 本文分析了移动计算的特点,提出了基于Agent的移动应用平台的设计方案,并在一个实例系统中应用了这个框架设计思想。无线网络和移动计算设备等技术在不断的发展中,关于移动计算领域的研究也越来越,移动应用领域...
  • 面向Agent的软件工程技术解决复杂环境问题的研究,任建华,汪赫瑜,Agent技术是一个在人工智能领域发展和应用的概念模型。自从1997年以来,越来越Agent研究者争论着这种技术和思想将会给主流软件工�
  • ADIDS采取无控制中心的多agent结构,充分利用agent本身的独立性与自主性,尽量降低各检测部件间的相关性,避免了单个中心分析器带来的单点失效问题。各个数据采集部件、检测部件都是独立的单元,不仅实现了数据收集...
  • 采用复杂性理论思想,在干流河道尺度分解的基础上形成水质体积微元,建立具有吸附行为、自净行为、沉降行为、挥发行为、平推行为、扩散行为和演化行为的复杂agent模型,开展基于高性能计算技术的agent计算力优化,...
  • 分享一种强化学习的建模过程,它是将通信当中的资源分配问题建立成强化学习方法,资源分配是指通信网络中,频谱资源、信道、带宽、天线功率等等是有限的,怎么管理这些资源来保证...这里智能体就是涉及博弈论的思想
  • piv-agent几乎完全基于思想和密码学。 重要提示:我不是密码专家,并且不对本软件的安全性或其他方面作任何断言。 yubikey-agent有什么问题? 没有! 我只是想更好地了解安全密钥上的PIV小程序如何工作以及Go ssh...
  • Agent之前-Object世界 在说起Agent...现在这么复杂的系统,不都是基于OO的思想设计出来的吗? 然也,OO的确为提高软件开发效率做出了很大的贡献,但是在使用过程中,OO也暴露出了一些痒处: 痒处一:OO并没有对

    Agent之前-Object世界

     

    在说起Agent之前,俺们还有必要先敬拜一下Agent的前辈Object,因为Agent实际上是由Object“进化”而来的。这话说出来,可能有些读者同志不太高兴了,Object有什么不好吗?现在这么多复杂的系统,不都是基于OO的思想设计出来的吗?

     

    然也,OO的确为提高软件开发效率做出了很大的贡献,但是在使用过程中,OO也暴露出了一些处:

     

    痒处一:OO并没有对现实世界中的实体加以区分

    OO世界中,所有的软件实体都是Object,现实世界中的一张发票和一为员工,映射到OO世界中都是一个ClassClass发票具有一些数据(日期,金额)和操作(效验,保存),Class员工也具有一些数据(姓名,职位)和操作(上班,下班),从映射的角度来看,任何现实世界的实体都是数据和操作的集合。但实际上,在现实世界中,发票和员工还是有区别的。区别在哪里呢?在于发票是一个物体, 而员工是一个有心智的实体。发票类的方法只能是被动地被调用,如果我们不调用,任何一张发票都不会自动的进行效验或者保存。而员工的方法调用与否,是由员工自己来决定的。今天生病了, 不高兴上班,上班操作就不会被执行,今天任务重,他就会自动执行加班这个操作。换句话说员工类的操作不是被动调用的,而是自发完成的。

    这种只能被动调用和自发执行的区别,归结一下其原因,是因为员工具有自己的心智,而发票是没有的。传统的OO并没有引入这个区分,而这种区分的却失所造成的结果就是所有的操作都是被动地等待调用。虽然我们也可以引入计时器,或者多线程技术来模拟主动操作,但这种并不完全贴合现实世界的设计思路是不是让各位隐约感觉有些不爽呢。

     

    痒处二:同步和异步被人为地剥离。

    上面讲的是OO对有些东东没有区分,这点说的是OO对某些东东又多余地加以了区分。比如,现实世界中,老师对同学们说:“请把书翻到78页。”老师并不需要知道翻书这个操作对于同学们来说是同步操作还是异步操作,他并没有说“请把书同步地/异步地翻到78页。”换句话说,翻书这个操作是同步还是异步,对于调用者(老师)来说,是不需要知道的,同学们知道就OK了。但是影射到OO世界中,对于调用者来说,他在调用的时候,就必须知道是同步调用还是异步调用。归纳起来说,在现实世界中,调用方式这种知识,是被调用方拥有的,而调用方是不需要考虑的,但在OO世界中,这个知识由被调用方转移到了调用方。Something is different。体会一下,这种差异会带来什么样的问题。

     

    痒处三:无法自然地模拟现实世界中的感知能力(Sensebility

    举个烧菜的例子来说明感知能力。老妈教俺烧菜的时候,常用的语法是:“当什么什么的时候,就怎么怎么样”。比如:当水烧开的时候,把肉放进去;当鸡块炸至金黄色的时候,捞出锅来。这就是感知能力的例子。鸡块作为感知源,它的属性可以发生变化;俺作为感知器,可以捕捉到鸡块的颜色这个属性的变化。如果鸡块的颜色由肉色转变至金黄色,俺就必须做出相应的操作/处理:把鸡块捞出锅来。

     

    这种感知能力在现实世界中是非常普遍地存在的,然而映射到OO世界中来,却显的有些别扭。如果我们将鸡块和人构造为两个Class,要想人能感知到鸡块上某个属性值的变化,首先想到的是使用观察者(Observer)模式,在.Net平台下呢,则是在鸡块类中构造一个delegate,然后将人的某个操作挂到这个delegate上,当鸡块颜色值发生变化的时候,触发这个delegate。这种方式至少存在三个让人感觉别扭的地方:

     

    l         鸡块就是鸡块,为什么鸡块这个Class里面要包含一个额外的delegate呢,这个delegate的存在对于实现鸡块这个class本身的逻辑来说没有任何意义,对于鸡块的逻辑而言,这个delegate是完全多余的,这还只是颜色属性上的delegate,不难想像,如果外界还有其他Class需要感知鸡块类其他属性上的变化,会有更多的delegate,更多的与鸡块本身逻辑不相干的代码出现。

     

    l         注意到一个比较细节的问题。俺在看到鸡块颜色变为金黄色后,执行的操作是把鸡块捞出锅。这个“捞出锅”的操作,是由俺的心智来完成的,不是受鸡块的心智指挥,它自己蹦出锅来的。而在上面提到的使用delegate的解决方案中,我们把“捞出锅”这个操作挂载到delegate上,则“捞出锅”是由鸡块当前占用的线程来执行的,如果将线程理解为心智的话,则意味着是由鸡块的心智控制着人将自己捞出锅。是不是很诡异J  更直白地说法是:应该有一个线程来处理鸡块颜色的变化,另外再有一个线程来收到颜色变化的通知,并执行“捞出锅”的操作。这里有同志应该说了:也好办,把delegate的机制修改为多线程的就OK了!的确是这样,但需要注意的是要保持多线程机制对鸡块和人的透明性,如果因为需要贴近现实世界而增加Class的复杂性,那也违背了我们的初衷。

     

    l         最后一个问题比较有意思。在现有的delegate解决方案中,我们只能针对实例(Instance)进行注册,而不可以针对类型(Type)进行注册。什么概念呢?比如锅里面有十个鸡块,俺得把“捞出锅”这个操作到这十个鸡块上依次注册一遍,才能保证每个鸡块在适当的时机被捞出来。是不是觉得和现实世界中的实际情况有些出入J 如果能够提供针对类型的注册机制,只要将俺的后续操作到鸡块类上注册一次,在感知范围内的所有鸡块,管他是十块还是二十块,都能被俺感知到颜色上的变化并执行正确的后续操作,这样会来的更简洁,更自然。

     

    上面罗罗嗦嗦给OO挑了些毛病。实际上归纳起来就一句话:OO并不是对现实世界最贴切地模拟。而软件世界的终极目标是为了模拟现实世界,既然OO并不是最贴切的模拟,问题也就暴露出来了,改进的余地也就显现出来了。

         怎么改进?轮到Object的接班人Agent出场了。
    展开全文
  • Agent之前-Object世界   在说起Agent之前,俺们还有...现在这么复杂的系统,不都是基于OO的思想设计出来的吗?    然也,OO的确为提高软件开发效率做出了很大的贡献,但是在使用过程中,OO也暴露出了
    Agent之前-Object世界
     
    在说起Agent之前,俺们还有必要先敬拜一下Agent的前辈Object,因为Agent实际上是由Object“进化”而来的。这话说出来,可能有些读者同志不太高兴了,Object有什么不好吗?现在这么多复杂的系统,不都是基于OO的思想设计出来的吗? 
     
    然也,OO的确为提高软件开发效率做出了很大的贡献,但是在使用过程中,OO也暴露出了一些处:
     
    痒处一:OO并没有对现实世界中的实体加以区分
    在OO世界中,所有的软件实体都是Object,现实世界中的一张发票和一为员工,映射到OO世界中都是一个Class。Class发票具有一些数据(日期,金额)和操作(效验,保存),Class员工也具有一些数据(姓名,职位)和操作(上班,下班),从映射的角度来看,任何现实世界的实体都是数据和操作的集合。但实际上,在现实世界中,发票和员工还是有区别的。区别在哪里呢?在于发票是一个物体, 而员工是一个有心智的实体。发票类的方法只能是被动地被调用,如果我们不调用,任何一张发票都不会自动的进行效验或者保存。而员工的方法调用与否,是由员工自己来决定的。今天生病了, 不高兴上班,上班操作就不会被执行,今天任务重,他就会自动执行加班这个操作。换句话说员工类的操作不是被动调用的,而是自发完成的。
    这种只能被动调用和自发执行的区别,归结一下其原因,是因为员工具有自己的心智,而发票是没有的。传统的OO并没有引入这个区分,而这种区分的却失所造成的结果就是所有的操作都是被动地等待调用。虽然我们也可以引入计时器,或者多线程技术来模拟主动操作,但这种并不完全贴合现实世界的设计思路是不是让各位隐约感觉有些不爽呢。
     
    痒处二:同步和异步被人为地剥离。
    上面讲的是OO对有些东东没有区分,这点说的是OO对某些东东又多余地加以了区分。比如,现实世界中,老师对同学们说:“请把书翻到78页。”老师并不需要知道翻书这个操作对于同学们来说是同步操作还是异步操作,他并没有说“请把书同步地/异步地翻到78页。”换句话说,翻书这个操作是同步还是异步,对于调用者(老师)来说,是不需要知道的,同学们知道就OK了。但是影射到OO世界中,对于调用者来说,他在调用的时候,就必须知道是同步调用还是异步调用。归纳起来说,在现实世界中,调用方式这种知识,是被调用方拥有的,而调用方是不需要考虑的,但在OO世界中,这个知识由被调用方转移到了调用方。Something is different。体会一下,这种差异会带来什么样的问题。
     
    痒处三:无法自然地模拟现实世界中的感知能力(Sensebility)
    举个烧菜的例子来说明感知能力。老妈教俺烧菜的时候,常用的语法是:“当什么什么的时候,就怎么怎么样”。比如:当水烧开的时候,把肉放进去;当鸡块炸至金黄色的时候,捞出锅来。这就是感知能力的例子。鸡块作为感知源,它的属性可以发生变化;俺作为感知器,可以捕捉到鸡块的颜色这个属性的变化。如果鸡块的颜色由肉色转变至金黄色,俺就必须做出相应的操作/处理:把鸡块捞出锅来。
     
    这种感知能力在现实世界中是非常普遍地存在的,然而映射到OO世界中来,却显的有些别扭。如果我们将鸡块和人构造为两个Class,要想人能感知到鸡块上某个属性值的变化,首先想到的是使用观察者(Observer)模式,在.Net平台下呢,则是在鸡块类中构造一个delegate,然后将人的某个操作挂到这个delegate上,当鸡块颜色值发生变化的时候,触发这个delegate。这种方式至少存在三个让人感觉别扭的地方:
     
    l         鸡块就是鸡块,为什么鸡块这个Class里面要包含一个额外的delegate呢,这个delegate的存在对于实现鸡块这个class本身的逻辑来说没有任何意义,对于鸡块的逻辑而言,这个delegate是完全多余的,这还只是颜色属性上的delegate,不难想像,如果外界还有其他Class需要感知鸡块类其他属性上的变化,会有更多的delegate,更多的与鸡块本身逻辑不相干的代码出现。
     
    l         注意到一个比较细节的问题。俺在看到鸡块颜色变为金黄色后,执行的操作是把鸡块捞出锅。这个“捞出锅”的操作,是由俺的心智来完成的,不是受鸡块的心智指挥,它自己蹦出锅来的。而在上面提到的使用delegate的解决方案中,我们把“捞出锅”这个操作挂载到delegate上,则“捞出锅”是由鸡块当前占用的线程来执行的,如果将线程理解为心智的话,则意味着是由鸡块的心智控制着人将自己捞出锅。是不是很诡异J 更直白地说法是:应该有一个线程来处理鸡块颜色的变化,另外再有一个线程来收到颜色变化的通知,并执行“捞出锅”的操作。这里有同志应该说了:也好办,把delegate的机制修改为多线程的就OK了!的确是这样,但需要注意的是要保持多线程机制对鸡块和人的透明性,如果因为需要贴近现实世界而增加Class的复杂性,那也违背了我们的初衷。
     
    l         最后一个问题比较有意思。在现有的delegate解决方案中,我们只能针对实例(Instance)进行注册,而不可以针对类型(Type)进行注册。什么概念呢?比如锅里面有十个鸡块,俺得把“捞出锅”这个操作到这十个鸡块上依次注册一遍,才能保证每个鸡块在适当的时机被捞出来。是不是觉得和现实世界中的实际情况有些出入J 如果能够提供针对类型的注册机制,只要将俺的后续操作到鸡块类上注册一次,在感知范围内的所有鸡块,管他是十块还是二十块,都能被俺感知到颜色上的变化并执行正确的后续操作,这样会来的更简洁,更自然。
     
    上面罗罗嗦嗦给OO挑了些毛病。实际上归纳起来就一句话:OO并不是对现实世界最贴切地模拟。而软件世界的终极目标是为了模拟现实世界,既然OO并不是最贴切的模拟,问题也就暴露出来了,改进的余地也就显现出来了。

         怎么改进?轮到Object的接班人Agent出场了。

    展开全文
  • 通过前几次强化学习实践讲解,我们基本上理解了个体与环境的建模思想,特别是对gym库有了一定的了解。在本讲中,我们将尝试编写一个简单的Agent类,并且使它能够和我们之前编写的格子世界环境类进行交互。然后我们将...
  • 通过前几次强化学习实践讲解,我们基本上理解了个体与环境的建模思想,特别是对gym库有了一定的了解。在本讲中,我们将尝试编写一个简单的Agent类,并且使它能够和我们之前编写的格子世界环境类进行交互。然后我们将...
  • 本节书摘来自华章计算机《人工智能:计算Agent基础》一书中的第1章,第1.9节,作者:(加)David L.Poole,Alan K.Mackworth 更章节内容可以访问云栖社区“华章计算机”公众号查看。 1.9 参考文献及进一步阅读 本章...
  • Agent之前-Object世界 在说起Agent之前,俺们还有必要先...现在这么复杂的系统,不都是基于OO的思想设计出来的吗? 然也,OO的确为提高软件开发效率做出了很大的贡献,但是在使用过程中,OO也暴露出了一些痒处: 
  • 文章提出了通过深度学习的方法,对代理间的通信协议进行学习的思想。从而通过代理之间的通信解决代理强化学习问题。 2. 论文摘要: We consider the problem of multiple agents sensing and acting in ...
  • 交互技术是协同虚拟环境中实现用户间的感知(视觉、听觉、触觉等)交流与协作的重要手段。目前,在协同虚拟环境中,由于对存在的交互种类缺乏系统、全面的研究方法,从而用户交互程度明显不足,严重影响了地理协同...
  • 2:声明式的好处就是简单,其他的不说,看下面的介绍 2:声明式Pipeline概述 pipeline { //里面写入决堤的stages,声明式由每一个不同的阶段构成 } 3:agent(这个指令是必须要有的) agent部分指定整个...
  • 基于代理和知识服务的敏捷知识重用系统研究,王君,刘鲁,针对如何快速恰当的重用企业现有知识的问题,提出了将企业的知识管理的业务逻辑与知识处理事务分开的思想,建立基于Multi-Agent和知�

空空如也

空空如也

1 2 3 4
收藏数 66
精华内容 26
关键字:

多agent思想