TileNet: Reducing Compute for Aerial Roof Inspection

Autonomous roof inspection on small unmanned aerial systems usually founders on a binary choice. You can offload data to the cloud with high latency, or install power-hungry GPUs that trigger thermal throttling. TileNet replaces the traditional monolithic deep learning model with a hybrid architecture that processes high-resolution imagery as discrete tiles. By breaking a frame into smaller segments, the processor handles a reduced active memory footprint. This keeps the total chip power draw within the cooling capacity of small passive heatsinks and avoids the clock-speed down-throttling that plagues continuous full-frame inference.

Hybrid CNN-SVM Architecture

Standard networks often rely on a dense softmax layer for final classification. This layer requires a full matrix-vector multiplication where the input feature vector is multiplied by a matrix of size N inputs by M classes. Every weight in that matrix must be accessed and processed. As the feature vector grows, the number of floating-point operations scales linearly, consuming cycles that embedded flight controllers cannot spare. TileNet uses a feature extraction backbone comprising five convolutional layers followed by four dense layers. The final dense layer feeds a flattened feature vector into a linear Support Vector Machine head, which replaces the standard softmax output.

During training, the SVM identifies a small subset of the training data known as support vectors, which reside on the edge of the optimal decision boundary. Because only these critical points define the boundary, inference requires calculating the inner product of the input vector against these specific stored vectors rather than the entire weight matrix. By calculating distance only against this sparse set of vectors, the system skips the bulk of the matrix-vector multiplication. This reduces the arithmetic load to a series of inner products, which is significantly faster for embedded processors with limited compute cycles. The classification happens by evaluating the sign of the decision function after comparing the flattened input feature vector against the learned support vectors.

Memory Management and Spatial Mapping

Processing high-resolution imagery on a drone usually requires massive memory buffers to hold entire frames. TileNet decouples the input image from the model's receptive field by using a pre-processing step that segments full-resolution frames into fixed-size grid chunks. Instead of loading an entire frame into RAM, the system utilizes a sliding window buffer that fetches specific tile coordinates from the local storage into the processing queue. The onboard processor only keeps the current tile and its local neighborhood in memory, which maintains a constant and predictable memory footprint regardless of the original image's total resolution.

The system reconciles these local detections with global positioning using a coordinate transformation matrix. To project an image pixel onto the ground, the system uses the camera's intrinsic parameters and the drone's extrinsic pose—its altitude, GPS coordinates, and attitude (pitch, roll, and yaw). Using the pinhole camera model, the algorithm calculates the ray vector from the camera center through the pixel; the intersection of this ray with the ground plane (at the measured altitude) provides the geographic coordinate. This transformation allows the post-processing software to map defect locations onto a unified orthomosaic. The field testing demonstrates an inference latency of approximately 100 milliseconds per tile on an NVIDIA Jetson platform, a throughput sufficient for real-time operation during flight.

Known Limitations and Tradeoffs

The primary risk is the loss of global context. Because the model sees only a small tile, it cannot distinguish between a minor surface crack and a structural failure that presents differently at a larger scale. This architecture is a tool for detecting specific, localized surface anomalies. While the use of an SVM head avoids the massive matrix-vector multiplications of a full softmax layer, it does introduce a specific scaling constraint: the number of inner products required at inference time is proportional to the number of support vectors stored. Increasing the defect class count effectively requires a larger set of support vectors to define those additional decision boundaries, which directly increases the number of inner-product operations per inference pass. This creates a ceiling for how many damage types can be monitored simultaneously before the compute cost returns to the levels of traditional deep neural networks.