✅ 博主简介：擅长数据搜集与处理、建模仿真、程序设计、仿真代码、论文写作与指导，毕业论文、期刊论文经验交流。

 ✅ 具体问题可以私信或扫描文章底部二维码。

（1）在现代工业制造体系中，产品质量控制是决定企业核心竞争力的关键环节，而缺陷检测作为质量控制的核心组成部分，其准确性和效率直接影响着产品的最终品质与生产成本。传统的工业品缺陷检测主要依赖人工目检，这种方法不仅存在主观性强、标准不一、容易因视觉疲劳导致漏检和误检等问题，而且在面对高速、大规模的生产线时，其效率瓶颈日益凸显，严重制约了智能制造的发展。随着工业4.0和人工智能技术的浪潮席卷全球，基于机器视觉的自动化检测技术应运而生，并逐渐取代了传统的人工检测。然而，早期的机器视觉系统多依赖于传统的图像处理算法，如阈值分割、边缘检测、模板匹配等，这些方法在处理背景简单、缺陷特征明显的场景时尚能胜任，但面对工业品表面纹理复杂、光照不均、缺陷形态多变、微小且对比度低等复杂情况时，其鲁棒性和泛化能力显得力不从心，需要耗费大量精力进行复杂的特征工程设计和参数调整。深度学习技术的崛起，特别是卷积神经网络（CNN）在图像识别领域的巨大成功，为工业缺陷检测带来了革命性的突破。深度学习模型能够自动从海量数据中学习和提取缺陷的深层抽象特征，摆脱了对人工设计特征的依赖，极大地提升了检测的准确性和适应性。本研究正是立足于这一背景，深入探索深度学习技术在工业品缺陷自动检测领域的具体应用与实践。我们选取了两种具有代表性的、挑战性极高的工业缺陷作为研究对象：一是太阳能电池生产过程中，丝网印刷环节可能出现的栅线断路、污染、偏移等结构性缺陷；二是高端显示面板制造中普遍存在的，表现为亮度或颜色不均匀的Mura缺陷。这两种缺陷类型恰好代表了工业检测中的两大难题：前者是目标明确、形态相对固定的局部缺陷，适合采用有监督的目标检测方法；后者则是形态模糊、边界不清、与正常样本差异细微的弥散性缺陷，难以获取和标注大量缺陷样本，更适合采用无监督的异常检测方法。通过对这两种截然不同的缺陷类型进行针对性研究，本文旨在构建一套完整且高效的自动化检测方案，验证深度学习在解决复杂工业检测问题上的有效性和普适性，为推动制造业的智能化升级提供坚实的技术支撑和实践参考。

（2）针对太阳能电池板丝网印刷环节产生的栅线缺陷，我们设计并实现了一套基于YOLOv5算法的高精度自动化检测系统。丝网印刷是太阳能电池片制造的关键工序，其质量直接决定了电池的光电转换效率。然而，在生产过程中，由于网版堵塞、印刷压力不均、设备对位偏差等多种因素，容易导致栅线出现断路、虚印、粗细不均、污染、偏移等多种缺陷。这些缺陷通常尺寸微小，形态各异，且常常出现在复杂的背景纹理之上，给自动检测带来了巨大挑战。我们首先对采集自实际产线的高分辨率图像数据集进行了深入分析，发现数据集存在严重的类别不平衡问题，即某些致命但罕见的缺陷（如微小断路）样本数量极少，而常见缺陷样本相对较多。这种不平衡会直接导致模型训练偏向于多数类，对少数类缺陷的检测能力急剧下降。为了解决这一难题，我们设计了一套复合型数据增强策略。除了常规的几何变换（如随机旋转、水平垂直翻转、缩放裁剪）和光度变换（如亮度、对比度、饱和度的随机调整）来扩充数据集、模拟不同工况外，我们重点开发了一种基于图像合成的缺陷样本生成技术。具体而言，我们从真实缺陷图像中手动切割出典型的缺陷区域作为“缺陷模板”，然后通过算法将这些模板随机地、无痕地粘贴到大量正常的太阳能电池板图像上。在粘贴过程中，我们采用了泊松融合算法，确保新粘贴的缺陷在光照、纹理和边缘上能与背景图像自然过渡，避免了生硬的拼接痕迹。同时，我们还模拟了缺陷的模糊、变形等效果，使得生成的缺陷样本更加逼真和多样化。通过这种方式，我们成功地将稀有缺陷类别的样本数量扩充了数十倍，有效缓解了数据不平衡问题，为后续模型的训练奠定了坚实的基础。在模型层面，我们选择了在速度与精度上取得良好平衡的YOLOv5作为基础检测框架。然而，直接将高分辨率的整张电池板图像（例如4096x4096像素）输入网络，不仅计算量巨大，而且经过多层下采样后，微小的缺陷特征极易丢失。为此，我们创新性地提出了一种“分块滑动检测与结果融合”的策略。该策略将高分辨率图像按照固定的尺寸（如1024x1024像素）和一定的重叠率（如20%）进行分割，形成多个图像块。然后，将每一个图像块独立地输入到训练好的YOLOv5模型中进行缺陷检测。由于每个图像块的分辨率相对较低，模型能够更精细地捕捉到局部区域的细节特征，从而显著提升了对微小缺陷的检出率。检测完成后，我们需要将所有图像块的检测结果融合回原始图像的坐标系中。这一过程需要处理两个关键问题：一是坐标映射，即将图像块内的检测框坐标转换回原始大图中的坐标；二是重叠区域的冗余检测消除，即当一个缺陷跨越多个图像块的边界时，可能会产生多个重叠的检测框。我们采用非极大值抑制（NMS）算法对融合后的所有检测框进行处理，仅保留置信度最高的检测框，从而得到最终精确的检测结果。实验结果表明，采用分块检测策略后，模型在验证集上的平均精度均值（mAP@0.5）相比直接检测整图的方法提升了近30个百分点，达到了0.95以上，同时，通过合理的并行计算设计，单张高分辨率图像的平均推理时间能够稳定控制在1秒以内，完全满足了实际产线的实时性要求。

