Towards Autonomous Powerline Inspection: A Real-Time UAV-Edge Computing Framework for Early Identification of Fire-Related Hazards

Highlights

What are the main findings?

• The system achieved a real-time inference speed of 32 FPS on the embedded Jetson TX2 platform by utilizing TensorRT optimization and FP16 quantization to significantly compress the lightweight YOLOv8 model.
• Flight tests in complex environments confirmed the system’s practical reliability, demonstrating a comprehensive detection accuracy of up to 95.4% for identifying fire risks and structural hazards along transmission corridors.

What are the implications of the main findings?

• This study confirms the feasibility of deploying high-performance AI on low-power edge devices, shifting inspection paradigms from cloud-dependent to onboard processing. This enables autonomous operations in remote, signal-denied environments while establishing a replicable framework for lightweight AI optimization.
• The system’s high accuracy and automation enable a transition from post-flight analysis to immediate intervention, preventing catastrophic failures. By replacing labor-intensive patrols with scalable, autonomous inspections, it significantly reduces operational costs and safety risks while increasing grid coverage.

Abstract

Transmission lines traversing forested areas pose significant fire risks, necessitating timely and efficient inspection mechanisms. Traditional manual patrols and cloud-based UAV inspections suffer from high latency, bandwidth dependence, and delayed response times. To address these challenges, this study proposes an integrated, real-time UAV-edge computing system for the early identification of fire risks and structural hazards along transmission corridors. The system integrates a DJI M300 RTK UAV with a Manifold 2-G edge computing unit (based on NVIDIA Jetson TX2), deploying a lightweight, TensorRT-optimized YOLOv8 model. By leveraging FP16 precision quantization and operator fusion, the system achieves a real-time inference speed of 32 FPS on the embedded platform. Furthermore, a custom Payload SDK integration ensures automated image acquisition and closed-loop data transmission via a dual-mode (4G/5G + Wi-Fi) communication link. Field experiments demonstrate that the system significantly reduces data transmission latency while maintaining high detection accuracy (mAP > 94%), providing a robust and replicable solution for intelligent power grid maintenance in resource-constrained environments.

1. Introduction

The stability of power transmission systems is critical to national energy security and economic operation [1]. Transmission lines, often spanning vast and complex terrains such as forests and mountains, are susceptible to external damages, including wildfires caused by vegetation encroachment and structural defects like insulator breakage [2,3,4,5,6,7,8]. Traditional inspection methods rely heavily on manual labor, which is inefficient, labor-intensive, and fraught with safety risks. While Unmanned Aerial Vehicles (UAVs) have revolutionized this domain by providing aerial perspectives [9,10,11], most existing solutions operate on a “store-and-forward” or “cloud-centric” model [12,13,14]. These approaches require transmitting massive amounts of high-resolution imagery to ground stations or cloud servers for processing, leading to significant latency and rendering them unsuitable for time-sensitive tasks such as early detection of fire-related hazards. Recent comprehensive reviews have further elaborated on the sensor technologies, artificial intelligence algorithms, and field applications of UAVs in power line inspection, highlighting the potential of integrating LiDAR, thermal cameras, and multispectral sensors for three-dimensional modeling and risk assessment [15].

The inspection of transmission corridors is a multi-objective task that requires the simultaneous detection of tower components, line anomalies, and environmental risks. Currently, the identification of fire hazards along transmission corridors primarily focuses on three categories: tower-based defects [16,17], line-hung foreign objects [18,19,20], and corridor environmental hazards [21,22,23,24]. For tower integrity, deep learning has superseded manual feature extraction, utilizing two-stage detectors for insulator defects and single-stage models for camouflaged bird nests. Similarly, detecting non-rigid foreign objects like kites and balloons employs lightweight CNNs and attention mechanisms to handle complex backgrounds. Beyond equipment, environmental risks such as vegetation encroachment are monitored using cost-effective vision-based segmentation, offering an alternative to expensive LiDAR. Furthermore, identifying human intrusions, including construction machinery and unauthorized structures, is critical for preventing external force damage. However, a critical gap remains: most existing approaches rely on computationally intensive ground [25] or cloud processing [26]. There is a distinct lack of unified, lightweight solutions capable of detecting this wide array of targets—from minute insulators to large vehicles—in real-time on resource-constrained edge devices.

