How to create my own system to work through collab notebooks with

[MatisPatel]

Hello,

I feel like this is a deeply noobish question but I come from a functional programming background and a biology background so some of the jargon around ODEs is beyond me.

I don't understand how to register my own custom ODEs. I have tried looking at how they are defined in psl.autonomous and copying it but that doesn't seem to generate the right class that the tutorial notebooks expect.

I also tried looking a the initial notebooks on syntax, but i didn't follow the cyclical graph explanation for a system or how that relates to making a new ground truth system for training.

I found a previous discussion #131
which looked promising however I can't seem to access the ODESystem class easily, and I run into several errors. I have managed to register a system using psl.base

from neuromancer.psl.base import ODE_Autonomous, cast_backend
import numpy as np

class LV_Harvesting(ODE_Autonomous):

    @property
    def params(self):
        variables = {'x0': [0.1, 0.5]} # Initial condition
        constants = {'ts': 0.1} # Time step for numerical simulation
        parameters = {'r': 2.0, 
                      'K': 1.0,
                      'h': 0.1}
        meta = {}
        return variables, constants, parameters, meta
        
    @cast_backend
    def equations(self, t, x):
        dNdt = self.r * x[0] * ( 1 - (x[0]/self.K)) - x[0]*self.h
        dhdt = self.h * x[0]
        return [dNdt, dhdt]

But I then get stuck in trying to convert it into a UDE problem.

Apologies if I am missing something obvious. If there is something obvious am missing I will fix it and try to add a tutorial notebook on the process if people think that would be useful.

Thanks for the help,
MP

[drgona]

Hi @MatisPatel, yeah I see how this can get confusing. Our PSL submodule is to be deprecated as it is overloaded with both pytorch and numpy backend.
For ODEs we encourage the users to use Classes in our ode.py.

I encourage you to have a look at this ODE example

Here, we define a custom ODE class for the Brusselator system as follows:

class BrusselatorParam(ODESystem):
    def __init__(self, insize=2, outsize=2):
        """

        :param insize:
        :param outsize:
        """
        super().__init__(insize=insize, outsize=outsize)
        self.alpha = nn.Parameter(torch.tensor([5.0]), requires_grad=True)
        self.beta = nn.Parameter(torch.tensor([5.0]), requires_grad=True)
    
    def ode_equations(self, x):
        x1 = x[:, [0]]
        x2 = x[:, [-1]]
        dx1 = self.alpha + x2*x1**2 - self.beta*x1 - x1
        dx2 = self.beta*x1 - x2*x1**2
        return torch.cat([dx1, dx2], dim=-1)

This class inherits from the ODESystem implemented in ode.py.
This ODESystem class is meant to be our primary interface for defining ODE systems in Neuromancer, all you need to do here is to implement your forward pass in the ode_equations method. Then you can use our integrators to solve the ODE and embed it as a symbolic layer via the Node class. To perform rollout on this symbolic layer we introduced the System class that acts as a recurrent net constructor on the Nodes.

For more examples you can also have a look at the Neural ODE and universal differential equation notebooks.