（3）与形态明确的栅线缺陷不同，显示面板的Mura缺陷检测是一项更为艰巨的任务。Mura一词源于日语，意为“不均匀”，它是一种在纯色背景下，人眼能够感知到的局部亮度或色度差异，其表现形式多种多样，如云状Mura、带状Mura、点状Mura等。这类缺陷的核心挑战在于其“低对比度”和“无明确边界”。缺陷区域与正常区域的像素值差异非常微弱，信噪比极低，且缺陷的形状不规则，边缘模糊，与正常的背景纹理过渡平缓，使得传统的基于阈值或边缘的检测方法完全失效。此外，Mura缺陷的定义本身带有一定的主观性，不同的人对同一块面板的判断可能存在差异，这给缺陷样本的标注带来了极大的困难，导致难以构建大规模、高质量的标注数据集来训练有监督的深度学习模型。因此，针对Mura缺陷的特性，我们另辟蹊径，提出了一种基于生成对抗网络（GAN）的无监督异常检测方法，并将其命名为UADD-GAN（Unsupervised Anomaly Detection with Discriminative Guidance）。该方法的核心思想是“只学习正常，重构异常”。我们假设模型只使用大量无缺陷的正常样本进行训练，使其深度学习并掌握正常显示面板的内在分布规律和纹理特征。训练完成后，当一张正常面板图像输入模型时，模型能够精确地将其重构出来，输入与输出之间的差异极小。然而，当一张含有Mura缺陷的图像输入时，由于模型从未见过此类异常模式，它无法准确地重构缺陷区域，导致重构图像在缺陷位置与原始输入产生显著的差异。通过计算并分析这种差异，我们便可以实现对Mura缺陷的定位和识别。我们的UADD-GAN模型主要由一个生成器和一个鉴别器构成。生成器采用了类似于U-Net的编码器-解码器结构。编码器通过一系列卷积和下采样操作，将输入图像压缩到一个低维的潜在空间表示，这个表示捕捉了图像最核心的特征。解码器则通过一系列转置卷积和上采样操作，将这个潜在表示逐步恢复成与原始图像尺寸相同的重构图像。跳跃连接结构被用于连接编码器和解码器中对应层级的特征图，这有助于保留图像在重构过程中的细节信息，防止信息丢失。鉴别器的设计是本模型的关键创新之一。它不仅仅是一个简单的二分类器，用于判断输入是“真实图像”还是“生成器重构的图像”，更重要的是，它扮演了一个“特征指导者”的角色。我们在鉴别器的多个不同深度的特征层上引入了监督机制。具体来说，在训练过程中，我们不仅计算最终的对抗损失，还计算原始正常图像和重构图像在鉴别器中间层特征图上的差异（即感知损失）。这种多层次的监督迫使生成器不仅要像素级地还原图像，更要在语义和纹理层面保持高度一致性，从而学习到更鲁棒、更本质的正常模式。对于缺陷的判定，我们设计了一个综合性的异常分数图。该分数图由两部分加权而成：一是像素级残差图，即原始输入图像与生成器重构图像之间的绝对差值；二是特征级残差图

import torch
import torch.nn as nn
import torch.nn.functional as F

