[Dprglist] Subsumption Discussion

[Rud Merriam]

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://mysticlakesoftware.com/>

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
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.dprg.org/pipermail/dprglist-dprg.org/attachments/20211028/49691922/attachment.html>