I'm pleased to meet you, I'm serious here, I work at the University Medical Center of Rotterdam in
the Netherlands, but by training I'm an engineer.
So I was fascinated by computational biology and I ended up working on it, this is what I learned.
So this is a quite fascinating topic from a programming aspect, as you'll see.
So we wish we didn't have to make all those dishes and wait for the neurons to behave
and the neurons dying and all that.
And we want to have the theories, but neurons because they think are the worst thing to
try to simulate.
They think themselves, you can't think about them.
So we have all those models on all those levels of detail, you see here, and there's
so complex.
Okay, we're most, we think we're the same one, but we end up having to use computers.
In a huge case of space, we want brain readers, we wish we have virtual humans, okay,
one other.
Over time, some things are being learned over weeks.
There's many time steps.
So what's happening now with this field is there are different ways to formulate a model.
Some people want to see how it works with FMI and see, I have very, very low resolution
models on the left.
Others say, okay, I can take a neuron and reduce it to a single dimension at a point, a
little ball.
So I'm going to play with netcours of the balls, that's in the middle.
As I'm going to say, no, I want to see the exact effect on the surface of the membrane
of this cell.
And this does matter.
For example, for drugs.
And then we have the, we try to simulate chemistry basically as fast as we want.
But then, the worst is, when we want to have a little bit of this, because we really want
to start with this part of the detail, but we also need to simulate the surroundings.
And then those come together and becomes a mess.
So every simulator I named up here has its own algorithm inside to process the data.
So if you want to port it, you have to reconsider everything, and it will only behave optimally
in terms of performance for one type, not the other one.
Then you want to port it, you have to think on different concepts.
Each one works in its own way.
And if that, if they don't agree on any point, you have to work out them.
Then they have the algorithm, which in the case of neuron was designed in the early 80s.
So we have problem where we would like to use accelerators.
And I said, many different level of details, imagine you want this and that and that
to work together and you have to work through the, it's one on squirks.
So what do we do then?
I wanted to do HPC on this stuff.
Instead, I have to learn the theory.
So I wanted to know stuff about how many flops is this, how much memory is that.
So I can design my kernels.
This is a summary.
Some people like computers, you know what I mean?
Go and say, I'm going to make one code for one model and be done with it.
And this is the way to get all the flops.
But then you have to rewrite.
And again, again, again.
It's unsustainable.
Then others say, I will have my engine and I would put everything on top of my engine,
kind of like Minecraft.
This, but then the other person goes and says, then they have to do more something.
Good luck putting your model.
And we do need to put models because every person, every neuroscientist have three different
opinions about how something should be modeled.
They need to characterize all the time.
So we wish we had the third one.
We wish those layers here are decoupled.
We wish you would say, like we do in papers, we write text, we could do language to say
what we mean.
And then some magical genie would come and deploy it to this or that or that hardware resource
we have, or some specialized kernel.
So if I want to simulate a grid with one neurons, I have a kernel for a grid with one
neurons and I'm not doing circles around that.
So I contribute to the mess of the landscape by making my own software.
So, but still, like, when I do everything at once, okay, how so, you'll see how.
So first of all, I didn't do all the job.
Someone made this nice declarative script from over here and I owe this person.
It's neural mel, it's kind of like HTML for neurons.
It's again, same structure data, but it's the most declarative thing you'll find around.
And what this means is we don't care about the engine anymore.
We said what we meant and the engine's problem to do to work as it will.
Now there are some issues with accuracy, let's say, with numerical methods, but this is, again,
we can work in another level, it shouldn't matter, we want to ignore that like that.
No then, I take it in XML, then I can pick it apart with very good details I want to go into.
You do the time to decide on how to take different choices, make different choices.
If it's like this, I'm going to use this kernel, otherwise, I'm going to use that kernel.
Maybe I can morph them with, as you can see, as you see, this is quite like a compiler.
So we want a compiler for neural methods and we usually don't have this sort of problem in software
we make for simulations, neurons are the worst, I'll go to it if I have time, but so we've been using it for a while.
Most of the time, they want more features than neural methods standardized, so we're exchanging it as well as I'll explain.
We have a very nice user guide that put two slides in the last moment.
We have people, but this doesn't mean it's Python based, it's actually common I based.
You can use it however, but people is the best way to deliver stuff to people without having to think about the architecture.
Having them on zip it in the wrong location, blah, blah, blah.
So really, I'm hijacking people, anyhow.
Reiterate, there is a front end, there is the sources of modulfines, maybe the user, hopefully.
They all are based in your email.
Then we do our stuff, I'll explain that part, and then we can do flow to even neural morphic hardware, like the one they did a human brain project.
If it fits the device, there's no reason it could run if we can understand it from your email.
Again, it's like a compiler.
In more detail, basically, those stages, a bit more described, but you'll see how easy it is to plug in something some new kernel or some new device.
Take the description, resolve it so we know which entity refers to what entity disambiguate, okay, that's technical.
Then find it, okay.
Can I run it?
How?
If I can find the way I can do it, then convert it to materialize this, how I'm going to do it,
and then run some optimized, hopefully, execution.
So, there is a vanilla backend that does everything your email has.
And there are some nice, there's some nice API, which is used for people to put their own plug-ins.
So, if you think of some magical device like my colleague did, I'm a physicist.
Like my colleague did, made this accelerator for this subset.
He knows how it's made, he knows if something will work or not ever.
He can put the detector, he can also put the computer at the same time,
and then loads here is FPGA and run the buffers as they should.
Likewise, repeat for all devices or for all specialized cabinets.
What simple?
So, this here, I just mentioned this, I want, okay.
So, the next step is we want more neural mel because people want even more wacky experiments.
Like, someone wants to simulate this world there, it's very famous, warm.
The can of this elegance.
Somewhere, they want to see the electromagnetic field of the neuron,
and maybe even interact with that.
Which has, we have electromagnetism, suddenly, in the order of physiology, not good.
But we have to do it.
See, absets.
You thought one neuron connects one another neuron?
Oh, maybe that's the thing, you don't.
Formalizes that.
Then, here, we want optimizations.
So, we want to see, we don't humanistics.
Is this efficient?
Where is the balance on which accelerator?
So, we can take this subset, let's say, we have this stuff to do.
This has this, and that's such features.
We can make a cannon for this, a cannon for that adaptively.
This would be, one, this could not just be done by hand.
We need some support.
So, neuron is like our LLVM for this stuff.
And then, we have backends for devices.
We can also export to jacks.
Why would we do that?
If people know about machine learning, what they have to do,
it's a very nice acceleration and optimization library.
We can, so, we can do parameter feeding.
It's all the rates now in computational science.
We can interface without a jacks simulation software
for robotics, for example.
And we can run it on the TPU without having to learn TPU.
That's, in my opinion, the best selling point.
So, conclusion.
And where geeky stuff is limited by when you want to port it.
Ha, you only help.
But that's how we get out of hell.
We use a declarative specification that we work like a compiler.
This way, geeks like me can do the corpus to see what people want
and decide what to optimize for.
Then users do not have to write HBC codes,
because then you decide this and they do it awfully.
I've seen them.
So, I just mentioned this very nice website with 3D renders,
also in hundreds of animations.
It took me six work a month.
So, please look at it if you care about simulating neurons.
And also, you can run everything in the column.
Binder, it's quite some effort underneath,
as the program is known.
So, this does conclude my presentation.
So, now, I can take questions.
My book.
Please excuse me, I forgot.
My boss is this guy.
The neuro computing lab in Rotterdam.
So, you can also point questions there.
Congratulations, sir.
Please go ahead.
Superdetic, eh?
Yeah.
But, I was pointing to write my own simulator.
For neurons.
For the neurons.
But, now that I think I think this is a much better option.
So, would you be open to setting a Vulcan backend,
which is in your view?
If we must do Vulcan, we can do Vulcan.
I was hoping I could get all the birds with one stone with jacks.
So, the thing is, Nurema is very expensive.
You can make the backend, the plugin, if you want,
as complex, as you want to go along it.
You can do one type of neurons.
You can do all of the neural melids.
Quite an explanation.
I hit that slide.
It's huge.
I know that drags is the default standard.
No, no, it's not.
Imagine.
What?
Do you think it's not very efficient?
I see.
My second question was, a huge part of the Vulcan backend,
or a Vulcan workflow runtime.
It's been just just jumping in between the simulator,
and the cybernetic model.
So, is there a Vulcan glowing,
because Vulcan will basically rot the pental file,
which cybernetic then read?
Yes.
Of course, you can place the files with pipes in Linux.
You can use a memory event.
I think that's absolutely the best you can get.
But, basically, as you know, open worm has 300
and two neurons always.
So, you can submit all the effect of them
and from them, on another level of the water simulation, let's say.
So, I didn't expect this on one of the similarities with neurons.
I'm very happy to meet you.
So, we have plenty of time for another question.
Yep?
Okay. So, I understand the MPI...
Yes.
Generally, I go,
to what if we didn't get to implement all the tools
because of the GPU power?
Of course.
What do you think of this question?
Yes.
So, the question was,
would it make sense to also port to Qda before Jax?
And indeed, this was the plan.
But, I first focused on extending the standard to support more models
because NeuroMail is an effort.
It tries to have the least common denominator
because it has to support everything.
It has to run everywhere.
People exploit specific scenarios, quirks.
And I think I made something that's now in preparation.
It's very, very submitted about how to extend them
while keeping the declarativeness.
So, for example, so then Qda,
there is a student from Shanghai,
who is interested in making Qda backend.
I would go for Qda personally,
but then for exotic stuff,
people seem to convert to something for accelerators.
Whatever it is, I will take it.
The big issue is NeuroMail is very, very extensive
because it tries to please everyone.
So, a complete vanilla backend for GPUs
is more involved than a CPU backend.
And as a side thing, because you mentioned MPI,
so with MPI, there's a big trade-off of using more nodes,
versus more having more lag.
Yes.
So, this is something I can study now
and take the models and say,
this has this many neurons.
It will take approximately this much compute,
or not, at both sides.
Test and then get heuristics.
In your opinion, how would you convince the scientists to use your code?
I would convince my scientists to use my code,
by competing with the rest of the space there.
So, the established solutions,
they have a big, a rather big user base,
not as big as proteomics here,
but quite big.
But they are, at some point,
they get really annoying, really difficult
to do what they want because it's outside their original design.
This is what I'm trying to go hit as a nation.