Recent advancements in edge computing have opened new avenues for “Edge Intelligence [27],” allowing data processing to occur directly on the UAV [28]. Deploying deep neural networks on resource-limited edge platforms poses significant challenges related to memory, computing power, and energy budgets, as extensively reviewed in the context of edge intelligence [29]. However, deploying deep learning models on resource-constrained embedded devices remains a challenge due to the trade-off between detection accuracy and inference speed [30]. Although lightweight models such as YOLO-inspection [31], GhostNet-based architectures [32,33,34], and MRA-YOLO [35] have been proposed, a comprehensive system that integrates robust hardware, optimized inference engines, and autonomous control logic is still lacking in practical engineering applications. Recent studies on leveraging large AI models for UAV edge computing design in low-altitude economy scenarios are highly relevant to this work [36,37], providing new context and inspiration for our research. Some recent efforts have demonstrated the integration of edge AI with UAVs for power line inspection, employing lightweight YOLO models and SLAM for autonomous navigation and obstacle avoidance [38]. Nevertheless, a holistic system that seamlessly integrates robust hardware, optimized inference, and autonomous control remains an open challenge.

To bridge this gap, this paper presents an integrated UAV-edge computing system for real-time transmission line risk detection. The main contributions of this work are as follows:

(1)

Heterogeneous System Architecture: We designed a tightly coupled hardware-software architecture integrating an industrial UAV with an embedded GPU module, ensuring stable power supply and data synchronization for autonomous operations.

(2)

Edge-Side Optimization Strategy: We implemented a TensorRT-based acceleration scheme, utilizing FP16 quantization and operator fusion to deploy an improved YOLOv8 model on the Jetson TX2 platform, achieving a balance between speed (32 FPS) and accuracy.

(3)

Automated Closed-Loop Workflow: A robust image ingestion and reporting mechanism was developed using the DJI Payload SDK and Web APIs, enabling real-time feedback of visual and geospatial data without human intervention.

(4)

Field Validation: Extensive flight tests in diverse environments verified the system’s reliability and engineering applicability.

2. System Architecture

The design of the proposed inspection system is driven by three core principles: autonomy, real-time responsiveness, and modularity. Given the remote and often hazardous nature of transmission corridors, the system must operate independently of consistent cloud connectivity while delivering immediate actionable intelligence.

To achieve these goals, we adopt a hierarchical “Edge–Cloud” collaborative architecture, as illustrated in Figure 1. The design rationale focuses on shifting the computational burden from the cloud to the network edge—specifically, the UAV itself. This approach minimizes the latency caused by bandwidth-limited 4G/5G networks in mountainous areas. The architecture is structured into three distinct layers:

• Perception Layer: Focuses on high-fidelity data acquisition using industrial-grade sensors to ensure input quality.
• Edge Computing Layer: Acts as the “brain” of the system, performing onboard inference to filter out irrelevant data and identify risks locally.
• Transmission Layer: Ensures reliable low-bandwidth communication, transmitting only critical detection results rather than raw data streams to the ground station.

Figure 1. Overall system architecture diagram.

Figure 1. Overall system architecture diagram.

This decoupled design not only enhances system robustness but also facilitates future hardware upgrades, allowing individual modules (e.g., sensors or AI processors) to be replaced without overhauling the entire architecture.

2.1. Perception Layer: Multi-Sensor Acquisition Platform

The foundation of the system is the DJI Matrice 300 RTK (M300 RTK) (SZ DJI Technology Co., Ltd. (DJI), Shenzhen, China), selected for its industrial-grade reliability and centimeter-level positioning accuracy via RTK modules. It supports a 55 min flight endurance, ensuring coverage of long-distance transmission corridors. The primary perception payload is the Zenmuse H20T (SZ DJI Technology Co., Ltd. (DJI), Shenzhen, China), a hybrid sensor solution integrating a 20MP zoom camera and a radiometric thermal camera. The device integration is shown in Figure 2.

