WEBVTT

00:00.000 --> 00:13.120
I'm pleased to meet you, I'm serious here, I work at the University Medical Center of Rotterdam in

00:13.120 --> 00:17.920
the Netherlands, but by training I'm an engineer.

00:17.920 --> 00:28.920
So I was fascinated by computational biology and I ended up working on it, this is what I learned.

00:28.920 --> 00:38.000
So this is a quite fascinating topic from a programming aspect, as you'll see.

00:38.000 --> 00:43.640
So we wish we didn't have to make all those dishes and wait for the neurons to behave

00:43.640 --> 00:47.040
and the neurons dying and all that.

00:47.040 --> 00:52.320
And we want to have the theories, but neurons because they think are the worst thing to

00:52.320 --> 00:53.320
try to simulate.

00:53.320 --> 00:56.320
They think themselves, you can't think about them.

00:56.320 --> 01:04.920
So we have all those models on all those levels of detail, you see here, and there's

01:04.920 --> 01:05.920
so complex.

01:05.920 --> 01:11.320
Okay, we're most, we think we're the same one, but we end up having to use computers.

01:11.320 --> 01:16.360
In a huge case of space, we want brain readers, we wish we have virtual humans, okay,

01:16.360 --> 01:17.360
one other.

01:17.360 --> 01:22.880
Over time, some things are being learned over weeks.

01:22.880 --> 01:24.880
There's many time steps.

01:24.880 --> 01:32.000
So what's happening now with this field is there are different ways to formulate a model.

01:32.000 --> 01:37.760
Some people want to see how it works with FMI and see, I have very, very low resolution

01:37.760 --> 01:40.120
models on the left.

01:40.120 --> 01:44.760
Others say, okay, I can take a neuron and reduce it to a single dimension at a point, a

01:44.760 --> 01:45.760
little ball.

01:45.760 --> 01:50.120
So I'm going to play with netcours of the balls, that's in the middle.

01:50.120 --> 01:54.600
As I'm going to say, no, I want to see the exact effect on the surface of the membrane

01:54.600 --> 01:55.600
of this cell.

01:55.600 --> 01:56.600
And this does matter.

01:56.600 --> 01:57.600
For example, for drugs.

01:57.600 --> 02:03.120
And then we have the, we try to simulate chemistry basically as fast as we want.

02:03.120 --> 02:08.680
But then, the worst is, when we want to have a little bit of this, because we really want

02:08.680 --> 02:12.320
to start with this part of the detail, but we also need to simulate the surroundings.

02:12.320 --> 02:16.360
And then those come together and becomes a mess.

02:16.360 --> 02:24.040
So every simulator I named up here has its own algorithm inside to process the data.

02:24.040 --> 02:30.480
So if you want to port it, you have to reconsider everything, and it will only behave optimally

02:30.480 --> 02:34.840
in terms of performance for one type, not the other one.

02:34.840 --> 02:39.720
Then you want to port it, you have to think on different concepts.

02:39.720 --> 02:41.360
Each one works in its own way.

02:41.360 --> 02:46.760
And if that, if they don't agree on any point, you have to work out them.

02:46.760 --> 02:53.760
Then they have the algorithm, which in the case of neuron was designed in the early 80s.

02:53.760 --> 02:58.640
So we have problem where we would like to use accelerators.

02:58.640 --> 03:04.160
And I said, many different level of details, imagine you want this and that and that

03:04.160 --> 03:08.520
to work together and you have to work through the, it's one on squirks.

03:08.520 --> 03:10.520
So what do we do then?

03:10.560 --> 03:14.080
I wanted to do HPC on this stuff.

03:14.080 --> 03:16.120
Instead, I have to learn the theory.

03:16.120 --> 03:21.560
So I wanted to know stuff about how many flops is this, how much memory is that.

03:21.560 --> 03:24.600
So I can design my kernels.

03:24.600 --> 03:26.120
This is a summary.

03:26.120 --> 03:28.640
Some people like computers, you know what I mean?

03:28.640 --> 03:32.920
Go and say, I'm going to make one code for one model and be done with it.

