WEBVTT

00:02:25.000 --> 00:02:38.000
So it's computing departments. Then I'm going to talk about Bayesian decision framework, process optimization that we're developing. And David's going to talk about the production processing, localizing

00:02:38.000 --> 00:02:51.000
So I should say disclaimer, these are pretty early stage projects, and so we haven't got any results. We're going to be talking about why we've got to see what our plans are, where this is going

00:02:51.000 --> 00:03:07.000
So I'm essentially going to be talking about how to optimize individual software components by thinking about parameters that are being used to run software. And David is going to be talking about how to optimize whole workloads through computational pipelines.

00:03:07.000 --> 00:03:22.000
So the conversational biology and imaging theme, there are four different groups. We've got the macromolecular histology group, which focuses on methods development and actually distributes a quite large software suite called CCP4

00:03:22.000 --> 00:03:34.000
The other veins, whether it's taking diffraction data, conversational crystallography, and trying to produce 3D structural models of molecular structure

00:03:34.000 --> 00:03:49.000
There's the molecular cellular electron microscopy here, which is very similar to CC4, only instead of focusing on crystal graphic experiments, focusing on electron microscopy. So the CHPM route will be taking

00:03:49.000 --> 00:04:01.000
Data in real space, unlike the reciprocal space, the fraction images that we're working with in the CSP4, but again, trying to produce 3D micro molecular structural models

00:04:01.000 --> 00:04:14.000
There's the biomolecular simulation group, which is performing molecular dynamics and silico experiments, essentially trying to simulate these 3D micro molecular structures that we are producing experimentally

00:04:14.000 --> 00:04:17.000
And there's computed tomography and imaging group

00:04:17.000 --> 00:04:33.000
Which comprises 6 people at CCPI, which focuses on material science. So the organic is supposed to be organic groups are focusing on the which is biological energy. So considering objects at a completely different

00:04:33.000 --> 00:04:38.000
the other groups are focusing on.

00:04:38.000 --> 00:04:49.000
So I personally have close interactions with C64 and 6pm and David here quite specifically in CP4. So we're going to focus on

00:04:49.000 --> 00:04:57.000
Not much like crystallography. That being said, I'm going to

00:04:57.000 --> 00:05:11.000
Try to not focus too much on a particular field, and talk about things in the general sense, so that hopefully maybe some of you might see some sort of parallels, and see if there could be links to problems that you're working on perhaps

00:05:11.000 --> 00:05:15.000
In order to really try at home that we're not even thinking about

00:05:15.000 --> 00:05:18.000
sites, let's say

00:05:18.000 --> 00:05:29.000
Let's consider them an archive. Let's consider if we're trying to think about how statistics, and here I'm including machine learning AI as well as possible statistics in the production and use of cars

00:05:29.000 --> 00:05:36.000
This body and frame, the engine

00:05:36.000 --> 00:05:38.000
Transmission

00:05:38.000 --> 00:05:49.000
Wheels, control systems and all of these different components have to be. So you have the automotive engineer who would be designing and producing these individual components

00:05:49.000 --> 00:05:55.000
We would have a mechanical engineer who would then be configuring and tuning these components.

00:05:55.000 --> 00:05:57.000
So that

00:05:57.000 --> 00:06:06.000
Instead of having something which kind of is minimum functional, actually gets tuned so that it's something that works really well.

00:06:06.000 --> 00:06:11.000
Quickly, what success means

00:06:11.000 --> 00:06:21.000
be different. So, if you're trying to have a car that is really fast, suitable for racing, well, that's one type of optimization. But it could be that we want something that is more

00:06:21.000 --> 00:06:26.000
Brilliant. I think about computational efficiency.

00:06:26.000 --> 00:06:29.000
And indeed, the development in one direction

00:06:29.000 --> 00:06:36.000
Because that's the helper development of different applications as well. So that's something that we're keeping in mind

00:06:36.000 --> 00:06:43.000
And then finally, we've also got customer operating the car again

00:06:43.000 --> 00:06:48.000
So here we've got three different areas that involve decision making

00:06:48.000 --> 00:06:50.000
The production and use of cop.

00:06:50.000 --> 00:06:56.000
So let's think about the analogy here to computational science

00:06:56.000 --> 00:07:01.000
Well, the person designing, producing software

00:07:01.000 --> 00:07:07.000
That would be people doing methods and software development

00:07:07.000 --> 00:07:10.000
The configuration and tuning, although it would be software optimization

00:07:10.000 --> 00:07:24.000
And just not operating the software will be one month, which could be a manual user using software. It could be an automated procedure

00:07:24.000 --> 00:07:30.000
Thinking where machine learning and AI could fit into these different components

00:07:30.000 --> 00:07:43.000
Well, in methods and software development and at least, there's been an explosion between approaches for various different pieces of the pieces of software over the past eight years, I'd say

00:07:43.000 --> 00:07:46.000
In terms of the operation.

00:07:46.000 --> 00:07:52.000
We're not thinking about AI-guided automated pipelines, which I'll really broad day to discuss

00:07:52.000 --> 00:07:55.000
Except not this tool

00:07:55.000 --> 00:08:05.000
But then what about software optimization? So I posed this as being mainly at heuristic and this huge improvement groups, at least in structural biology

00:08:05.000 --> 00:08:15.000
So, something like a virtual practice. But really, I'm kind of making fun of myself here, because I, for a very long time, was one of the software developers who was

00:08:15.000 --> 00:08:22.000
Coming up with heuristics for what would be the optimal practice for different pieces of software.

00:08:22.000 --> 00:08:27.000
And then spent many years going and teaching in international workshops

00:08:27.000 --> 00:08:30.000
How people should

00:08:30.000 --> 00:08:38.000
When something goes wrong, have a look through the log file, interpret what that information means, and then use that to change those very parameters that I've actually got in the software in the first place.

00:08:38.000 --> 00:08:44.000
I thought this is crazy, we shouldn't be doing this. Like, instead of asking the user to

00:08:44.000 --> 00:08:46.000
figuring this out. We should just

00:08:46.000 --> 00:08:51.000
have multiple systems. So we worked it out well in the first place.

00:08:51.000 --> 00:08:56.000
It sounds easier than it is, but that's the kind of motivation behind

00:08:56.000 --> 00:08:59.000
Yes, sir.

00:08:59.000 --> 00:09:07.000
So if we just focus now on this aspect, this configuration and tuning of the software, come back to the car's analogy

00:09:07.000 --> 00:09:11.000
And think about, well, should drivers be left to shoot their own cars?

00:09:11.000 --> 00:09:25.000
Because if everyone tuned their own cars, we'd get huge issues with what to control consistency, reproducibility. Ultimately, user experience satisfaction. Terrible

00:09:25.000 --> 00:09:38.000
Indeed, drivers are neither engineers nor mechanics in the same way that our software users are neither programmers nor analysts. So we shouldn't expect them to take on these different roles

00:09:38.000 --> 00:09:44.000
The next question is, should we use AI, especially in this age that everyone's using it for everything.

