Robotics Vision: Deep Learning Models for Visual Segmentation

Core Principles and Learning Goals in Robotic Vision

• Definition of Segmentation in Robotics: Visual segmentation is the process of partitioning an image or spatial point set into distinct, semantically meaningful regions. In autonomous systems, visual segmentation converts unstructured raw sensor pixels into actionable spatial semantics that directly inform motion planning, control, and physical interaction.

• Core Architectural Frameworks:

  • Convolutional Neural Network (CNN) Encoder–Decoder Models: Structural paradigms like U-Net that contract spatial dimensions to capture global semantic context and subsequently expand features back to original resolutions using skip connections.

  • Atrous / Multiscale Architectures: Networks such as DeepLabv3+ that employ dilated (atrous) convolutions and Atrous Spatial Pyramid Pooling (ASPP) to expand the model's receptive field without sacrificing spatial resolution.

  • Transformer-Based Models: Architectures like SegFormer that leverage hierarchical self-attention mechanisms to capture long-range contextual relationships and global dependencies across the image plane.

  • Foundation Models & Promptable Segmentation: Zero-shot and interactive models such as Segment Anything Model (SAM), SAM 2, and MobileSAM that accept flexible prompt types (points, bounding boxes, masks, text) to segment arbitrary structures.

• Deployment and Systems Integration Goals:

  • Formulating model selection criteria under strict robotic platform constraints, including execution latency, volatile memory consumption, power draw, prediction accuracy, environmental robustness, and explainability.

  • Designing complete data collection, annotation, validation, and optimization pipelines tailored for mobile ground robots, unmanned aerial vehicles (drones), and robotic manipulators.

  • Translating dense 2D segmentation masks into 3D geometric structures to feed control loops for autonomous navigation, grasp point synthesis, dynamic obstacle avoidance, and industrial defect inspection.

Primary Robotic Applications and Operational Motivations

• Spatial Boundaries vs. Spatial Labels: Autonomous robots require both categorical labels and precise geometric boundaries. A general perception algorithm might answer whether a floor exists, whereas a robotic navigation stack requires explicit spatial boundaries determining "where is the drivable floor area?"

• Autonomous Navigation:

  • Delineation of free-space, curb boundaries, lane markers, sidewalk boundaries, stair steps, and crosswalks.

  • Human-aware motion planning, enabling robots to establish safety buffers around stationary and dynamic pedestrians.

• Robotic Manipulation & Bin Picking:

  • Generating detailed object instance masks to improve 6D pose estimation accuracy.

  • Calculating viable end-effector grasp points for bin picking, automated sorting, and multi-object singulation.

• Industrial & Agricultural Inspection:

  • Pixel-level defect masks to localize structural cracks, surface corrosion, missing components, or assembly errors.

  • Agricultural health analysis, including crop stress detection, weed localization, and canopy area estimation.

• Human–Robot Interaction (HRI):

  • Tracking human bodies, hand gestures, active safety zones, tool handovers, and shared workspace boundaries to prevent collisions and support joint human-robot task execution.

Taxonomy of Visual Segmentation Tasks

• Semantic Segmentation:

  • Assigns a categorical class label to every individual pixel in the image.

  • Does not differentiate between separate object instances belonging to the same semantic class (e.g., multiple adjacent pedestrians are assigned the same mask label).

• Instance Segmentation:

  • Detects and delineates every individual object instance within target categories.

  • Outputs a unique binary mask for each object instance, serving as an essential precursor for object counting and robotic gripping.

• Panoptic Segmentation:

  • Unifies semantic segmentation and instance segmentation into a comprehensive scene perception framework.

  • Categorizes unstructured background regions ("stuff" classes such as road, floor, sidewalk, or wall) while simultaneously generating distinct instance masks for isolated objects ("thing" instances such as people, tools, vehicles, or obstacles).

• 3D Segmentation:

  • Extends dense spatial labeling directly into 3D geometric spatial representations.

  • Applies semantic or instance labels to 3D point clouds, surface meshes, voxel grids, or fused RGB-D (Red-Green-Blue-Depth) spatial data structures.

Mathematical Formulations and Spatial Overlap Metrics

