TensorRT VS jetson-inference

> It's not rocket science to implement matrix multiplication in any GPU.

You're right, it's harder. Saying this as someone who's done more work on the former than the latter. (I have, with a team, built a rocket engine. And not your school or backyard project size, but nozzle bigger than your face kind. I've also written CUDA kernels and boy is there a big learning curve to the latter that you gotta fundamentally rethink how you view a problem. It's unquestionable why CUDA devs are paid so much. Really it's only questionable why they aren't paid more)

I know it is easy to think this problem is easy, it really looks that way. But there's an incredible amount of optimization that goes into all of this and that's what's really hard. You aren't going to get away with just N for loops for a tensor rank N. You got to chop the data up, be intelligent about it, manage memory, how you load memory, handle many data types, take into consideration different results for different FMA operations, and a whole lot more. There's a whole lot of non-obvious things that result in high optimization (maybe obvious __after__ the fact, but that's not truthfully "obvious"). The thing is, the space is so well researched and implemented that you can't get away with naive implementations, you have to be on the bleeding edge.

Then you have to do that and make it reasonably usable for the programmer too, abstracting away all of that. Cuda also has a huge head start and momentum is not a force to be reckoned with (pun intended).

Look at TensorRT[0]. The software isn't even complete and it still isn't going to cover all neural networks on all GPUs. I've had stuff work on a V100 and H100 but not an A100, then later get fixed. They even have the "Apple Advantage" in that they have control of the hardware. I'm not certain AMD will have the same advantage. We talk a lot about the difficulties of being first mover, but I think we can also recognize that momentum is an advantage of being first mover. And it isn't one to scoff at.

[0] https://github.com/NVIDIA/TensorRT

(python demo_txt2img.py "a beautiful photograph of Mt. Fuji during cherry blossom"). https://github.com/NVIDIA/TensorRT/tree/release/8.6/demo/Diffusion

- https://github.com/NVIDIA/TensorRT

TVM and other compiler-based approaches seem to really perform really well and make supporting different backends really easy. A good friend who's been in this space for a while told me llama.cpp is sort of a "hand crafted" version of what these compilers could output, which I think speaks to the craftmanship Georgi and the ggml team have put into llama.cpp, but also the opportunity to "compile" versions of llama.cpp for other model architectures or platforms.

https://github.com/NVIDIA/TensorRT/issues/982

Maybe? Looks like tensorRT does work, but I couldn't find much.

highly optimized transformer-based encoder and decoder component, supported on pytorch, tensorflow and triton

TensorRT, custom ml framework/ inference runtime from nvidia, https://developer.nvidia.com/tensorrt, but you have to port your models

It uses the nvidia demo code from: https://github.com/NVIDIA/TensorRT/tree/main/demo/Diffusion

The traditional way to deploy a model is to export it to Onnx, then to TensorRT plan format. Each step requires its own tooling, its own mental model, and may raise some issues. The most annoying thing is that you need Microsoft or Nvidia support to get the best performances, and sometimes model support takes time. For instance, T5, a model released in 2019, is not yet correctly supported on TensorRT, in particular K/V cache is missing (soon it will be according to TensorRT maintainers, but I wrote the very same thing almost 1 year ago and then 4 months ago so… I don’t know).

I've tried to speed it up with TensorRT and followed this example: https://github.com/NVIDIA/TensorRT/blob/main/demo/HuggingFace/notebooks/t5.ipynb - it does give considerable speedup for batch-size=1 but it does not work with bigger batch sizes, which is useless as I can simply increase the batch-size of HuggingFace model.

Jetson Nano’s are obsolete and no longer supported; but to answer your question, this might be a good place to start.

I’m trying to do the tutorial, where they retrain the neural network to detect fruits (jetson-inference/pytorch-ssd.md at master · dusty-nv/jetson-inference · GitHub 1)

Jetson-Inference is another amazing resource to get started on. This will allow you to try out a number of neural networks (classification, detection, and segmentation) all with your own data or with sample images included in the repo.

Hello! I'm looking for some pre trained image classification models to use on a Jetson Nano. I already know about the model zoo and the pre trained models included in the https://github.com/dusty-nv/jetson-inference repo. For demonstration purposes, however, I need a model trained on small objects from the context of production, ideally nuts, bolts, and similar small objects. Does anyone happen to know a source for this? Thanks a lot!

> They provide some SSD-Mobilenet-v2 here: https://github.com/dusty-nv/jetson-inference

I was aware of that repository but from taking a cursory look at it I had thought dusty was just converting models from PyTorch to TensorRT, like here[0, 1]. Am I missing something?

> I get 140 fps on a Xavier NX

That really is impressive. Holy shit.

[0]: https://github.com/dusty-nv/jetson-inference/blob/master/doc...

[1]: https://github.com/dusty-nv/jetson-inference/issues/896#issu...

If you have a screen and keyboard and mouse plugged into the Nano, I would recommend starting with Hello AI World on https://github.com/dusty-nv/jetson-inference#hello-ai-world

Well, don't get me wrong. I do like my Jetson Nano. For a hobbyist who likes to tinker with machine learning in their spare time it's definitely a product cool and there are quite a few repositories on Github[0, 1] with sample code.

Unfortunately… that's about it. There is little documentation about

- how to build a custom OS image (necessary if you're thinking about using Jetson as part of your own product, i.e. a large-scale deployment). What proprietary drivers and libraries do I need to install? Nvidia basically says, here's a Ubuntu image with the usual GUI, complete driver stack and everything – take it or leave it. Unfortunately, the GUI alone is eating up a lot of the precious CPU and GPU resources, so using that OS image is no option.

- how deployment works on production modules (as opposed to the non-production module in the Developer Kit)

- what production modules are available in the first place ("Please refer to our partners")

- what wifi dongles are compatible (the most recent Jetson Nano comes w/o wifi)

- how to convert your custom models to TensorRT, what you need to pay attention to etc. (The official docs basically say: Have a look at the following nondescript sample code. Good luck.)

- … (I'm sure I'm forgetting many other things that I've struggled with over the past months)

Anyway. It's not that this information isn't out there somewhere in some blog post, some Github repo or some thread on the Nvidia forums[2]. (Though I have yet to find a reliably working wifi dongle…) But it usually takes you days orweeks to find it. From a product which is supposed to be industry-grade I would have expected more.

[0]: https://github.com/dusty-nv/jetson-inference

https://github.com/dusty-nv/jetson-inference#system-setup