00:09:44.000 --> 00:09:47.000
Is this not suitable application

00:09:47.000 --> 00:09:52.000
Maybe, but there are things. Let's consider the use case.

00:09:52.000 --> 00:10:04.000
In our particular field, there's a number of power users that can use the software here as well. We've also got the clueless users and offices who are using the software that don't know how to at all

00:10:04.000 --> 00:10:14.000
We've got frustrated users that know what they should be doing, but it's just not working. That's what he wants it to. And the ability issues know what they should be doing, but don't really care

00:10:14.000 --> 00:10:24.000
And all of this data ends up in protein data in that particular case, but a huge database, hundreds of thousands of microbial structures now

00:10:24.000 --> 00:10:30.000
And so if we go to using all of this data generated by our user base

00:10:30.000 --> 00:10:38.000
For AI, well, that's going to mean that we're going to end up with suboptimal machines that are limited by the training data

00:10:38.000 --> 00:10:59.000
Indeed, islands just across the road has got huge amounts of data. And I've said, well, can't we just use this for training? Well, yeah, if you want us to automatically be able to do just as bad as people are today. But really, we want to be thinking about what comes next and how do we actually make it better

00:10:59.000 --> 00:11:03.000
So I suppose that AI, and here I've got AI in quotes

00:11:03.000 --> 00:11:14.000
AI in terms of like the modern definition of people talk about large language models is good at finding plausible answer from sets or space of reasonable answers.

00:11:14.000 --> 00:11:19.000
So, for example, if you go to an agent and say, give me a picture of a cat

00:11:19.000 --> 00:11:24.000
So it'll probably be quite a good picture of a cat.

00:11:24.000 --> 00:11:32.000
Then you can ask it again for which we can give you a different picture of a cat. Do that many times, and end up with lots and lots of pictures of cats

00:11:32.000 --> 00:11:37.000
And none of them is the correct or wrong answer

00:11:37.000 --> 00:11:44.000
There was no correct picture of the captain, so it's a misspecified problem

00:11:44.000 --> 00:11:51.000
Which is fine if what we want is a plausible answer, but actually in science, a lot of the time what we want is the right answer.

00:11:51.000 --> 00:12:07.000
We can't get to the right answer, but what we think that we could get to is an approximation of the right answer. Ideally, with uncertainty information, so we now have reliable that is.

00:12:07.000 --> 00:12:14.000
So AI can learn from historical use behavior. So it's very suitable in cases like

00:12:14.000 --> 00:12:23.000
Mimicking behavior of graphical interfaces, which are extremely complex. Optimal pathways to workflows which we'll hear about afterwards from David

00:12:23.000 --> 00:12:38.000
And, like, Agentic AI can do things like read software documentation, tutorials, historical records, do a really good job of making current and historical behavior. But historical decisions are heterogeneous

00:12:38.000 --> 00:12:40.000
And it's often swapped

00:12:40.000 --> 00:12:45.000
Really, we want to be doing a better job.

00:12:45.000 --> 00:12:52.000
So the solution we're going for is to use absolutely design experiments combined with critical statistical modeling

00:12:52.000 --> 00:13:00.000
An important thing, as part of this design, we want it to be robust and efficient. So I'm sure that

00:13:00.000 --> 00:13:06.000
Reaching to acquire paper. Let's just kind of recap statistical robustness and efficiency.

00:13:06.000 --> 00:13:22.000
So I suppose you've got some sort of function, which is a score function, and we're trying to identify what a particular parameter is. So this could be, like, maybe a point between a likelihood and prior information given

00:13:22.000 --> 00:13:27.000
We could just fruit look at all the different parameter values and choose the one

00:13:27.000 --> 00:13:32.000
That is the lowest, the best score you want. Very close estimate.

00:13:32.000 --> 00:13:43.000
Well, we could do something like add some regularization, smoother, at which point this would give us a new estimate. So here we've got smooth estimates for the optimal frames value

00:13:43.000 --> 00:13:51.000
Well, we could say that we know something about the system. Let's assume that we've got some sort of quadratic signal underlying this noise data set

00:13:51.000 --> 00:13:56.000
At which point, we have got some new prince recipients

00:13:56.000 --> 00:14:08.000
So, I actually know what the answer is, because I generalized that sequence. That's a time series that I generated. And this green dashed line actually is the entry.

00:14:08.000 --> 00:14:12.000
Where the signal corresponds to having a parameter value of 5

00:14:12.000 --> 00:14:28.000
to imagine that if you were to generate this process many different types, have many different data sets, different levels of noise, different instances of noise, then we would get a variety of different answers

00:14:28.000 --> 00:14:39.000
So in thinking about robustness, how much does the answer change when data change? And the answer is the brute force approach is extremely robust.

00:14:39.000 --> 00:14:52.000
Thinking by statistical efficiency, well, what if we were to repeat this experiment, say, a thousand times? We were going to collect lots and lots of different data sets about the same underlying signal, but different instances of noise

00:14:52.000 --> 00:14:54.000
This situation

00:14:54.000 --> 00:15:10.000
Calculate what's the optimal parameter values for each of these, and we could do the same for all those smooth curves and all the parameterized curves we could estimate in each case, and get the whole distribution of these parameter values that are optimal across these different species

00:15:10.000 --> 00:15:23.000
And what we see is that large numbers comes to the rescue and all of these average is over all of those instances produce a pretty good estimate of the truth

00:15:23.000 --> 00:15:25.000
That was funny, but

00:15:25.000 --> 00:15:35.000
That's the brute force approach has actually got quite a lot of variance. It's quite a lot of uncertainty associated with that estimate.

00:15:35.000 --> 00:15:44.000
And the smooth version as well. But then if we inject some sorts of sensible parameterization, if you know something about the system, then variance

00:15:44.000 --> 00:15:46.000
of that customer reduces

00:15:46.000 --> 00:15:52.000
So that's what we're referring to when thinking about efficiency. How precisely can we answer the question?

00:15:52.000 --> 00:15:54.000
Given the data that we've got

00:15:54.000 --> 00:16:04.000
Sega messages here being that, firstly, single safe data set brute force search is a bad fit. It's not about extreme variable

00:16:04.000 --> 00:16:07.000
And specific drugs do very poor search

00:16:07.000 --> 00:16:13.000
And the sad reality is that that is exactly what structural biologists are doing today.

00:16:13.000 --> 00:16:16.000
Might take months, grinded Crystal

00:16:16.000 --> 00:16:27.000
And then take it to the beam, collect the data set, and then proceed throughout the whole procedure, estimating parameters for the software that they're using based on brute force fitting to that one data set.

00:16:27.000 --> 00:16:31.000
Yeah, we don't even have three representatives here.

00:16:31.000 --> 00:16:35.000
And this is a huge problem

00:16:35.000 --> 00:16:40.000
Because it really raises questions about what the efficiency is on the processes that we

00:16:40.000 --> 00:16:46.000
I can't use infrastructure bias, whether it be crystallography, primary microscopy