• Visual Data: The zoom camera captures high-resolution RGB images (4056 × 3040), enabling detailed inspection of tower components and small hazards like bird nests.
• Environmental Data: An optional Air Meteorological Module can be mounted to monitor localized weather conditions (wind speed, temperature) that may affect flight stability or fire risk. All sensors are mechanically stabilized by a 3-axis gimbal to counteract flight vibrations.

Figure 2. UAV-borne devices and their integration.

Figure 2. UAV-borne devices and their integration.

2.2. Edge Computing Layer: Onboard Inference Engine

The core intelligence resides in the DJI Manifold 2-G (NVIDIA, Santa Clara, CA, USA), an embedded onboard computer powered by the NVIDIA Jetson TX2 module (NVIDIA, Santa Clara, CA, USA). This layer bridges the gap between raw data and decision-making.

• Hardware Integration: The Manifold 2-G connects to the UAV via the E-Port Developer Expansion Module. This interface provides both power supply and high-bandwidth data links (UART/USB), allowing the edge unit to function independently without ground control intervention.
• Software Framework: The software stack leverages two key SDKs:

  (1)

  Onboard SDK (OSDK): Accesses flight telemetry (attitude, GPS, velocity) to correlate detection results with precise geospatial coordinates.

  (2)

  Payload SDK (PSDK): Manages the H20T camera, triggering image capture and retrieving video streams in real-time. The Target Extraction and Management Program runs the optimized deep learning models (e.g., YOLOv8 with TensorRT) to process incoming data streams, identifying risks with minimal latency (approx. 30 ms).

2.3. Transmission Layer: Hybrid Communication Link

To guarantee reliable reporting in complex terrains, the system employs a robust communication strategy.

• Data Link: The processed results—consisting of compressed images with bounding boxes and metadata—are transmitted via integrated 4G/5G modules. A fallback Wi-Fi link is available for local debugging and log retrieval.
• Cloud & Visualization: A Data Transmission Program packages the inference results using a Web API (HTTP/RESTful). To optimize bandwidth usage in remote areas, an adaptive compression algorithm (WebP) is applied to the images, prioritizing the quality of Regions of Interest (ROI). The ROI is defined by the bounding box coordinates generated by the YOLO-PowerLite inference engine: during WebP encoding, ROI areas are encoded with higher quality, while background regions are more heavily compressed to minimize transmission bandwidth while preserving critical information. The data is finally rendered on the Ground Monitoring System, providing operators with a real-time visual map of potential hazards.

3. Methodology: Edge-Side Optimization and Deployment

Deploying complex neural networks on embedded devices requires rigorous optimization. This section details the software pipeline, from model compression to autonomous control logic.

3.1. Lightweight Model Architecture

To achieve real-time inference on resource-constrained edge platforms, we deploy YOLO-PowerLite [39], a custom lightweight detector optimized based on YOLOv8n [40]. This model has been proposed and validated in our previous work [39]; here we integrate it into the UAV-edge system, focusing on system-level optimization and deployment. The model is specifically engineered to address the challenges of transmission line inspection, such as complex background interference and the need for high computational efficiency. As illustrated in Figure 3, the architecture incorporates three core innovations:

• Adaptive Feature Fusion (C2f_AK & BiFPN): The traditional neck structure is enhanced by integrating the Bidirectional Feature Pyramid Network (BiFPN) [41], which enables efficient weighted feature fusion across different scales [42]. Furthermore, the standard C2f modules are replaced with C2f_AK modules. These modules utilize Alterable Kernel Convolution (AKConv) [43], which dynamically adjusts the kernel shape and size based on input feature characteristics [44]. This allows the model to adaptively capture irregular targets (e.g., camouflaged bird nests or varying insulator shapes) while significantly reducing parameter redundancy.
• Attention-Enhanced Backbone: To mitigate the impact of complex environmental noise (e.g., vegetation, terrain), the Coordinate Attention (CA) [45] mechanism is embedded into the backbone network. By encoding channel relationships and long-range dependencies with precise positional information, the CA module forces the network to focus on the salient regions of transmission components, improving detection accuracy in cluttered backgrounds.
• Lightweight Shared Detection Head: We redesigned the detection head by adopting a parameter-sharing strategy. Unlike the fully decoupled head in YOLOv8, the YOLO-PowerLite head shares convolutional layers for the initial stages of classification and regression tasks. This modification drastically reduces the computational burden (FLOPs) without compromising feature representation capabilities.

