Pure Python Frontend for Mesa

[ankitk50]

Hi all,

I am looking at a pure python frontend framework to be used for Mesa. So far I'm looking into StreamLit, Dash and Panel. All these are open-source packages.

For an initial pipe-cleaner/proof of concept I tried to the Boltzmann Money Model example from the documentation. I was able to start the simulation and visualise the results using StreamLit browser based UI . The more details on the approach and the instruction to run the UI can be found here: github Link.

Here is a screenshot:

I now try to see the Jupyter compatibility of these packages. Looking forward for your views on this.

[wang-boyu]

What a coincidence! I was exploring this very topic yesterday. Mesa models can be run headless without browser, so in theory it should be possible to use any Python frontend for visualization, with of course some extra work linking Mesa models and these frontend frameworks.

What I created yesterday was a very simple visual for the Schelling example. The code is available at this link and it looks like the following:

If Mesa can provide some View classes for the built-in spaces (grid, continuous, network, etc), then we can re-use lots of widgets/components (slider, button, etc) in Streamlit, and plot whatever diagram we want in matplotlib and show it in Streamlit app.

The downside of it is that there's an extra dependency on Streamlit, and users will need to learn how to use it. But given the ease of use and richness of its documentation, hopefully this won't cause too much trouble.

[rht]

I read about it, and it's actually a limitation of Streamlit that the entire code is always re-executed whenever there is a state update. The model is recreated every time, and there needs an explicit caching instead. I have searched the internet on whether someone had written a game of life in Streamlit. Couldn't find it. Meanwhile you can readily find it in Panel gallery of examples. It looks like hash.ai's 3D renderings.

Regarding with using Matplotlib, I think it's not necessarily slower than explicit portrayal UI components, as the latter still needs full redraw during updates anyway. I'm more concerned of the several seconds of delay. Should it come to this, I think custom Streamlit components are much harder to write, as Streamlit is inflexible

[ankitk50]

Yes, I also came across this limitation for StreamLit. If you pause the execution of the page in between then there is no way to continue the execution from there, instead the whole page is reloaded. And as you mentioned, the way to make it faster is caching the system states.

[wang-boyu]

If the Game of Life demo in Panel was based on PyDeck (as mentioned in their website), then perhaps it can also be ported to Streamlit using its st.pydeck_chart?

[ankitk50]

I can give this a try!

[ankitk50]

I tried porting Conway's game of life example in mesa to Streamlit. I just submitted a PR here.

[ankitk50]

Hi all,

I also tested Panel. It works quite well with Jupyter notebook.

I use the same example. The source can be found in the notebook

[rht]

I think Panel is relatively more extensible (and that it is 100% FOSS). One way to test this would be to implement the modal popup for shutdown in #1675, in various frameworks. It doesn't make sense to have the shutdown button in a Jupyter notebook, but it does in the stand alone instance.

[ankitk50]

I can give it a try out this weekend, thanks for the idea.

[rht]

I made a working prototype for the boltzmann_wealth_model example in Panel
https://gist.github.com/rht/e0a63e1cae232a49d8142eb1952c0bd2. To try it, you simply put the gist file in the boltzmann_wealth_model root folder.

Based on reading https://panel.holoviz.org/about/comparisons.html, in addition to the lack of Jupyter support in Streamlit, a key takeaway:

Streamlit’s key difference from those other tools is that with streamlit, the entire Python source file is effectively re-run every time a widget changes value, which has the advantage of not allowing confusing out-of-order execution of notebook cells, and also can make it simpler to reason about state in general. However, for this approach to be practical, it requires all lengthy computations to be made cacheable, which is not always straightforward and can introduce its own highly complicated reasoning about state.

However, 2 main issues I have with Panel are:

• It requires Bokeh, which requires huge dependencies installation. I suppose in 2023 people don't care much about storage size, and so I'm willing to relax the condition of Mesa being lean
• The server startup time is several seconds. A bit too slow

An alternative option would be do use plain ipywidgets and run it as a standalone application, see https://discourse.jupyter.org/t/ipython-display-in-standalone-application/1048.

[rht]

The server startup time can be ruled out because @wang-boyu's Streamlit implementation also takes several seconds to load.

The ipywidgets option is essentially Voilà.

[rht]

There is also Voilà.

[ankitk50]

Yes, I checked this one during early analysis and they only allowed publishing Jupyter notebook via a Webserver.

[rht]

I created a prototype with the most number of features (among the Streamlit, Panel, etc demo) so far, in Voilà: https://github.com/rht/mesa-examples/tree/voila2.

[rht]

Comparison articles:

• https://quansight.com/post/dash-voila-panel-streamlit-our-thoughts-on-the-big-four-dashboarding-tools
• https://medium.datadriveninvestor.com/streamlit-vs-dash-vs-voil%C3%A0-vs-panel-battle-of-the-python-dashboarding-giants-177c40b9ea57#acf9 (has a table that neatly summarizes the 4 frameworks)
• https://panel.holoviz.org/about/comparisons.html (possibly biased because it is written by Panel)

[rht]

Install size comparisons from a fresh virtualenv:

• pip install panel ipywidgets ipywidgets_bokeh 349.6 MiB: bokeh (84.7 MiB), panel (75.3 MiB), numpy (34 MiB), ...
• pip install streamlit 384.4 MiB: pyarrow (126.3 MiB), pandas (61.6 MiB), numpy (34 MiB), ..., streamlit (28.3 MiB)
• pip install ipywidgets voila 172.0 MiB: babel (33.0 MiB), debugpy (17.4 MiB), ...

As such, this rules out my concern that Panel has the heaviest dependencies, as Streamlit actually is comparable due to the pyarrow dependency.

[rht]

