Product Introduction

A solar farm can hold anywhere from tens of thousands to several million modules. Day after day they sit out in the heat, wind, sand, rain and snow, so it's no surprise they pick up all sorts of ailments. The most common one, and also the most dangerous, is the hotspot.

A hotspot is just a small patch on a module that runs abnormally hot. At best it eats into your power output. At worst it burns through the backsheet and starts a fire, putting the whole plant at risk. The trouble is, modules are packed edge to edge. Sending crews out to check them one by one with a handheld instrument is slow and misses things. So the pairing of infrared thermography with deep learning has been pushed into the spotlight.

Point an infrared camera at a module, capture its temperature spread as a heat map, then let a trained neural network read that map for you and mark where it's hot and how hot. Sounds straightforward. But getting it to actually work in the field is another story. Infrared images come with three built-in flaws that trip up ordinary algorithms: low resolution, wildly different defect sizes, and messy backgrounds.

A new method called SESPNet (Semantic Enhancement and Scale Perception Network) goes straight after those three flaws. Its numbers are solid: 92.1% mean average precision, 62.4 frames per second, and it's small enough to run in real time on a palm-sized embedded device. This piece breaks down how it pulls every hotspot out of a dull grey infrared frame.

First, why hotspots matter. A PV module is many cells wired in series. If one cell loses output because of shading, a micro-crack or dirt, it stops contributing current and starts acting like a resistor, turning the current from the other cells into heat and burning it off inside itself. That one cell becomes the heat source for the whole string, running tens of degrees hotter than its neighbours. Mild cases drag down the string's output. Severe ones cook the encapsulant over time, burn through the backsheet, and can even ignite. Finding hotspots early and dealing with them fast is a job PV operations can't avoid.

Figure 1: Solar collector modules mounted on a rooftop, exposed to the outdoors for years, where localized temperature spikes form hotspots.

Figure 2: The five-step workflow of infrared thermal detection for PV module defects, from capturing temperature to pinpointing the faulty panel.

Technical Parameters

Why Infrared Is a Must for Hotspot Detection

To understand this algorithm, start with the basics: why a visible-light camera won't cut it for hidden PV faults, and why infrared is the only way.

Visible-light imaging is just ordinary photography. High resolution, rich detail, good for spotting cracks, scratches and dirt on the surface, the kind of thing you can see. But it has one fatal limit. It only reads appearance, not temperature. A micro-crack or a cold solder joint inside a module often doesn't change how it looks early on, yet it blocks current at that spot and heats it up. Visible-light cameras are helpless against these thermal faults, and at night or in poor light they're useless.

Infrared takes a different road. Any object above absolute zero radiates infrared, and the hotter it is the stronger the radiation. An infrared camera captures that radiation and paints the invisible temperature spread straight onto a color or greyscale heat map. It needs no external light, so it works day or night. Where a module is hot and by how much shows up clearly. For heat-driven defects like hotspots and broken gridlines, infrared is the natural cure.

That's why infrared has become a key way to lift both accuracy and speed of defect detection at PV plants. A drone with an infrared camera can sweep an entire array in a few minutes, dozens of times faster than a manual crew. But that ability to see heat comes at a price: image quality is far lower than visible light.

The old manual method has workers carrying instruments and measuring panel by panel. It's slow and leans heavily on experience. With modules packed tight and counted in the thousands, reading them one at a time is exhausting, error-prone, and nearly impossible at night. The drone-plus-infrared combo maxes out the capture step, but if you still read those thousands of images by hand, the bottleneck just moves from measuring to looking. To close the loop you need an algorithm to read the images. That's the cue for deep learning.

Figure 3: A typical infrared heat map. The hotter the area, the warmer its color, and the overheated region stands out at a glance. This is the raw material for hotspot detection.

Figure 4: The division of labor between visible-light and infrared imaging. For thermal faults, infrared is the natural cure.

Three Tough Bones in Infrared Defect Detection

Infrared can see heat, but it hands detection algorithms three hard problems. These three are exactly why many off-the-shelf algorithms fail on PV infrared work.

One: low contrast. Infrared frames are dull and grey overall. The greyscale difference between defect and background is small to begin with, and imaging noise on top of that lets defects get swallowed by the background. The algorithm can't grab the key features, so accuracy suffers.