00:16:46.000 --> 00:16:50.000
This is something that we're dealing with.

00:16:50.000 --> 00:17:02.000
It's acknowledge that good regularization for health. It can produce something that's more robust, less sensitive to noise, but it's not necessarily going to increase the efficiency. It still requires substantial data

00:17:02.000 --> 00:17:06.000
in order to get so good estimate.

00:17:06.000 --> 00:17:10.000
But if we can actually appropriately parameterize the problem

00:17:10.000 --> 00:17:14.000
Then we can improve not just robustness, but also efficiency

00:17:14.000 --> 00:17:20.000
acknowledging that unsuitable parameterization just transfer bias, which is not good. So got to be careful

00:17:20.000 --> 00:17:26.000
But if we can do this, then maybe that solves this problem without me having one data set

00:17:26.000 --> 00:17:33.000
Indeed, if we've got hundreds of thousands of data sets positive data back, maybe we can utilize that whole

00:17:33.000 --> 00:17:35.000
The source of information

00:17:35.000 --> 00:17:38.000
In order to

00:17:38.000 --> 00:17:46.000
Appropriately parameterized the system to flashly estimates what parameters should be for a given data set.

00:17:46.000 --> 00:17:51.000
So as part of designing this process optimization framework, our objectives are

00:17:51.000 --> 00:17:58.000
To improve the quality of that. So we want the results to be improved, robust, and reproducible

00:17:58.000 --> 00:18:07.000
We also improve computational efficiency, so less computational waste, but it's scalable, ideally transferable to different problems where possible

00:18:07.000 --> 00:18:19.000
And we want the user experience to improve, which means system works faster, easier, more connected. So we're not asking for much

00:18:19.000 --> 00:18:23.000
But nevertheless, let's let's give it a go. Let's try

00:18:23.000 --> 00:18:39.000
I should clarify at this point that we are not talking about aim to modify the actual scientific methods, the internal algorithms or thinking about computational acceleration, anything like that. We're simply talking about making the most out of existing software implementations

00:18:39.000 --> 00:18:42.000
By figuring out

00:18:42.000 --> 00:18:48.000
parameter values, which arguments use for a given data set

00:18:48.000 --> 00:18:54.000
The core idea is that, what if we consider verbal parameters as random variables

00:18:54.000 --> 00:18:58.000
And optimize condition with probabilities

00:18:58.000 --> 00:19:12.000
So if we consider the expectation of prices overall data sets, that will give you a one-fits-all solution. Coming into typically the program or interface defaults in software

00:19:12.000 --> 00:19:25.000
This is often heuristic for programs deciding what these defaults should be based on very limited information and testing. And it's the most common approach in CC4 at least.

00:19:25.000 --> 00:19:34.000
The next last thing we could do is consider the expectation of the program parameters conditioned on a given data set

00:19:34.000 --> 00:19:40.000
All data set properties. So we're tuning these parameter estimates to properties of data

00:19:40.000 --> 00:19:53.000
And this is something that's quite uncommon in CP4, and there are a few cases where it has been done, it's typically hard-coded heuristics that are done to actually tune given parameters to data set properties.

00:19:53.000 --> 00:19:59.000
So what if we instead consider the whole probability distribution as opposed to the expectation

00:19:59.000 --> 00:20:01.000
So consider

00:20:01.000 --> 00:20:08.000
I thought uncertainty aware representation of these programs

00:20:08.000 --> 00:20:13.000
Meaning the confidence in decision is also retained.

00:20:13.000 --> 00:20:26.000
So the way that we are doing this is using the Bayesian objective aggregation by marginal expected utility maximization, giving this function here, which I'll just break it down to make it a little bit more bite-sized

00:20:26.000 --> 00:20:40.000
I personally like to look in terms of expectation notation. So we'll use this formula here. What we're trying to do is to choose a set of weights, object

00:20:40.000 --> 00:20:43.000
validation metrics

00:20:43.000 --> 00:20:46.000
The maximized score, which

00:20:46.000 --> 00:20:48.000
Could be different, different applications

00:20:48.000 --> 00:21:00.000
associated with the expected set of process hyperparameters Y, where prototype parameters what I'm calling here

00:21:00.000 --> 00:21:09.000
Given expected coefficients beta, which is what we're trying to optimize as part of this procedure

00:21:09.000 --> 00:21:12.000
I responded to give away to say

00:21:12.000 --> 00:21:18.000
To try and make that a little bit clearer, I'm going to explain the opposite way around as well.

00:21:18.000 --> 00:21:25.000
Is there a function down at the bottom. So given a given data set

00:21:25.000 --> 00:21:33.000
We're asking what are the coefficients beta we need to estimate associated with predictors or independent variables X

00:21:33.000 --> 00:21:35.000
From a given dataset D

00:21:35.000 --> 00:21:40.000
It tells us the process hyperparameters Y

00:21:40.000 --> 00:21:43.000
That would result in the best score

00:21:43.000 --> 00:21:48.000
After having executed the process

00:21:48.000 --> 00:21:54.000
But we don't know how to score the process out, so just figure it out by estimating this weighting parameter.

00:21:54.000 --> 00:21:56.000
Because that's the formulation we're working with

00:21:56.000 --> 00:22:06.000
I appreciate that that would probably take a little bit of time to kind of properly digest. So instead, let's consider what this actually means in practice when training this

00:22:06.000 --> 00:22:19.000
So a typing data set, which in our particular case could be writing data bank, huge publicly available data resource, which we can split into training, validation and test sets

00:22:19.000 --> 00:22:22.000
And then we can use the training set to train

00:22:22.000 --> 00:22:24.000
a model

00:22:24.000 --> 00:22:32.000
Where the response is the process hyperparameter. So these… this is what we're trying to predict. These optimal parameters for the software

00:22:32.000 --> 00:22:41.000
And the predictors will be derived properties from data. Could be the raw data machine learning module

00:22:41.000 --> 00:22:52.000
Then we sample from the posterior predictor and use stratified sampling in order to predict which drops, so which data sets and which sets of parameter values

00:22:52.000 --> 00:22:59.000
would maximally be informative to give us information about the, high-dimensional hydroctor space

00:22:59.000 --> 00:23:01.000
So then we can run jobs

00:23:01.000 --> 00:23:08.000
proposed jobs to sample from packet parameter space itself

00:23:08.000 --> 00:23:25.000
Evaluating the outputs of those jobs, and typically you've got multiple competing validation metrics. So it could be you've got something that represents the fit between model and data, something that represents overfitting, something that represents agreement with prior information, for example.

00:23:25.000 --> 00:23:35.000
And these need to somehow be aggregated assembled by the slot. So for this, we're using technology from Modern portfolio theory.

00:23:35.000 --> 00:23:45.000
Notes about the risk and reward when doing such aggregation, tuning isn't a validation set or generalizability

00:23:45.000 --> 00:23:53.000
Before then, the multi-criteria decision analysis in order to get the phase optimal action corresponding to each data set.

00:23:53.000 --> 00:24:01.000
So this allows us to estimate the response, so the hyperparameter and exits ratio repeat. Essentially, this system is learning

