Latest / EDGE AI POD / Hardware-Aware AI, Not Just Bigger Models

Transcript

Hardware-Aware AI, Not Just Bigger Models · EDGE AI POD

• 0:08
  SPEAKER_00: I guess we all know the Ferrari.
• 0:12
  SPEAKER_00: And when I think about the Ferrari, I think about speed.
• 0:17
  SPEAKER_00: It made for asphalt, for smooth curves.
• 0:22
  SPEAKER_00: But putting it in an environment it was not made for, it will sink.
• 0:28
  SPEAKER_00: All that horsepower lost.
• 0:31
  SPEAKER_00: Or here.
• 0:32
  SPEAKER_00: The hummingbird.
• 0:34
  SPEAKER_00: Meteorism on overdrive at a wing speed ninety wing speeding 90 times a second.
• 0:45
  SPEAKER_00: It needs to fuel up.
• 0:47
  SPEAKER_00: It needs to visit flowers, up to a thousand flowers a day, feeding every 10 to 15 minutes.
• 0:57
  SPEAKER_00: And asking it to cross an ocean, we would never do that.
• 1:02
  SPEAKER_00: So why are we asking our models in HII to be deployed in an environment that they are not made for?
• 1:12
  SPEAKER_00: There's nothing quite so useless as doing something with great efficiency that should not be done at all.
• 1:21
  SPEAKER_00: The Ferrari is made for asphalt.
• 1:24
  SPEAKER_00: The hummingbird is made where there is fuel, where there are flowers, and where they fail, the Jeep and the Swift Excel.
• 1:37
  SPEAKER_00: Today we have three goals.
• 1:39
  SPEAKER_00: And today I want to compress the knowledge we have gained at Embattel over the last couple of years in deep learning optimization.
• 1:49
  SPEAKER_00: And teach you some of that.
• 1:51
  SPEAKER_00: And I hope everyone of you get something out of this presentation.
• 1:56
  SPEAKER_00: My name is Jonah Matizen, and I'm a deep learning researcher at Embattel.
• 2:00
  SPEAKER_00: And I'm mostly involved in the algorithm development.
• 2:03
  SPEAKER_00: Have seen many different customer projects, have seen many different issues that arise when it comes to deploying models onto the edge.
• 2:12
  SPEAKER_00: And today we're going to try to tackle some of them.
• 2:15
  SPEAKER_00: And we're going to see how we can solve the issue of deploying models onto environments they are not made for.
• 2:23
  SPEAKER_00: And we're going to look first at some examples, and then at the end, I show you some practical tips on how to avoid all those traps and tricks.
• 2:37
  SPEAKER_00: So let's start with this.
• 2:39
  SPEAKER_00: I think most of you have probably seen this.
• 2:41
  SPEAKER_00: And maybe today we are we are getting better at at not doing this, but it is still kind of true.
• 2:48
  SPEAKER_00: When we try to optimize models, when we try to increase the accuracy of models, oftentimes the solution to it, or what we think the solution, is to just stack more lays, making the models larger and larger.
• 3:01
  SPEAKER_00: Instead of really maybe improving the architectural or the other, uh maybe the training or the data set.
• 3:10
  SPEAKER_00: Our silly approach may be to just stack more layers.
• 3:18
  SPEAKER_00: I said in the beginning we're going to look at some of the examples of what not to do, of where models are meant to be run in a different environment.
• 3:29
  SPEAKER_00: And the first example we're going to look at is uh WestNet 18 and MobileNet V2.
• 3:35
  SPEAKER_00: So those are even today, even though they are quite old architectures, they are widely used even today in vision models, perhaps as backbones in some object detection models, or uh image uh classification by themselves, or semantic segmentation.
• 3:53
  SPEAKER_00: So the uh areas we deploy those models are huge.
• 3:57
  SPEAKER_00: And they are quite distinct.
• 4:01
  SPEAKER_00: They are quite different.
• 4:03
  SPEAKER_00: Even though they have roughly the same acquaintance on ImageNet, uh in terms of flops, in terms of parameters, and in terms of architecture, they differ quite a lot.
• 4:14
  SPEAKER_00: So the uh mobile net v2 is roughly six times smaller than the ResNet 18.