Figure 3. YOLO-PowerLite network structure.

Figure 3. YOLO-PowerLite network structure.

Evaluations on the NVIDIA Jetson Xavier NX platform (used in our subsequent field tests) demonstrate that YOLO-PowerLite achieves an inference speed of 31.2 ms per frame, satisfying the real-time requirements of UAV patrols. Compared to the baseline YOLOv8n, the model reduces parameters by 42.3% and FLOPs by 30.9%, while maintaining a high detection precision (mAP@0.5 of 94.2%).

3.2. TensorRT Acceleration Strategy

Although the YOLO-PowerLite model is structurally lightweight, deploying it directly via the PyTorch v.2.10.0 framework on embedded devices (e.g., NVIDIA Jetson TX2/Xavier NX) incurs significant overhead due to the heavy Python v.3.14.3 interpreter and unoptimized memory access patterns. To maximize the hardware utilization and achieve the target frame rate, we implemented a comprehensive acceleration strategy using NVIDIA TensorRT v.8.2., a high-performance deep learning inference SDK. The detailed implementation pipeline is depicted in Figure 4.

Figure 4. TensorRT Acceleration Pipeline.

3.2.1. Model Export and Intermediate Representation

The first step involves decoupling the trained model from the training framework. We utilize the torch.onnx.export tool to convert the dynamic PyTorch computation graph into the Open Neural Network Exchange (ONNX) format.

• Opset Compatibility: To ensure all custom modules (such as the C2f_AK and Coordinate Attention) are correctly interpreted, we specify a compatible Opset version (e.g., Opset 11 or higher) during export.
• Static Batching: Given the fixed input resolution of the camera stream, we define a static input shape (Batch = 1, Channel = 3, Height = 640, Width = 640) to allow the compiler to pre-allocate memory buffers, eliminating runtime allocation overhead.

3.2.2. Engine Construction and Optimization

The core acceleration is achieved during the “Build Phase,” where the TensorRT builder converts the ONNX graph into a hardware-specific execution engine (.engine file). Key optimization techniques applied include:

• Layer & Tensor Fusion: TensorRT identifies compatible layers and fuses them into a single CUDA kernel. For instance, the convolution, batch normalization, and activation layers (Conv + BN + ReLU) in the YOLO backbone are fused vertically. This significantly reduces the GPU memory bandwidth usage by minimizing read/write operations to the global memory.
• Precision Calibration (FP16): To fully leverage the Tensor Cores available on the Jetson platform, we enable FP16 (Half-Precision) mode. This reduces the memory footprint of weights and activations by 50% and doubles the theoretical peak throughput compared to FP32, with negligible impact on detection accuracy (mAP drop < 0.5%).
• Kernel Auto-Tuning: The builder empirically tests various algorithm implementations for each layer (e.g., Winograd convolution vs. GEMM) on the target hardware and selects the optimal kernel that minimizes latency.

3.2.3. Serialized Inference Runtime

The final optimized engine is serialized into a binary file. During the flight mission, the onboard C++ application loads this engine using the TensorRT Runtime API. The inference process is executed asynchronously:

• Zero-Copy Memory: We utilize CUDA mapped memory to allow the GPU to access image data directly from the camera buffer without explicit CPU-to-GPU memory copy (Host-to-Device), further reducing system latency.
• Output Decoding: The raw output tensors are post-processed (Non-Maximum Suppression) using optimized CUDA implementations (e.g., via torchvision or custom CUDA kernels) rather than CPU-based Python loops.

3.3. Real-Time Image Acquisition Pipeline