00:24:01.000 --> 00:24:03.000
What's the best parameters would be

00:24:03.000 --> 00:24:06.000
For each of the datasets

00:24:06.000 --> 00:24:08.000
Based on

00:24:08.000 --> 00:24:14.000
Hopefully low dimensionality predictor information.

00:24:14.000 --> 00:24:15.000
So that's the idea

00:24:15.000 --> 00:24:29.000
That's what happens during training. But the idea is that once we create this model, it should be millisecond level, especially used. So from a user perspective, it's quite different. User perspective is that they've got their data set

00:24:29.000 --> 00:24:34.000
to get predictors from that, at which point

00:24:34.000 --> 00:24:38.000
And just go to our framework or the model that's been trained

00:24:38.000 --> 00:24:48.000
Which can take additional prior information at that point. So if you've got a workflow controller, user could override the system or provide expert guidance.

00:24:48.000 --> 00:24:55.000
And then you would immediately get sense of what it thinks are the optimal parameters for that particular data set.

00:24:55.000 --> 00:24:57.000
Supposedly.

00:24:57.000 --> 00:25:00.000
including uncertainties on those parameters.

00:25:00.000 --> 00:25:08.000
They asked to make predicted outcomes, so predict what the final violation statistics would be after running the job running the job

00:25:08.000 --> 00:25:18.000
Including estimates of runtime and additional diagnostic information so that you've got an idea about how reliable this information is or at least how reliable

00:25:18.000 --> 00:25:21.000
The system makes this information X.

00:25:21.000 --> 00:25:27.000
Should you be trusting it, or is this outside of the domain of the training data

00:25:27.000 --> 00:25:29.000
At which point

00:25:29.000 --> 00:25:32.000
You can access the executive process

00:25:32.000 --> 00:25:41.000
At which point, the user no longer has to think about doing some sort of brute force search with different parameter values, running lots of different jobs. It can just take

00:25:41.000 --> 00:25:46.000
The single sets of optimal premises there should be doing a good job.

00:25:46.000 --> 00:25:49.000
That's the idea.

00:25:49.000 --> 00:25:58.000
So the vision is that the users should only ever have to work one job. In most cases, they're not pathological or outside of the domain of what we've seen already

00:25:58.000 --> 00:26:07.000
We're in the improved robustness and efficiency, and it's hoping for a substantial reduction in computational wastage, because we're doing all the computers up front

00:26:07.000 --> 00:26:09.000
This only has to come from one job

00:26:09.000 --> 00:26:11.000
And we have got

00:26:11.000 --> 00:26:18.000
Many thousands of years around the, world, so I guess this does

00:26:18.000 --> 00:26:25.000
The synergy with this type of development with automated workflows. So, for example.

00:26:25.000 --> 00:26:31.000
I'll look at macrofty workflow, to be honest, it doesn't really matter exactly what results are.

00:26:31.000 --> 00:26:46.000
The idea is that data goes into the system and then there's data processing, molecular placement, and then it's multiple refinement stages that repeat until producing a final output

00:26:46.000 --> 00:26:51.000
There are automated pipelines that try to automate this whole procedure

00:26:51.000 --> 00:27:01.000
And I think David's going to be talking about how to augment this with AI decision making to improve such automated decision making

00:27:01.000 --> 00:27:04.000
What I've been talking about so far

00:27:04.000 --> 00:27:14.000
There's actually something that optimizes the individual nodes within such a system. So we're trying to consider each of these 1, 2, 3, 4 in this case, different nodes, and try to optimize how

00:27:14.000 --> 00:27:17.000
That's how it's work

00:27:17.000 --> 00:27:20.000
But importantly.

00:27:20.000 --> 00:27:29.000
Such an AI-guided decision-making pipeline could actually have massive control over the individual nodes within that workflow

00:27:29.000 --> 00:27:35.000
The parameters could be nudged by trial or overridden by marginalization

00:27:35.000 --> 00:27:51.000
And this is a bi-directional feedback. So the individual models can actually provide the posterior distribution. Posterior predictive distribution and additional diagnostics, which are natural language

00:27:51.000 --> 00:27:55.000
So this can be used to inform the work

00:27:55.000 --> 00:28:01.000
So this, the work is funded by the Andy Lovelace Center for the Scientific Computing Department

00:28:01.000 --> 00:28:11.000
And the first demonstrator is being developed by who is implementing the generic framework for this whole activity

00:28:11.000 --> 00:28:15.000
Working on macromolecular structure refinement with cell curves

00:28:15.000 --> 00:28:18.000
We've also got Milan Kumar, who's working on

00:28:18.000 --> 00:28:22.000
applying this to probably have 3D new construction.

00:28:22.000 --> 00:28:25.000
And Sarat Slava

00:28:25.000 --> 00:28:31.000
find this crystal that is processing the dogs. That's along with the donut.

00:28:31.000 --> 00:28:34.000
Hey, I'm very excited to see at this time.

00:28:34.000 --> 00:28:39.000
Okay, a new speaker and a new font.

00:28:39.000 --> 00:28:48.000
Right, so yeah, so what's been talking about is all very generic and high level, kind of showing how… what he's discussing can be applied in

00:28:48.000 --> 00:29:07.000
Really any context, we are thinking about optimizing something you're doing regularly within these kind of data sets. What I'm going to try and do is talk about, as Bob said, thinking about it at different levels of abstraction, and get more of a flavor of how we're applying suggestion and what the actual kind of problems, the reasons we're trying to do this. Now, what we kind of have to do this now, basically

00:29:07.000 --> 00:29:21.000
So just to give some context, what crystallography is, so really it's the study of molecules in the crystalline state. And this is one of the, if you like the core microscopes we have to study structure at this scale and

00:29:21.000 --> 00:29:25.000
It's a very old material field, so there's many novel prices associated with it

00:29:25.000 --> 00:29:33.000
Even the United Nations. And what I'm trying to get across here is that it's a very mature field, so this is not us

00:29:33.000 --> 00:29:46.000
I mean, although there are so many scientific problems associated with this field, it's also very much an engineering problem. We have massive infrastructure on the backbone of crystallographic techniques, like things like source analysis, etc

00:29:46.000 --> 00:30:02.000
Now, macromolecular processes crystallography that Rob mentioned is specifically to study biological structures, and this is really a big part of the life sciences sector. I just realized this is now data, because these are exists, but still applies, hopefully. But the key idea

00:30:02.000 --> 00:30:18.000
Again, what I'm trying to get across is a mature field, massive amounts of data, massive infrastructure. And so we're thinking about data processing, we have to think along the lines of thousands and thousands of base points and really thinking of that kind of

00:30:18.000 --> 00:30:20.000
Higher level, if you like

00:30:20.000 --> 00:30:31.000
So, as Rob mentioned, within the computational biology theme, CCP4 is one of the groups, and as he said, we have a software suite for processing

