Latest / Satellite image deep learning / AutoML for Spaceborne AI

Transcript

AutoML for Spaceborne AI · Satellite image deep learning

• 0:04
  SPEAKER_00: Hi, Roberto.
• 0:05
  SPEAKER_00: Welcome back.
• 0:05
  SPEAKER_01: Hi, Robin.
• 0:07
  SPEAKER_01: It's always a pleasure.
• 0:08
  SPEAKER_00: Third time now.
• 0:09
  So let's have a little intro to yourself and what's been going
• 0:13
  on recently.
• 0:15
  SPEAKER_01: All right.
• 0:16
  Like last time,
• 0:16
  I still work in ESA,
• 0:18
  the Philop,
• 0:20
  and I serve as an internal research fellow.
• 0:22
  SPEAKER_01: So it's like a postdoc position.
• 0:25
  My domain of expertise is how to bring artificial intelligence
• 0:28
  on board satellites.
• 0:29
  SPEAKER_00: Mm-hmm.
• 0:30
  SPEAKER_01: Lately,
• 0:30
  I've been working on a very specific topic which concerns the
• 0:35
  automatic machine
• 0:36
  SPEAKER_01: learning or AutoML.
• 0:38
  SPEAKER_00: Fantastic.
• 0:40
  SPEAKER_01: And what I've been working on is like,
• 0:42
  how can speed up the development of models to deploy it on our
• 0:47
  satellites in a more
• 0:48
  SPEAKER_01: fast and efficient way.
• 0:50
  SPEAKER_01: Whereas the result is kind of overhead in training your model,
• 0:53
  SPEAKER_01: selecting your model,
• 0:54
  SPEAKER_01: fine tune it,
• 0:56
  SPEAKER_01: deploy it on your satellite,
• 0:57
  try to strike a good balance or a good trade off between the
• 1:02
  accuracy of your model
• 1:04
  SPEAKER_01: and the latency.
• 1:05
  SPEAKER_01: So how fast they can go.
• 1:07
  Right,
• 1:08
  so on the satellite,
• 1:09
  you don't really obviously get to choose among different
• 1:11
  hardwares.
• 1:12
  SPEAKER_00: They've selected something.
• 1:13
  SPEAKER_00: You need to optimize your solution for what's already there.
• 1:17
  SPEAKER_01: Exactly, exactly.
• 1:18
  SPEAKER_01: And you don't have all the power that you will have on the ground, right?
• 1:21
  SPEAKER_00: Right, interesting.
• 1:23
  SPEAKER_01: You have a lot of things.
• 1:26
  SPEAKER_00: Yeah, I mean, just ballpark, how would it compare on the ground?
• 1:30
  SPEAKER_00: I've got my GPUs available in space.
• 1:32
  Are we talking about like 10% of the available compute,
• 1:36
  5%,
• 1:36
  something like that?
• 1:38
  SPEAKER_01: So let's say on ground, you could have something like 300 watts of power.
• 1:43
  SPEAKER_00: Mm-hmm.
• 1:44
  on board you can have something like three watts but it
• 1:47
  strongly depends on how big
• 1:48
  is your satellite for cubesat maybe 10 watts right so we're
• 1:53
  talking a couple of
• 1:54
  orders of magnitude in difference in available power generally
• 1:58
  speaking very
• 1:59
  interesting right so you have a paper that you've been working
• 2:03
  on let's cover some
• 2:04
  SPEAKER_00: of the details
• 2:06
  SPEAKER_01: Yes,
• 2:06
  SPEAKER_01: so I was questioning myself,
• 2:08
  SPEAKER_01: okay,
• 2:09
  we always try to bring this model from literature when we need
• 2:13
  to solve a task.
• 2:14
  SPEAKER_01: But most of these models that comes from literature,
• 2:17
  SPEAKER_01: they've been hardly optimized on specific data set and some specific data
• 2:21
  SPEAKER_01: distribution.
• 2:23
  SPEAKER_01: But when it comes to the satellite and to the new space segment,
• 2:27
  SPEAKER_01: we're always looking at verticalized application.