Two: wildly varying defect scale. Within a single infrared frame, hotspot sizes can differ by tens of times. Some are a whole bypassed string glowing across a big patch; others are just one cell warming slightly in one corner. A fixed receptive field, the range the network can see clearly in one pass, tends to lose one for the other against such a spread: get the big target and you miss the small one, or the other way around.

Three: small-target information gets lost. This is the trickiest. Neural networks downsample layer by layer, shrinking the image to pull out high-level meaning. But small hotspots that were only tens of pixels to start with get smoothed away as they shrink, until almost nothing is left by the time a decision is made, and recognition takes a big hit.

Put all three together and it's clear: PV infrared defect detection is hard because you have to fight "can't see clearly, sizes all over the place, easily lost" at the same time. SESPNet's three core upgrades each target one of these bones: one boosts semantics to suppress the background, one builds a pyramid to handle sizes, one guards the channels to recover small targets.

Why not just grab an off-the-shelf detector? Object detection has moved fast, and it splits into two routes. One is two-stage: first rough-screen candidate regions, then judge each carefully, high accuracy but slow. The other is one-stage: one look gives both location and class, fast and suited to real time. The YOLO series is the one-stage flagship. But these general algorithms are trained on ordinary visible images, and dropped onto low-contrast, wildly scaled PV infrared frames, they struggle. SESPNet's upgrades fill in those three gaps, custom-made for infrared defects.

Figure 5: The three tough bones of infrared defect detection: low contrast, multiple scales, and small targets.

Figure 6: A multi-rotor drone carrying a camera, flying over the array to grab infrared images in bulk, sweeping in minutes what a crew would take half a day to cover.

Technical Advantages

Move One: Semantic Enhancement, Floating Defects Out of the Background

SESPNet builds on YOLOv10 as its base model. YOLOv10 is one of today's most popular real-time detectors, released by a Tsinghua team in May 2024, built to be fast, accurate and deployment-friendly. SESPNet performs three operations on it, and the first embeds a Semantic Information Enhancement Module, SIEM, in the backbone.

What it solves is the low-contrast problem. Poor contrast in infrared defect images lets background noise interfere with the features the model pulls out, hurting accuracy. SIEM works two ways at once. A global attention branch takes in the whole image's overall meaning, working out what's background and what might be hiding a defect, so the clutter's interference gets pushed down. A local attention branch focuses on the defect's own detail and texture, sharpening its feature expression.

Each branch watches its own thing, then global and local get weighted and fused together. Think of it like squinting to make out the whole roof's outline and rule out clutter, then leaning in to stare at the one suspicious patch. Near and far combined, and the defect gets lifted out of the dull background. The fused features keep the defect's detail while suppressing background interference, so feature expression is clearly stronger.

The payoff shows plainly in the ablation study later: add SIEM alone and mean precision rises across all three target classes, with real gains in resisting complex backgrounds.

The backbone is the part of the model that first touches the image and pulls out the base features. Putting SIEM here means cleaning up at the source: before anything is passed on, the defect's features are already strengthened and the background noise already suppressed. With a clean source, the later scale handling and target localization won't get led astray by clutter. That's why it sits in the backbone and nowhere else. Treat the pollution early.

Figure 7: The dual-branch structure of the SIEM semantic-enhancement module. The global branch reads the big picture to suppress background, the local branch watches detail to strengthen the defect, then the two are weighted and fused.

Figure 8: A rooftop PV array. The dense field of modules is exactly the messy scene that feeds interference to a detection algorithm.

Move Two: Pyramid Pooling, Big and Small Hotspots Both in Focus

The second change swaps YOLOv10's original spatial pyramid pooling module for a Space Attention Pyramid Pooling Module, SAPPM. It targets the varying-scale problem.

"Pyramid pooling" can be read as scanning the same feature map with several windows of different sizes at once. Small windows see fine detail, good for small hotspots; big windows see wide, good for big hotspots. The study runs several pooling windows from small to large in parallel, so whether a defect fills several rows or is just a palm-sized speck, the right window catches it.

On top of that, SAPPM adds a layer of spatial attention. It assigns different weights to the features from different windows, so the truly key scale information is kept front and center while the irrelevant is dialed down, then stitches these multi-scale features into a fuller feature map. In short, the first part handles "seeing every size," the second handles "highlighting what should be seen." Together they sharply boost the model's sense of multi-scale targets.