00:30:31.000 --> 00:30:48.000
data sets from that current epistemology. And this is used all around the world, you know, industry and academia, and so when we're considering how we optimize our software, this is being applied a lot of places where things like cost really matters and things like high throughput are really a big

00:30:48.000 --> 00:31:04.000
If you don't really understand that diffraction is just kind of a subfield of crystallography, essentially the idea of firing a beam particles whose wavelength is on the order of the distances between atoms in a given crystalline sample

00:31:04.000 --> 00:31:14.000
This creates some nice patterns, and using a lot of maths, you can then understand what is the underlying structures that are responsible for generating those diffraction patterns.

00:31:14.000 --> 00:31:22.000
And this process of purchasing these kind of data sets can be broken into these discrete steps

00:31:22.000 --> 00:31:37.000
For the kind of problems that we're thinking about. And so, we get data collection, where we're looking at identifying where these crystals are, and which ones to use, showing, well, this nice little video over here, we're actually firing particles onto a sample, generating atom here.

00:31:37.000 --> 00:31:52.000
We then go through the data and identify where are these spots in this kind of diffraction patterns, and we then generate a model that we think represents the symmetry of the spot distribution that we see. We refine that model, and then we then use that model to integrate

00:31:52.000 --> 00:31:56.000
over at the next step, basically.

00:31:56.000 --> 00:32:13.000
Now, these thefts within this kind of diffraction processing can be optimized individually. And indeed, as Rob was saying, machine learning is a big thing now. And so we are also just looking at in these individual steps outside of things like Bayesian optimization. Can we just use machine learning tools in these areas?

00:32:13.000 --> 00:32:29.000
We have people like Amato Petrovic and Yahu Jha, who have been looking at incorporating aspects of computer vision, for example, in the data collection area, so we can identify automatically where crystals are on our samples, where good crystals are, or what are good and bad

00:32:29.000 --> 00:32:33.000
potentially data sets, and then guides are

00:32:33.000 --> 00:32:45.000
Our machinery to move towards those automatically, rather than do this manually by hand, which is a key bottleneck for these kinds of processes. Equally, you have to be looking at Agentic data collection. So

00:32:45.000 --> 00:32:52.000
Obviously now, as Bob was saying, AI now just a large language models

00:32:52.000 --> 00:33:09.000
And there's a lot going on in places like Diamond Light Source now, where we're looking at not just asking things like thought models, but developing our own, local models with a predefined fixed toolset. So you can still use natural language to communicate your problem and what you want to do to

00:33:09.000 --> 00:33:19.000
process your data, but you can then use a suite of predefined tools that the large language model selects based on its inference, essentially.

00:33:19.000 --> 00:33:31.000
So that's one aspect of the things we're thinking about in terms of machine learning and AI. As Rob's been saying, we ought to consider the entire workflow. We don't want to think about just things in isolation. We need to consider

00:33:31.000 --> 00:33:44.000
How we optimize the entire way of thinking about our data processing. So to think about that, I just want to very quickly take a short diverge to show where we're sitting in the context of the field. So

00:33:44.000 --> 00:33:58.000
When you're doing these kind of experiments, this might be at a synchrotron. You can have multiple different instruments. And historically, these might have all had their own software data processing. And then over time, generic software came about and they could process data from multiple different sources

00:33:58.000 --> 00:34:08.000
But still, many of these exist, and they exist in different strengths, different algorithms, and if you're a user, you just want to get a key, robust result for your data

00:34:08.000 --> 00:34:26.000
You might want to explore many of these and declare which ones allow you to process your data. But this creates a lot of friction for a user, because it can be very hard to compare between software packages and understand why you're getting the different result in one rather than the other, even though you're using the same algorithm, for example.

00:34:26.000 --> 00:34:30.000
So one of the things we did, which is kind of in a sense

00:34:30.000 --> 00:34:44.000
preparing this field more for this kind of workflow machine learning AI stuff we're talking about is we developed a ground space interface that enables you enables you to visualize workflows from different software packages and on the browser.

00:34:44.000 --> 00:34:55.000
And so this allows you to send an abstract away all this working from packages and you have a common space where you can explore the packages and then compare life is like much more easily.

00:34:55.000 --> 00:35:11.000
This analogy, for example, with this software package, you can run a given pipeline and then another one by even pipeline all within but more importantly, it allows you to actually move between the packages within these discrete steps. So we now have interfaces between all the different packages

00:35:11.000 --> 00:35:23.000
As you can kind of imagine what this is leading to is this opens up the potential space exploring the optimal pathway for your data sets far larger than we have been able to do before.

00:35:23.000 --> 00:35:27.000
So, going back to diffraction processing

00:35:27.000 --> 00:35:35.000
As I mentioned earlier, this is largely like places like Diamond light source and it's increasingly moving to very high throughput. And indeed with things like Diamond2

00:35:35.000 --> 00:35:53.000
single lines. These are all different instruments within Undiamond, all running experiments all the time, mostly automated. A single one of these is hoping to produce about 10,000 data sets per day with Diamond2. So this is just too much data to manually investigate

00:35:53.000 --> 00:35:59.000
I needed to do this brute force investigation of maximizing the results, as Rob was saying.

00:35:59.000 --> 00:36:12.000
I also argue it's kind of too much data to store and train. So, as Rob said, we have this protein data bank that has a large amount of data. It's obviously self-selected for data that has worked and is publishable

00:36:12.000 --> 00:36:20.000
And what we really want is to understand the full space of this problem of these kind of experiments. And so

00:36:20.000 --> 00:36:32.000
We want to think about not just training from fixed datasets, but also thinking about online learning as well, and bolting these onto all of the data processing that's already going on anyway

00:36:32.000 --> 00:36:45.000
And then the software that we're using is currently largely static. So if I use a piece of software to process a data set, I might play around with it a bit and get a certain result. I then get another data set

00:36:45.000 --> 00:36:55.000
The software hasn't changed in those two datasets. I might have done something as an instrument scientist. But again, with 10,000 data sets per day, I'm not going to

00:36:55.000 --> 00:37:04.000
I don't have time to manually learn those things. So what we want to do is, as Rob was saying, the software should be dynamically improving over time in response to the data.

00:37:04.000 --> 00:37:14.000
are these big leases down here again is what Rob's already alluded to. So we want to reduce the computational costs. So right now this 10,000 data sets per day is kind of worse than it looks, because

00:37:14.000 --> 00:37:20.000
For every data set, you will run an ensemble of pipelines, different software, different parameters

00:37:20.000 --> 00:37:30.000
Just hope one of them works, or choose the best one. So it's very brute force and wasteful. We want to reduce the amount of pipelines that are running.

00:37:30.000 --> 00:37:34.000
And use this information that's being lost. So most of the time

00:37:34.000 --> 00:37:46.000
Yeah, we're just throwing up this data away, any bad data, any… all these different observations we could be using. This is currently being thrown away, and then improving kind of what quality of data can actually be processed. So

00:37:46.000 --> 00:37:58.000
Right now, there's a limit on what we know we can process, but often this hasn't been fully explored. How can we stretch the software to allow us to process more poor quality data, for example?

