ankursinha.in/blog - Fedora

Building an AI assistant for computational modelling with NeuroML

2026-01-30T16:19:10+00:00

Brain models are hard to build

While experiments remain the primary method by which we neuroscientists gather information on the brain, we still rely on theory and models to combine experimental observations into unified theories. Models allow us to modify and record from all components, and they allow us to simulate various conditions---all of which is quite hard to do in experiments.

Researchers model the brain at multiple levels of detail depending on what it is they are looking to study. Biologically detailed models, where we include all the biological mechanisms that we know of---detailed neuronal morphologies and ionic conductances---are important for us to understand the mechanisms underlying emergent behaviours.

These detailed models are complex and difficult to work with. NeuroML, a standard and software ecosystem for computational modelling in Neuroscience, aims to help by making models easier to work with. The standard provides ready-to-use model components and models can be validated before they are simulated. NeuroML is also simulator independent, which allows researchers to create a model and run it using a supported simulation engine of choice.

In spite of NeuroML and other community developed tools, a bottleneck remains. In addition to the biology and biophysics, to build and run models, one also needs to know modelling/simulation and related software development practices. This is a lot, presents quite a steep learning curve and makes modelling less accessible to researchers.

LLM based assistants provide a possible solution

LLMs allow users to interact with complex systems using natural language by mapping user queries to relevant concepts and context. This makes it possible to use LLMs as an interface layer where researchers can continue to use their own terminology and domain-specific language, rather than first learning a new tool's vocabulary. They can ask general questions, interactively explore concepts through a chat interface, and slowly build up their knowledge.

We are currently leveraging LLMs in two ways.

RAG

The first way we are using LLMs is to make it easier for people to query information about NeuroML.

As a first implementation, we queried standard LLMs (ChatGPT/Gemini/Claude) for information. While this seemingly worked well and the responses sounded correct, given that LLMs have a tendency to hallucinate, there was no way to ensure that the generated responses were factually correct.

This is a well known issue with LLMs, and the current industry solution for building knowledge systems using LLMs with correctness in mind is the RAG system. In a RAG system, instead of the LLM answering a user query using its own trained data, the LLM is provided with curated data from an information store and asked to generate a response strictly based on it. This helps to limit the response to known correct data, and greatly improves the quality of the responses. RAGs can still generate errors, though, since their responses are only as good as the underlying sources and prompts used, but they perform better than off-the-shelf LLMs.

For NeuroML we use the following sources of verified information:

the documentation from https://docs.neuroml.org
NeuroML publications
other sources, such as well validated models from our Open Source Brain platform

I have spent the past couple of months creating a RAG for NeuroML. The code lives here on GitHub and a test deployment is here on HuggingFace. It works well, so we consider it stable and ready for use.

Here is a quick demo screen cast:

We haven't dedicated too many resources to the HuggingFace instance, though, as it's meant to be a demo only. If you do wish to use it extensively, a more robust way is to run it locally on your computer. If you have the hardware, you can use it completely offline by using locally installed models via Ollama (as I do on my Fedora Linux installation). If not, you can also use any of the standard models, either directly, or via other providers like HuggingFace.

The package can be installed using pip, and more instructions on installation and configuration is included in the package Readme. Please do use it and provide feedback on how we can improve it.

Implementation notes (for those interested)

The RAG system is implemented as a Python package using LangChain/LangGraph. The "LangGraph" for the system is shown below. We use the LLM to generate a search query for the retrieval step, and we also include an evaluator node that checks if the generated response is good enough---whether it uses the context, answers the query, and is complete. If not, we iterate to either get more data from the store, to regenerate a better response, or to generate a new query.

The RAG system exposes a REST API (using FastAPI) and can be used via any clients. A couple are provided---a command line interface and a Streamlit based web interface (shown in the demo video).

The RAG system is designed to be generic. Using configuration files, one can specify what domains the system is to answer questions about, and provide vector stores for each domain. So, you can also use it for your own, non-NeuroML, purposes.

Model generation and simulation