• 2:29
  So I think like a satellite with onboard AI that generally has
• 2:33
  to do only one thing
• 2:35
  SPEAKER_01: and it has to do it very,
• 2:36
  SPEAKER_01: very quickly.
• 2:37
  SPEAKER_01: Like, I don't know, detect a wildfire here.
• 2:40
  So they have a segment with the constellation of these
• 2:43
  AI-enabled satellites.
• 2:45
  SPEAKER_01: and they want to do only a single task.
• 2:48
  SPEAKER_01: So in that case,
• 2:49
  the model that we bring on orbit must be tailored and optimized
• 2:53
  towards that task
• 2:54
  SPEAKER_01: and data distribution.
• 2:57
  But we fail and do that because we usually take models already
• 3:02
  pre-made by the
• 3:03
  SPEAKER_01: literature to solve very different problems like,
• 3:08
  SPEAKER_01: I don't know,
• 3:08
  SPEAKER_01: classification on ImageNet or object detection on Cocoa dataset,
• 3:13
  which the data is completely different and therefore their
• 3:16
  architecture is made for
• 3:17
  SPEAKER_01: doing something completely different.
• 3:21
  SPEAKER_00: So you have a specific task, you know, fire detection.
• 3:24
  SPEAKER_00: You've curated a specific data set for that satellite.
• 3:28
  SPEAKER_00: And the next optimization is curating the model.
• 3:32
  exactly exactly the thing is that you want to squeeze as much
• 3:35
  as you can the
• 3:36
  performance of that model and on that hardware that is
• 3:40
  available on your satellite
• 3:42
  because you want to reduce the duty cycle so you want to use as
• 3:46
  much as less power
• 3:48
  as you can because if you use less power you use less energy of
• 3:52
  course and the
• 3:53
  battery gets benefits from it so you can extend the lifetime of
• 3:56
  your mission and so
• 3:58
  SPEAKER_01: it's a lot of money that you can save in the end
• 4:01
  SPEAKER_00: Yeah,
• 4:01
  SPEAKER_00: so the best performance for the least possible power,
• 4:04
  SPEAKER_00: that's the point you're trying to find.
• 4:07
  So the point is that best performance for satellite application
• 4:10
  and this kind of a
• 4:11
  SPEAKER_01: segment is not always having the best accuracy,
• 4:15
  SPEAKER_01: in my opinion.
• 4:16
  You don't want to have a model that performs three,
• 4:19
  four,
• 4:19
  five points of percentage at maximum.
• 4:22
  You don't want to have that delta increase if that costs you a
• 4:25
  lot of power on orbit.
• 4:26
  SPEAKER_01: Mm-hmm.
• 4:28
  SPEAKER_01: You want to strike a good balance between the accuracy,
• 4:31
  SPEAKER_01: so how performant is your model in that sense,
• 4:34
  but also how fast that model is in processing the whole
• 4:39
  acquisition on your
• 4:40
  SPEAKER_01: satellite.
• 4:41
  SPEAKER_00: Right.
• 4:41
  SPEAKER_00: So we're not just talking about a metric that we're targeting now,
• 4:44
  we're talking about different kind of characteristics of a
• 4:47
  model that we want to
• 4:48
  SPEAKER_00: achieve.
• 4:49
  SPEAKER_01: We can say that we are looking at a multi-objective optimization.
• 4:54
  which we have two concurrent objectives,
• 4:56
  and we try to optimize both of them.
• 4:59
  SPEAKER_00: Right, okay.
• 5:01
  That segues nicely into how you're doing that with the
• 5:04
  architecture search.
• 5:06
  SPEAKER_01: So I've been looking a little bit,
• 5:08
  and I discovered that this kind of technology was already
• 5:14
  developed for computer
• 5:15
  SPEAKER_01: vision tasks,
• 5:16
  SPEAKER_01: but it was not really applied a lot in the geospatial community.
• 5:19
  SPEAKER_01: So I decided to make my own framework.
• 5:25
  SPEAKER_01: And yeah,