To ensure the seamless ingestion of high-resolution imagery during dynamic flight operations, a custom acquisition pipeline was developed utilizing the DJI Payload SDK. This module acts as a bridge between the camera’s storage system and the onboard inference engine, addressing the challenges of data latency and file redundancy. The workflow is illustrated in Figure 5.

• Asynchronous Polling Mechanism: The system initiates a persistent daemon thread (represented by a while (1) loop) that continuously monitors the camera’s file system directory. This ensures that new images are detected within milliseconds of capture.
• Redundancy Elimination: To prevent computational waste, a deduplication logic is implemented via the IsFileAlreadyDownloaded() function. This routine computes and compares unique file hashes (or checks file indices) against a local registry of processed images, ensuring that each target is analyzed exactly once.
• Robust Exception Handling: Given the vibration-prone environment of UAVs, I/O interruptions may occur. The system incorporates a fault-tolerant retry mechanism. If an image ingestion fails due to a temporary read error, the pipeline automatically attempts to re-acquire the data up to a predefined threshold before logging an error, guaranteeing the stability of the continuous detection stream.

Figure 5. Image Acquisition Pipeline.

Figure 5. Image Acquisition Pipeline.

4. Experimental Results and Analysis

4.1. System Implementation and Test Environment

To validate the real-world performance of the proposed UAV-Edge framework, we established a hardware-in-the-loop simulation and conducted field tests. The hardware setup for the field tests reported in Section 4.2.2 and Section 4.3 consists of an NVIDIA Jetson Xavier NX (8 GB) embedded module integrated into a DJI Matrice 300 RTK UAV platform. In the initial test (Section 4.2.1), the Manifold 2-G (Jetson TX2) was used; the Xavier NX represents an upgraded version adopted in later experiments. A generic USB camera was used to capture 1080p video streams, which were resized to 640 × 640 pixels for model inference. Unlike conventional studies conducted on high-performance servers, our experiments focus on onboard performance metrics, evaluating the system’s ability to perform real-time processing under the limited power and thermal constraints of an embedded aerial platform.

Evaluation Metrics

To quantitatively assess detection performance, we adopt standard metrics: Precision (P), Recall (R), Average Precision (AP), and mean Average Precision (mAP). Precision and Recall are defined as:

$$Precision={\displaystyle \frac{TP}{TP +FP}}; Recall={\displaystyle \frac{TP}{TP + FN}}$$

(1)

where TP, FP, and FN denote true positives, false positives, and false negatives, respectively. AP for a single class is the area under the Precision-Recall curve, and mAP is the average of AP across all classes:

$$mAP={\displaystyle \frac{1}{N}}{\sum }_{i=1}^N{\int }_0^{1}Precision\left(Recall\right)dRecall$$

(2)

In this study, we report mAP at an IoU threshold of 0.5 (mAP@0.5). The term “recognition accuracy” used in flight test results (Section 4.2.1 and Section 4.2.2) refers to Precision, i.e., the proportion of correctly identified targets among all detections.

4.2. Flight Scenarios

4.2.1. Scenario 1: Suburban-Rural Corridor in Langfang, Hebei

A field test was conducted along a 5 km transmission line segment in Langfang City, Hebei Province, which included 13 high-voltage towers and was located near the edge of a residential area, traversing mainly roads and farmland. The test aimed to evaluate the system’s image acquisition, edge inference, result transmission, visualization, and operational stability under realistic engineering conditions.

The UAV followed a pre-planned waypoint cruise trajectory, capturing images at fixed intervals with transmission towers as key nodes. The system recorded the flight path in real time and visualized it as a 3D trajectory, as shown in Figure 6.

Figure 6. Flight trajectory of the field test mission.

During the mission, the edge computing module (Manifold 2-G) processed incoming images in real time, performed target detection, bound detection results to spatial coordinates, and displayed them visually on the ground station interface. Operators could intuitively monitor UAV position, detection outcomes, and positioning information, with additional functions such as image query and trajectory playback support (see Figure 7).

Figure 7. Visual interface showing real-time detection and positioning.