• Dense Pixel-Wise Learning Formulation:

  • Given an input image $I$, a parameterised deep segmentation network $f_{\theta}$ predicts a dense tensor of class logits $Z$ across spatial dimensions $H \times W$ and class count $C$:         $f_{\theta}(I) \rightarrow Z \in \mathbb{R}^{H \times W \times C}$

  • The predicted probability vector for each pixel location $i$ is computed via the softmax function, and the final discrete class prediction $\hat{y}_i$ is extracted via argmax:         $\hat{y}_i = \arg\max_c \left( \text{softmax}(Z_{i,c}) \right) = \arg\max_c \left( \frac{e^{Z_{i,c}}}{\sum_{k=1}^{C} e^{Z_{i,k}}} \right)$

• Supervised Categorical Cross-Entropy Loss:

  • When dense pixel ground-truth labels $y_{i,c} \in \{0, 1\}$ are available, the standard supervised learning objective is evaluated as:         $L_{CE} = -\sum_{i=1}^{H \times W} \sum_{c=1}^{C} y_{i,c} \log(p_{i,c})$         where $p_{i,c}$ represents the predicted probability of pixel $i$ belonging to class $c$.

• Spatial Overlap Evaluation Metrics:

  • Intersection over Union (IoU): Evaluates the spatial overlap ratio between the predicted pixel mask set $P_c$ and ground-truth mask set $G_c$ for class $c$:         $\text{IoU}_c = \frac{|P_c \cap G_c|}{|P_c \cup G_c|}$

  • Mean Intersection over Union (mIoU): Averages IoU across all active semantic classes $C$:         $\text{mIoU} = \frac{1}{C} \sum_{c=1}^{C} \text{IoU}_c$

• Robotics-Specific Metric Interpretation:

  • High mIoU alone does not guarantee robotic operational safety. A model achieving high overall mIoU can cause total system failure if it exhibits temporal flickering or fails to identify small, high-risk objects like hanging cables or thin floor obstacles.

  • Mask as an Action Prior: Following camera calibration and coordinate transformation, predicted spatial masks act as direct priors for robot controllers—converting directly into local cost maps, grasp candidate zones, traversability indices, forbidden collision regions, or inspection heatmaps.

End-to-End System Integration and Perception Pipeline

• Closed-Loop Autonomy Processing Stack:

  • 1. Sensor Acquisition: Captures synchronized physical environment data using RGB cameras, RGB-D sensors, LiDAR units, or event-based vision sensors.

  • 2. Segmentation Model Inference: Processes multi-modal inputs using CNNs, Vision Transformers, or promptable foundation networks to output dense semantic or instance masks.

  • 3. Post-Processing & Refinement: Applies spatial and temporal refinements using Conditional Random Fields (CRFs), morphological closing/opening, object tracking filters, and probability thresholding.

  • 4. Geometry Fusion: Projects 2D mask outputs into 3D space, incorporating data into Truncated Signed Distance Fields (TSDFs), 3D occupancy maps, or spatial SLAM (Simultaneous Localization and Mapping) pose graphs.

  • 5. Robot Execution Policy: Feeds structured 3D spatial semantics into trajectory planners, grasp synthesis modules, automated inspection managers, and physical motor controllers.

Training Datasets, Labeling Paradigms, and Data Strategies

• Annotation Formats & Label Types:

  • 2D vector polygons, rasterized pixel-wise masks, scribbles, bounding boxes paired with coarse masks, 2D point prompts, and 3D point cloud labels.

• Data Generation Sources:

  • Robot-mounted cameras executing real operational sweeps, high-fidelity photorealistic simulations (e.g., Isaac Sim, Gazebo), public driving datasets (e.g., Cityscapes, Mapillary Vistas), aerial drone surveys, and automated industrial factory cells.

• Managing Annotation Costs:

  • Generating manual dense pixel masks is labor-intensive and costly. Modern pipelines utilize active learning to sample uncertain frames and deploy foundation-assisted labeling models (e.g., SAM) to auto-generate initial candidate masks.

• Robotics-Centric Dataset Design Rules:

  • Sequence Collection: Collect sequential video clips rather than isolated image frames to capture real-world operational effects like camera motion blur, dynamic occlusions, and transient lighting shifts.

  • Safety-Critical Class Balancing: Over-represent rare but high-risk objects, such as pedestrian bodies, thin hanging cables, floor steps, transparent glass surfaces, small tools, and crop weeds.

  • Calibration Metadata Preservation: Preserve complete sensor metadata alongside raw frames, including internal camera intrinsic matrices $K$, extrinsic transformation matrices $T_{\text{robot} \leftarrow \text{cam}}$, depth sensor scaling factors, robot odometry poses, and hardware synchronization timestamps.

  • Domain-Matched Validation Sets: Construct validation datasets using actual physical deployment environments rather than relying exclusively on public academic benchmarks.