• 4:22
  SPEAKER_00: However, if we deploy this model onto a Nvidia GPU, it will be slower.
• 4:31
  SPEAKER_00: Even though theoretically, just looking at the numbers, just looking at the flops or the number of parameters, this model is tiny.
• 4:39
  SPEAKER_00: It should run fast.
• 4:41
  SPEAKER_00: It should be much faster than this ResNet 18 just looking at the numbers.
• 4:45
  SPEAKER_00: But the architecture has implications.
• 4:50
  SPEAKER_00: And if we remember the mobile net paper, it is called mobile net for a reason.
• 4:56
  SPEAKER_00: And mobile in this context means CPU devices.
• 5:01
  SPEAKER_00: MobileNet V2 mainly consists of death by several convolutions.
• 5:06
  SPEAKER_00: And those convolutions are many small sequential computations.
• 5:11
  SPEAKER_00: Great for a CPU, but definitely not for a GPU.
• 5:16
  SPEAKER_00: And ResNet 18, very old architecture, but mainly consists of the typical dense convolution.
• 5:23
  SPEAKER_00: Even then, even though it is very old, it outperforms the MobileNet V2 just because its architecture fits the hardware better.
• 5:37
  SPEAKER_00: Second example.
• 5:38
  SPEAKER_00: We stick with the ResNet 18 or ResNet 15, in this case, just a larger ResNet 18 that's like like this.
• 5:45
  SPEAKER_00: We quantized it.
• 5:46
  SPEAKER_00: And here we see an extract from the Battle Hub, which is essentially a large benchmarking website, among other things.
• 5:58
  SPEAKER_00: And we deployed this model onto different devices.
• 6:02
  SPEAKER_00: Mainly we are now going to focus on the first and the last.
• 6:07
  SPEAKER_00: The first being the Nvidia Jetson AGX Owen, the last being the Qualcomm's Netduring 8 Gen 3.
• 6:14
  SPEAKER_00: The first is the GPU, the last one an NPU.
• 6:19
  SPEAKER_00: And on the Owen, the WestNet 50 runs at roughly 0.61 milliseconds.
• 6:29
  SPEAKER_00: But on the Qualcomm, with much lower TOPS, and TOPS being kind of an approximation of the hardware capabilities, it is faster.
• 6:39
  SPEAKER_00: So just looking at the tops of a hardware is also not really helping us.
• 6:45
  SPEAKER_00: We need to look at both, with the model architecture and the hardware capabilities, and then make decisions based on those factors.
• 6:57
  SPEAKER_00: I just leave it at that.
• 7:04
  SPEAKER_00: So how do we become hardware aware?
• 7:08
  SPEAKER_00: And the background looks a bit strange.
• 7:11
  SPEAKER_00: It is not my but uh let me make a statement.
• 7:17
  SPEAKER_00: And even in this room where we are supposed to be experts, I am quite certain that most of us are still using the wrong model, are still using models that are not entirely a good fit for the hardware.
• 7:32
  SPEAKER_00: Of course, now I'm gonna trigger a couple of you, and uh, and you will hate me for it, but that's the point.
• 7:39
  SPEAKER_00: And what's the issue and what can we do?
• 7:45
  SPEAKER_00: On the edge, there is a wide range of hardware vendors.
• 7:51
  SPEAKER_00: A wide range of hardware I can choose.
• 7:55
  SPEAKER_00: And I, as a maybe as a naive developer, how should I know which hardware to choose?
• 8:01
  SPEAKER_00: How should I know which hardware render fits my model, fits my application best?
• 8:07
  SPEAKER_00: And on top of that, another challenge is on the edge, there's a wide range of hardware architectures, each of them having unique challenges, unique capabilities, and each of them have a perfect use case and a perfect model that fits it very well.
• 8:30
  SPEAKER_00: But how do I become hardware aware?
• 8:35
  SPEAKER_00: And I'm gonna present four steps.
• 8:38
  SPEAKER_00: Very simplified, but maybe or hopefully all of you get something out of it.
• 8:44
  SPEAKER_00: And maybe some of the steps may be something you already do today, but I hope some other step may be something you can implement already in your existing pipelines as well.
