Adding weakref by default to Agents

[colinfrisch]

Hey everyone ! Recently, while building a model, I had quite a bit of trouble with referencing : I set the target attribute of one of my agents to another agent, but when the second was removed, it was still referenced in target. @quaquel explained to me weakref and how it could be of use in my case. After some thinking, I think that it could benefit to almost all cases.

A weak reference in Python allows one object to reference another without preventing its garbage collection.

The goal of this discussion is to study weather or not it could/should be incorporated directly into the Agent class, either as a permanent feature, either as an option that someone could toggle at the creation of their new agents. After some reseach, what I found was that I should be possible to complete the dunder methods that are in charge of the referencing : it could be done by overriding both __setattr__ and __getattribute__ methods so the user can access attributes without even having to know if they're weak refs.

### Basic version here for the example, but there are many ways to optimize it (caching, WeakRefManager class, etc.)

class Agent:
    def __setattr__(self, name, value):
        # Wrap Agent instances in weak refs - could be done for all objects
        if isinstance(value, Agent):
            super().__setattr__(name, weakref.ref(value))
        else:
            super().__setattr__(name, value)

    def __getattribute__(self, name):
        value = super().__getattribute__(name)
        # Automatically dereference weakref.ref objects
        if isinstance(value, weakref.ref):
            return value()
        return value

Besides eliminating circular referencing issues and allowing automatic cleanup, this allows a more efficient memory management. There are also a few features that come directly with weak referencing that could be useful to statistics (for the agg method, hello @EwoutH) like ref counts, or the ability to naturally execute some code when a ref is about to be removed, etc.

All in all, I think that could be a useful feature, and I'm willing to put some work into it. What do you guys think ? Do you have some ideas ?

[quaquel]

It's worth exploring further. However, there are at least two issues to be aware of.

1. Creating and resolving weakrefs incurs a penalty. The weakref structure in model.agents adds about 20% overhead on the benchmark models if I recall correctly.
2. Your example works only when directly referencing another agent. However, there are many ways in which one agent might hold references to other agents, most notably in all kinds of collections. Of course, best practice would be to use AgentSet for this.

I am curious to see a benchmark for this idea on your virus model to check the overhead. Just to get a sense of point 1.

Because of point 2, I am inclined to also improve the best practices documentation with a separate entry on agents, memory, weakrefs, and agentset. This would add value regardless of point 1.

Next to using weakrefs, another option is to rely on mesa.experimental.mesa_signals. In that approach, agents would not hold refs to each other but would subscribe to state changes they are interested in. These signals are internally already implemented using weakrefs. This, however, only works if one agent never needs to call a method on another agent directly but only needs to know some state information.

[colinfrisch]

1. Creating and resolving weakrefs incurs a penalty. The weakref structure in model.agents adds about 20% overhead on the benchmark models if I recall correctly.

I'll definitely dive into this, plus, there might be ways to make it more efficient like I said in the code (caching, external class, etc.)

2. Your example works only when directly referencing another agent. However, there are many ways in which one agent might hold references to other agents, most notably in all kinds of collections. Of course, best practice would be to use AgentSet for this.

Very good point. I think AgentSet already uses weakref for agents, so it could be a logical next step to make refs go through agentset (and make them weakrefs).

Ill try to make a PR on this, but first, I'd be very interested to hear first the opinions of @Sahil-Chhoker or @wang-boyu who may be interested in this from what I've seen.

[quaquel]

agentsets are for collections, this is about a ref to a single agent.

[colinfrisch]

Yes exactly, that was part of Jan's point (and the goal of this discussion - determine if and how to do it).
What I think from here is that direct referencing could be handled directly in the agent class and AgentSet could handle group referencing (in a list or other). Still digging on the question though, be interested to hear your ideas on the subject !

[colinfrisch]

@Sahil-Chhoker @quaquel
From what I've seen, intercepting referenced and adding weakref directly in collections requires quite a lot of quite complex code, since we're overriding base methods for the classes and the object themselves. Right now, I don't think it makes up for very maintainable code, but I'll definitely dive deeper into it. A viable option would be to build wrappers for the main datastructures.

For now, what would you think about adding weakrefs by default only to direct references (or as an option when making a model and building our agent classes) ? If the overhead is alright, would it be an interesting feature, or not enough added value alone ?

[colinfrisch]

After a bit of experimenting to make simple direct referencing weakref, I get this :

Model	Size	Init time [95% CI]	Run time [95% CI]
BoltzmannWealth	small	🔴 +70.4% [+68.4%, +72.5%]	🔴 +143.2% [+142.6%, +143.7%]
BoltzmannWealth	large	🔴 +75.7% [+65.8%, +81.4%]	🔴 +127.4% [+124.8%, +129.7%]
Schelling	small	🔴 +87.0% [+86.2%, +87.7%]	🔴 +150.3% [+149.2%, +151.5%]
Schelling	large	🔴 +90.7% [+89.3%, +92.0%]	🔴 +115.0% [+113.4%, +116.7%]
WolfSheep	small	🔴 +90.5% [+89.3%, +91.8%]	🔴 +116.9% [+115.3%, +118.7%]
WolfSheep	large	🔴 +92.0% [+89.6%, +95.2%]	🔴 +110.8% [+107.2%, +114.7%]
BoidFlockers	small	🔴 +56.9% [+55.0%, +58.9%]	🔴 +18.5% [+17.8%, +19.3%]
BoidFlockers	large	🔴 +52.5% [+50.7%, +54.6%]	🔴 +16.6% [+15.9%, +17.7%]

Overhead takes a big hit in all models, and I don't think that I can optimize it much more (though I will try) so I don't think that it's a good idea to implement is as a default feature. The question is, can it still be useful to implement it as an option passed on as a boolean when creating an agent ?

[quaquel]

I am not surprised by these numbers. I think just documenting the weak references stuff under best practices is a better idea than making agent creation more complicated.