• 5:26
  what I did is like applying a genetic algorithm optimizer and
• 5:32
  like build this
• 5:32
  SPEAKER_01: framework,
• 5:33
  SPEAKER_01: which is called Pinus,
• 5:34
  SPEAKER_01: that works in this way.
• 5:36
  SPEAKER_01: Essentially, it creates population of networks.
• 5:38
  And then you just see which of these networks are the most top
• 5:44
  performing.
• 5:45
  SPEAKER_01: And then you optimize the topology of those network in a cycle.
• 5:51
  But the key part in this framework is that we profile each
• 5:55
  model on the specific edge device.
• 5:58
  SPEAKER_01: So we have similar devices to the one that are flying on the satellites,
• 6:03
  SPEAKER_01: and we see how these models are performing on these devices.
• 6:06
  SPEAKER_00: Okay,
• 6:07
  SPEAKER_00: so you have on your desk literally these different computers plugged in,
• 6:11
  SPEAKER_00: and you run your software,
• 6:12
  SPEAKER_00: and you get scores for each of the different hardwares.
• 6:17
  SPEAKER_01: Exactly, exactly.
• 6:20
  SPEAKER_01: So...
• 6:21
  to expand a little bit on that each vendor mixes memories on
• 6:26
  the device in a very
• 6:27
  different way so you might find that some layers are better
• 6:31
  suited for some devices
• 6:33
  or in some other devices seems they use their own compilation
• 6:38
  some layers are not
• 6:39
  even supported so you cannot use all the layers of modern deep
• 6:43
  learning on some
• 6:44
  SPEAKER_01: devices
• 6:46
  really a matter of finding what is the best solution for that
• 6:50
  kind of hardware that
• 6:51
  you have software for your hardware interesting yeah what are
• 6:57
  some of the sort of
• 6:58
  SPEAKER_00: constraints there what kind of layers are we talking about typically
• 7:02
  SPEAKER_01: So,
• 7:02
  SPEAKER_01: for instance,
• 7:04
  SPEAKER_01: in a Miriam 2 that is flying on a Fisat,
• 7:07
  SPEAKER_01: on Fisat 2,
• 7:08
  SPEAKER_01: and was flying on Canini and Fisat 1,
• 7:11
  SPEAKER_01: well,
• 7:11
  SPEAKER_01: on that kind of device,
• 7:12
  SPEAKER_01: vision transformers are not very well supported.
• 7:16
  As you know,
• 7:17
  transformers are kind of the basic block of the modern deep
• 7:20
  learning architectures.
• 7:23
  So these are generally examples,
• 7:25
  but there are also other layers that are not supported.
• 7:30
  In other cases,
• 7:31
  during compilation times,
• 7:32
  the kernel gets fused together.
• 7:34
  SPEAKER_01: So sometimes,
• 7:37
  SPEAKER_01: let's say,
• 7:38
  three convolution with a kernel of 3x3 works better than a
• 7:42
  single convolution with
• 7:43
  SPEAKER_01: a kernel of 7x7,
• 7:45
  SPEAKER_01: or for some other devices.
• 7:49
  SPEAKER_01: It's really a challenge of discovering what is the best for your device.
• 7:55
  SPEAKER_00: Right.
• 7:56
  SPEAKER_00: So for each device,
• 7:57
  you have a table which says these are the kind of optimized
• 8:00
  layers that you should
• 8:01
  SPEAKER_00: utilize.
• 8:02
  Now,
• 8:02
  design and architecture that utilizes them and gives me the
• 8:05
  best result.
• 8:07
  Yeah,
• 8:07
  it works kind of like that,
• 8:09
  but I let the optimizer do all the job for me.
• 8:11
  SPEAKER_00: Mm-hmm.
• 8:13
  SPEAKER_01: by simply profiling each of these models on the devices,
• 8:17
  he's looking at which is the top architecture that is
• 8:21
  performing the best.
• 8:23
  SPEAKER_01: And then after tweaking that architecture a little bit,
• 8:26
  SPEAKER_01: discovering path,