00:37:58.000 --> 00:38:15.000
So thinking back to these steps that I was talking about earlier of what you do when you're processing a fraction dataset and thinking about this through a machine learning lens and this idea of kind of optimizing a fixed pipeline. So say you have a given software package like this one here

00:38:15.000 --> 00:38:22.000
And we can think for each of these steps, we have a certain data in a certain state at that point

00:38:22.000 --> 00:38:34.000
And also we are learning things about the data regarding, so we're getting these kind of metrics that are showing in response to decisions I've made, I have some more information, and this leads further on down the line.

00:38:34.000 --> 00:38:47.000
And then for a given node, we can say what we want to improve this particular aspect. And so we can do what we're saying is using a Bayesian model, and indeed, this is what Terrence Logo has been working on, and we have another

00:38:47.000 --> 00:38:51.000
probably in the new year

00:38:51.000 --> 00:38:57.000
Another approach that we're also investigating looking at is a reinforcement learning approach.

00:38:57.000 --> 00:39:12.000
Reinforcement learning. You might have heard this in things like apply to problems in like video games, soccer or chess, for example. These are ideal kind of algorithms for sequential learning for

00:39:12.000 --> 00:39:25.000
Understanding that the best decision to make at a given state, given all the states that happened before and the previous decisions. And so this is very kind of complementary to, Bayesian optimization. And I would say, increasingly, these things

00:39:25.000 --> 00:39:37.000
These all distinctions are kind of all merging together. It's often reinforcement learning models now, when you're exploring your potential actions that you can do, you would use Bayesian inference to figure out the best

00:39:37.000 --> 00:39:45.000
point in your action distribution to kind of access next, for example. Equally, you can use the outcome of these kind of reinforcement learning models

00:39:45.000 --> 00:39:55.000
as a prior for Bayesian models as well. But yeah, there's different kind of models where we are playing around with, and what's nice about reinforcement learning models is you can learn this

00:39:55.000 --> 00:40:02.000
complex sequential cumulative set of rewards, and often we are not just thinking about

00:40:02.000 --> 00:40:14.000
say, steps in a given pipeline being kind of correlated from one to the next. Also, the experiments that are running next can be correlated to previous ones. That can also inform, so we can think about models that are thinking

00:40:14.000 --> 00:40:19.000
index processing pipeline.

00:40:19.000 --> 00:40:23.000
So how does this actually work in practice?

00:40:23.000 --> 00:40:26.000
I didn't know if

00:40:26.000 --> 00:40:41.000
So we have a this is a this is a plugin for that different package I showed before. We can create our pipelines dynamically visually now, and the kind of nodes you can connect together are completely dependent on if the data states match up with each other

00:40:41.000 --> 00:40:52.000
And so this is reiterating the steps in that diffraction pipeline I was showing before, and then we can click on the given node and then decide we want to optimize that node

00:40:52.000 --> 00:41:06.000
We then have a suite of machine learning models that reinforce models, for example, that we can choose from. And then we can say we want to optimize this particular step with respect to these metrics, which we're getting from anything downstream

00:41:06.000 --> 00:41:18.000
in the Connected pipeline. So here we're optimizing this node with a particular model against metrics from here, and then here we're optimizing this node from much further down the line.

00:41:18.000 --> 00:41:30.000
So this is a way you can use, for example, reinforcement learning models to, again, achieve a similar output to what Rob was saying of optimizing a given part of the chain.

00:41:30.000 --> 00:41:43.000
So what's nice about, so as you can imagine, as we develop this, so on the single, say, beam line at Diamond, we will develop machine learning models that are optimizing different parts of these pipelines

00:41:43.000 --> 00:41:48.000
And then we can share these between beam lines. So suddenly we're expanding our

00:41:48.000 --> 00:41:56.000
I'll training data, and we're just bolting these on to pipelines that are already being run. So whenever a pipeline is being run

00:41:56.000 --> 00:42:13.000
The data processing is happening anyway, and we have machine learning models that are watching that processing and then learning from given this action, here's what happened, here's the reward, and then we can explore a bit around the decision that was made at that time. And we can use things like Bayesian inference to figure out the best

00:42:13.000 --> 00:42:16.000
To do that given what we know about the experiment

00:42:16.000 --> 00:42:23.000
So we can share between beam lines, and we're doing… we do this using this ML flow package that you might have heard of. So it's like an open source

00:42:23.000 --> 00:42:28.000
package for managing machine learning models, large language models

00:42:28.000 --> 00:42:41.000
Yeah, monitoring the sort of how well these models fall across different contexts, etc. So now we can start to develop an ecosystem of beam lines that are sharing

00:42:41.000 --> 00:42:46.000
models between them for optimizing pipelines in different contexts. They kind of grow a suite of

00:42:46.000 --> 00:42:49.000
Making the software dynamic in these different interfaces

00:42:49.000 --> 00:42:52.000
As I said before, it doesn't work with gift review

00:42:52.000 --> 00:43:00.000
We can expand these pipelines beyond just a given software package. So we can say we ought to use this software package here

00:43:00.000 --> 00:43:09.000
another one here. We can also say for this particular node. Let's just use a machine learning model directly. Let's use something like ResNets or

00:43:09.000 --> 00:43:19.000
I don't know, a convolutional neural network to approximate this traditional physics-based model, and as long as it matches the data state going in and out, we can pop that into our flowchart.

00:43:19.000 --> 00:43:22.000
As we would anything else.

00:43:22.000 --> 00:43:26.000
So just as with these 10,000 data sets a day, we can't

00:43:26.000 --> 00:43:29.000
visualize each one of those

00:43:29.000 --> 00:43:32.000
I would argue this this this

00:43:32.000 --> 00:43:41.000
The possible types of workflows you can do is just too big to manually design yourself. So we have the software now where you can manually design these things, but I would argue equally

00:43:41.000 --> 00:43:42.000
We want to consider

00:43:42.000 --> 00:43:57.000
adapting the pipelines for a given problem again in an automated way, rather than letting the user or the instrument beam scientists, in this case, do this. So when we're thinking about it, the context of this is kind of the high level above this meta thing that Bob was talking about

00:43:57.000 --> 00:44:04.000
You can say, not just given a node, what's the best action I can do here, what's the best set of parameters

00:44:04.000 --> 00:44:18.000
It's the best algorithm I should be using. We can also say, given my data, what should my pipeline actually look like? So the space is not just for software across the whole space of what parameters, what algorithm, what software, etc.

00:44:18.000 --> 00:44:33.000
So we are now using reinforcement learning for this as well. And as you can imagine, this is where reinforcement learning is kind of ideal because you have a very you have to think about what cumulative rewards across multiple sequential steps, which is really what reinforcement learning was really designed to do

00:44:33.000 --> 00:44:39.000
There are also other kinds of models that are very useful in this context. So things like

00:44:39.000 --> 00:44:45.000
Well, going into tax and planning or go which again is very popular in the video game world for like

