Optimizing and Deploying AI Models on NVIDIA Jetson

You launched YOLOv8 on Jetson Nano and got 5 FPS instead of the expected 30. Typical situation: a model not adapted for edge hardware wastes resources. Optimization via TensorRT gives 3–10x speedup, and DeepStream squeezes the maximum out of the video stream. We have deployed CV models and LLMs on Jetson AGX for industrial robots — here’s how we do it.

The problem is not the hardware itself: Jetson Orin is a powerful edge computer, but without proper optimization you hit memory bandwidth limits and inefficient kernel calls. For example, YOLOv8n on PyTorch with FP32 consumes 8 GB RAM and delivers 12 ms per frame — whereas TensorRT with INT8 reduces latency to 3 ms and RAM drops to 2 GB. Result: 30 FPS on the same camera.

Jetson Model Lineup (Current)

How TensorRT Accelerates Models on Jetson

TensorRT compiles ONNX/PyTorch models for the specific Jetson GPU. The conversion process:

1. Export to ONNX with fixed dynamic axes (batch, height, width).
2. Build an engine via trtexec with selected precision (FP16 by default, INT8 for maximum).
3. Calibrate INT8 on a representative dataset (at least 500 images) to preserve mAP.
4. Integrate via C++ API or Python bindings.

import tensorrt as trt
# or via trtexec:
# trtexec --onnx=model.onnx --saveEngine=model.trt --fp16

Typical speedup: 3–10x vs. PyTorch. For ResNet-50 on Orin AGX we got 7x, for YOLOv8 — 5x. We guarantee p99 latency within specification: e.g., YOLOv8 on Orin NX in INT8 — 12 ms per frame.

DeepStream for Video Analytics

NVIDIA DeepStream SDK is an optimized pipeline for multi-camera analytics. The GStreamer-based pipeline provides batch inference, scaling, tracker and output to RTSP or Kafka. Typical performance on Orin AGX: 30+ Full HD cameras with YOLOv8 detection. We also configure primary processing (NvStreamMux, nvdrmvideosink) and integration with ROS2.

Why Choose Orin AGX for Complex Tasks?

Orin AGX delivers 275 TOPS and 64 GB RAM — enough to run Llama 3 8B (4-bit) with context window 8192, RAG with ChromaDB, and parallel inference of 8 CV models. Compared to Orin Nano: AGX is 14x faster in FLOPS, but for a simple single-camera detector the Nano is a budget solution. Our experience: for autonomous robots we always take AGX, for stationary inspection — NX.

RAG on Jetson

We use ollama or llama.cpp for LLM inference, ChromaDB for vector search — everything fits in 16 GB of Orin NX. Typical pipeline: sentence-transformers for 768‑dim embeddings, faiss for indexing, langchain for the calling chain. Response latency: 500 ms per query with 2k token context on Orin AGX.

ROS2 + Jetson

Robotics: ROS2 Humble is natively supported on JetPack 5/6. Isaac ROS provides NVIDIA‑optimized ROS2 packages for computer vision. We integrated Isaac ROS with a custom detector — 60 FPS on Orin NX for two cameras.

What’s Included

• Model conversion to TensorRT/ONNX Runtime
• DeepStream or Triton Inference Server setup
• Peripheral integration: cameras (GMSL/USB), sensors, GPIO
• Performance testing: latency, throughput, power
• CI/CD pipeline for model updates
• Documentation and team training
• Guarantee on specified metrics (p99, FPS)

Estimated Timeline: 2 to 8 Weeks

The cost is calculated individually — depends on model complexity, number of cameras, and latency requirements. We'll evaluate your project in one day. Get a consultation — our engineers will show case studies and select the optimal solution.

Our experience: 5 years in edge AI market, 40+ projects for industry and logistics. NVIDIA certified engineers — we guarantee results.

Edge AI and Optimization: How to Deploy Models Without Cloud?

Imagine: your face recognition model has 4 seconds latency on Jetson Orin, the battery runs out in an hour, and the model crashes with OOM. We are a team of Edge AI engineers with 5+ years in production — we have optimized over 150 models for edge devices. Without profiling and proper choice of quantization or distillation, the project is doomed. The gap between research code and edge deployment is a separate engineering discipline; we help you master it in 2–16 weeks turnkey. Edge AI and model optimization services are not just export, but systematic work with hardware.

Why Simply Exporting a Model Doesn't Work?

A PyTorch model with float32 and batch_size=32 is not ready for edge. Typical problems:

• ResNet-50 in fp32 occupies 98 MB, inference on Cortex-A78 — 380 ms. After INT8 quantization via torch.ao.quantization — 24 MB, 95 ms. Export to ONNX + TensorRT on Jetson — 28 ms.
• YOLOv8m on Raspberry Pi 5 in fp32 — 2.8 fps. TFLite INT8 — 9.4 fps. With XNNPACK delegate — 14 fps (1.5× faster than pure INT8).
• Transformer encoder on mobile CPU: MobileBERT in fp16 via CoreML on iPhone 15 — 18 ms/inference. distilbert-base-uncased in ONNX — 42 ms.

The problem is not choosing "quantize or not" — the right path is determined by the device, task, and acceptable metric degradation. We offer an assessment of your project: within 24 hours we will tell you how feasible it is to speed up the model.

How to Choose Quantization Method for Your Task?

PTQ (Post-Training Quantization) — a quick path. Take a trained model, run a calibration dataset (200–1000 samples), get INT8 or INT4 weights. Tools: torch.ao.quantization, ONNX Runtime quantization tool, bitsandbytes. Accuracy degradation: 0.5–2% on classification. Red zone — small object detection and segmentation, where PTQ gives -4–8% mAP.

QAT (Quantization-Aware Training) — training with simulated quantization noise. More expensive (retraining), but degradation 0.1–0.5%. Justified when PTQ is unacceptable. In PyTorch — torch.ao.quantization.prepare_qat().

GPTQ / AWQ — for LLMs. AWQ better preserves quality at 4-bit quantization. llm-compressor from Neural Magic or autoawq are the main libraries.

Potential savings from choosing the right method can be substantial — for example, reducing cloud inference costs by up to 70% when deploying to edge. Project cost is calculated individually based on model complexity and target platform.

When to Use Pruning vs Distillation?

Structural pruning removes channels or layers. torch.nn.utils.prune — basic tool. For transformers — attention head pruning (LTP, movement pruning). Result: ResNet-50 after removing 40% of channels with fine-tuning — -35% size, -28% latency, -1.2% top-1 accuracy.

Knowledge distillation — train a small student to mimic a large teacher. Classic via KLDivLoss on soft labels. Feature distillation on intermediate layers is more effective. Hugging Face DistilBERT: 66M vs 110M parameters, -40% latency, -3% on GLUE. This is a model compression technique.

Combined approach: distillation → pruning → QAT. Gives maximum effect on limited hardware. We recorded a case where a client achieved 70% reduction in cloud compute spend after moving to edge with this pipeline.

Target Platforms and Tools

TensorRT — the main tool for NVIDIA edge. TRT builds a graph with operator fusion, selects optimal kernels. On Jetson AGX Orin YOLOv8m in TRT INT8 gives 78 fps vs 22 fps in fp16 PyTorch — 3.5× improvement.

Practical Case: How We Detected Defects on a Production Line (Our Client)

Task: real-time scratch detection on metal, 30 fps, camera to Jetson Xavier NX (16GB). Original model YOLOv8l mAP50 0.91, server inference 28 ms, on Jetson in fp16 — 110 ms (9 fps). Not suitable.

Optimization steps we performed for our client:

1. Switch to YOLOv8m — mAP50 0.887 (-2.3%), 68 ms
2. Export to TensorRT FP16 via yolo export format=engine half=True — 31 ms (32 fps)
3. INT8 calibration on 500 frames — 22 ms (45 fps), mAP50 0.879

Result: 3.5% degradation at 5× speedup. Client received engine and documentation. We guarantee metric will not drop below agreed threshold — specified in contract.

What is Included in the Work?

• Report on model profiling on target device (layer latency, bottlenecks)
• Selection and justification of optimization methods (quantization / pruning / distillation)
• Optimized model (TensorRT engine / TFLite / CoreML / ONNX)
• Configs for reproducibility (scripts, Docker image, instructions)
• Testing on real device (at least 10,000 inferences)
• Training of your team (2 hours online)
• 1 month support after delivery

How to Order Model Optimization

1. Submit a request on the website or contact us in any convenient way.
2. We perform free profiling of your model on the target device within 24 hours.
3. We prepare an optimization plan with trade-off estimates (speed vs quality).
4. You approve the plan — we start work.
5. After completion, we deliver the optimized model, configs, and documentation.
6. We train your team and provide monthly support.

Timeline: optimization of an existing model — 2–4 weeks. Development from scratch for edge — 6–16 weeks.

Get a consultation — we will evaluate your model for free and offer a plan within 24 hours. Order free profiling now. For complex projects, contact our engineering team to discuss custom optimisation strategies.