pip install solara 256.7 MiB: numpy (35.3 MiB), numpy.libs (34.4 MiB), solara (17.5 MiB), ...
The effective size should be smaller, because the largest 2 packages are NumPy's.

[maartenbreddels]

Note, Solara is now about ~164MB (well, the soon to be released)

[rht]

Why is it far smaller?

[maartenbreddels]

Less dependencies by default widgetti/solara#214

pillow, numpy, watchgod, pygments and jupyter-server are removed

[rht]

I have this thought in mind but haven't said it: the extra value in Mesa in switching to pure Python frontend is that we may no longer have to deal with custom JS deps downloads. They all can be removed, and we can finally move to declarative pyproject.toml and setup.cfg. (Then finally I can have the bandwidth to grow mesa-examples instead of having to worry about the software engineering stuff.)

[rht]

I have seen that https://gradio.app/ is used in the UIs for Hugging Face. @wang-boyu have you looked into it, since it is listed in one of the possible frameworks to use in the GSoC wiki?
See also #1276.

[ankitk50]

It's by hugging face and looks like more inclined towards machine learning applications.

[rht]

But it can run on Jupyter. Can it do animation?

[ankitk50]

I will have to check with Jupyter native, although here is seems to do animation in colab notebook.

[rht]

They have an explicit update method, but it's not via existing plotting libraries. Did you do redraw from scratch, or update, in the game of life example?

[ankitk50]

I have a base graph object and then I compute the mesh grid and plot it every time on the base layer.

[tpike3]

see attached proposal and provide comments and or critiques. A lot was taken from Ankit's proposal but based on the typeform where it needs to be submitted I was unable to add pictures in my test so no diagram.

Mesa NumFOCUS Small Development Grant Application Questions -draft.pdf

[wang-boyu]

Thanks Tom for preparing this! The submission deadline is June 16th? Hope we can get it this time. Besides, I think there's a typo in my first name (probably due to grammar checker : ))

[tpike3]

Whoops, sorry about that @wang-boyu, yes definitely auto-correct. I will get that fixed and clean up the language some more as well

Yes, June 16th is the deadline.

[ankitk50]

Hi Tom, very nice proposal. There is a typo in your email address [dot(cm)] (please ignore if that is intentional to avoid web crawlers).

[tpike3]

Proposal submitted..... Based on the feedback, I used the enclosed.
Submitted-- NumFOCUS Small Development Grant Application Questions.pdf

[Corvince]

Maybe this is also a good time to rethink splitting mesa into different packages? (#1295) With mesa-examples already gone it would be a smaller step to create an own repo for the frontend and leave the remaining bits of mesa as mesa-core.
This would mitigate the problem of large dependencies coming from the frontend frameworks discussed in this thread.

It would also allow us to keep the current frontend in a separate repo. I think the current ModularServer has some nice properties that would be a pity to miss. First of all the possibility to create truly custom displays is something I have rarely seen anywhere. Second it is fairly easy to host. You just have to start the server and that's it.

Separating the repo would also have the advantage that we could build the frontend gradually without worrying about breaking changes for mesa-core. Starting in a pre-v1 environment allows for rapid development, whereas we should be more careful with mesa-core.

On the topic of choosing a framework, I think it would be very nice to have the ability to trigger an action on clicks inside the visualisations as this would allow you to build more interactive experiences. I don't know which of the proposed frameworks allow this.

[Corvince]

And just to be clear: I think a pure python frontend is a very good idea and the advantages of the modular server are very niche. Focusing on a jupyter notebook friendly interface should definitely take precedence.

[tpike3]

I absolutely agree, I think the future of ABMs is a rich ecosystem of components so individuals can rapidly piece together models and grow their emergent phenomena of interest. I have dabbled in this Mesa Behaviors and Mesa Data but the largest challenge is sustaining it.

[maartenbreddels]

Hi,

you might also want to consider Solara (disclaimer: I'm an author for both Voila and Solara). Voila is focused on executing Jupyter notebooks, and rendering the output, where ipywidgets are the default way to build interactive interfaces. Solara has two parts:

1. UI part that contains ipywidget-based components with a React-like flavor over it
2. A server that can execute a notebook or Python script and render a single ipywidget.

The server part can be seen as an alternative to Voila if the focus is to only show a UI (and not notebook output) and will perform better due to having a single process vs 1 kernel/process per request.
Hope that helps in making decisions.

Regards,

Maarten

[rht]

I have made a version in Solara: https://github.com/rht/mesa-examples/blob/voila2/examples/boltzmann_wealth_model/mesa_solara.py. The user-facing code is https://github.com/rht/mesa-examples/blob/voila2/examples/boltzmann_wealth_model/run_solara.py. To run the frontend, simply do solara run run_solara.py. The UI is about as slick as Streamlit, yet much more performant. I have implemented step, play, pause -- all the necessary features for it to replace our Tornado-based frontend in the tutorial. We should be able to have a Colab-ready tutorial with this.

We then need to revamp the tutorial, simplify the cookiecutter, etc. Maybe we will have a 3.0 release a few months after 2.0. @ankitk50 if you are up for doing this once we know the NumFOCUS grant result.

[rht]

[ankitk50]

looks great! I can try out some more examples.

[rht]

It has been merged in the mesa-examples repo: projectmesa/mesa-examples#44, in the folder examples/schelling_experimental and examples/boltzmann_wealth_model_experimental.

Can be readily used via from mesa_models.experimental import JupyterViz (to install mesa_models, do pip install git+https://github.com/projectmesa/mesa-examples).

On another note, here is a blog post comparing Solara and Streamlit: https://blog.londogard.com/posts/2023-06-30-solara/.

[ankitk50]

I would work to integrate Solara with Mesa as part of the next release (3.0). The discussion is started at #1765 .