00:44:45.000 --> 00:45:02.000
You know, enemy artificial intelligence, for example. So here, if you know, like, the A-star algorithm for minimizing the distance for a given minimum path for a given distance to a goal orientation action planning

00:45:02.000 --> 00:45:13.000
Things about that in the context of rewards. So what's the minimum, also the maximum in this case pathway to maximize reward across a complex space. And we can apply this in the same context. So

00:45:13.000 --> 00:45:22.000
At each node, we can say, what's my predicted reward for given actions? And again, we could use, Bayesian inference for that part of the pipeline

00:45:22.000 --> 00:45:33.000
And we can build up a path using things like planning to do that kind of thing as well. So that's the kind of things we're thinking about, how to apply this at this high level abstraction.

00:45:33.000 --> 00:45:41.000
So the elephants back in. So to kind of summarize how we're thinking about this. So firstly, we're thinking about

00:45:41.000 --> 00:45:45.000
Individual processes should always… should be

00:45:45.000 --> 00:45:54.000
optimal and dynamically reacting to the data that we have, rather than just the user deciding how things should be, how things should be carried out.

00:45:54.000 --> 00:46:06.000
And these workflows, they are… they are… we know they are correlated, and so we should be learning not just how to apply individual node, but how to connect things together such that we're thinking about metrics all all across the chain.

00:46:06.000 --> 00:46:17.000
And it's like a longer-term goal is that the software is dynamic. It's not, static. I should say, we're not shoehorning machine learning into these software. We're

00:46:17.000 --> 00:46:26.000
There's not a little AI agent popping up when you load the software now. This all sits above it in a separate framework that just influences how the software is used. So the software is still

00:46:26.000 --> 00:46:33.000
Here for machine learning, but we are exploiting these tools to allow us to dynamically change how we use it.

00:46:33.000 --> 00:46:48.000
And, Rob sunrise very passively here. Do you come up with this? But yeah, so you've automated expertise, rather than just the existing behavior, which is, I think, a really good way of thinking about this. So we have

00:46:48.000 --> 00:46:58.000
A very fixed almost engineering problem. We have a lot of data. We need to understand how to capture this data, and how to exploit that at any different level of abstraction.

00:46:58.000 --> 00:47:05.000
Yeah, thank you, Benny.

00:47:05.000 --> 00:47:10.000
Thank you very much. If you all have questions

00:47:10.000 --> 00:47:24.000
How do you avoid that you're missing cases? Thank you for the talk and in general, I agree, having done bean type of diamond in other places, it needs user interfaces where we can help the user to optimize their setup

00:47:24.000 --> 00:47:26.000
Definitely.

00:47:26.000 --> 00:47:32.000
But how do you avoid that if you're optimizing for OC an average

00:47:32.000 --> 00:47:37.000
The typical result. How do you avoid not seeing the one that is special?

00:47:37.000 --> 00:47:57.000
Well, I can say, yes, from my perspective, I would say one of the benefits of this online learning aspect. So yeah, when we've approached, so we're working multiple B minds with this kind of work and all the data sets they're giving us, there's already been human hands on it so self-selecting certain things. And so

00:47:57.000 --> 00:48:14.000
To best capture the space, we want to see everything that's happening, essentially, and many actions and response to those actions as possible. So, to me, bolting on this online learning, like a watchdog setup, where you're just watching everything that happens and exploring in response to that

00:48:14.000 --> 00:48:33.000
with the phase-in models, that once you have a sense of the distribution of these action spaces, you can kind of see where it's poorly explored. I think that, to me, is a good way of kind of going about that case. But yeah, yeah, I think

00:48:33.000 --> 00:48:45.000
There's two things that comes in and trusts your workflow, because it now runs, and it produces magic results. That's why I think it's important for workflows and any sort of advice that's coming through the system.

00:48:45.000 --> 00:48:53.000
To take into account errors. We think about error propagation, given uncertainty estimates. So it's okay to give an estimate what should be done.

00:48:53.000 --> 00:49:06.000
As long as the confidence in us is presented as well. So that's why diagnostic information comes in, including knowing whether or not a given data set is

00:49:06.000 --> 00:49:14.000
is nicely well embedded within the training data that was used to develop that system, or whether actually this is an edge case because it literally hasn't been seen before.

00:49:14.000 --> 00:49:21.000
At which point we could still produce a prediction for that. But with the flag to be very careful.

00:49:21.000 --> 00:49:30.000
Yeah, so the reinforcement learning algorithm, they're all policy gradient measures. So we are predicting distributions for those as well.

00:49:30.000 --> 00:49:32.000
Well, I would say

00:49:32.000 --> 00:49:38.000
We're also, so when we are running this at Sailor Diamond light source

00:49:38.000 --> 00:49:42.000
So I was comparing it to the current way people are doing things. So like

00:49:42.000 --> 00:49:59.000
And if their prediction is far better than ours, I can actually think about it as like an airline kind of model. This is like a disaster. We need to learn the maximum amount from this case, because clearly our models haven't accounted for this kind of information. So

00:49:59.000 --> 00:50:09.000
Yeah, again, I think it comes back just watching as much data as possible and having an understanding of the different distributions that you're working with.

00:50:09.000 --> 00:50:15.000
It's like there's going to tell the edge cases.

00:50:15.000 --> 00:50:30.000
Sort of relates to what you've been talking about with having to have uncertainty estimate. I think in our field, we have a lot of people who are very excited about machine learning algorithms, and they spend huge training runs to get a point estimate out. How do you build in

00:50:30.000 --> 00:50:36.000
uncertainties to the kind of training run, so that your inference can also produce uncertainty

00:50:36.000 --> 00:50:46.000
So, I know exactly how to do that in Bayesian models. Could you comment in the context of machine learning? Well, yeah, so machine learning, that has been

00:50:46.000 --> 00:50:54.000
A problem that I say parties solve with rules of thumb and the kind of frequentist machine learning field. The one way of doing it is when you have things like

00:50:54.000 --> 00:51:10.000
I mean, some of these methods are so old now, but does that dropout being on, say, neural network models, you're randomly dropping out nodes in your training. If you randomly drop out nodes in your inference as well, you're approximating an ensemble of those networks. And so then you can start to think.

00:51:10.000 --> 00:51:15.000
Each of those predictions, something that's generating a distribution of possible. So that that's the kind of

00:51:15.000 --> 00:51:22.000
At least after the moment when I was doing my PhD, that's the main way of inferring uncertainty and those things. But then again, I would say

00:51:22.000 --> 00:51:33.000
Yeah, a lot of these reinforcement learning methods. So I which is policy gradient methods. They are aimed for a different distribution with a mean and a variance. So they are. They are

00:51:33.000 --> 00:51:35.000
From a different kind of philosophy

00:51:35.000 --> 00:51:39.000
Kind of leaning towards the same

00:51:39.000 --> 00:51:54.000
Idea of not listing a single value, but a distribution as the kind of Bayesian approach. So in the reinforcement learning space, I'd say it's much more tangible than say in the supervised set of cases where you're thinking about. Yeah, a lot of the conventional machine learning approaches simply