class Generator(nn.Module):
    def __init__(self, in_channels=3, out_channels=3):
        super(Generator, self).__init__()
        self.encoder1 = nn.Sequential(nn.Conv2d(in_channels, 64, kernel_size=4, stride=2, padding=1), nn.LeakyReLU(0.2, inplace=True))
        self.encoder2 = nn.Sequential(nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1), nn.BatchNorm2d(128), nn.LeakyReLU(0.2, inplace=True))
        self.encoder3 = nn.Sequential(nn.Conv2d(128, 256, kernel_size=4, stride=2, padding=1), nn.BatchNorm2d(256), nn.LeakyReLU(0.2, inplace=True))
        self.encoder4 = nn.Sequential(nn.Conv2d(256, 512, kernel_size=4, stride=2, padding=1), nn.BatchNorm2d(512), nn.LeakyReLU(0.2, inplace=True))
        self.encoder5 = nn.Sequential(nn.Conv2d(512, 512, kernel_size=4, stride=2, padding=1), nn.BatchNorm2d(512), nn.LeakyReLU(0.2, inplace=True))
        self.encoder6 = nn.Sequential(nn.Conv2d(512, 512, kernel_size=4, stride=2, padding=1), nn.BatchNorm2d(512), nn.LeakyReLU(0.2, inplace=True))
        self.bottleneck = nn.Sequential(nn.Conv2d(512, 512, kernel_size=4, stride=1, padding=1), nn.ReLU(inplace=True))
        self.decoder6 = nn.Sequential(nn.ConvTranspose2d(512, 512, kernel_size=4, stride=2, padding=1), nn.BatchNorm2d(512), nn.ReLU(inplace=True))
        self.decoder5 = nn.Sequential(nn.ConvTranspose2d(1024, 512, kernel_size=4, stride=2, padding=1), nn.BatchNorm2d(512), nn.ReLU(inplace=True))
        self.decoder4 = nn.Sequential(nn.ConvTranspose2d(1024, 256, kernel_size=4, stride=2, padding=1), nn.BatchNorm2d(256), nn.ReLU(inplace=True))
        self.decoder3 = nn.Sequential(nn.ConvTranspose2d(512, 128, kernel_size=4, stride=2, padding=1), nn.BatchNorm2d(128), nn.ReLU(inplace=True))
        self.decoder2 = nn.Sequential(nn.ConvTranspose2d(256, 64, kernel_size=4, stride=2, padding=1), nn.BatchNorm2d(64), nn.ReLU(inplace=True))
        self.decoder1 = nn.Sequential(nn.ConvTranspose2d(128, out_channels, kernel_size=4, stride=2, padding=1), nn.Tanh())

    def forward(self, x):
        e1 = self.encoder1(x)
        e2 = self.encoder2(e1)
        e3 = self.encoder3(e2)
        e4 = self.encoder4(e3)
        e5 = self.encoder5(e4)
        e6 = self.encoder6(e5)
        b = self.bottleneck(e6)
        d6 = self.decoder6(b)
        d6 = torch.cat((d6, e5), dim=1)
        d5 = self.decoder5(d6)
        d5 = torch.cat((d5, e4), dim=1)
        d4 = self.decoder4(d5)
        d4 = torch.cat((d4, e3), dim=1)
        d3 = self.decoder3(d4)
        d3 = torch.cat((d3, e2), dim=1)
        d2 = self.decoder2(d3)
        d2 = torch.cat((d2, e1), dim=1)
        d1 = self.decoder1(d2)
        return d1

class Discriminator(nn.Module):
    def __init__(self, in_channels=3):
        super(Discriminator, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(in_channels, 64, kernel_size=4, stride=2, padding=1),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1),
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(128, 256, kernel_size=4, stride=2, padding=1),
            nn.BatchNorm2d(256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(256, 512, kernel_size=4, stride=2, padding=1),
            nn.BatchNorm2d(512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(512, 1, kernel_size=4, stride=1, padding=1),
        )
        self.feature_layers = [self.model[i] for i in [0, 3, 6, 9]]

    def forward(self, x):
        features = []
        for i, layer in enumerate(self.model):
            x = layer(x)
            if i in [2, 5, 8, 10]:
                features.append(x)
        return x, features

class UADD_GAN(nn.Module):
    def __init__(self, in_channels=3, out_channels=3):
        super(UADD_GAN, self).__init__()
        self.generator = Generator(in_channels, out_channels)
        self.discriminator = Discriminator(in_channels)

    def forward(self, x):
        reconstructed_image = self.generator(x)
        real_output, real_features = self.discriminator(x)
        fake_output, fake_features = self.discriminator(reconstructed_image.detach())
        return reconstructed_image, real_output, fake_output, real_features, fake_features

    def get_anomaly_map(self, x):
        with torch.no_grad():
            reconstructed_image = self.generator(x)
            _, real_features = self.discriminator(x)
            _, fake_features = self.discriminator(reconstructed_image)
            
            pixel_diff = torch.abs(x - reconstructed_image)
            pixel_diff = torch.mean(pixel_diff, dim=1, keepdim=True)
            
            feature_diff = 0
            for r_feat, f_feat in zip(real_features, fake_features):
                diff = torch.abs(r_feat - f_feat)
                diff = F.interpolate(diff, size=x.shape[2:], mode='bilinear', align_corners=False)
                feature_diff += torch.mean(diff, dim=1, keepdim=True)
            
            anomaly_map = 0.7 * pixel_diff + 0.3 * feature_diff
            return anomaly_map

如有问题，可以直接沟通

👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