• 8:27
  SPEAKER_01: changing the topology,
• 8:29
  SPEAKER_01: trying to see if that kind of architecture can be improved.
• 8:33
  SPEAKER_00: Right.
• 8:33
  That's the zone in a parallel way,
• 8:36
  employing different models at the same time.
• 8:39
  SPEAKER_00: Right.
• 8:39
  SPEAKER_00: I just want to understand the algorithm a little bit more there.
• 8:41
  SPEAKER_00: So it starts with a kind of grid search,
• 8:43
  SPEAKER_00: finds some promising architectures,
• 8:46
  SPEAKER_00: and then experiments further on those,
• 8:48
  SPEAKER_00: does it?
• 8:49
  SPEAKER_01: Yeah.
• 8:49
  SPEAKER_01: No, this class of algorithm are known in literature as meta-heuristic.
• 8:54
  SPEAKER_01: and are used to solve non-convex problems.
• 8:58
  SPEAKER_01: This one in particular is a population-based, is the genetic algorithm.
• 9:02
  SPEAKER_01: So you can consider it a grid, I see it more like a population.
• 9:07
  SPEAKER_01: You have a population made of several different individuals,
• 9:10
  SPEAKER_01: and each individual for you represents a model.
• 9:14
  SPEAKER_01: And after each generation,
• 9:16
  you kill the worst performing and then you recompile together
• 9:22
  the top performing,
• 9:23
  SPEAKER_01: creating a new architecture.
• 9:26
  The process continues in an iterative way until you reach a top
• 9:32
  performing architecture.
• 9:33
  SPEAKER_00: Right.
• 9:34
  So you basically are watching these different models kind of
• 9:37
  rising up a ramp
• 9:38
  towards some kind of best solution with the low performers
• 9:41
  being picked up.
• 9:43
  exactly actually we at the end of this optimization we obtain a
• 9:48
  set of top
• 9:48
  performing model and one can cherry pick uh the model that best
• 9:53
  satisfies his
• 9:53
  trade-off maybe someone is more interested in having a little
• 9:57
  bit of more of
• 9:58
  accuracy maybe someone else for another device is interested in
• 10:02
  having a little bit
• 10:03
  more of latency so at the end you obtain this solution which
• 10:06
  has like the pareto
• 10:08
  efficient solutions and you can cherry pick the model based on
• 10:11
  on your requirements
• 10:13
  So is there a lot of user skill required to get the best
• 10:16
  solution or is it pretty
• 10:17
  SPEAKER_00: much sort of push the button and it will arrive at the best solution?
• 10:22
  SPEAKER_01: Well,
• 10:22
  SPEAKER_01: you can tweak a little bit the parameters,
• 10:24
  SPEAKER_01: but more or less the optimizer should do the job for you.
• 10:28
  SPEAKER_01: You can't change how big are this population,
• 10:31
  SPEAKER_01: so how many models you want to train at the same time,
• 10:34
  SPEAKER_01: how much these models can be big,
• 10:36
  SPEAKER_01: so how many layers,
• 10:38
  SPEAKER_01: which layers they can use.
• 10:40
  SPEAKER_01: You can tweak this,
• 10:41
  SPEAKER_01: but on a general level,
• 10:43
  I would say that the optimizer really simplifies what you need
• 10:46
  to do because it
• 10:48
  SPEAKER_01: does all the job in the back end and you don't have to
• 10:50
  SPEAKER_01: to watch and to select which layers you need to use.
• 10:54
  SPEAKER_01: It does that for you.
• 10:56
  SPEAKER_00: Okay, so no transformers based on what's supported by the hardware.
• 10:59
  SPEAKER_00: What kind of architectures did you arrive at for your different tasks?
• 11:04
  SPEAKER_01: Well,
• 11:04
  usually they are kind of similar to mix of ConvNext and ResNets
• 11:10
  or mobile and
• 11:11
  SPEAKER_01: virtual bottlenecks.
• 11:14
  SPEAKER_01: Different kind of modules stack one on top of each other.
• 11:18
  SPEAKER_01: That's the kind of solution that he gets.