Typical detection results from this continuous flight are presented in Figure 8. Bounding boxes are clearly displayed with a confidence score of 0.76, showing high consistency with manual annotations. The mean Average Precision reached 94.2%, with stable edge-side detection and reliable data transmission back to the ground system. While maintaining an equivalent 94% map accuracy as the original YOLOv8n model, the parameter count, computational load, and model size of our research model have been reduced by 42.3%, 30.9%, and 40.4%, respectively, compared to the baseline model YOLOv8n.

Figure 8. Example of detected target details. (Note: Although the Zenmuse H20T payload includes a radiometric thermal camera, this study focuses on visible light image detection; the integration and fusion of thermal data are left for future work.).

4.2.2. Scenario 2: Long-Distance Rural Corridor in Yixian, Hebei

To validate the robustness and adaptability of the system under varying hardware and algorithmic conditions, a second flight test was conducted. This test evaluated the performance of the system after upgrading both the onboard equipment and the recognition model, focusing on its operational stability and detection consistency in a distinctly different environment.

The test was performed along a 6 km transmission line comprising 12 high-voltage towers in Yixian County, Hebei Province. The environment primarily consisted of open rural terrain with sporadic vegetation, presenting a different set of background complexities compared to the first scenario.

The planned and executed flight trajectory for this mission is shown in Figure 9.

Figure 9. Flight trajectory of the second test mission.

Detection results from this flight are displayed in Figure 10. Bounding boxes remain clear with a minimum confidence score of 0.74, again aligning well with manual labels. The mean Average Precision achieved 95.4%, meeting system requirements for both detection precision and data transmission reliability.

Figure 10. Detailed view of detected targets in the second scenario.

4.3. Real-Time Processing Capability Evaluation

A core requirement for autonomous inspection is that the system must process video frames faster than the camera’s capture rate (typically 25–30 FPS) to avoid data backlog. We compared three deployment configurations, as summarized below and illustrated in Figure 11:

Figure 11. System performance of edge computing device model inference method.

• Proposed Framework (Jetson TX2 + TensorRT): With FP16 quantization, kernel fusion, and zero-copy memory access, the system achieved a stable 32 FPS (31.2 ms latency) on the Manifold 2-G. On the upgraded Xavier NX platform, similar performance (32 FPS) was maintained, confirming the scalability of the optimization.
• Edge Baseline (Jetson tx2 + ONNX): Deploying the model via the ONNX runtime without TensorRT-specific optimizations resulted in an average speed of 20.3 FPS (49.2 ms latency). While faster than pure PyTorch, this configuration still falls short of the 30 FPS threshold for seamless real-time processing.
• Edge Baseline (Jetson tx2 + PyTorch): Direct execution of the model through the PyTorch interpreter on the Jetson platform yielded only 12 FPS (81 ms latency). This performance is insufficient for real-time operation, introducing noticeable video lag that would critically hinder the identification of transient fire risks.

Discussion: The improvement from 12 FPS (PyTorch baseline) to 32 FPS (TensorRT-optimized) represents a qualitative leap, transforming the system from a lag-prone prototype to a production-ready solution capable of synchronized flight and real-time detection. The ONNX baseline, while intermediate, underscores the necessity of hardware-aware optimizations like those provided by TensorRT to fully leverage edge-device capabilities.

4.4. Performance in Identifying Fire-Related Hazards

The system’s primary value lies in its ability to accurately identify potential fire hazards. We evaluated performance on a dataset containing two key risk categories: Bird Nests (flammable materials) and Foreign Objects (e.g., balloons/kites that may cause short circuits).

• Detection Accuracy: The integrated detection module achieved a mean Average Precision (mAP) of 94.2%, ensuring high reliability in hazard identification.
• Qualitative Analysis: As visualized in Figure 8, the system successfully localized bird nests within complex tower structures. The Coordinate Attention mechanism proved effective in distinguishing nesting materials from background vegetation—a common source of false alarms in prior systems.
• Risk Assessment: In simulated scenarios, the system consistently flagged foreign objects hanging on transmission lines, demonstrating a high recall rate essential for early-warning applications.