Convolutional Neural Network Architectures

Generic Encoder–Decoder Pattern

• Structural Mechanics:

  • Input Stage: Raw image tensor of shape $H \times W \times 3$

  • Encoder Path: Sequentially reduces spatial resolution while extracting higher-level semantic features using large receptive fields.

  • Bottleneck: Captures high-level contextual information at reduced spatial resolutions.

  • Decoder Path: Upsamples feature maps and merges spatial details to construct an output prediction mask tensor of shape $H \times W \times C$

  • Skip Connections: Transfers fine-grained spatial feature maps directly from encoder stages to matching decoder stages, preserving sharp boundary locations and small object structures.

• Hardware and Latency Pressures: Generating high-resolution output masks provides fine spatial detail for trajectory planning and robotic gripping; however, every added upsampling operation increases memory bandwidth requirements and inference execution time.

• Common Architectural Components:

  • Backbones: ResNet, MobileNet, EfficientNet, Mix Transformer (MiT), Swin Transformer.

  • Decoders: Fully Convolutional Network (FCN) heads, U-Net decoders, Atrous Spatial Pyramid Pooling (ASPP), Feature Pyramid Networks (FPN), All-MLP decoders, and Mask Transformers.

U-Net Architecture

• Core Architectural Mechanism: Developed by Ronneberger et al. (2015), U-Net features a symmetric contracting path (encoder) to compute semantic context paired with an expanding path (decoder) for spatial localization.

• Channel and Dimension Dynamics:

  • An input tile size of $572 \times 572 \times 1$ passes through dual $3 \times 3$ unpadded convolutions and $2 \times 2$ max pooling operations ($2 \times 2$ stride), downsampling spatial dimensions while scaling feature channel depth: $64 \rightarrow 128 \rightarrow 256 \rightarrow 512 \rightarrow 1024\,\text{channels}$.

  • The expansion path executes $2 \times 2$ up-convolutions, concatenating matching cropped feature maps transferred via skip connections from the contracting path, stepping down channels: $1024 \rightarrow 512 \rightarrow 256 \rightarrow 128 \rightarrow 64\,\text{channels}$.

  • A final $1 \times 1$ convolution maps the $64\,\text{channel}$ output vector to a dense multi-class segmentation map ($388 \times 388 \times 2$ in the original unpadded formulation).

• Robotic Applications: Serves as a robust baseline network when training data is constrained, precise object boundaries are critical, and rapid retraining is required for specific domains (e.g., crop-weed division, industrial part inspection, indoor floor parsing, tool tracking).

DeepLabv3+ Architecture

• Atrous (Dilated) Convolutions: Introduces space-filling factors into convolutional kernels, expanding the model's spatial receptive field to collect wide contextual information without downsampling spatial resolutions or adding trainable parameters.

• Atrous Spatial Pyramid Pooling (ASPP): Evaluates multi-scale contextual features in parallel using a $1 \times 1$ convolution, three $3 \times 3$ atrous convolutions with varying expansion rates ($r = 6, 12, 18$), and an Image Pooling block. Features are concatenated and processed through a $1 \times 1$ convolution.

• Decoder Structure: Combines upsampled ASPP features ($4\times$ upsampling) with low-level spatial features extracted directly from the backbone via a $1 \times 1$ convolution. Convolutions ($3 \times 3$) refine boundary maps prior to a final $4\times$ upsampling step.

• Robotic Trade-Off: Delivers high accuracy for dense ground surface parsing and urban scene understanding, but requires substantial memory bandwidth and computation, often necessitating network pruning or quantization for embedded deployment.

Embedded Real-Time CNNs

• ENet (Efficient Neural Network): Optimized for low-power mobile platforms. Reduces parameter counts and floating-point operations (FLOPs) by enforcing early spatial downsampling and leveraging asymmetric bottleneck sub-modules.

• Fast-SCNN (Fast Segmentation Convolutional Neural Network): Uses a dual-branch design. A dual-resolution "learning-to-downsample" branch rapidly compresses spatial size while extracting low-level details, while a feature fusion module recombines spatial details with global context.