• 11:21
  But the remarkable thing is that these models are very,
• 11:23
  very tiny compared to the literature.
• 11:26
  We're talking over thousands of parameters compared to
• 11:29
  multi-million parameters
• 11:31
  that you will find in another model taken from another task for
• 11:35
  a computer vision
• 11:36
  SPEAKER_01: problem.
• 11:38
  SPEAKER_00: And what's the sort of trade-off in performance look like there?
• 11:42
  SPEAKER_01: So for defining the trade-off, I used a mathematical formula.
• 11:46
  SPEAKER_01: So it's basically combining two values in a single one.
• 11:51
  SPEAKER_01: And that is the value that I try to optimize.
• 11:53
  It's like having a sort of a weighted function that tries to
• 11:57
  balance both the
• 11:58
  SPEAKER_01: accuracy and the latency of my task.
• 12:04
  then at the end i can see the results on these graphs and then
• 12:06
  i can cherry pick
• 12:08
  which is like the the model that mostly satisfies my
• 12:12
  constraints that can be
• 12:13
  different depending on the on the type of mission that they
• 12:16
  have or on the type of
• 12:18
  task that i need to satisfy right okay so these results are
• 12:22
  presented in the paper
• 12:23
  um sounds very exciting what which model is going to be
• 12:27
  deployed first then
• 12:30
  SPEAKER_01: I think we have a lot of promising models here.
• 12:32
  SPEAKER_01: We have a model for wildfire detection.
• 12:34
  SPEAKER_01: This is further described in the paper.
• 12:38
  We also have a model for vessel detection that has been
• 12:42
  presented to a conference.
• 12:46
  SPEAKER_00: And I just want to have a look at the bigger picture here.
• 12:47
  SPEAKER_00: So you have this model that's on the satellites making some detections.
• 12:51
  SPEAKER_00: Maybe the accuracy has been traded a bit.
• 12:53
  Do they then integrate it to some wider pipeline where other
• 12:56
  models are maybe
• 12:58
  SPEAKER_00: looking at the images again on the ground?
• 13:02
  SPEAKER_00: Or is it just that single model that's going to do all the work?
• 13:08
  SPEAKER_01: So, okay, you're touching a bit of a pain of a problem.
• 13:12
  SPEAKER_01: That's like the domain gap.
• 13:14
  Because usually we train models on different data distribution
• 13:18
  on a different
• 13:18
  dataset compared to the data that is actually sensed by this
• 13:23
  new space satellite.
• 13:24
  Because they mount different sensors that are typically
• 13:27
  different from the data
• 13:29
  SPEAKER_01: that we already have collected.
• 13:31
  SPEAKER_01: And so it's always like this problem on filling that gap.
• 13:36
  SPEAKER_01: Because we try and with simulators,
• 13:38
  SPEAKER_01: we try to simulate the kind of data that we expect from that satellite.
• 13:42
  SPEAKER_01: But even in that case,
• 13:43
  there's still an existing gap between what we make synthetic
• 13:46
  expecting what the
• 13:47
  kind of sensor is acquiring and what is actually acquiring on
• 13:52
  that satellite.
• 13:53
  SPEAKER_01: So there is always this process of training one time,
• 13:56
  then you downlink again your images and then you fine tune
• 14:00
  again your images,
• 14:01
  SPEAKER_01: your model on these new images.
• 14:05
  SPEAKER_01: I will not say it's a continual learning process,
• 14:07
  SPEAKER_01: but we try to fine-tune to tweak the performance,
• 14:10
  SPEAKER_01: and we need to re-up the model in most of the cases.
• 14:14
  SPEAKER_01: This is something that happened in the past.
• 14:17
  SPEAKER_01: And I will say that having models that are very small is an advantage,
• 14:21
  SPEAKER_01: because it's kind of easy to fine-tune it,
• 14:23
  SPEAKER_01: and it's kind of easy to update again these models,
• 14:26
  SPEAKER_01: because their weight in terms of megabytes is very,
• 14:29
  SPEAKER_01: very low.