4.5. System Resource Efficiency

For a UAV-borne system, computational efficiency directly impacts flight endurance. We monitored the system resources during the inspection mission:

• GPU Utilization: On the Xavier NX platform, the TensorRT engine maintained a steady GPU utilization of ~85%.
• Memory Footprint: The optimized engine consumed only 1.2 GB of the 8 GB shared memory. This is a critical advantage, as it leaves sufficient memory for other essential processes, such as flight control communication, video streaming, and telemetry logging.

5. Discussion

5.1. From Algorithm to Autonomous Application

The results presented above extend beyond the validation of a neural network; they confirm the feasibility of the entire UAV-Edge Framework. The integration of AI and UAVs has emerged as a transformative trend across multiple domains, including agriculture, surveillance, and disaster management, driven by advancements in edge computing and green technologies [46].

• Autonomy vs. Latency: The achievement of 32 FPS on the edge means the UAV does not need to rely on unstable 4G/5G links to offload computation to the cloud. This enables truly autonomous operation in remote areas (e.g., deep mountains) where signal coverage is poor, ensuring that fire risks are identified immediately regardless of connectivity. This design philosophy aligns with broader efforts to achieve real-time edge intelligence; for instance, a recent UAV-agnostic monitoring system demonstrated a modular architecture capable of balancing on-board and remote processing for multiple road inspection tasks simultaneously [47]. In contrast to such systems which reported an average end-to-end latency of 2.9 s from image capture to ground operator [47], our framework achieves millisecond-level detection, which is critical for time-sensitive fire risk identification.
• Practical Implications: The ability to detect flammable objects (nests) and short-circuit risks (foreign bodies) in real-time allows for a shift from “periodic maintenance” to “condition-based intervention.” Maintenance teams can be alerted to specific tower coordinates immediately upon detection, drastically reducing the response time to potential fire outbreaks.
• Scalability: The low memory footprint suggests that this framework can be further expanded. Future iterations could integrate thermal imaging algorithms or visual SLAM (Simultaneous Localization and Mapping) on the same hardware chip, further enhancing the UAV’s situational awareness without requiring hardware upgrades.

5.2. Feasibility of Autonomous Early Identification of Fire-Related Hazards

This study demonstrates the viability of a integrated, edge-resident framework for early identification of fire-related hazards in powerline corridors. Unlike traditional inspection paradigms that rely on offline data processing or high-bandwidth cloud transmission, our proposed UAV-Edge Computing Framework enables decision-making directly at the source. The integration of the lightweight YOLO-PowerLite detector with the TensorRT-accelerated inference engine on the Jetson platform proves that complex deep learning tasks can be executed in real-time (32 FPS) on resource-constrained embedded devices. This capability is critical for “Early Identification”—the system can detect precursors to fire hazards (e.g., bird nests near live parts, foreign objects bridging conductors) within milliseconds, triggering immediate alerts before a catastrophic failure occurs. This shift from “post-flight analysis” to “in-flight intervention” represents a fundamental advancement in grid maintenance strategies, mirroring similar trends in other domains such as traffic monitoring, where systems like MultEYE have successfully optimized vehicle detection and tracking for real-time onboard execution on comparable hardware [48]. The parallels extend to search and rescue operations, where AI-empowered UAV systems equipped with real-time image recognition and autonomous navigation have demonstrated significant improvements in response times and mission success rates [49].

5.3. Synergy Between Algorithms and Edge Hardware

A key finding of this research is that algorithm design cannot be decoupled from hardware constraints. The success of our framework lies not just in the architecture of the detection model, but in the holistic optimization strategy that bridges the gap between software and hardware.