This directly eases the old lose-one-for-the-other problem. A fixed-receptive-field network drops the small target while minding the big one; with SAPPM in place, big and small hotspots can both be seen clearly in the same pass, no matter how wide the size gap.

Figure 9: A sketch of the SAPPM multi-scale feature pyramid pooling, scanning in parallel with windows of different sizes then stitching them with spatial attention weighting.

Figure 10: An aerial shot of a plant. Drones capture at different heights, making the same defect appear at even more varied scales in the image.

Move Three: Channel Attention, Fishing Back the Small Targets Nearly Lost

The third change lands in the neck network, building a multi-scale channel attention mechanism, MCI. It cures the trickiest problem, small-target information loss.

First, a word on channels. When a network processes an image, it splits features into many parallel channels, each describing the image from a different angle. Small-target features are already weak, scattered across these channels, and if each channel minds only itself with no exchange, that precious bit of information easily drowns in the layer-by-layer handoff.

MCI's approach is to build interaction between channels, letting them talk to each other. Wherever a channel still holds a trace of the small target, cross-channel cooperation amplifies and preserves it. This further strengthens the extraction of small-scale feature information, and those small hotspots that were about to vanish in downsampling get fished back.

Where these three moves sit in the network is deliberate too. SIEM cleans features at the backbone source, SAPPM sums up multi-scale information at the backbone's tail, and MCI does the final polish at the neck that links backbone to detection head. Front, middle, back, together they cover the full chain of extracting, summing and outputting features, and each step gets a targeted remedy for an infrared-defect pain point.

The three moves have clear roles: SIEM handles contrast, SAPPM handles scale, MCI handles small targets. They don't fight alone but pass the baton: lift the defect out of the background first, then cover all sizes, then catch the small target most likely to slip away. With this combination, the three toughest bones of infrared defect detection come apart one by one.

Figure 11: Infrared hotspots sorted by scale into Large, Middle and Mini. The size gap is huge, and the smallest hotspots are the easiest to miss.

Figure 12: A faint target caught by the infrared camera. The smaller and dimmer the target, the easier it is to get smoothed away in processing.

Product Application

The Scorecard: 92.1% Accuracy, 62 Frames a Second

The effect of the three moves comes down to data. The researchers built their own PV module infrared defect dataset, labeling hotspots by the pixel size they take up in the image into three classes: over 64x64 pixels is Large, between 32x32 and 64x64 is Middle, under 32x32 is Mini. Whether detection is good has to be read class by class, scale by scale.

Accuracy leans on two metrics. One is recall, R, answering "of the defects that should be found, how many were recovered." The other is mean average precision, PmA, a综合 of detection precision across classes, the total score a detector cares about most. Add detection speed, measured in frames processed per second, and those three numbers together tell the full story of an algorithm.

Start with the module-by-module ablation. With stock YOLOv10 as the baseline, its mean average precision is 89.8%. Add SIEM alone, up to 90.4%; SAPPM alone, 90.5%; MCI alone, 90.7%. Every move helps. Stack all three, the full SESPNet, and mean average precision jumps to 92.1%. The standout is small targets: the baseline's Mini precision is only 86.7%, and with all three it climbs to 90.3%, a full 3.6 points, which proves MCI's work in recovering small targets.

Figure 13: The module-by-module ablation. With the three modules stacked, the hardest small-target precision rises from 86.7% to 90.3%.

Figure 14: An endless large ground-mounted plant. Its thousands upon thousands of modules are exactly what this algorithm has to check one by one.

Head to Head: Nine Algorithms on One Stage

Comparing against itself isn't enough. The study puts SESPNet on the same stage as eight other mainstream algorithms, trains them on the same dataset, and measures accuracy and speed side by side.

The result speaks for itself. Classic two-stage algorithms like Faster R-CNN and Cascade R-CNN have limited feature extraction and run slow, landing at 86% to 88% mean average precision, not fit for scenes that demand high real-time performance. SSD is the fastest but its accuracy is only 74.3%, clearly low. The YOLO series is more balanced overall: from YOLOv7's 88.1%, through YOLOX, YOLOv8, YOLOv10 and YOLOv11, accuracy climbs to the 89% to 90% range with speeds all around fifty to sixty frames a second.