• 14:29
  SPEAKER_01: We're talking about...
• 14:30
  megabytes of models or sometimes even more even less it's kind
• 14:35
  of easy uplink so
• 14:38
  you anticipate updating the models in response to gathering
• 14:41
  more data of course um
• 14:45
  uh and also how practical is it to deploy these models if you
• 14:48
  want to deploy a new
• 14:49
  version is it kind of a straightforward deployment like cicd
• 14:53
  kind of operation or
• 14:55
  is there a lot of work to sort of get date and model ready for
• 14:58
  gag on a satellite
• 15:00
  SPEAKER_01: I would say most of the work here is mostly on the data side.
• 15:04
  SPEAKER_01: It's not really on the model side.
• 15:07
  SPEAKER_01: Because this pipeline here,
• 15:09
  SPEAKER_01: they're not really in CI,
• 15:11
  SPEAKER_01: CD,
• 15:12
  SPEAKER_01: but they are kind of optimized and automatized.
• 15:14
  SPEAKER_01: So there is not too much work on that.
• 15:17
  SPEAKER_01: But on data side, you really have to make a pipeline for your new data.
• 15:23
  SPEAKER_01: And then you need to update that model.
• 15:25
  SPEAKER_01: Because mostly of this data is not labeled.
• 15:28
  SPEAKER_01: So you really have to bear that in mind.
• 15:30
  SPEAKER_00: Right, okay.
• 15:32
  SPEAKER_00: So there'll be a period where you're basically onboarding this model and,
• 15:36
  SPEAKER_00: you know,
• 15:37
  viewing the predictions maybe and adding some more data to the
• 15:41
  training data set
• 15:42
  and potentially tweaking the architecture a bit and kind of
• 15:45
  going around this loop
• 15:46
  SPEAKER_00: a few times until you're happy.
• 15:48
  SPEAKER_01: That's something that usually happens.
• 15:51
  SPEAKER_01: Maybe not tweaking again the architecture,
• 15:53
  SPEAKER_01: but it really depends,
• 15:54
  SPEAKER_01: but at least giving a bit of fine tuning on this new data.
• 15:58
  SPEAKER_01: Sometimes it's not necessary to have a lot of this data.
• 16:01
  You can do a small fine tuning on only some very good quality
• 16:05
  information,
• 16:06
  SPEAKER_01: but you have to know that there is this gap and you need to close it.
• 16:10
  SPEAKER_00: Right, of course.
• 16:12
  SPEAKER_00: Moving on to the actual hardware that's available,
• 16:14
  what are the brands and what are the performance look like of
• 16:17
  those hardwares?
• 16:20
  SPEAKER_01: So, okay.
• 16:23
  SPEAKER_01: We have, of course, Nvidia with the Jetson chipset.
• 16:29
  SPEAKER_01: We have the Myriad from Intel.
• 16:31
  SPEAKER_01: And some of the boards developed by Botica.
• 16:35
  SPEAKER_01: And we have some boards developed from KP Labs as well.
• 16:39
  SPEAKER_01: I hope to not forget someone, but I think I'm going to forget someone.
• 16:43
  SPEAKER_01: But still,
• 16:44
  it's a lot of hardware and there's a lot of push on this kind
• 16:48
  of processing unit
• 16:49
  SPEAKER_01: that can do accelerators for small satellites.
• 16:54
  SPEAKER_00: Very interesting.
• 16:55
  SPEAKER_00: And do these different providers,
• 16:56
  do they take different approaches or target different kind of
• 16:59
  applications?
• 17:02
  SPEAKER_01: Let's say that they are very different,
• 17:04
  SPEAKER_01: one from each other,
• 17:05
  SPEAKER_01: also in the way they work from a model during the compilation time.
• 17:11
  SPEAKER_01: And that's,
• 17:12
  SPEAKER_01: again,
• 17:12
  SPEAKER_01: the problem that we were referring at the beginning,
• 17:15
  SPEAKER_01: that not each layer is supported by each one of those hardware.
• 17:19
  SPEAKER_00: Right.