• Deployment Design Principle: In real-time robotic systems, a lightweight model delivering stable frame rates is often safer than a high-capacity model subject to variable execution latency or unexpected execution spikes.

Modern Universal and Transformer-Based Segmentation Architectures

Instance Segmentation: Mask R-CNN & YOLO-seg

• Mask R-CNN: Extends Faster R-CNN by adding a parallel Fully Convolutional Network (FCN) mask branch alongside existing region proposal classification and bounding box regression heads. Uses Region of Interest Align (RoIAlign) to preserve pixel-level spatial accuracy by eliminating feature map quantization errors.

• YOLO Instance Segmentation (YOLO-seg): Single-stage detection architecture that predicts bounding boxes and class probabilities while simultaneously generating a set of prototype mask coefficients. Linear combinations of prototype masks produce real-time instance masks suited for high-speed pick-and-place operations.

Universal Mask Classification: Mask2Former

• Universal Mask Paradigm: Replaces dedicated task-specific architecture heads with a unified query-based mask classification formulation that addresses semantic, instance, and panoptic segmentation within a single network.

• Core Architectural Components:

  • Pixel Decoder: Converts multi-scale backbone feature maps into high-resolution spatial feature tensors.

  • Transformer Decoder with Masked Attention: Uses learnable mask queries. Replaces standard cross-attention with masked attention, constraining cross-attention computation to localized predicted mask regions computed at each decoder layer.

• Robotic Utility: Enables a single deployed model to identify both continuous ground surfaces ("stuff") and isolated manipulation targets ("things"), eliminating the need to maintain separate perception pipelines.

Transformer Segmentation: SegFormer

• Mix Transformer (MiT) Encoder: Generates hierarchical multi-scale feature maps at varying spatial scales ($1/4, 1/8, 1/16, 1/32$ of input resolution) without requiring positional embeddings, allowing flexible input image resolutions during deployment.

• Lightweight All-MLP Decoder: Aggregates multi-scale features extracted by the Mix Transformer encoder using simple Multi-Layer Perceptron (MLP) layers, eliminating heavy spatial decoding operations while utilizing global self-attention context.

• Contextual Advantage: Global self-attention enables transformers to correctly classify ambiguous objects by leveraging broader spatial context (e.g., identifying a small object based on its location on a workbench).

Foundation Models and Promptable Segmentation in Robotics

• Promptable Segmentation Concept: Accepts versatile input prompts—such as spatial points, bounding boxes, freeform foreground/background scribbles, or natural language text strings—to generate target binary masks.

• Segment Anything Model 2 (SAM 2):

  • Extends promptable mask generation from static images to continuous video streams.

  • Incorporates a real-time streaming memory bank, memory attention modules, and a memory encoder to propagate object masks across sequential video frames, handling dynamic object occlusions and reappearance.

• MobileSAM & Distilled Variants: Replaces heavy Vision Transformer image encoders (e.g., ViT-H) with lightweight, distilled encoders (e.g., TinyViT). This significantly reduces parameter counts and computation, enabling promptable segmentation workflows on edge compute boards.

• Robotics Integration Strategy: While foundation models serve as powerful tools for automated pseudo-label generation, zero-shot region proposal, and interactive operator corrections, their high computational overhead and non-deterministic outputs require caution before using them as direct, unhedged real-time control inputs.

Spatial Geometry, 3D/RGB-D Back-Projection, and Temporal Tracking

3D Back-Projection Geometry

• Coordinate Transformation Pipeline: To enable spatial planning, 2D image pixel classifications must be projected into 3D robot base frame coordinates:     $\mathbf{X}_{\text{cam}} = d \cdot K^{-1} \begin{pmatrix} u \\ v \\ 1 \end{pmatrix}$     where $(u, v)$ represents 2D pixel coordinates, $d$ is the aligned metric depth value, and $K$ is the calibrated camera intrinsic matrix:     $K = \begin{pmatrix} f_x & 0 & c_x \\ 0 & f_y & c_y \\ 0 & 0 & 1 \end{pmatrix}$