00:51:54.000 --> 00:52:03.000
Didn't produce uncertainty estimates. And I think that even when we have got uncertainty estimates, say from the reinforcement learning, exactly what those uncertainties correspond to

00:52:03.000 --> 00:52:06.000
The exact interpretation is extremely important

00:52:06.000 --> 00:52:09.000
Thinking about whether or not all the errors are actually being propagated

00:52:09.000 --> 00:52:16.000
And so I think there's still some work to be done on these technologies in this area. It's still involving fear

00:52:16.000 --> 00:52:19.000
But at least it's heading in that direction.

00:52:19.000 --> 00:52:29.000
Cool. Yeah, I'd say also to the demo point, yeah, I think everyone's keen to jump to using a vision transform or a convolutional neural network

00:52:29.000 --> 00:52:37.000
just try and scikit-learn the kdos neighbors model often gets you 90% of the way there, and then you have much more tractability over

00:52:37.000 --> 00:52:51.000
Well, understanding how this multiple problems are things like accounting process or abandonment forest, these things, although not as sexy as all these, you know, these models, they allow much ability off the bat just from the way they've been designed

00:52:51.000 --> 00:53:03.000
That's one of the reasons why to go to animating it first, so that we can have something that we understand causality about, we can interpret, and then maybe replace components with machine learning-based

00:53:03.000 --> 00:53:07.000
Technologies actually

00:53:07.000 --> 00:53:12.000
But if you're going down your dynamic learning routes and you

00:53:12.000 --> 00:53:16.000
of you, we extract knowledge.

00:53:16.000 --> 00:53:19.000
In many ways, but we do machine learning, what we would like to have is

00:53:19.000 --> 00:53:35.000
the knowledge that is being trained into that somehow humanly comprehensively re-extracted. I think often we find that we find really as soon as we go to deep neural networks or convolutionals, it starts getting really hazy about what is it actually doing

00:53:35.000 --> 00:53:43.000
And there's a big question, if you figure out how to run Diamond optimally, why would you try and get an Albert's rest?

00:53:43.000 --> 00:53:51.000
I suppose that is one of the nice things about the Bayesian approach, and one of the very difficult things about the optimization.

00:53:51.000 --> 00:54:02.000
I guess you can get an answer for an individual data set, individual situation, but it's not the case that you can just write down a simple model on a page. That's absolutely wrong.

00:54:02.000 --> 00:54:11.000
Yeah, I mean, in a general, like, supervised neural network approach, there are ways of inverting the space so you can almost explore the input space that would lead to a maximum

00:54:11.000 --> 00:54:26.000
And there are ways of, you know, because it's a black body is sort of probing and then seeing the response. And you can probe around the values and things like that. But yeah, I think that's what we're saying

00:54:26.000 --> 00:54:32.000
The great thing about these Bayesian models, often the things that in this diffraction case, in our diamond case

00:54:32.000 --> 00:54:49.000
the kind of things we're putting into these models will be things about the experiments that are physically tangible. And so, from a Bayesian perspective, you can say how much of this have a weighting on these predictions and that kind of thing. So that's that's why it's really useful to think about things in that context

00:54:49.000 --> 00:55:02.000
Yeah, I think there's like two main areas where machine learning really has its own place here. One is where the system is just too complex for everything else, such as with these workflows that they talk about

00:55:02.000 --> 00:55:08.000
The other one is once you've got everything you can out of interpretive model and then you want the additional explicit

00:55:08.000 --> 00:55:15.000
So at that point, you've already got most of the interpretation, and then you're trying to fine tune your estimate

00:55:15.000 --> 00:55:25.000
But at that point, it's very difficult to know exactly where they come from.

00:55:25.000 --> 00:55:26.000
Thank you for the thought.

00:55:26.000 --> 00:55:29.000
So I'm a relatively

00:55:29.000 --> 00:55:41.000
you to using machine learning, so it might be a bit of an elementary question. But looking from your description about reinforce learning

00:55:41.000 --> 00:55:49.000
What are the benefits compared to just using all remnants to optimize all my sequential

00:55:49.000 --> 00:56:02.000
Well, yeah, I would say a lot of these fields started separately, but they are all increasingly, like, merging together. There's so many hybrid models, so I wouldn't think of these as

00:56:02.000 --> 00:56:09.000
necessarily separate. I mean, the good thing about reinforcement learning is you don't have to

00:56:09.000 --> 00:56:19.000
a tangible mapping of one thing to another. So it can be a very… that's why it works in context of things like, I don't know, paying donor 2 or whatever, because it's very hard to say

00:56:19.000 --> 00:56:25.000
I think that action leads to this reward very far ahead in time. And so

00:56:25.000 --> 00:56:29.000
That's where reinforcement learning kind of excels, is where you have this kind of

00:56:29.000 --> 00:56:35.000
Loose or poorly understood mapping of how a given action needs to respond

00:56:35.000 --> 00:56:49.000
But, yeah, again, I would say these things mix together. So a lot of supervised training of a model, you would do some reinforcement training. I could see the same model. So these things are all mixed together. It's just different ways of

00:56:49.000 --> 00:57:03.000
probing how to navigate this wave space of these very large models. So yeah, I wouldn't think of things as two separated these days, but there's so many combinations. So in that case, would it be, like, a good idea to train

00:57:03.000 --> 00:57:09.000
Like, modularizer problem trained by multiple RNNs of each, and then optimize

00:57:09.000 --> 00:57:12.000
results from those with the

00:57:12.000 --> 00:57:16.000
Yes, absolutely. And so, yes.

00:57:16.000 --> 00:57:22.000
Machine learning, in our field, been attempted for a while. I think

00:57:22.000 --> 00:57:31.000
It's been difficult to get good results for that, partly because maybe, yes, we're going too much from here's my data, here's my very end results

00:57:31.000 --> 00:57:53.000
Now that's let's optimize that. But if you breaking that down into these nodes or short term rewards as well as long term rewards. And yeah, embedding smaller neural networks and that kind of thing. I think, yes, it's definitely a much better way of making the problem more attractive and easier to train in many cases.

00:57:53.000 --> 00:57:58.000
Yeah, and in practice, it's quite hard to know what's going to work the best for a given case. So

00:57:58.000 --> 00:58:05.000
Benchmarking and trying to figure out what happens, what works best for a given application as part of the process

00:58:05.000 --> 00:58:08.000
Very much.

00:58:08.000 --> 00:58:15.000
On Zoom, maybe?

00:58:15.000 --> 00:58:17.000
That's the only question

00:58:17.000 --> 00:58:27.000
Okay. Is there no more questions. Let's thank our speakers again.

00:58:27.000 --> 00:58:40.000
Where we have launched

00:58:40.000 --> 00:58:53.000
There were two or three Alexes.

00:58:53.000 --> 00:59:21.000
One of them was the one on your slide. Okay, very good. Excuse me, are the slides going to be uploaded on the page? Yes. LinkedIn and obviously we don't say any of this umbrella stuff is good or bad