As a renewable and environmentally friendly energy source, solar power has become a key direction in the global energy transition. Solar panels, as the core components of photovoltaic systems, are exposed to harsh outdoor conditions such as wind, rain, temperature fluctuations, sand, and hail, which inevitably lead to various surface defects including cracks, dust accumulation, and foreign object coverage. These defects can significantly reduce the energy conversion efficiency of the panels and even cause hot spots, posing serious risks to the safety and stability of the entire photovoltaic system. Therefore, accurate and efficient detection of surface defects on solar panels, as well as reliable estimation of the resulting power generation loss, is crucial for the operation and maintenance of photovoltaic plants.
Traditional defect detection methods, including manual visual inspection and electrical analysis, suffer from low efficiency, high cost, or limited ability to identify defect types and locations. Machine vision approaches, especially those based on deep learning, have emerged as promising solutions due to their high accuracy, speed, and low deployment cost. In this work, I present a comprehensive study on deep learning-based surface defect detection for solar panels. The main contributions of this thesis are threefold: first, an improved Deep Convolutional Generative Adversarial Network (DCGAN) is proposed to augment the limited and imbalanced defect dataset; second, an enhanced Single Shot MultiBox Detector (SSD) model, named R2F-SSD, is developed to achieve high-precision and high-speed detection of solar panel surface defects; third, a transfer learning strategy is employed to build a power generation efficiency loss prediction model, and a software platform is designed to facilitate practical inspection tasks.
The remainder of this article is organized as follows: Section 2 describes the image augmentation techniques, including traditional methods and the improved DCGAN. Section 3 presents the improved SSD model together with experimental validation. Section 4 discusses the power loss estimation system and the software implementation. Section 5 concludes the work and outlines future research directions.
Image Augmentation for Solar Panel Surface Defects
Deep learning models require large amounts of annotated data to achieve high performance. However, collecting a large-scale, balanced dataset of solar panel surface defects is challenging and expensive. In this study, I first built an initial dataset (named D_initial) containing 1800 images, with 600 images for each of three defect types: broken, dirt, and foreign object coverage. The images were collected from field photography and online sources. Due to the limited number of images and the risk of class imbalance, I applied both traditional and deep learning-based image augmentation techniques to enlarge the dataset.
Traditional Image Augmentation
Traditional image augmentation generates new samples by applying various transformations to existing images. In this work, I used the following operations: horizontal and vertical flipping, rotation, color transformation, noise addition, and cropping. These operations preserve the main semantic features of the original images while increasing the diversity of the training data. For example, flipping and rotation improve the model’s robustness to orientation variations, color transformation simulates different lighting conditions, noise addition helps the model tolerate noisy inputs, and cropping provides positional invariance. Applying these operations to D_initial, I created an augmented dataset named D_tradition with 3600 images (1200 per defect class).
Overview of DCGAN
Generative Adversarial Networks (GANs) have shown remarkable capability in generating realistic synthetic images. DCGAN is a widely used variant that applies convolutional and transposed convolutional layers in the discriminator and generator, respectively. The generator takes a random noise vector from a latent space and produces an image, while the discriminator attempts to distinguish between real and generated images. The training process is a minimax game with two competing loss functions: the discriminator loss \(L_D\) and the generator loss \(L_G\). The standard DCGAN uses binary cross-entropy loss, which can be expressed as:
\[
L_D = -\frac{1}{m}\sum_{i=1}^{m} \left[ y_i \log D(x_i) + (1-y_i) \log(1-D(G(z_i))) \right]
\]
\[
L_G = -\frac{1}{m}\sum_{i=1}^{m} \log D(G(z_i))
\]
where \(x_i\) denotes real samples, \(z_i\) is the input noise, \(G(z_i)\) is the generated sample, \(D(\cdot)\) is the discriminator output probability, and \(y_i\) is the label (1 for real, 0 for fake). Although DCGAN performs well in many tasks, it suffers from training instability and mode collapse, especially when the dataset is small. To address these issues, I proposed several improvements to the DCGAN architecture and training objective.
Improved DCGAN for Image Augmentation
My improved DCGAN introduces three main modifications: (1) adding a Convolutional Block Attention Module (CBAM) after the last transposed convolution layer in the generator, (2) replacing the ReLU activation function with the Exponential Linear Unit (ELU) in the generator, and (3) adopting the Wasserstein distance as the loss function. These changes aim to enhance feature extraction, avoid the “dying ReLU” problem, and stabilize the training process.
CBAM combines channel attention and spatial attention mechanisms. The channel attention module computes channel-wise weights by squeezing spatial information, while the spatial attention module highlights important spatial regions. The overall process can be described as:
\[
F’ = M_c(F) \otimes F
\]
\[
F” = M_s(F’) \otimes F’
\]
where \(F\) is the input feature map, \(M_c\) and \(M_s\) are the channel and spatial attention maps, and \(\otimes\) denotes element-wise multiplication. By incorporating CBAM, the generator focuses on the most informative features, thereby producing higher-quality defect images.
The ELU activation function is defined as:
\[
ELU(y) = \begin{cases}
y, & y > 0 \\
\alpha(e^y – 1), & y \le 0
\end{cases}
\]
where \(\alpha\) is a positive hyperparameter. Unlike ReLU, ELU has a non-zero gradient for negative inputs, which mitigates the neuron death problem and improves information flow during backpropagation.
To further stabilize training, I adopted the Wasserstein distance with gradient penalty (WGAN-GP style). The generator loss and discriminator loss become:
\[
L_G = -E_{x \sim p_g}[D(x)]
\]
\[
L_D = E_{x \sim p_g}[D(G(z))] – E_{x \sim p_r}[D(x)] + \lambda E_{\hat{x} \sim p_{\hat{x}}}[(||\nabla_{\hat{x}} D(\hat{x})||_2 – 1)^2]
\]
where \(p_r\) is the real data distribution, \(p_g\) is the generated data distribution, \(p_{\hat{x}}\) is the distribution of interpolated samples, and \(\lambda\) is the gradient penalty coefficient. The improved DCGAN model structure is illustrated in the figure below. The generator comprises five transposed convolution layers, each followed by batch normalization and ELU activation, with the final layer using tanh activation. After the last transposed convolution, a CBAM module is added to refine the generated features.
Experimental Results of Image Augmentation
I conducted experiments to evaluate the effectiveness of the improved DCGAN. The evaluation metrics include Maximum Mean Discrepancy (MMD), Structural Similarity Index Measure (SSIM), and Fréchet Inception Distance (FID). MMD measures the difference between the generated and real distributions; a smaller MMD indicates better quality. SSIM evaluates the structural similarity between generated and real images; a higher SSIM value is better. FID computes the distance between feature representations; lower FID corresponds to higher image quality. The definitions are as follows:
\[
MMD^2(P,Q) = \frac{1}{n^2}\sum_{i,j} k(x_i,x_j) + \frac{1}{m^2}\sum_{i,j} k(y_i,y_j) – \frac{2}{nm}\sum_{i,j} k(x_i,y_j)
\]
\[
SSIM(x,y) = \frac{(2\mu_x \mu_y + C_1)(2\sigma_{xy} + C_2)}{(\mu_x^2 + \mu_y^2 + C_1)(\sigma_x^2 + \sigma_y^2 + C_2)}
\]
\[
FID = ||\mu_r – \mu_g||^2 + Tr(\Sigma_r + \Sigma_g – 2(\Sigma_r \Sigma_g)^{1/2})
\]
First, I performed an ablation study to verify each modification. Four models were compared: Model1 (original DCGAN), Model2 (Model1 + CBAM), Model3 (Model2 + ELU), and Model4 (Model3 + Wasserstein loss). The results are summarized in Table 1.
| Defect Type | Model | Avg-SSIM (%) | FID |
|---|---|---|---|
| Broken | Model1 | 48.74 | 337.46 |
| Model2 | 49.32 | 323.13 | |
| Model3 | 49.63 | 247.36 | |
| Model4 | 50.19 | 209.49 | |
| Dirt | Model1 | 47.63 | 359.36 |
| Model2 | 47.98 | 337.40 | |
| Model3 | 48.65 | 259.16 | |
| Model4 | 49.63 | 224.78 | |
| Foreign | Model1 | 48.41 | 341.15 |
| Model2 | 48.94 | 332.12 | |
| Model3 | 49.12 | 253.10 | |
| Model4 | 49.78 | 219.16 |
It is evident that each improvement contributes positively to image quality. The combination of all three modifications yields the best SSIM and FID values across all defect categories. The convergence curves of MMD also demonstrate that the improved model converges faster and to a lower value than the original DCGAN.
Next, I compared the improved DCGAN with other state-of-the-art GAN models: WGAN, WGAN-GP, CycleGAN, SAGAN, BEGAN, BigGAN, and ProGAN. Table 2 lists the quantitative comparisons.
| Defect Type | Model | Avg-SSIM (%) | FID |
|---|---|---|---|
| Broken | WGAN | 48.64 | 247.48 |
| WGAN-GP | 48.72 | 246.36 | |
| CycleGAN | 49.12 | 228.95 | |
| SAGAN | 49.89 | 223.59 | |
| BEGAN | 47.40 | 259.41 | |
| BigGAN | 50.13 | 217.15 | |
| ProGAN | 49.30 | 225.36 | |
| Ours | 50.19 | 209.49 | |
| Dirt | WGAN | 48.29 | 250.70 |
| WGAN-GP | 48.35 | 248.18 | |
| CycleGAN | 48.61 | 238.94 | |
| SAGAN | 49.16 | 235.18 | |
| BEGAN | 48.76 | 256.16 | |
| BigGAN | 49.45 | 228.41 | |
| ProGAN | 48.73 | 237.50 | |
| Ours | 49.63 | 224.78 | |
| Foreign | WGAN | 49.51 | 230.23 |
| WGAN-GP | 49.57 | 227.49 | |
| CycleGAN | 49.60 | 223.46 | |
| SAGAN | 50.10 | 216.46 | |
| BEGAN | 48.65 | 229.36 | |
| BigGAN | 50.39 | 215.49 | |
| ProGAN | 49.66 | 220.94 | |
| Ours | 49.78 | 219.16 |
While BigGAN and SAGAN achieve slightly better SSIM and FID for the foreign defect class, the proposed method yields the best overall performance across all three defect types. The generated images show richer details and more realistic defect characteristics, confirming that the improved DCGAN is effective for augmenting solar panel defect datasets.
To demonstrate the practical impact on detection models, I trained Faster R-CNN, YOLOv8n, and the proposed R2F-SSD model on three datasets: D_initial, D_tradition, and an augmented dataset generated by the improved DCGAN (named D_deep). D_deep also contains 3600 images (1200 per class). The detection performance measured by mean Average Precision (mAP) is reported in Tables 3-5.
| Dataset | Broken | Dirt | Foreign | mAP |
|---|---|---|---|---|
| D_initial | 75.63 | 65.94 | 67.89 | 69.82 |
| D_tradition | 77.02 | 68.10 | 71.45 | 72.19 |
| D_deep | 80.72 | 70.02 | 76.63 | 75.79 |
| Dataset | Broken | Dirt | Foreign | mAP |
|---|---|---|---|---|
| D_initial | 66.40 | 58.63 | 59.80 | 61.61 |
| D_tradition | 68.35 | 60.10 | 62.74 | 63.73 |
| D_deep | 70.62 | 60.52 | 64.82 | 65.32 |
| Dataset | Broken | Dirt | Foreign | mAP |
|---|---|---|---|---|
| D_initial | 73.83 | 62.96 | 68.83 | 68.54 |
| D_tradition | 75.02 | 63.27 | 73.12 | 70.47 |
| D_deep | 79.92 | 68.12 | 75.04 | 74.36 |
These results clearly show that using the deep-learning-augmented dataset D_deep leads to the highest detection accuracy for all models, outperforming both the original dataset and the traditionally augmented dataset. This demonstrates that the improved DCGAN can generate high-quality synthetic images that help alleviate data scarcity and class imbalance, thereby improving the performance of downstream detection models for solar panel surface defects.
Improved SSD Model for Solar Panel Surface Defect Detection
The Single Shot MultiBox Detector (SSD) is a popular one-stage object detection algorithm that predicts bounding boxes and class labels directly from feature maps in a single forward pass. The original SSD uses a modified VGG-16 as the backbone and extracts features from six convolution layers at different scales. Despite its fast inference speed, SSD suffers from insufficient semantic information in shallow layers and weak correlation between feature layers, leading to suboptimal detection accuracy, especially for small or subtle defects on solar panels. To overcome these limitations, I proposed an improved SSD model named R2F-SSD, which incorporates three key enhancements: a modified ResNet50 backbone, a Feature Pyramid Network (FPN) with ECA attention, and the Focal Loss function.
Modified ResNet50 Backbone
ResNet50 is a deep residual network that introduces shortcut connections to address the degradation problem in very deep networks. The residual learning block can be formulated as:
\[
y = \mathcal{F}(x, \{W_i\}) + x
\]
where \(x\) is the input, \(\mathcal{F}(\cdot)\) represents the residual mapping to be learned, and \(y\) is the output. By learning the residual \(\mathcal{F}(x) = H(x) – x\), the network can easily learn an identity mapping, which prevents gradient vanishing and allows the training of much deeper architectures. Compared with VGG-16, ResNet50 has fewer parameters and stronger feature representation capability, which helps improve both accuracy and inference speed.
I modified the original ResNet50 architecture by replacing the final fully connected layer, softmax layer, and classification layer to match the three defect classes (broken, dirt, foreign). Additionally, I inserted a new convolutional layer followed by batch normalization and ReLU activation before the global average pooling layer. The revised feature extraction pathway extracts more discriminative features for solar panel defect detection.
Feature Fusion Pyramid Network with ECA
SSD already uses a pyramidal feature hierarchy for multi-scale detection, but it lacks cross-scale connections. To enable better fusion of high-level semantic information and low-level spatial details, I introduced a Feature Pyramid Network (FPN). FPN constructs a top-down pathway with lateral connections, as shown in the following equations:
\[
F_{i}^{top} = upsample(F_{i+1}^{top}) + F_{i}^{lateral}
\]
where \(F_{i}^{top}\) is the fused feature at level \(i\), \(F_{i+1}^{top}\) is the higher-level feature, and \(F_{i}^{lateral}\) is the corresponding feature from the bottom-up pathway. This fusion enriches each scale with contextual information. To further refine the fused features, I added the Efficient Channel Attention (ECA) module. ECA captures channel dependencies with only a few parameters by performing global average pooling followed by a 1D convolution. The attention weights are computed as:
\[
\omega = \sigma(Conv1D(GAP(F)))
\]
where \(GAP\) is global average pooling, \(Conv1D\) is a one-dimensional convolution with a kernel size determined by the number of channels, and \(\sigma\) is the sigmoid function. The refined feature map is obtained by channel-wise multiplication.
Focal Loss for Class Imbalance
In object detection, the number of negative samples (background anchors) far exceeds the number of positive samples, causing a severe class imbalance that can bias the training process. To address this, I replaced the standard cross-entropy loss with the Focal Loss, defined as:
\[
FL(p_t) = -\alpha_t (1 – p_t)^\gamma \log(p_t)
\]
where \(p_t\) is the model’s predicted probability for the true class, \(\alpha_t\) is a weighting factor, and \(\gamma\) is the focusing parameter. When \(\gamma > 0\), the loss contribution from easily classified samples is down-weighted, allowing the model to focus more on hard examples. In my implementation, I set \(\alpha_t\) to balance positive and negative samples and \(\gamma = 2\).
R2F-SSD Network Architecture
The complete R2F-SSD network starts with a 300×300 input image, followed by the modified ResNet50 backbone. The feature maps from selected layers are fused using the FPN and then passed to the prediction heads. The original SSD’s extra convolutional layers are retained to provide additional scales. The overall architecture is depicted in the schematic diagram below. The improvements allow R2F-SSD to achieve high detection accuracy while maintaining a real-time inference speed.
Experimental Results and Analysis
I evaluated R2F-SSD on the D_deep dataset, which contains 3600 images and is split into training, validation, and test sets with a ratio of 6:2:2. The training epochs were set to 30, and the initial learning rate was 0.0005 with a decay schedule. I first performed an ablation study to verify each improvement, and the results are given in Table 6.
| Model | ResNet50 | FPN | Focal Loss | mAP (%) | FPS |
|---|---|---|---|---|---|
| Model1 | – | – | – | 67.95 | 48.36 |
| Model2 | ✓ | – | – | 70.83 | 54.28 |
| Model3 | ✓ | ✓ | – | 73.07 | 53.58 |
| Model4 (R2F-SSD) | ✓ | ✓ | ✓ | 74.36 | 53.09 |
Compared with the original SSD, R2F-SSD improves the mAP by 6.41 percentage points and increases the detection speed from 48.36 FPS to 53.09 FPS. The replacement of the backbone significantly boosts both accuracy and speed. The FPN contributes a further accuracy gain, while Focal Loss adds another 1.29% mAP improvement with a negligible speed penalty.
I then compared R2F-SSD with several state-of-the-art detectors, including Faster R-CNN, FSSD, RSSD, MDSSD, FoveaBox, FCOS, ATSS, YOLOv3, YOLOv5, and YOLOv8n. Table 7 summarizes the quantitative results.
| Model | Broken AP (%) | Dirt AP (%) | Foreign AP (%) | mAP (%) | FPS |
|---|---|---|---|---|---|
| Faster R-CNN | 80.72 | 70.02 | 76.63 | 75.79 | 8.17 |
| SSD | 72.16 | 61.45 | 70.24 | 67.95 | 48.36 |
| FSSD | 68.91 | 65.34 | 70.56 | 68.27 | 47.69 |
| RSSD | 73.34 | 60.49 | 73.44 | 69.09 | 44.31 |
| MDSSD | 72.16 | 66.15 | 67.61 | 68.64 | 39.72 |
| FoveaBox | 74.19 | 68.31 | 69.30 | 70.60 | 16.21 |
| FCOS | 66.36 | 60.12 | 63.06 | 63.18 | 30.94 |
| ATSS | 70.21 | 63.47 | 67.71 | 67.13 | 24.34 |
| YOLOv3 | 64.23 | 52.47 | 59.79 | 58.83 | 52.33 |
| YOLOv5 | 69.87 | 55.86 | 60.78 | 62.17 | 55.64 |
| YOLOv8n | 70.62 | 60.52 | 64.82 | 65.32 | 56.40 |
| R2F-SSD | 79.92 | 68.12 | 75.04 | 74.36 | 53.09 |
Although Faster R-CNN achieves a slightly higher mAP (75.79%) than R2F-SSD (74.36%), its inference speed is only 8.17 FPS, which is far below real-time requirements. In contrast, R2F-SSD runs at over 53 FPS while maintaining comparable accuracy. Among the real-time detectors, R2F-SSD outperforms all YOLO variants and other SSD-based algorithms in accuracy. Qualitative results confirm that R2F-SSD accurately localizes defects with higher confidence scores and produces more complete bounding boxes than most competing methods. This demonstrates that the proposed R2F-SSD is well-suited for practical solar panel surface defect detection.
Power Generation Efficiency Loss Estimation and System Implementation
In addition to detecting the types of defects, it is crucial to assess their impact on the power generation efficiency of solar panels. To this end, I developed a power loss estimation model based on transfer learning. The model can identify not only the defect category but also the defect grade and the corresponding efficiency loss.
Data Collection and Loss Calculation
I selected an AK-25W solar panel and collected field data including surface defect images, electrical parameters, and environmental information. The power generation efficiency loss for a single defect can be computed using the following formulas:
\[
\eta_d = \frac{P_m – P_{max}}{A_i P_{in}} = \frac{P_{max} \cdot \eta \cdot (T_b – T_s) \cdot R}{A_i P_{in}}
\]
\[
\eta_l = 1 – \frac{\eta_d}{\eta}
\]
where \(\eta\) is the rated efficiency of the solar panel, \(\eta_d\) is the efficiency with a defect, \(\eta_l\) is the loss rate, \(P_m\) is the measured output power, \(P_{max}\) is the maximum rated output power, \(T_b\) is the panel temperature, \(T_s\) is the rated operating temperature, \(R\) is the power temperature coefficient, \(P_{in}\) is the irradiance, and \(A_i\) is the panel area. Using this method, I assembled a power loss dataset containing 12 defect grades: broken1-4, dirt1-4, and foreign1-4, with a total of 600 images. Each image is annotated with the defect type, the grade, and the average efficiency loss rate.
| Parameter | Value |
|---|---|
| Rated power | 25 W |
| Operating voltage | 36 V |
| Operating current | 0.694 A |
| Weight | 1.95 kg |
| Dimensions | 530×350×25 mm |
The average loss rates for the various defect grades were found to be: broken1-4: 6.4%, 11.8%, 15.4%, 20.6%; dirt1-4: 5.2%, 9.6%, 13.7%, 21.5%; foreign1-4: 6.3%, 14.9%, 20.8%, 30.8%. These numeric labels were attached to the corresponding images to build the training targets.
Transfer Learning for the Power Loss Model
Since collecting a large dataset with power loss labels is impractical, I applied transfer learning from the pre-trained R2F-SSD detection model. The source model was trained on the large D_deep dataset and can recognize broken, dirt, and foreign defects. The target task requires distinguishing 12 distinct classes (defect type + grade). To transfer knowledge, I froze the first three convolutional blocks (Conv1, Conv2_x, Conv3_x) because they capture low-level generic features. The higher-level blocks (Conv4_x, Conv5_x) were fine-tuned using a progressive unfreezing strategy: initially frozen, then gradually unfrozen from top to bottom during training. This strategy avoids overfitting while allowing the model to adapt high-level features to the new task. The fully connected layer was replaced with a new layer having 12 output units. The training was performed on the power loss dataset with a small learning rate.
I compared two transfer learning approaches: standard fine-tuning (m1) and progressive unfreezing (m2). Table 9 lists the average precision values for each defect grade.
| Model | b1 | b2 | b3 | b4 | d1 | d2 | d3 | d4 | f1 | f2 | f3 | f4 | mAP |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| m1 | 78.3 | 77.2 | 77.1 | 76.2 | 63.4 | 64.1 | 64.2 | 65.3 | 74.1 | 75.5 | 73.8 | 73.1 | 71.9 |
| m2 | 79.8 | 80.3 | 80.7 | 81.2 | 66.2 | 68.3 | 67.4 | 68.7 | 78.4 | 79.6 | 79.7 | 79.9 | 75.9 |
The progressive unfreezing approach improves the mAP from 71.9% to 75.9%, a gain of 4 percentage points. In particular, the model correctly identifies the defect grade and the corresponding power loss value, which is critical for maintenance decisions. The standard transfer learning model sometimes misjudges the severity, leading to inaccurate loss estimation. Thus, the progressive unfreezing strategy is essential for building an accurate power loss estimation model.
Software Platform Design and Implementation
To make the developed methods practically usable, I designed and implemented a solar panel surface defect detection system using Visual Studio and the WinForm framework. The system contains four functional modules: (1) login and registration, (2) image augmentation, (3) defect detection, and (4) detection result statistics.
The login module authenticates users; a default administrator account is provided, and users can register new accounts. After logging in, the main interface displays a defect detection area, a function selection area, and a result display area. The image augmentation module allows users to load a dataset, check if the image count is sufficient (at least 1000 images recommended), and then run the improved DCGAN to generate synthetic images. The augmentation progress is displayed in real time, and generated images can be previewed and saved.
The defect detection module lets users upload an image, load a pre-trained model (e.g., R2F-SSD or the power loss model), and perform detection. The resulting annotated image is shown in the main window, and detailed information including file name, defect type, defect grade, estimated power loss, and confidence score is listed in the result area. The user can save the annotated image and the result text for future reference.
I demonstrated the system using the R2F-SSD model and the transfer-learning-based power loss model. Both models successfully detected defects and displayed the corresponding information. The system provides a convenient and intuitive interface for solar plant maintenance personnel, fulfilling the requirements of practical inspection workflows.
Conclusion and Future Work
In this article, I presented a systematic study on deep learning-based surface defect detection for solar panels. The key findings are summarized as follows:
First, an improved DCGAN was developed to address the limited size and class imbalance of the solar panel defect dataset. By integrating a CBAM attention module, ELU activation, and a Wasserstein distance loss, the generator produces higher-quality synthetic images. Experimental results showed that the proposed method outperforms several popular GAN models in terms of MMD, SSIM, and FID. Moreover, when the augmented dataset was used to train detection models, the mAP improved significantly compared with using only real images or traditionally augmented images.
Second, I proposed the R2F-SSD detector, which combines a modified ResNet50 backbone, a feature fusion pyramid with ECA attention, and Focal Loss. This model achieved a mAP of 74.36% on the solar panel defect dataset at 53.09 FPS, representing a substantial improvement over the original SSD and competitive with other real-time detectors. The enhanced architecture effectively captures fine-grained defect features and generalizes well to unseen images.
Third, a power generation efficiency loss estimation model was built using transfer learning from R2F-SSD. The progressive unfreezing strategy enabled the model to recognize 12 defect grades with an mAP of 75.9%, allowing the system to predict not only the defect type but also its severity and the corresponding efficiency loss. Finally, a user-friendly software platform was developed to integrate image augmentation, defect detection, and result management, demonstrating the practical applicability of the proposed methods.
There are several directions for future research. The proposed DCGAN may still exhibit mode collapse when the training set is extremely small; introducing diversity constraints or conditional generation could further improve stability. The current study only considers three types of defects; expanding to other common defects such as aging or EVA detachment would enhance the robustness of the system. In real-world scenarios, multiple defects often coexist on a single solar panel; investigating combined effects on power efficiency remains a challenging but important task. In addition, the software system could be improved by integrating drone-based image acquisition for automated large-scale inspection. Finally, images captured in dusty or foggy environments may be unclear; collecting such challenging samples from arid regions would help improve model resilience in practical deployments.
In conclusion, the deep learning-based approaches presented in this work provide an effective and efficient solution for solar panel surface defect detection and power loss estimation, contributing to the reliable operation of photovoltaic power plants.