• 17:20
  SPEAKER_00: Okay.
• 17:21
  I'm curious if there'd be a feedback loop that you would
• 17:23
  basically discover certain
• 17:24
  classes of models were optimal for certain kinds of tasks and
• 17:28
  that would drive you
• 17:29
  SPEAKER_00: towards particular hardware and give an edge to one provider.
• 17:34
  It's very difficult to extrapolate this generic rule because it
• 17:37
  also depends on the
• 17:38
  SPEAKER_01: way you make your optimization.
• 17:41
  SPEAKER_01: In the sense that if you look at the paper,
• 17:43
  you will notice that the model strain for the myriad were much
• 17:47
  strongly optimized
• 17:49
  SPEAKER_01: towards the latency.
• 17:51
  That is coming from a physical problem that the Myriad is a
• 17:55
  very low power device.
• 17:57
  So when you set that function to optimize this fitness between
• 18:02
  accuracy and
• 18:03
  SPEAKER_01: latency,
• 18:05
  SPEAKER_01: this is strongly pushing towards the latency compared to the accuracy.
• 18:09
  SPEAKER_00: Interesting.
• 18:10
  SPEAKER_00: And so a different provider might head in a different direction,
• 18:13
  SPEAKER_00: sort of utilize more power,
• 18:14
  SPEAKER_00: but be targeting a different kind of task.
• 18:18
  I would say that NVIDIA hardware is more general purpose and in
• 18:23
  particular is more powerful.
• 18:24
  Intel devices are much more focused towards certain kind of
• 18:29
  layers that are a bit
• 18:30
  SPEAKER_01: more efficient and they use much less power consumption that this
• 18:35
  nvidia chipset that we have right now but we are also in an
• 18:38
  historical period where
• 18:39
  things change very very quickly new hardware gets updated and
• 18:44
  new satellite gets
• 18:45
  launched uh every every six months i know for sure that next
• 18:50
  year we're gonna have
• 18:51
  new mission like ix there is also a constellation of uh ai
• 18:57
  enabled satellite by
• 18:58
  SPEAKER_01: planet that's uh the constellation so um
• 19:03
  SPEAKER_01: I think that the thing is going to change quickly in the future,
• 19:05
  but there is something that will be always constant in each one
• 19:09
  of these missions,
• 19:10
  SPEAKER_01: that is the efficient optimization of the models for a specific hardware.
• 19:18
  SPEAKER_01: That is something that you cannot overlook.
• 19:20
  SPEAKER_01: You need,
• 19:20
  SPEAKER_01: of course,
• 19:21
  SPEAKER_01: to use as much less power as you need,
• 19:24
  SPEAKER_01: because this is going to extend the lifetime of your mission.
• 19:27
  SPEAKER_00: Fantastic.
• 19:28
  SPEAKER_00: Well, really interesting topic.
• 19:29
  SPEAKER_00: Congratulations on the paper.
• 19:31
  SPEAKER_00: That's already published or that's to be released soon?
• 19:35
  SPEAKER_01: Published.
• 19:36
  SPEAKER_01: It's open source.
• 19:37
  SPEAKER_01: The code is available.
• 19:38
  SPEAKER_01: The data sets are all freely available.
• 19:40
  But in case you have any doubts,
• 19:43
  I feel free to,
• 19:44
  I ask you to connect with me.
• 19:46
  SPEAKER_01: Just send me an email or a message on LinkedIn.
• 19:49
  SPEAKER_01: I would be happy to provide with more information.
• 19:52
  SPEAKER_00: Brilliant.
• 19:52
  SPEAKER_00: I'll drop all the details in the show notes.
• 19:54
  SPEAKER_00: Well,
• 19:55
  SPEAKER_00: once again,
• 19:55
  thank you for joining me and all the best with the deployments
• 19:59
  and let's catch up
• 20:00
  SPEAKER_00: again in the future.
• 20:02
  SPEAKER_00: Ciao, bye-bye.
• 20:02
  SPEAKER_01: Thank you.
• 20:03
  SPEAKER_00: Ciao.