• Robot Frame Transformation:     $\mathbf{X}_{\text{robot}} = T_{\text{robot} \leftarrow \text{cam}} \cdot \mathbf{X}_{\text{cam}} = \begin{pmatrix} R_{\text{cam}}^{\text{robot}} & \mathbf{t}_{\text{cam}}^{\text{robot}} \\ \mathbf{0}^T & 1 \end{pmatrix} \begin{pmatrix} \mathbf{X}_{\text{cam}} \\ 1 \end{pmatrix}$     where $T_{\text{robot} \leftarrow \text{cam}}$ represents the spatial extrinsic calibration transformation matrix between the sensor frame and the physical robot base reference frame.

• Multi-Modal Sensor Fusion Paradigms:

  • Early Fusion: Concatenates raw RGB images and depth maps into a 4-channel tensor ($H \times W \times 4$) prior to network feature extraction.

  • Late Fusion: Predicts spatial segmentation masks and geometric depth maps through independent model branches, merging outputs during post-processing.

  • Geometry-Aware 3D Fusion: Projects 2D class probabilities directly into 3D voxel spaces, Truncated Signed Distance Fields (TSDFs), or persistent semantic point maps.

Temporal Consistency and Video Mask Tracking

• Operational Risk of Temporal Flicker: Independent frame-by-frame segmentation can suffer from mask boundary jitter or transient class swapping across consecutive frames. In closed-loop systems, this causes trajectory instability, robot vibration, grasp oscillation, or unsafe human-tracking behavior.

• Temporal Stabilization Techniques:

  • Evaluating optical flow vectors to warp and propagate spatial masks across consecutive frames ($t \rightarrow t+1 \rightarrow t+2$).

  • Deploying recurrent spatial states, tracking-by-segmentation frameworks, Kalman-filtered mask probabilities, or map-level Bayesian occupancy updates.

Embedded Hardware Deployment and Real-Time Optimization Constraints

• Multidimensional Operational Constraints:

  • Inference Latency: Perception latency must stay within the robot's control loop update budget (e.g., $10\text{--}30\,\text{ms}$ per frame for mobile platform navigation).

  • Volatile Memory Footprint: Models must fit within limited edge device SRAM and VRAM pools without exhausting system memory bandwidth.

  • Electrical Power Draw: Heavy GPU processing drains onboard battery supplies, reducing overall operational endurance.

  • Environmental Robustness: Perception pipelines must maintain reliability under fluctuating ambient lighting, camera vibration, lens dirt, motion blur, and domain shifts.

  • Safety Constraints: Segmentation models must reliably detect high-risk, low-frequency classes (e.g., pedestrians, cables, structural edges) across varying environmental conditions.

• Latency Metrics: Optimization targets worst-case latency distributions (99th percentile execution time) rather than average frame-rate (FPS) metrics, as isolated processing delays can destabilize physical control loops.

• Optimization Approaches: Downscaling input image resolution, applying early downsampling strides, pruning decoder channel widths, executing INT8/FP16 post-training quantization, and compiling computational graphs using TensorRT, ONNX Runtime, or TFLite execution engines.

Objective Functions, Training Protocols, and Evaluation Metrics

Composite Training Loss Formulations

• Integrated Multi-Term Loss Function:     $L = L_{CE} + \lambda_1 L_{\text{Dice}} + \lambda_2 L_{\text{boundary}} + \lambda_3 L_{\text{aux}}$

• Loss Component Mechanics:

  • Weighted Cross-Entropy ($L_{CE}$): Standard pixel classification objective. Uses loss weights or focal loss scaling factors to compensate for severe class imbalance.

  • Dice / Lovász Loss ($L_{\text{Dice}}$): Directly optimizes spatial intersection ratios, preventing small object masks from being ignored during gradient updates.

  • Boundary Loss ($L_{\text{boundary}}$): Penalizes distance metrics between predicted mask contours and ground-truth edges, yielding sharp spatial boundaries for gripping, curb detection, and crack inspection.

  • Auxiliary Supervision Heads ($L_{\text{aux}}$): Attaches intermediate prediction heads to internal encoder layers to stabilize gradient flow and refine multi-scale feature learning.

• Targeted Sampling Strategies: To prevent dominant background classes (walls, sky, roads) from overwhelming training, sample crops around rare object categories and failure cases rather than relying exclusively on uniform random spatial cropping.

Performance Metrics Summary

Safety Criticality, Failure Modes, and Operational Mitigations