03:32.920 --> 03:36.640
And this is the way to get all the flops.

03:36.640 --> 03:38.160
But then you have to rewrite.

03:38.160 --> 03:39.920
And again, again, again.

03:39.920 --> 03:42.000
It's unsustainable.

03:42.000 --> 03:46.360
Then others say, I will have my engine and I would put everything on top of my engine,

03:46.360 --> 03:48.560
kind of like Minecraft.

03:48.560 --> 03:54.240
This, but then the other person goes and says, then they have to do more something.

03:54.240 --> 03:56.240
Good luck putting your model.

03:56.240 --> 04:00.800
And we do need to put models because every person, every neuroscientist have three different

04:00.800 --> 04:04.200
opinions about how something should be modeled.

04:04.200 --> 04:07.280
They need to characterize all the time.

04:07.280 --> 04:09.200
So we wish we had the third one.

04:09.280 --> 04:13.320
We wish those layers here are decoupled.

04:13.320 --> 04:20.080
We wish you would say, like we do in papers, we write text, we could do language to say

04:20.080 --> 04:21.760
what we mean.

04:21.760 --> 04:27.880
And then some magical genie would come and deploy it to this or that or that hardware resource

04:27.880 --> 04:30.280
we have, or some specialized kernel.

04:30.280 --> 04:33.640
So if I want to simulate a grid with one neurons, I have a kernel for a grid with one

04:33.640 --> 04:38.800
neurons and I'm not doing circles around that.

04:38.800 --> 04:44.800
So I contribute to the mess of the landscape by making my own software.

04:44.800 --> 04:50.960
So, but still, like, when I do everything at once, okay, how so, you'll see how.

04:50.960 --> 04:53.720
So first of all, I didn't do all the job.

04:53.720 --> 04:59.920
Someone made this nice declarative script from over here and I owe this person.

04:59.920 --> 05:03.720
It's neural mel, it's kind of like HTML for neurons.

05:03.720 --> 05:10.360
It's again, same structure data, but it's the most declarative thing you'll find around.

05:10.360 --> 05:14.720
And what this means is we don't care about the engine anymore.

05:14.720 --> 05:20.560
We said what we meant and the engine's problem to do to work as it will.

05:20.560 --> 05:25.920
Now there are some issues with accuracy, let's say, with numerical methods, but this is, again,

05:25.920 --> 05:31.040
we can work in another level, it shouldn't matter, we want to ignore that like that.

05:31.040 --> 05:38.480
No then, I take it in XML, then I can pick it apart with very good details I want to go into.

05:38.480 --> 05:45.640
You do the time to decide on how to take different choices, make different choices.

05:45.640 --> 05:48.200
If it's like this, I'm going to use this kernel, otherwise, I'm going to use that kernel.

05:48.200 --> 05:55.440
Maybe I can morph them with, as you can see, as you see, this is quite like a compiler.

05:55.440 --> 06:00.440
So we want a compiler for neural methods and we usually don't have this sort of problem in software

06:00.440 --> 06:09.840
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.

06:09.840 --> 06:16.240
Most of the time, they want more features than neural methods standardized, so we're exchanging it as well as I'll explain.

06:16.240 --> 06:20.440
We have a very nice user guide that put two slides in the last moment.

06:20.440 --> 06:24.640
We have people, but this doesn't mean it's Python based, it's actually common I based.

06:24.640 --> 06:30.240
You can use it however, but people is the best way to deliver stuff to people without having to think about the architecture.

06:30.240 --> 06:34.240
Having them on zip it in the wrong location, blah, blah, blah.

06:34.240 --> 06:38.240
So really, I'm hijacking people, anyhow.

06:38.240 --> 06:46.440
Reiterate, there is a front end, there is the sources of modulfines, maybe the user, hopefully.

06:46.440 --> 06:49.640
They all are based in your email.

06:49.640 --> 06:58.640
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.

06:58.640 --> 07:05.840
If it fits the device, there's no reason it could run if we can understand it from your email.

07:05.840 --> 07:08.640
Again, it's like a compiler.