The second way in which we are looking to accelerate modelling using LLMs is by using them to help researchers build and simulate models.

Unfortunately, off-the-shelf LLMs don't do well when generating NeuroML code, even though they are consistently getting better at generating standard programming language code. In my testing, they tended to write "correct Python", but mixed up lots of different libraries with NeuroML APIs. This is likely because there isn't so much NeuroML Python code out there for LLMs to "learn" from during their training.

One option is for us to fine tune a model with NeuroML examples, but this is quite an undertaking. We currently don't have access to the infrastructure required to do this, and even if we did, we will still need to generate synthetic NeuroML examples for the fine-tuning. Finally, we would need to publish/host/deploy the model for the community to use.

An alternative, with function/tool calls becoming the norm in LLMs, is to set up a LLM based agentic code generation workflow.

Unlike a free-flowing general-purpose programming language like Python, NeuroML has a formally defined schema which models can be validated against. Each model component fits in at a particular place, and each parameter is clearly defined in terms of its units and significance. NeuroML provides multiple levels of validation that give the user specific, detailed feedback when a model component is found to be invalid. Further, the NeuroML libraries already include functions to validate models, read and write them, and to simulate them using different simulation engines.

These features lend themselves nicely to a workflow in which an LLM iteratively generates small NeuroML components, validates them, and refines them based on structured feedback. This is currently a work in progress in a separate package.

I plan to write a follow up post on this once I have a working prototype.

While being mindful of the hype around LLMs/AI, we do believe that these tools can accelerate science by removing/reducing some common accessibility barriers. They're certainly worth experimenting with, and I am hopeful that the modelling/simulation pipeline will help experimentalists that would like to integrate modelling in their work do so, completing the neuroscience research loop.

Zaphod is now on PyPi as zaphodtex

2025-09-19T14:31:15+01:00

A quick announcement post.

I had written Zaphod several years ago. It is a python wrapper around LaTeXdiff that enables a Git workflow for generating diffs in LaTeX documents. A demonstration is in the initial announcement post. It lets you generate a diff, and it also lets you pick and choose what bits from the diff you want to incorporate. It does all of this using Git, so no work is every lost, and everything can be undone (or redone).

I finally got around to publishing it on PyPi as a package. Unfortunately, the name, zaphod, was already taken, so I have published it as zaphodtex.

So, you can now install it on your system directly using pip or uv:

uv pip install zaphodtex

It will also make it easier for people to use it in their projects, on GitHub Actions and so on.

2025: Week --37 update

2025-09-12T11:39:55+01:00

The last time I wrote an update was, funnily enough, about a year ago. Also week 37. Clearly a lot has happened since then, but it won't all fit in this one post. I'll limit this post to the higher level details

Job/Research

Work has been extremely busy as always, and also busy enough where my backlog has been growing and growing. There is just so much to do.

Modelling

I have been working on a number of computational models.

We are close to having the full Human L2-3 Cortical Micro-circuit converted to NeuroML. The cells have all been standardised. This includes the ion channels, and the various morphologies and biophysics. What remains is replicating the network behaviour. This is not the hard bit. We have already done all that.