• 8:57
  SPEAKER_00: And one of the issues I see, or we see at MBATL, is oftentimes when it comes to a model selection, when it comes to optimizing models, when it comes to we have a use case, we optimize for accuracy first.
• 9:16
  SPEAKER_00: And then oftentimes the second step, maybe as an afterthought, is to optimize for your hardware and take other KPIs, latency, power consumption, into account.
• 9:28
  SPEAKER_00: And we should change that sentiment.
• 9:32
  SPEAKER_00: And we should change and become more KPI rare, more hardware rare early on in our development cycle.
• 9:40
  SPEAKER_00: And how do we do that?
• 9:41
  SPEAKER_00: We do that by doing profiling early on.
• 9:45
  SPEAKER_00: We need to measure on real hardware from day one.
• 9:51
  SPEAKER_00: We need to ensure compatibility.
• 9:53
  SPEAKER_00: No one wants to develop and train a model for years and then find out that half of its layers are not compatible on the hardware we are going to deploy on.
• 10:04
  SPEAKER_00: This sounds manual.
• 10:06
  SPEAKER_00: So the next step is to make it automatic.
• 10:10
  SPEAKER_00: There's of course the term of premature optimization.
• 10:14
  SPEAKER_00: So depending on your use case, that's perhaps one thing to consider.
• 10:19
  SPEAKER_00: But long term, you want to do it in an automatic analog an automatic way.
• 10:26
  SPEAKER_00: You want to uncover latency and accuracy bottlenecks without having the reliance on experts, without maybe having some sentiment from your even deep learning researchers who may be choosing the mobile network because they really like it.
• 10:45
  SPEAKER_00: You want to take the human out of the loop.
• 10:50
  SPEAKER_00: And then finally, to take the loop and come up with optimize with context.
• 10:58
  SPEAKER_00: Not just make the model smaller, but make the model hardware aware.
• 11:03
  SPEAKER_00: And especially today, there were quite many presentations on hardware aware optimization techniques.
• 11:10
  SPEAKER_00: And even I've seen some uh demo tables downstairs and some posts on, for example, hardware air nas, pruning, mixed position, quantization, all those techniques we all know about, but now make them part of the pipeline and of the model selection and optimization uh techniques.
• 11:35
  SPEAKER_00: I hope I have three minutes left, perfect.
• 11:39
  SPEAKER_00: I want to finish with one example on what we did internally.
• 11:42
  SPEAKER_00: So, since I'm a researcher at MBETL, I want to finish with some uh research work we have done roughly half a year ago, and then we have hopefully about a couple uh questions left at the end.
• 11:56
  SPEAKER_00: And since it's not that much time left, I'm gonna go through that a bit quicker.
• 12:01
  SPEAKER_00: And in this project, we optimize the Lama 3.2 for Qualcomm chip.
• 12:06
  SPEAKER_00: Specifically, we optimized the Lama 3.2 1 billion, which is by itself already mobile friendly.
• 12:13
  SPEAKER_00: And we optimized it for the Qualcomm Snapdragon Gen 3A chip.
• 12:19
  SPEAKER_00: And I guess in this room we all know this chip, otherwise uh it's for example employed in the Galaxy S24 Ultra.
• 12:28
  SPEAKER_00: And as I said, this model is already mobile friendly, but what can we do on top?
• 12:34
  SPEAKER_00: How can we make it qualcom friendly in this case?
• 12:37
  SPEAKER_00: And apart from all compatibility issues, maybe making the model run at all and making a quanti uh quantization of the model, our focus in this project was to apply hardware rare compression and specifically pruning.
• 12:53
  SPEAKER_00: And without much talk, let's just get to the numbers right away.
• 12:58
  SPEAKER_00: And through do by making this model not only mobile friendly but Qualcomm friendly, having hardware rare optimization that fits the hardware best.
• 13:10
  SPEAKER_00: Uh, we made the uh token generation rate roughly 31% faster, prompt processing rate 25% faster, initialization time, how long it takes to get started and to get an output from the network, 126% faster.
• 13:30
  SPEAKER_00: And all those numbers within or below 1% drop in accuracy.
• 13:44
  SPEAKER_00: Thank you so much.