[Dprglist] Subsumption Discussion

[David P. Anderson]

Hi Rud,

Ok, that sounds good to me.  Different descriptions of basically the 
same thing.   I'd be more inclined to emphasize the "subsume" nature of 
subsumption and it's ramifications, which are pretty deep once you 
scratch the surface.

cheers!

David


On 10/28/21 1:13 PM, Rud Merriam via DPRGlist wrote:
>
> */[EXTERNAL SENDER]/*
>
> David,
>
> I'd like to discuss where we differ on the definition of subsumption. 
> I'm looking at your page on subsumption 
> https://www.dprg.org/articles/2007-03a/ since I don't have the books 
> you are referencing. (Actually, I found a PDF of "Mobile Robots" at 
> https://cs.au.dk/~ocaprani/legolab/DigitalControl.dir/NXT/Lesson9.dir/11128_Mobile_Robots_Inspiration_to_Implementation-Flynn_and_Jones.pdf" 
>
>
> The book I started from was elementary and I disposed of it during a 
> recent move. I have read much on the web about subsumption and BTs, 
> and have implemented BTs for robotics work.
>
> You refer to layers which I call behaviors. Rodney Brooks original 
> paper often conflated the two.
>
> Looking at your section III. Arbitration you say:
>
>     Subsumption tasks are arranged by priority, from lowest to
>     highest, as determined by the robot builder for a particular
>     problem set.  An arbitrator() selects the output of the highest
>     priority task whose flag is true to pass on to the physical
>     subsystem (motors or whatever) for this pass through the loop,
>     this 20th of a second.
>
>     Low priority tasks can only control the robot when all higher
>     priority tasks' flags are false.
>
> My description would be:
>
>     Behaviors are listed in order of priority from highest to lowest.
>     Once the list is processed the highest priority task that 'fires'
>     is given control of the system. The default behavior is the last
>     on the list.
>
> Although my original reading of subsumption was that the entire list 
> was not processed but control passed once a behavior fired. I modified 
> this to process the entire list. Thus, my original understanding may 
> have been incorrect but I in inadvertently changed to the correct 
> processing.
>
> You provide code from Flynn and Jones:
>
> void arbitrate()
> {
>      while (1) {
>          if (cruise_output_flag == 1)
>              {motor_input = cruise_output; }
>          if (follow_output_flag == 1)
>              {motor_input = follow_output; }
>          if (avoid_output_flag == 1)
>              {motor_input = avoid_output; }
>          if (escape_output_flag == 1)
>              {motor_input = escape_output; }
>          sleep(tick);
>      }
> }
>
> I assert that this is an OR process with the caveat that the default 
> behavior always results in a true condition so it has control. BTs are 
> more complex having multiple lists to process so a given set of 
> behaviors (layer) is not likely to have a default behavior. 
> Subsumption is a /sequence/ in a BT. From 
> https://www.gamedeveloper.com/programming/behavior-trees-for-ai-how-they-work
>
>     Their main power comes from their ability to represent multiple
>     different courses of action, in order of priority from most
>     favorable to least favorable, and to return success if it managed
>     to succeed at any course of action.
>
> We may simply have a difference in terminology, as above, and 
> implementation details.
>
>
> -73 -
> *Rud Merriam K5RUD*
> /Mystic Lake Software/ 
> <http://secure-web.cisco.com/1FKz_X0Ge1ie37k5LHDucUXiDVc-D1xvohLqcTDESE8BjeMVz7ksqQwfV3iUyqpDovtR-0-tn_yo8xt3L2xqvqvv1McOdn6AJOJQ-sFHYPgpnyZbMrjcS1zL51KTf7SbGRDPmH40a1teuLnvGDFDeNOk23sIq4YNsSUIGc-VZkskk0UV7LZfvdcOt95nBziNnV4YwBopI_dF6oloKbUyhiVLmT4A_2qMkmYYIVGNbo_menDPskLCcvqr7VqB-Q-sN4obSw-KecZ1m1TTzyy0Hz9W-oraDa2B2qGphSnHGPY4/http%3A%2F%2Fmysticlakesoftware.com%2F> 
>
>
> On 10/28/21 8:35 AM, David P. Anderson via DPRGlist wrote:
>> Howdy DPRG
>>
>> On 10/27/21 10:23 PM, Rud Merriam via DPRGlist wrote:
>>
>> [snip]
>>>
>>> If you're not familiar with subsumption is is a list of behaviors or 
>>> actions. Every cycle the list begins again until one of the 
>>> behaviors "fires". The processing starts again at the beginning of 
>>> the list. That's simplified but gives the idea. I actually found 
>>> that setting a flag and letting the list finish processing also 
>>> worked. Once the flag was any following behavior would not "fire" 
>>> but it could record information. That was useful for handling 
>>> behaviors that did a timing function.
>>>
>>> [snip]
>>>
>>> Subsumption is basically an OR operation, just like a logic gate. If 
>>> one behavior fires the overall  gate becomes true and returns to a 
>>> higher level in the tree. There is also an AND operation where all 
>>> the behaviors must fire before returning true. If one fails to fire 
>>> a false is returned. The other main operation is NOT which is an 
>>> inverter of the output of a list.
>>>
>> If you're not familiar with subsumption,  the above is not an 
>> accurate description.  At all.   ;)
>>
>> For those who might be interested, the Joseph Jones books "Mobile 
>> Robots" and "Behavior Based Robotics" provide sort of the canonical 
>> definitions for subsumption and how it works.  If you don't want to 
>> read that much then I think I did a pretty good job of describing it 
>> in the DPRG talk from last June, for which there is a YouTube video 
>> on the club web page, (miss-labeled "May 12" rather than "June 12").
>>
>> cheers!
>>
>> David
>>
>>
>> _______________________________________________
>> DPRGlist mailing list
>> DPRGlist at lists.dprg.org
>> http://lists.dprg.org/listinfo.cgi/dprglist-dprg.org
>
> _______________________________________________
> DPRGlist mailing list
> DPRGlist at lists.dprg.org
> http://lists.dprg.org/listinfo.cgi/dprglist-dprg.org
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.dprg.org/pipermail/dprglist-dprg.org/attachments/20211028/45203cb2/attachment.html>