• Algorithmic Efficiency: The use of AKConv and BiFPN in the detection module was essential to reduce the computational load to a level manageable by the onboard GPU.
• Hardware Acceleration: The TensorRT optimization pipeline (specifically FP16 quantization and layer fusion) acted as the catalyst, unlocking the full potential of the Jetson Xavier NX’s CUDA cores (tested on both Jetson TX2 and Xavier NX). Alternative optimization pathways exist, such as the network slimming technique applied to DeepLabV3+ for real-time forest fire segmentation, which successfully reduced model complexity while maintaining high accuracy on an embedded platform [50]. Our results indicate that a co-design approach—where the neural network is tailored specifically for the target deployment platform—is far superior to simply porting generic desktop-class models. Beyond model-level optimization, system-level resource management strategies, such as joint optimization of caching, task offloading, and UAV deployment in layered edge–cloud architectures, have demonstrated significant reductions in both energy consumption and task latency [51]. These complementary approaches highlight the multifaceted nature of achieving efficiency in UAV-enabled edge computing systems. This synergy ensures that the system maintains high detection precision (94.2% mAP) without sacrificing the low latency required for safe UAV navigation.

5.4. Robustness in Complex Inspection Environments

The discussion of environmental adaptability is crucial for practical deployment. Powerline corridors are often located in complex terrains with varying backgrounds. Our framework addresses this through the Coordinate Attention mechanism, which effectively suppresses environmental noise (e.g., vegetation, terrain textures). However, the “Real-Time” aspect of our title also implies a dependency on stable flight performance. The lightweight nature of our computational payload ensures that the UAV’s flight controller is not overburdened by power consumption or thermal throttling, maintaining a stable flight duration suitable for long-range patrols. This balance between computing power and flight endurance is a critical factor often overlooked in purely algorithmic studies but central to our system-level evaluation.

5.5. Limitations and System-Level Challenges

While the current framework establishes a solid baseline for autonomous inspection, several system-level challenges remain:

• Multi-Modal Fusion: Currently, the system relies solely on visual (RGB) data. For fire risk identification, visual data may be insufficient for detecting internal overheating of components. Future iterations should integrate thermal imaging (infrared) data, fusing RGB and IR streams at the edge to provide a more comprehensive risk assessment. The value of multi-sensor integration has been well demonstrated in other geohazard applications; for instance, in landslide investigations, UAVs equipped with RGB, multi-spectral, thermal IR, and LiDAR sensors enable comprehensive characterization of both static terrain features and dynamic slope movements [52]. Adopting a similar multi-modal approach could significantly enhance the situational awareness of our powerline inspection system.
• Communication Reliability: Although the system processes data locally, sending alerts still requires a communication link. In remote mountainous areas with weak signal coverage, the “alert transmission” latency might become a bottleneck, even if “detection” latency is low. Developing a store-and-forward mechanism or integrating satellite communication modules would be necessary for truly remote operations. To proactively address such system-level challenges, formal modeling approaches, such as the use of Stochastic Petri Nets for evaluating the performance of drone-based fire monitoring systems under various resource and service-time configurations, could provide valuable insights for optimizing future system architectures [53].
• Dynamic Path Planning: The current framework focuses on detection. A integrated system should also close the loop by integrating detection results with the UAV’s flight control, enabling dynamic path re-planning (e.g., hovering closer to a suspected target for verification) without human intervention.

6. Conclusions

This study presents a comprehensive and validated UAV-edge computing framework for real-time inspection of transmission lines, specifically targeting early identification of fire-related hazards. By tightly integrating a DJI M300 RTK UAV with an NVIDIA Jetson-based embedded module (Manifold 2-G/Xavier NX) and a TensorRT-accelerated YOLO-PowerLite detector, we establish an autonomous closed-loop workflow from image acquisition to onboard inference and risk reporting. The system achieves real-time performance at 32 FPS with a mean Average Precision exceeding 94%, effectively overcoming the latency and bandwidth bottlenecks inherent in cloud-dependent approaches. Field experiments in diverse suburban and rural corridors confirm its practical reliability, demonstrating robust detection of critical hazards such as bird nests and foreign objects under complex backgrounds. The successful deployment of high-performance AI on resource-constrained edge devices marks a paradigm shift from post-flight analysis to in-flight intervention, enabling scalable, cost-effective, and autonomous power grid maintenance. Future work will focus on multi-sensor fusion (visible, thermal, LiDAR) and 3D defect reconstruction to further enhance situational awareness and early warning capabilities.