Another model I have been working on is the Golgi cell network that was previously developed in the lab (https://doi.org/10.1016/j.neuron.2021.03.027, model: https://github.com/sanjayankur31/GolgiCellNetwork). There are several predictions about how the Granule cells in the Cerebellum function, and the effect of Golgi cell inhibition on them that will be investigated using this model.

The Golgi cell network model also led to a CookieCutter template, but that merits its own post.

NeuroML

Since the last update, we have publish a NeuroML paper in E-Life after a few rounds of review (https://doi.org/10.7554/eLife.95135.3). This was a great achievement and it did take a lot of work.

Other than that, multiple new releases of the NeuroML libraries have been made. We continue to maintain them and push out improvements and fixes regularly on PyPi under the NeuroML PyPi organisation: https://pypi.org/org/neuroml/.

Google Summer of Code

We participated in Google Summer of Code (GSoC) again this year. Our candidate, Hengye, did an excellent job of converting various bits of the Macaque auditory thalamocortical model to NeuroML. The conversion also lives on GitHub, under the Open Source Brain organisation: https://github.com/OpenSourceBrain/Macaque_auditory_thalamocortical_model_data/tree/feat-neuroml-gsoc. We are going to continue working on this to standardise the full model.

Open Source Brain

Open Source Brain (OSB), an integrated web-platform for neuroscience, continues to tick along. We have made a number of maintenance updates and bug fixes. A new release is ready to be deployed to production after more testing.

We have worked on also integrating the E-BRAINS models into OSBv2. I need to test the E-BRAINS adapter implementation to prepare the PR for merging. This was blocked by some access issues, but they have now been ironed out and this can now proceed.

A paper on OSB is in the works, and should be published as a pre-print in the next coming months.

Grants and funding

This has taken a lot of time since the last update. We have applied for two Wellcome Discovery Awards, two Software Sustainability Institute grants, and are going to apply for several more.

So far, we have not been lucky enough to be accepted even though we were highly rated. Each Wellcome grant application takes about a month of dedicated work. Further, once triaged and accepted for interview, it is another two weeks of preparation. So, it has been a lot of work for no rewards at all.

There just seems to be quite a limited amount of funding, and the intense competition for them means that the success rate for most grant applications has dropped. So, more time spent on writing grants with fewer rewards. It is currently an even tougher time to be a researcher/academic than it already normally is.

Volunteering

I have managed to find time for volunteering, but with the increased work load, this time has reduced.

Software carpentries

I completed my Software Carpentry Instructor Training, and now am a certified instructor. The training was excellent. It pointed out lots of good practices for teaching newcomers/novices computational skills.

I will probably teach a session or two here at UCL this year and if time permits do a couple of classes for the Fedora classrooms.

Fedora

Package maintenance continues. So does the Fedora Join SIG.

We have shifted how we do things in NeuroFedora. We just had too many packages, and it was no longer clear if people were using these. So, we are now testing lots of Python packages directly from PyPi instead of packaging them. You can read more about this post: Packaging changes at NeuroFedora.

The Join SIG is doing well. Quite a few new people are now helping out with onboarding and the Welcome to Fedora process, which means we have so much more human resource at our disposal. There are also more discussions on how we can do better. So we expect tweaks and improvements to make the "Welcome to Fedora" process even better.

OCNS

I remain an elected member of the Board of Directors for the Organization for Computational Neuroscience. I could not get a Schengen visa to attend the annual conference in Florence, though (again). That was quite disappointing, but not a lot can be done about it. Europe is really popular in the summer, and there just aren't enough appointments for visa applications.

Summary

That will do for now. There is certainly a lot happening on multiple fronts, and I have been busy---too busy to write blog posts even. I am going to try to restart regular blog writing, but that's what I said last year before dropping out. So who knows.

Bash functions for working with UV

2025-09-10T17:04:09+01:00

I finally made the switch from pip to uv recently. uv is much quicker that pip. I won't go into how/why here, but I will link you to this video that explains it. When working with packages such as PyNeuroML that have quite a few dependencies, the speed up begins to matter, especially when one is developing and may create and remove virtual environments quite often.

I used to use Pew to manage my Python virtual environments. It is a great tool. Unfortunately, it isn't quite maintained any more, and that means support for things like uv are probably not going to happen soon.

I went looking for a similar wrapper around uv and there are some, but they're simple enough where I thought writing my own bash functions/aliases is probably preferable. So, here's what I've added to my bashrc. They are a number of functions/aliases to:

list virtual environments
create a new virtual environment using uv
activate virtual environments
remove virtual environments
install packages using uv

A simple bash shell completion function is also setup. The listing and removal functions aren't really uv specific here, but I prefix them with uv for consistency.

(I don't use another shell, so please adapt these to whatever you use):

# uv helpers
export VIRTUAL_ENV_HOME="$HOME/.virtualenvs/"
uvnew () {
    if command -v uv 2>&1 > /dev/null
    then
        pushd $VIRTUAL_ENV_HOME && uv venv "$@" && popd
    else
        echo "uv not installed"
    fi
}
uvls () {
    ls $VIRTUAL_ENV_HOME
}
uvrm () {
    venv_name=$1
    read -p "Delete env \"$venv_name\"? Are you sure? (Yy)" -n 1 -r
    # (optional) move to a new line
    echo
    # input is stored in REPLY if no var is given to read
    if [[ $REPLY =~ ^[Yy]$ ]]
    then
        echo "Removing $VIRTUAL_ENV_HOME/$venv_name"
        rm -rf $VIRTUAL_ENV_HOME/$venv_name
    fi
}
_venv_completions () {
    local cur
    cur="${COMP_WORDS[COMP_CWORD]}"
    pushd $VIRTUAL_ENV_HOME 2>&1 >/dev/null
        COMPREPLY=($(compgen -o dirnames -- "$cur"))
    popd >/dev/null 2>&1
}
uvactivate () {
    venv_name=$1
    if [ -e "$VIRTUAL_ENV_HOME/$venv_name/bin/activate" ]
    then
        source "$VIRTUAL_ENV_HOME/$venv_name/bin/activate"
    else
        echo "Could not find activation script"
        echo "Available venvs are"
        uvls
    fi
}
complete -F _venv_completions uvactivate
complete -F _venv_completions uvrm

alias uvpip="uv pip"

On Fedora, uv is in the repositories, so it can be installed with:

sudo dnf install uv

If you have your own wrappers for working with uv that are better than these simple bits, please drop me a word.

Accessing UCL VPN using OpenConnect on Linux systems

2024-11-25T14:49:25+00:00

I needed to use the UCL VPN again, on my Fedora/Linux machine. Linux isn't really supported by the university infrastructure, but there are instructions that others have come up with and they had worked for me the last time I'd needed VPN access. Unfortunately, that was a few years ago, and things have changed a little since then. Notably, UCL has introduced two factor authentication (2FA).

I had to look around a little but I did manage to get it to work again using NetworkManager. I thought I'd write it up quickly so everyone that needs it, including future me, have a quick reference to look at.

This is on Fedora 41 with the following OpenConnect packages:

$ rpm -qa \*openconnect\*
openconnect-9.12-6.fc41.x86_64
NetworkManager-openconnect-1.2.10-6.fc41.x86_64
NetworkManager-openconnect-gnome-1.2.10-6.fc41.x86_64

In NetworkManager one needs to create a new VPN connection with the following settings:

Here are the settings in a list too:

VPN Protocol: Cisco AnyConnect or OpenConnect
Gateway: vpn.ucl.ac.uk
User Agent: AnyConnect
CA Certificate: <None>
Proxy: <leave blank>
Allow security scanner trojan (CSD): Yes (checked)
Trojan (CSD) wrapper script: /usr/libexec/openconnect/csd-post.sh
Reported OS: Windows 10 (I didn't try another)
Machine certificate: <None>
Machine private key: <will be greyed out>
User certification: <None>
User private key: <will be greyed out>
Use FSID for key passphrase: No (unchecked)
Prevent user from manually accepting invalid credentials: No (unchecked)
Token mode: TOTP - manually entered

This is similar to what had worked before. What changed:

It didn't work without setting the User Agent to "AnyConnect"
I set the token mode to "TOTP - manually entered"

This opens up a web login page where one can enter their credentials.

Week 27--36 update

2024-09-06T15:06:07+01:00

It's been a busy summer, so here's a consolidated post on what went on. I'm sure there's a lot more, but here are the salient points.

Conference: CNS 2024 in July

The annual conference for computational neuroscience, held by the Organization for Computational Neurosciences happens in July every year. It alternates between Europe and non-Europe locations to ensure that it's accessible to as much of the research community as possible. This year, it was organised in Natal, Brazil.

We had a tutorial on NeuroML and a couple of posters accepted at the conference. We also had a couple of posters accepted.

I'm also on the Board of Directors for CNS. As part of my duties, I organised a career development session this year on life "beyond academia" where we had a panel of people who had trained in academia but now had moved on to non-academic careers. The idea was to give students and early career researchers (ECRs) some idea of the "black box" that is industry, given that most of us have never worked in industry and therefore don't quite know much about it, which makes moving from academia to non-academic careers quite a daunting task.

The conference was great. It was nice to see a lot of our colleagues, who we hadn't seen in a while. Natal, and Brazil in general, was a brilliant place to go to too. We had numerous Caipirinhas, delicious food, and enjoyed the warm weather. The days were hectic as always---absorbing information non-stop from 9 o'clock till the end of the day at about six o'clock, but then heading over to the socials and staying out late too.

I had half a day extra or so after the conference, and a few of us drove to Praia de Pipa (Pipa Beach). It was absolutely beautiful. Since I was flying out in the evening and had already checked out of my hotel, I didn't get into the water, but we paddled around for quite a bit before having a scrumptious sea-food lunch.

NeuroML related

NeuroML is a standard and software ecosystem for biophysically detailed neuronal modelling.

Google Summer of Code

Google Summer of Code finished recently. Both Ioannis and Aditya passed their final evaluations, of course. They both did great work and we were very lucky to have them.

Aditya completed implementing the SWC to NeuroML converter. I reviewed his PR and made some tweaks before merging it in. The new converter is now part of the recent PyNeuroML 1.3.9 release. One can convert morphologies, for example from https://neuromorpho.org, using either the API or the command line tool:

pynml-swc2nml <swc file>

It runs a number of tests when loading the SWC file, and then validates the NeuroML once generated.

Now that we can export SWC files to NeuroML, we also can visualise them. We first convert them to NeuroML and use our NeuroML visualisation tools. This means that one can now do:

pynml-plotmorph -i <swc file>

One limitation to keep in mind with our handling of SWC is that each SWC file must only hold one neuron (cell), since this is what the standard that NeuroMorpho.org follows specifies.

Ioannis completed a number of tasks related to the Vispy viewer. Initially, our code was using a small number of meshes with many InstancedMesh objects because my understanding was that this was the most efficient way of going about it. Later though, we realised that instead, we could just use one Mesh that included all our individual shapes (spheres and cylinders) and that would be much more performant. So, I refactored our visualization code to use a single mesh. This really simplified a number of things, including lighting and "picking". We can also store the single mesh to a file so that it can be loaded in other analysis tools and visualisers like Paraview. It opens up a bunch of possibilities of what we can do with the morphology visualisation.

Your browser does not support the video tag. Download it from `here <{static}/images/20240906-hl23.mp4>`__

Our viewer can also be used in Jupyter notebooks now, although there's a bug when trying to use multiple visualisations in the same notebook that upstream is looking into.

Paper review responses

A lot of our time went in responding to reviews for our submission to E-Life. As part of the improvements suggested by the reviewers, one was to allow neuronal morphologies to be stored in separate files that could be "included" in other files. We added this functionality too. It had been a long open issue anyway, and this gave us the opportunity to finally implement it. It did require quite a few changes in our Java and Python stacks, but it's all complete now, and our modified paper has been re-submitted for review. The pre-print has also been updated to the latest version.

INCF/OCNS Software Working Group

The working group is ticking along. We hosted another session where Adam Tyson spoke to us about the software tools their group develops.

The Neuroinformatics Unit at the Sainsbury Wellcome Centre develops software tools for systems neuroscience.

We'll organise more sessions now that the summer holidays are over.

Some time off and other things

I took a few days off here and there to relax too; it wasn't all work. Since I'd already been away for the conference, I didn't have another holiday planned this summer, though. A few of our friends got married over the summer and we were lucky enough to be there to share their special day with them. We were also lucky enough to see Shania Twain and Stevie Nicks perform in London at the British Summertime Festival at Hyde Park. Obviously very moving, and great fun.

So, it's been a good couple of months.

Week 26 update

2024-07-01T17:13:10+01:00

NeuroML related

NeuroML is a standard and software ecosystem for biophysically detailed neuronal modelling.

Windows issues

We have a few interns working on NeuroML projects and a few of them that use Windows as their primary operating system have reported issues on installing/using various bits of the NeuroML stack. Unfortunately, none of us on the NeuroML developer team use Windows, so we haven't run into these issues and they're harder for us to fix.

Generally, installing the basic bits of the NeuroML stack on Windows is not too hard. One needs to have a functioning Java Runtime Environment (JRE) along with a Python installation. Both of these aren't very hard to install, since installers for Windows are readily available.

From then on, one only needs to set up a virtual environment and install pyNeuroML using pip. This pulls in all the Python dependencies, and we also bundle the necessary Java bits with it.

Other optional dependencies, though, can be tricky. For example, one can install NEURON on Windows using the installer they provide, however, one also needs to have a compiler tool chain to use NEURON, and that isn't necessarily straightforward. I still don't know how this is to be set up correctly.

Next, a few folks have reported issues getting our Vispy based visualization code to run on Windows. Vispy requires a backend to run, like Qt5 or Qt6, so one has to make sure these work on their Windows installs to use Vispy.

The Windows Subsystem for Linux is something lots of Windows users now use. It's great for development, but GUI elements don't seem to work on it out of the box (from what I hear).

Using SWC morphology files

Screenshot of NeuroMorpho.org

SWC is a specification/format used to store reconstructions of biological entities, like neurons. It's commonly used in various places like on https://neuromorpho.org, a database of neuronal reconstructions.

A use-case that NeuroML needs to support is the use of these reconstructions in models. Of course, these reconstructions are not always made for use in models, so they can have various issues that need to first be corrected. We have a page on these in the docs.

A few tools do allow the semi-automated conversion of SWC morphologies to NeuroML. CVApp is one such tool. We made some updates/fixes to it this week to ensure it works correctly, and also updated the documentation to add a page dedicated to the conversion of SWC to NeuroML.

We also support storing these NeuroML morphologies in separate files now, and I updated pyNeuroML to also visualise these using our Vispy viewer

Google Summer of Code

I merged Ioannis's PR that included tweaks to our 3D visualiser to make cells look "upright". I also made some other tweaks to it to show the X, Y, Z, axes with the plots and improve the camera view. Ioannis is now looking into making our visualisations work in Jupyter notebooks.

I reviewed Aditya's PR and gave some feedback. He's made his changes now, and I've got to do another review, hopefully tomorrow. In the meantime, Aditya is playing with CVApp and other tools to gain a better understanding of the SWC to NeuroML conversion process.

Paper review responses

We worked on replying to the reviewers' responses on our submission to E-Life. We hope to send the updated version back in this week. This took quite a while.

INCF/OCNS Software Working Group

I met Adam Tyson of the Sainsbury Wellcome Centre at the Neuroscience Symposium at UCL the other week. I'd asked them if they'd do a talk for our Software Working Group on the software tools their group develops. They were happy to do one, so I set it up last week.

The Neuroinformatics Unit at the Sainsbury Wellcome Centre develops software tools for systems neuroscience.

Week 25 update

2024-06-21T13:16:43+01:00

UCL

The UCL Neuroscience symposium was on Thursday. The talks and posters were great and very informative, e.g.:

on visual processing (using really cool virtual reality experiments)
on the role of sleep on synapses numbers
Dementia with particular focus on Alzheimer's disease and the role of the tau protein

We'd also had a really interesting talk on the GLP-1 receptor, which is involved in the secretion of insulin for maintenance of blood sugar levels, at our Neuroscience, Pharmacology, and Physiology (NPP) departmental seminar.

I'm also involved with the mentoring programme that the Division of Biosciences runs for PhD students. We had discussed this at the divisional meeting last week, and now we have a few tasks to carry out to improve the programme's reach to more students.

OCNS

The annual conference of the Organization for Computational Neurosciences will happen in July in Natal, Brazil, this year.

I'm organising the career development workshop at the annual conference of the Organization for Computational Neuroscience as part of my Board member responsibilities. This year, we're hosting a "beyond academia" session where we'll have folks who have worked or are currently working in industry after their doctorates and initial academic positions will speak about their experiences. The goal is to discuss careers that academics can take up outside of the traditional academic research domain. With help from a number of Board members and others at the lab at UCL, I had a list of people to reach out to. We now have a panel of four, so we're on track.

The programme for the conference is also now online on Sched, and registration is still open.

I also had a quick meeting with the OCNS EDI chair, Eirini Mavristaki, about the mentoring programme that the OCNS is trying to set up for its members. Eirini has already got most of it ready, and I'll help with the remaining bits to try and launch it at the conference or soon after.

Week 24 update

2024-06-17T12:37:22+01:00

Setting up Vim for multi-repo Java projects

Because the NeuroML Java code is broken down into a number of different Java packages (org.neuroml.import, org.neuroml.export and so on), while working on jLEMS, I had to remind myself how to work on multi-repository/multi-project Java projects in Vim. I use YouCompleteMe (YCM) which is quite excellent for completion and code navigation. I had to figure out how to configure it to allow me to jump from one Java project to another (like one would do in an Eclipse workspace).

The documentation didn't really help me, unfortunately. It says to use Eclipse/Maven/Gradle configuration files that JDT (the engine YCM uses for Java) understands, but doesn't really say much about how to configure these. So, were the pom.xml files that our projects had enough? Didn't look like it---they do have dependency information, but only as packages, not as related source directories. So, I wasn't sure how to go about it. I tried to copy all my Java repositories into a "top level" (workspace style) folder and configure that as a "multi-project" Java maven package. I don't think that quite worked, or perhaps I didn't know how to quite set it up. I didn't want to have to create a new project either.

Eventually, I tried an Eclipse .project file to the top level directory which tells JDT what project/repository folders are related to each other. Again, I wasn't sure how to write this by hand, but turns out a minimal one is quite sufficient.

So, for example, my NeuroML/software folder looks like this:

AllenInstituteNeuroML/    inspyred/  libNeuroML/          netpyne/         NeuroMLCAP/             OpenCortex/          org.neuroml.model/                  pylems/
biosimulations-runutils/  jLEMS/     MDF/                 neuroConstruct/  NeuroMLlite/            org.neuroml1.model/  org.neuroml.model.injectingplugin/  pyNeuroML/
eden/                     jNeuroML/  modelspec/           NeuroML2/        neuroml-template-repo/  org.neuroml.export/  osb-model-validation/               pynsgr/
generateds-code/          LEMS/      morphology_include/  NeuroML_API/     neurotune/              org.neuroml.import/  pyelectro/

The main exporter code is in org.neuroml.export, but it references code in jLEMS and org.neuroml.import and so on. Adding a minimal .project file to this top level directory was enough:

<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
        <name>parent-project</name>
        <comment></comment>
        <projects>
        </projects>
        <buildSpec>
                <buildCommand>
                        <name>org.eclipse.m2e.core.maven2Builder</name>
                        <arguments>
                        </arguments>
                </buildCommand>
        </buildSpec>
        <natures>
                <nature>org.eclipse.m2e.core.maven2Nature</nature>
        </natures>
        <filteredResources>
                <filter>
                        <id>1718191734481</id>
                        <name></name>
                        <type>30</type>
                        <matcher>
                                <id>org.eclipse.core.resources.regexFilterMatcher</id>
                                <arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
                        </matcher>
                </filter>
        </filteredResources>
</projectDescription>

Week 23 update

2024-06-11T11:24:46+01:00

Internet woes

Our internet connection went down last week, and was supposed to by Tuesday. They said it was an issue at the "exchange" and that they didn't need to access our home to fix it. Get to Monday, and I get a call from the engineer at work saying it was issue with the local fibre cabinet and that they need to tinker with our connection to the router to figure out what had gone wrong. So, I dropped everything and rushed home (as you do, if you want internet access at home). It took them an hour or so, but they did manage to fix it. So we're back online.

NeuroML related

NeuroML is a standard and software ecosystem for biophysically detailed neuronal modelling.

GSoC

Work continues on this front. Both Aditya and Ioannis already have pull requests open, so I've been reviewing them and providing feedback. We're making sure we follow best practices right from the start---so doc strings, unit tests, type hints are all already in use.

I also added coverage information to our pyNeuroML CI. It doesn't use a third party service like Coveralls/Codecov/Codespace at the moment. It's a combination of two GitHub actions---one summarises the coverage that we generate using pytest-cov, and the other comments on the pull request. It works well enough. The commenter action replaces to same comment each time too, so it doesn't spam the pull request with repeated comments.

This has pointed out that some of our code needs more testing, so we've put that on our agenda too now.

Model conversion

I continued to work on converting the Purkinje cell model from Zang et al. Using my test script, I've converted another couple of channels. While converting the "Large conductance Ca2+ activated K+ channel" (mslo.mod), I was reminded of this excellent features of LEMS:

LEMS is unit and dimension aware: one does not have to worry about units while writing equations, one can use whatever units one wishes and LEMS will convert them to the right multipliers depending on the dimensions.

So, for example, even if a model component provides the temperature value in degrees C, LEMS will convert this into Kelvin when it's being used somewhere. Here's how it needs to be explicitly converted in the mod file:

alpha = exp(Qo*FARADAY*v/R/(273.15 + celsius))

Here's how the corresponding LEMS looks:

<DerivedVariable name="alpha_beta" dimension="none" value="exp((Qo_Qc * Faraday * v/R) / EXP_TEMP_CELSIUS)"/>

(The variable names have been tweaked so that the same derived variable can also be used for other calculations that follow the same formalism)

Here are the plots for the kinetic state variables for the NEURON and NeuroML conversions for a simple protocol where we:

create a simple single compartmental cell, with only a soma
add the ion channel to it
add the minimal biophysics
use a "Calcium clamp" to set the intra- and extra-cellular calcium concentrations to some values for a part of the simulation

We then record all the states and plot them to see how our conversion went. You'll see that they match almost exactly, which is always a good sign.

Values of kinetic state variables from a test simulation of the original implementation in NEURON.

Values of kinetic state variables from a test simulation of the NeuroML conversion.

There are two more channels left to convert. These are of a third type---they use the "GHK" (Goldman-Hodgkin-Katz) equation. I'll work on converting them next. Then, we need to place these on the cell morphology to verify that the NEURON implementation and our standardised NeuroML implementation show the same dynamics.

ankursinha.in/blog - Fedora

Building an AI assistant for computational modelling with NeuroML

Brain models are hard to build

LLM based assistants provide a possible solution

RAG

Implementation notes (for those interested)

Model generation and simulation

Zaphod is now on PyPi as zaphodtex

2025: Week --37 update

Job/Research

Modelling

NeuroML

Google Summer of Code

Open Source Brain

Grants and funding

Volunteering

Software carpentries

Fedora

OCNS

Summary

Bash functions for working with UV

Accessing UCL VPN using OpenConnect on Linux systems

Week 27--36 update

Conference: CNS 2024 in July

NeuroML related

Google Summer of Code

Paper review responses

Open Source Brain related

End of grant report

INCF/OCNS Software Working Group

Fedora related

Some time off and other things

Week 26 update

NeuroML related

Windows issues

Using SWC morphology files

Google Summer of Code

Paper review responses

INCF/OCNS Software Working Group

Fedora related

Week 25 update

NeuroML related

Google Summer of Code

Model conversion

UCL

OCNS

Fedora related

Week 24 update

NeuroML related

GSoC

Model conversion

Setting up Vim for multi-repo Java projects

Week 23 update

Internet woes

NeuroML related

GSoC

Model conversion

Fedora related