SESPNet pushes that curve further to the top right: 92.1% mean average precision, about 2 points above the runner-up, and 62.4 frames per second, right in step with the YOLO speedsters. It doesn't sacrifice speed to lift accuracy; it holds the top-right spot of fast-and-accurate that others can't reach. That's its biggest value. In a scene of massive module counts where you judge as you patrol, every bit of slowness is cost.

R = TP ÷ ( TP + FN ) · P = TP ÷ ( TP + FP )

Those two lines are the base definitions of the accuracy metrics. R (recall) measures the share of real defects recovered, P (precision) measures how many of the reported defects are real, and PmA is the total score computed across classes and across precision levels. The logic isn't complex: miss as little as possible (high recall) and false-alarm as little as possible (high precision), keep both ends in check, and you have a dependable detector.

Figure 15: The accuracy-speed comparison of nine algorithms. SESPNet holds the top-right corner with 92.1% accuracy and 62.4 FPS.

Figure 16: A real-world test on an embedded platform. The most accurate SESPNet still holds steady at 12.6 FPS.

Squeezed Into a Palm-Sized Box and Still Real Time

Running well in the lab doesn't mean it's usable in the field. PV plants are mostly out in the wild, where inspection gear is limited in compute and power. Whether the algorithm can fit into a low-power little box and run in real time is the last hurdle for real deployment.

The researchers ported it to an embedded platform called Jetson Nano to verify. Its processor is a quad-core ARM chip paired with an entry-level 128-core GPU, far below the lab workstation with its dedicated card in both compute and power. SESPNet was deployed at the same input scale, then raced against the other algorithms on this little board.

The result again proves its balance. Classic two-stage algorithms show their true colors in the embedded setting: Faster R-CNN drops to 1.9 frames per second, barely real time; Cascade R-CNN only 3.7. The YOLO series generally falls to around eleven or twelve frames, while SESPNet holds 12.6 frames per second while keeping the top 92.1% accuracy, right alongside the lightweight YOLOs, even a touch ahead. Compute slashed hard, it stays accurate and steady, showing how well the design fits resource-constrained scenes.

This means a drone or a portable inspector fitted with this algorithm won't have to ship images back to the cloud to crunch slowly. On the spot, in real time, it can tell which panel has a hotspot. Both inspection efficiency and response speed move up another step.

The value of judging on the fly is more than saving one round trip. Putting compute at the edge means inspection can still run at remote plants with poor signal; spot a suspected hotspot and you can mark it on the spot and re-fly to confirm right away, no waiting for data to return and manual review before a second sortie. For big plants measured in hundreds of megawatts with modules counted in the millions, this on-site real-time ability directly decides whether a full inspection takes hours or days.

Closing: Nowhere Left to Hide for Every Overheating Panel

Looking back, the cleverness of SESPNet isn't in stacking some elaborate structure but in treating the right symptoms. Infrared contrast is low, so semantic enhancement suppresses the background. Defect scale is a mess, so pyramid pooling covers all sizes. Small targets are easily lost, so channel attention fishes them back. Three moves, each to its task, and passing the baton.

What's rarer is that it didn't fatten the model for accuracy's sake. Many algorithms chase high accuracy blindly, end up bloated, drag down speed, and can't even fit onto an embedded device. SESPNet holds its speed while topping accuracy, and it survived the test of drastically cut compute. That balance of accurate, fast and light is exactly the quality the field values most. Whether a technology is any good comes down to whether it can do real work at a real plant.

92.1% mean average precision, 62.4 frames per second, and small enough to run real time in a palm-sized box. Those three numbers together sketch a tool that can truly go down to the plant and get to work. It turns a dull grey infrared image, once hard even for the human eye, into a health report where defects have nowhere to hide.

When a drone carrying an algorithm like this sweeps over field after field of blue arrays, every quietly overheating panel gets pinned and dealt with in the first moment. Hidden hotspots become visible, and seemingly tiny risks get snuffed out. What holds up is exactly a plant that turns sunlight into power, long, safe and at full load.

Ooitech's View

What strikes us most here is how detection and manufacturing are two sides of the same reliability coin. A hotspot flagged in the field often traces back to a micro-crack or a cold solder joint born on the line, which is why stringer welding, layup alignment and lamination control matter so much on a module production line. Get those steps right and you feed fewer hotspots into the field in the first place. If you want to see how a real module line is built and tuned, our factory walkthroughs on the Ooitech YouTube channel (www.youtube.com/ooitech) are worth a look and a subscribe.