07:08.640 --> 07:17.040
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.

07:17.040 --> 07:25.440
Take the description, resolve it so we know which entity refers to what entity disambiguate, okay, that's technical.

07:25.440 --> 07:27.440
Then find it, okay.

07:27.440 --> 07:29.240
Can I run it?

07:29.240 --> 07:31.240
How?

07:31.240 --> 07:39.840
If I can find the way I can do it, then convert it to materialize this, how I'm going to do it,

07:39.840 --> 07:44.640
and then run some optimized, hopefully, execution.

07:44.840 --> 07:48.840
So, there is a vanilla backend that does everything your email has.

07:48.840 --> 07:54.840
And there are some nice, there's some nice API, which is used for people to put their own plug-ins.

07:54.840 --> 07:58.840
So, if you think of some magical device like my colleague did, I'm a physicist.

07:58.840 --> 08:02.240
Like my colleague did, made this accelerator for this subset.

08:02.240 --> 08:07.040
He knows how it's made, he knows if something will work or not ever.

08:07.040 --> 08:10.240
He can put the detector, he can also put the computer at the same time,

08:10.240 --> 08:15.040
and then loads here is FPGA and run the buffers as they should.

08:15.040 --> 08:19.840
Likewise, repeat for all devices or for all specialized cabinets.

08:19.840 --> 08:21.440
What simple?

08:21.440 --> 08:27.440
So, this here, I just mentioned this, I want, okay.

08:27.440 --> 08:33.440
So, the next step is we want more neural mel because people want even more wacky experiments.

08:33.440 --> 08:36.840
Like, someone wants to simulate this world there, it's very famous, warm.

08:36.840 --> 08:39.040
The can of this elegance.

08:39.040 --> 08:41.840
Somewhere, they want to see the electromagnetic field of the neuron,

08:41.840 --> 08:44.440
and maybe even interact with that.

08:44.440 --> 08:49.840
Which has, we have electromagnetism, suddenly, in the order of physiology, not good.

08:49.840 --> 08:51.640
But we have to do it.

08:51.640 --> 08:52.640
See, absets.

08:52.640 --> 08:54.640
You thought one neuron connects one another neuron?

08:54.640 --> 08:56.640
Oh, maybe that's the thing, you don't.

08:56.640 --> 08:58.240
Formalizes that.

08:58.240 --> 09:02.840
Then, here, we want optimizations.

09:02.840 --> 09:07.040
So, we want to see, we don't humanistics.

09:07.040 --> 09:08.040
Is this efficient?

09:08.840 --> 09:12.240
Where is the balance on which accelerator?

09:12.240 --> 09:15.240
So, we can take this subset, let's say, we have this stuff to do.

09:15.240 --> 09:17.040
This has this, and that's such features.

09:17.040 --> 09:21.040
We can make a cannon for this, a cannon for that adaptively.

09:21.040 --> 09:25.640
This would be, one, this could not just be done by hand.

09:25.640 --> 09:27.040
We need some support.

09:27.040 --> 09:30.440
So, neuron is like our LLVM for this stuff.

09:30.440 --> 09:33.240
And then, we have backends for devices.

09:33.240 --> 09:34.840
We can also export to jacks.

09:34.840 --> 09:35.840
Why would we do that?

09:35.840 --> 09:38.240
If people know about machine learning, what they have to do,

09:38.240 --> 09:42.640
it's a very nice acceleration and optimization library.

09:42.640 --> 09:44.840
We can, so, we can do parameter feeding.

09:44.840 --> 09:47.640
It's all the rates now in computational science.

09:47.640 --> 09:50.640
We can interface without a jacks simulation software

09:50.640 --> 09:52.640
for robotics, for example.

09:52.640 --> 09:56.840
And we can run it on the TPU without having to learn TPU.

09:56.840 --> 10:00.840
That's, in my opinion, the best selling point.

10:00.840 --> 10:04.840
So, conclusion.

10:04.840 --> 10:08.440
And where geeky stuff is limited by when you want to port it.

10:08.440 --> 10:10.240
Ha, you only help.