• Primary Segmentation Failure Modes:

  • False Negatives (Missed Detections): An obstacle or human is omitted from the prediction mask, creating an immediate collision risk.

  • False Positives (Spurious Detections): Free space is incorrectly flagged as an obstacle, causing unexpected vehicle stops, oscillatory detours, or system freezes.

  • Boundary Localization Errors: Predicted mask boundaries shift relative to real object contours, leading to gripper positioning errors or contact collisions.

  • Temporal Flicker: Prediction masks fluctuate across adjacent frames, causing trajectory jitter and unstable motion control.

• Engineering Safety Mitigations:

  • Enforcing prediction uncertainty thresholds to trigger conservative trajectory adjustments when confidence drops.

  • Using multi-sensor fusion (e.g., combining visual segmentation with LiDAR ranges or radar measurements).

  • Applying temporal voting and spatial confidence filters to smooth predictions across time steps.

  • Maintaining conservative geometric inflation buffers around detected obstacle boundaries.

  • Deploying real-time sanity checks, explicit system fallbacks, and manual remote operator overrides.

Domain Case Studies in Autonomous Systems

Mobile Robot Navigation

• Execution Sequence:

  1. Segment drivable path surfaces, curb edges, surrounding vegetation, nearby pedestrians, dynamic vehicles, and road signage.

  2. Project output 2D spatial masks into local 2D/3D cost maps using calibrated internal intrinsics and depth inputs.

  3. Inflate dynamic obstacles and uncertain classifications into higher-cost spatial collision zones.

  4. Fuse temporal predictions with platform wheel odometry or visual SLAM pose estimates to smooth boundary jitter.

  5. Pass refined cost maps to motion planners to calculate collision-free trajectories that account for robot footprint dimensions and velocity limits.

• Recommended Architectures: Fast-SCNN, BiSeNet, or DeepLab-lite for embedded edge processors; SegFormer-B0/B1 when onboard GPU acceleration is available.

Industrial Manipulation & Bin Picking

• Execution Sequence:

  1. Generate individual instance masks for randomly oriented parts stacked inside a storage bin.

  2. Estimate 6D object poses by combining 2D instance masks with registered 3D depth maps or point cloud surfaces.

  3. Sort object instances by accessibility, evaluating target occlusion levels and gripper collision risks.

  4. Synthesize valid end-effector grasp poses, evaluating candidates using geometric rules or simulated physics models.

  5. Execute end-effector pick trajectories, updating spatial masks as remaining objects shift inside the bin.

• Recommended Architectures: Mask R-CNN or YOLO-seg for fast instance masking; Mask2Former for unified scene parsing; SAM-assisted annotation tools for rapidly onboarding new part geometries.

Agricultural and Field Robotics

• Target Operations: Differentiating crops from weeds, mapping plant stress and disease regions, extracting crop row vectors, counting fruit yields, and identifying traversable ground terrain.

• Environmental Challenges: Seasonal foliage variations, shifting solar illumination, wind-induced motion blur, dense canopy occlusions, complex leaf structures, extreme class imbalance, and regional soil shifts.

• Recommended Strategy: Combine high-resolution drone aerial surveys with ground robot imagery; apply heavy color jitter, crop, and blur data augmentations; execute active learning loops; and cross-validate models across distinct geographical fields.

Model Selection Matrix and Hands-On Implementation Workflow

Operational Model Selection Matrix

Practical Implementation Workflow

• Step 1: Dataset Acquisition: Collect 100–300 sequence sequences from target robot-mounted cameras, ensuring coverage of operational floors, obstacles, or tabletop manipulation environments.

• Step 2: Mask Annotation: Generate masks using annotation suites (e.g., CVAT, Label Studio) accelerated by SAM interactive prompts. Split datasets into training, validation, and test sets by distinct environment scenes rather than random frame sampling.

• Step 3: Baseline Model Training: Train a U-Net or DeepLab-lite network as a baseline, comparing performance against pretrained lightweight transformer architectures (e.g., SegFormer-B0) or single-stage instance segmentation models (e.g., YOLO-seg).

• Step 4: Comprehensive Evaluation: Evaluate models on validation sets, tracking mIoU, Boundary-IoU, mean inference latency, memory footprint, and downstream task success rates.

• Step 5: Compilation and Deployment: Export model graphs to optimized open formats (e.g., ONNX, TensorRT, TFLite). Measure end-to-end execution latency—covering camera capture, preprocessing, network inference, post-processing, and path generation—directly on target edge hardware platforms.