Edge Computing ML: Docker for Jetson Xavier & ARM64

1# Stage 1: Builder (compilation des dépendances)
2FROM nvcr.io/nvidia/l4t-ml:r35.2.1-py3 AS builder
3
4# Installer les outils de build
5RUN apt-get update && apt-get install -y \
6    build-essential cmake git
7
8# Compiler TensorFlow from source avec optimisations ARM64
9RUN git clone https://github.com/tensorflow/tensorflow.git && \
10    cd tensorflow && \
11    bazel build --config=opt --config=cuda //tensorflow/tools/pip_package:build_pip_package
12
13# Stage 2: Runtime (image minimale)
14FROM nvcr.io/nvidia/l4t-base:r35.2.1
15
16# Copier uniquement les binaires compilés
17COPY --from=builder /tensorflow/bazel-bin /opt/tensorflow
18
19# Installer les dépendances runtime minimales
20RUN apt-get update && apt-get install -y --no-install-recommends \
21    libcudnn8 libnvinfer8 && \
22    rm -rf /var/lib/apt/lists/*
23
24# Résultat : 1.8GB vs 8GB original

1# optimize_model.py
2import tensorflow as tf
3from tensorflow.python.compiler.tensorrt import trt_convert as trt
4
5def optimize_for_jetson(model_path: str, output_path: str):
6    """Optimiser un modèle TensorFlow avec TensorRT pour Jetson."""
7
8    # Charger le modèle
9    model = tf.saved_model.load(model_path)
10
11    # Convertir en TensorRT
12    converter = trt.TrtGraphConverterV2(
13        input_saved_model_dir=model_path,
14        precision_mode=trt.TrtPrecisionMode.FP16,  # Précision moitié pour vitesse
15        maximum_cached_engines=100
16    )
17    converter.convert()
18
19    # Sauvegarder le modèle optimisé
20    converter.save(output_path)
21
22    print(f"✅ Modèle optimisé: {model_path} → {output_path}")
23    print(f"   Précision: FP16 (2x plus rapide que FP32)")

1# inference.py
2import cv2
3import tensorrt as trt
4import numpy as np
5
6class JetsonInference:
7    def __init__(self, model_path: str):
8        self.engine = self.load_engine(model_path)
9        self.context = self.engine.create_execution_context()
10
11    def infer(self, image: np.ndarray) -> List[Detection]:
12        """Exécuter l'inférence sur une image."""
13        start = time.time()
14
15        # Prétraitement
16        input_tensor = self.preprocess(image)
17
18        # Inférence (GPU)
19        outputs = self.context.execute_v2(bindings=[input_tensor])
20
21        # Post-traitement
22        detections = self.postprocess(outputs)
23
24        latence = (time.time() - start) * 1000
25        print(f"Inférence: {latence:.1f}ms")
26
27        return detections