10:10.240 --> 10:13.840
But that's how we get out of hell.

10:13.840 --> 10:19.840
We use a declarative specification that we work like a compiler.

10:19.840 --> 10:26.040
This way, geeks like me can do the corpus to see what people want

10:26.040 --> 10:28.640
and decide what to optimize for.

10:28.640 --> 10:31.840
Then users do not have to write HBC codes,

10:31.840 --> 10:33.640
because then you decide this and they do it awfully.

10:33.640 --> 10:36.040
I've seen them.

10:36.040 --> 10:43.040
So, I just mentioned this very nice website with 3D renders,

10:43.040 --> 10:45.440
also in hundreds of animations.

10:45.440 --> 10:48.440
It took me six work a month.

10:48.440 --> 10:52.240
So, please look at it if you care about simulating neurons.

10:52.240 --> 10:55.440
And also, you can run everything in the column.

10:56.440 --> 11:00.440
Binder, it's quite some effort underneath,

11:00.440 --> 11:03.440
as the program is known.

11:03.440 --> 11:09.440
So, this does conclude my presentation.

11:09.440 --> 11:11.440
So, now, I can take questions.

11:11.440 --> 11:12.440
My book.

11:12.440 --> 11:19.440
Please excuse me, I forgot.

11:19.440 --> 11:21.440
My boss is this guy.

11:21.440 --> 11:24.440
The neuro computing lab in Rotterdam.

11:24.440 --> 11:27.440
So, you can also point questions there.

11:27.440 --> 11:28.440
Congratulations, sir.

11:28.440 --> 11:30.440
Please go ahead.

11:47.440 --> 11:49.440
Superdetic, eh?

11:49.440 --> 11:50.440
Yeah.

11:50.440 --> 11:56.440
But, I was pointing to write my own simulator.

11:56.440 --> 11:57.440
For neurons.

11:57.440 --> 11:58.440
For the neurons.

11:58.440 --> 12:01.440
But, now that I think I think this is a much better option.

12:01.440 --> 12:04.440
So, would you be open to setting a Vulcan backend,

12:04.440 --> 12:06.440
which is in your view?

12:06.440 --> 12:09.440
If we must do Vulcan, we can do Vulcan.

12:09.440 --> 12:13.440
I was hoping I could get all the birds with one stone with jacks.

12:13.440 --> 12:17.440
So, the thing is, Nurema is very expensive.

12:17.440 --> 12:20.440
You can make the backend, the plugin, if you want,

12:20.440 --> 12:23.440
as complex, as you want to go along it.

12:23.440 --> 12:25.440
You can do one type of neurons.

12:25.440 --> 12:27.440
You can do all of the neural melids.

12:27.440 --> 12:29.440
Quite an explanation.

12:29.440 --> 12:31.440
I hit that slide.

12:31.440 --> 12:32.440
It's huge.

12:32.440 --> 12:36.440
I know that drags is the default standard.

12:36.440 --> 12:37.440
No, no, it's not.

12:37.440 --> 12:38.440
Imagine.

12:38.440 --> 12:39.440
What?

12:39.440 --> 12:41.440
Do you think it's not very efficient?

12:41.440 --> 12:42.440
I see.

12:42.440 --> 12:47.440
My second question was, a huge part of the Vulcan backend,

12:47.440 --> 12:50.440
or a Vulcan workflow runtime.

12:50.440 --> 12:54.440
It's been just just jumping in between the simulator,

12:54.440 --> 12:56.440
and the cybernetic model.

12:56.440 --> 12:59.440
So, is there a Vulcan glowing,

12:59.440 --> 13:03.440
because Vulcan will basically rot the pental file,

13:03.440 --> 13:05.440
which cybernetic then read?

13:05.440 --> 13:06.440
Yes.

13:06.440 --> 13:09.440
Of course, you can place the files with pipes in Linux.

13:09.440 --> 13:10.440
You can use a memory event.

13:10.440 --> 13:12.440
I think that's absolutely the best you can get.

13:12.440 --> 13:15.440
But, basically, as you know, open worm has 300

13:15.440 --> 13:17.440
and two neurons always.

13:17.440 --> 13:20.440
So, you can submit all the effect of them

13:20.440 --> 13:24.440
and from them, on another level of the water simulation, let's say.

13:24.440 --> 13:28.440
So, I didn't expect this on one of the similarities with neurons.

13:28.440 --> 13:32.440
I'm very happy to meet you.

13:32.440 --> 13:35.440
So, we have plenty of time for another question.

13:35.440 --> 13:37.440
Yep?

13:37.440 --> 13:41.440
Okay. So, I understand the MPI...

13:41.440 --> 13:42.440
Yes.

13:42.440 --> 13:44.440
Generally, I go,

13:44.440 --> 13:49.440
to what if we didn't get to implement all the tools

13:49.440 --> 13:52.440
because of the GPU power?

13:52.440 --> 13:53.440
Of course.

13:53.440 --> 13:54.440
Of course.

13:54.440 --> 13:56.440
What do you think of this question?

13:56.440 --> 13:57.440
Yes.

13:57.440 --> 13:59.440
So, the question was,

13:59.440 --> 14:02.440
would it make sense to also port to Qda before Jax?

14:02.440 --> 14:04.440
And indeed, this was the plan.

14:04.440 --> 14:09.440
But, I first focused on extending the standard to support more models

14:09.440 --> 14:12.440
because NeuroMail is an effort.

14:12.440 --> 14:14.440
It tries to have the least common denominator

14:14.440 --> 14:16.440
because it has to support everything.

14:16.440 --> 14:18.440
It has to run everywhere.

14:18.440 --> 14:21.440
People exploit specific scenarios, quirks.

14:21.440 --> 14:24.440
And I think I made something that's now in preparation.

14:24.440 --> 14:27.440
It's very, very submitted about how to extend them

14:27.440 --> 14:29.440
while keeping the declarativeness.

14:29.440 --> 14:33.440
So, for example, so then Qda,

14:33.440 --> 14:35.440
there is a student from Shanghai,

14:35.440 --> 14:38.440
who is interested in making Qda backend.

14:38.440 --> 14:40.440
I would go for Qda personally,

14:40.440 --> 14:42.440
but then for exotic stuff,

14:42.440 --> 14:45.440
people seem to convert to something for accelerators.

14:45.440 --> 14:48.440
Whatever it is, I will take it.

14:48.440 --> 14:53.440
The big issue is NeuroMail is very, very extensive

14:53.440 --> 14:55.440
because it tries to please everyone.

14:55.440 --> 14:58.440
So, a complete vanilla backend for GPUs

14:58.440 --> 15:00.440
is more involved than a CPU backend.

15:01.440 --> 15:05.440
And as a side thing, because you mentioned MPI,

15:05.440 --> 15:08.440
so with MPI, there's a big trade-off of using more nodes,

15:08.440 --> 15:10.440
versus more having more lag.

15:10.440 --> 15:13.440
Yes.

15:13.440 --> 15:15.440
So, this is something I can study now

15:15.440 --> 15:17.440
and take the models and say,

15:17.440 --> 15:18.440
this has this many neurons.

15:18.440 --> 15:20.440
It will take approximately this much compute,

15:20.440 --> 15:21.440
or not, at both sides.

15:21.440 --> 15:24.440
Test and then get heuristics.

15:31.440 --> 15:36.440
In your opinion, how would you convince the scientists to use your code?

15:36.440 --> 15:38.440
I would convince my scientists to use my code,

15:38.440 --> 15:42.440
by competing with the rest of the space there.

15:42.440 --> 15:44.440
So, the established solutions,

15:44.440 --> 15:46.440
they have a big, a rather big user base,

15:46.440 --> 15:48.440
not as big as proteomics here,

15:48.440 --> 15:49.440
but quite big.

15:49.440 --> 15:51.440
But they are, at some point,

15:51.440 --> 15:54.440
they get really annoying, really difficult

15:54.440 --> 15:57.440
to do what they want because it's outside their original design.

15:57.440 --> 16:01.440
This is what I'm trying to go hit as a nation.

