#实战项目：工业缺陷检测

"""
工业缺陷检测的重要性：

1. 质量控制：
   - 自动化检测，减少人为误差
   - 提高检测精度和一致性
   - 实时监控产品质量

2. 成本效益：
   - 降低人力成本
   - 减少废品率
   - 提高生产效率

3. 安全保障：
   - 防止缺陷产品流入市场
   - 保障消费者安全
   - 维护品牌声誉
"""

def industrial_inspection_importance():
    """
    工业缺陷检测的重要性
    """
    importance_factors = {
        "自动化": "替代人工检测，提高效率",
        "一致性": "确保检测标准统一",
        "实时性": "在线检测，及时发现缺陷",
        "可追溯": "记录检测数据，便于分析",
        "经济性": "降低检测成本，提高收益"
    }
    
    print("工业缺陷检测的重要性:")
    for factor, desc in importance_factors.items():
        print(f"• {factor}: {desc}")

industrial_inspection_importance()

def defect_types_and_challenges():
    """
    缺陷类型和检测挑战
    """
    defect_types = {
        "表面缺陷": "划痕、凹坑、污渍、裂纹",
        "尺寸缺陷": "超差、变形、缺料",
        "结构缺陷": "气泡、杂质、分层",
        "装配缺陷": "错位、缺失、松动"
    }
    
    challenges = [
        "光照变化: 不同环境下的照明条件",
        "复杂纹理: 产品本身纹理与缺陷区分",
        "实时性要求: 高速生产线上的快速检测",
        "小缺陷检测: 微小缺陷的识别难度",
        "样本不平衡: 正常样本远多于缺陷样本"
    ]
    
    print("缺陷类型:")
    for category, types in defect_types.items():
        print(f"• {category}: {types}")
    
    print("\n检测挑战:")
    for challenge in challenges:
        print(f"• {challenge}")

defect_types_and_challenges()

import numpy as np
import cv2
from sklearn.ensemble import IsolationForest
from sklearn.svm import OneClassSVM
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt

class TraditionalAnomalyDetector:
    """
    传统异常检测器
    """
    def __init__(self, method='isolation_forest', contamination=0.1):
        self.method = method
        self.contamination = contamination
        self.scaler = StandardScaler()
        self.feature_extractor = PCA(n_components=50)  # 降维
        self.model = self._initialize_model()
    
    def _initialize_model(self):
        """
        初始化模型
        """
        if self.method == 'isolation_forest':
            return IsolationForest(contamination=self.contamination, random_state=42)
        elif self.method == 'one_class_svm':
            return OneClassSVM(nu=self.contamination)
        else:
            raise ValueError(f"Unsupported method: {self.method}")
    
    def extract_features(self, images):
        """
        提取图像特征
        """
        features = []
        for img in images:
            # 转换为灰度图
            gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) if len(img.shape) == 3 else img
            
            # 提取纹理特征 (使用LBP)
            lbp_features = self._extract_lbp_features(gray)
            
            # 提取梯度特征
            grad_features = self._extract_gradient_features(gray)
            
            # 提取统计特征
            stats_features = self._extract_statistical_features(gray)
            
            # 合并特征
            combined_features = np.concatenate([lbp_features, grad_features, stats_features])
            features.append(combined_features)
        
        return np.array(features)
    
    def _extract_lbp_features(self, image):
        """
        提取LBP特征
        """
        from skimage.feature import local_binary_pattern
        
        # LBP参数
        radius = 3
        n_points = 8 * radius
        
        lbp = local_binary_pattern(image, n_points, radius, method='uniform')
        hist, _ = np.histogram(lbp.ravel(), bins=n_points + 2, 
                              range=(0, n_points + 2), density=True)
        return hist
    
    def _extract_gradient_features(self, image):
        """
        提取梯度特征
        """
        # 计算梯度
        grad_x = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=3)
        grad_y = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=3)
        
        # 梯度幅值和方向
        magnitude = np.sqrt(grad_x**2 + grad_y**2)
        orientation = np.arctan2(grad_y, grad_x)
        
        # 统计特征
        features = [
            np.mean(magnitude),
            np.std(magnitude),
            np.mean(orientation),
            np.std(orientation),
            np.percentile(magnitude, 25),
            np.percentile(magnitude, 75)
        ]
        
        return np.array(features)
    
    def _extract_statistical_features(self, image):
        """
        提取统计特征
        """
        features = [
            np.mean(image),      # 均值
            np.std(image),       # 标准差
            np.var(image),       # 方差
            np.min(image),       # 最小值
            np.max(image),       # 最大值
            np.median(image),    # 中位数
            np.percentile(image, 25),  # 25%分位数
            np.percentile(image, 75)   # 75%分位数
        ]
        
        return np.array(features)
    
    def train(self, normal_images):
        """
        训练模型 (仅使用正常样本)
        """
        # 提取特征
        features = self.extract_features(normal_images)
        
        # 标准化
        features_scaled = self.scaler.fit_transform(features)
        
        # 降维
        features_reduced = self.feature_extractor.fit_transform(features_scaled)
        
        # 训练模型
        self.model.fit(features_reduced)
        
        print(f"模型训练完成，使用 {len(normal_images)} 个正常样本")
    
    def predict(self, images):
        """
        预测缺陷
        """
        # 提取特征
        features = self.extract_features(images)
        
        # 标准化和降维
        features_scaled = self.scaler.transform(features)
        features_reduced = self.feature_extractor.transform(features_scaled)
        
        # 预测
        predictions = self.model.predict(features_reduced)
        scores = self.model.decision_function(features_reduced)
        
        # -1 表示异常，1 表示正常
        return predictions, scores

def traditional_anomaly_detection():
    """
    传统异常检测示例
    """
    print("传统异常检测示例:")
    print("""
# 初始化检测器
detector = TraditionalAnomalyDetector(method='isolation_forest', contamination=0.1)

# 训练 (使用正常产品图像)
detector.train(normal_images)

# 检测新图像
predictions, scores = detector.predict(test_images)

# 解释结果
for i, pred in enumerate(predictions):
    if pred == -1:
        print(f"图像 {i} 检测到缺陷")
    else:
        print(f"图像 {i} 正常")
""")

traditional_anomaly_detection()

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import torchvision.transforms as transforms

class ConvolutionalAutoencoder(nn.Module):
    """
    卷积自编码器用于异常检测
    """
    def __init__(self, input_channels=3):
        super(ConvolutionalAutoencoder, self).__init__()
        
        # 编码器
        self.encoder = nn.Sequential(
            nn.Conv2d(input_channels, 32, kernel_size=4, stride=2, padding=1),  # 224->112
            nn.ReLU(inplace=True),
            nn.Conv2d(32, 64, kernel_size=4, stride=2, padding=1),             # 112->56
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1),            # 56->28
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 256, kernel_size=4, stride=2, padding=1),           # 28->14
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 512, kernel_size=4, stride=2, padding=1),           # 14->7
            nn.ReLU(inplace=True)
        )
        
        # 解码器
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(512, 256, kernel_size=4, stride=2, padding=1),  # 7->14
            nn.ReLU(inplace=True),
            nn.ConvTranspose2d(256, 128, kernel_size=4, stride=2, padding=1),  # 14->28
            nn.ReLU(inplace=True),
            nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1),   # 28->56
            nn.ReLU(inplace=True),
            nn.ConvTranspose2d(64, 32, kernel_size=4, stride=2, padding=1),    # 56->112
            nn.ReLU(inplace=True),
            nn.ConvTranspose2d(32, input_channels, kernel_size=4, stride=2, padding=1),  # 112->224
            nn.Sigmoid()  # 输出范围 [0,1]
        )
    
    def forward(self, x):
        encoded = self.encoder(x)
        decoded = self.decoder(encoded)
        return decoded

class DeepAnomalyDetector:
    """
    深度异常检测器
    """
    def __init__(self, input_size=(3, 224, 224), learning_rate=1e-4, device=None):
        self.device = device or torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        self.model = ConvolutionalAutoencoder(input_size[0]).to(self.device)
        self.optimizer = optim.Adam(self.model.parameters(), lr=learning_rate)
        self.criterion = nn.MSELoss()
        self.input_size = input_size
        self.threshold = None
    
    def train(self, normal_images, epochs=100, batch_size=32):
        """
        训练自编码器 (仅使用正常样本)
        """
        # 准准备数据
        transform = transforms.Compose([
            transforms.ToTensor(),
            transforms.Resize(self.input_size[1:]),
            transforms.Normalize(mean=[0.485, 0.456, 0.406], 
                               std=[0.229, 0.224, 0.225])
        ])
        
        # 转换图像
        processed_images = []
        for img in normal_images:
            if isinstance(img, np.ndarray):
                img = torch.from_numpy(img).permute(2, 0, 1).float() / 255.0
            processed_img = transform(img)
            processed_images.append(processed_img)
        
        dataset = TensorDataset(torch.stack(processed_images))
        dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
        
        # 训练循环
        self.model.train()
        for epoch in range(epochs):
            total_loss = 0
            for batch_idx, (data,) in enumerate(dataloader):
                data = data.to(self.device)
                
                # 前向传播
                reconstructed = self.model(data)
                loss = self.criterion(reconstructed, data)
                
                # 反向传播
                self.optimizer.zero_grad()
                loss.backward()
                self.optimizer.step()
                
                total_loss += loss.item()
            
            avg_loss = total_loss / len(dataloader)
            if epoch % 10 == 0:
                print(f"Epoch [{epoch}/{epochs}], Loss: {avg_loss:.6f}")
    
    def calculate_threshold(self, normal_images, percentile=95):
        """
        计算异常检测阈值
        """
        errors = []
        self.model.eval()
        
        with torch.no_grad():
            for img in normal_images:
                if isinstance(img, np.ndarray):
                    img = torch.from_numpy(img).permute(2, 0, 1).float() / 255.0
                img_tensor = transforms.Resize(self.input_size[1:])(img).unsqueeze(0).to(self.device)
                
                reconstructed = self.model(img_tensor)
                error = torch.mean((reconstructed - img_tensor) ** 2).item()
                errors.append(error)
        
        # 使用百分位数作为阈值
        self.threshold = np.percentile(errors, percentile)
        print(f"计算得出的阈值: {self.threshold:.6f}")
    
    def detect(self, images):
        """
        检测缺陷
        """
        if self.threshold is None:
            raise ValueError("必须先调用 calculate_threshold 方法计算阈值")
        
        results = []
        self.model.eval()
        
        with torch.no_grad():
            for img in images:
                if isinstance(img, np.ndarray):
                    img = torch.from_numpy(img).permute(2, 0, 1).float() / 255.0
                img_tensor = transforms.Resize(self.input_size[1:])(img).unsqueeze(0).to(self.device)
                
                reconstructed = self.model(img_tensor)
                error = torch.mean((reconstructed - img_tensor) ** 2).item()
                
                is_defective = error > self.threshold
                results.append({
                    'is_defective': is_defective,
                    'reconstruction_error': error,
                    'confidence': min(error / self.threshold, 2.0)  # 归一化置信度
                })
        
        return results

def deep_learning_anomaly_detection():
    """
    深度学习异常检测示例
    """
    print("深度学习异常检测示例:")
    print("""
# 初始化检测器
detector = DeepAnomalyDetector(input_size=(3, 224, 224))

# 训练 (使用正常产品图像)
detector.train(normal_images, epochs=50)

# 计算阈值
detector.calculate_threshold(normal_images, percentile=95)

# 检测新图像
results = detector.detect(test_images)

# 解释结果
for i, result in enumerate(results):
    if result['is_defective']:
        print(f"图像 {i} 检测到缺陷 (重建误差: {result['reconstruction_error']:.4f})")
    else:
        print(f"图像 {i} 正常 (重建误差: {result['reconstruction_error']:.4f})")
""")

deep_learning_anomaly_detection()

class VariationalAutoencoder(nn.Module):
    """
    变分自编码器用于异常检测
    """
    def __init__(self, input_dim=224*224*3, hidden_dim=512, latent_dim=128):
        super(VariationalAutoencoder, self).__init__()
        
        self.input_dim = input_dim
        self.latent_dim = latent_dim
        
        # 编码器
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU()
        )
        
        # 潜在空间参数
        self.fc_mu = nn.Linear(hidden_dim, latent_dim)
        self.fc_logvar = nn.Linear(hidden_dim, latent_dim)
        
        # 解码器
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, input_dim),
            nn.Sigmoid()
        )
    
    def encode(self, x):
        h = self.encoder(x.view(-1, self.input_dim))
        return self.fc_mu(h), self.fc_logvar(h)
    
    def reparameterize(self, mu, logvar):
        std = torch.exp(0.5 * logvar)
        eps = torch.randn_like(std)
        return mu + eps * std
    
    def decode(self, z):
        return self.decoder(z).view(-1, 3, 224, 224)
    
    def forward(self, x):
        mu, logvar = self.encode(x)
        z = self.reparameterize(mu, logvar)
        recon_x = self.decode(z)
        return recon_x, mu, logvar

def vae_loss_function(recon_x, x, mu, logvar):
    """
    VAE损失函数 (重建损失 + KL散度)
    """
    BCE = nn.functional.binary_cross_entropy(recon_x.view(-1, 224*224*3), 
                                           x.view(-1, 224*224*3), reduction='sum')
    
    KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
    
    return BCE + KLD

def vae_anomaly_detection_principle():
    """
    VAE异常检测原理
    """
    print("VAE异常检测原理:")
    print("• 潜在空间: 学习数据的低维表示")
    print("• 重建能力: 正常样本能很好重建")
    print("• 概率建模: 学习数据分布")
    print("• 异常识别: 异常样本重建误差大")

vae_anomaly_detection_principle()

class Discriminator(nn.Module):
    """
    GAN判别器用于异常检测
    """
    def __init__(self, input_channels=3):
        super(Discriminator, self).__init__()
        
        self.model = nn.Sequential(
            nn.Conv2d(input_channels, 32, kernel_size=4, stride=2, padding=1),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(32, 64, kernel_size=4, stride=2, padding=1),
            nn.BatchNorm2d(64),
            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.AdaptiveAvgPool2d(1),
            nn.Flatten(),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )
    
    def forward(self, x):
        return self.model(x)

def gan_based_anomaly_detection():
    """
    GAN基础异常检测
    """
    print("GAN基础异常检测:")
    print("• 训练判别器: 识别真实样本")
    print("• 异常样本: 判别器给出低概率")
    print("• 无需生成器: 仅使用判别器")
    print("• 适应性强: 能处理复杂模式")

gan_based_anomaly_detection()

class IndustrialDefectDetectionSystem:
    """
    完整的工业缺陷检测系统
    """
    def __init__(self, detection_method='autoencoder', image_size=(224, 224)):
        self.detection_method = detection_method
        self.image_size = image_size
        self.detector = None
        self.preprocessor = ImagePreprocessor(image_size)
        self.results_db = ResultsDatabase()
        
    def setup_detector(self, **kwargs):
        """
        设置检测器
        """
        if self.detection_method == 'autoencoder':
            self.detector = DeepAnomalyDetector(
                input_size=(3,) + self.image_size,
                **kwargs
            )
        elif self.detection_method == 'traditional':
            self.detector = TraditionalAnomalyDetector(**kwargs)
        else:
            raise ValueError(f"Unsupported detection method: {self.detection_method}")
    
    def train(self, normal_images, epochs=50):
        """
        训练检测器
        """
        print("开始训练检测器...")
        
        if hasattr(self.detector, 'train'):
            self.detector.train(normal_images, epochs=epochs)
        
        # 如果是深度学习方法，还需要计算阈值
        if hasattr(self.detector, 'calculate_threshold'):
            self.detector.calculate_threshold(normal_images)
        
        print("训练完成!")
    
    def detect_single_image(self, image_path):
        """
        检测单张图像
        """
        # 预处理
        image = self.preprocessor.preprocess_image(image_path)
        
        # 检测
        if hasattr(self.detector, 'detect'):
            results = self.detector.detect([image])
            result = results[0]
        else:
            predictions, scores = self.detector.predict([image])
            result = {
                'is_defective': predictions[0] == -1,
                'anomaly_score': abs(scores[0]),
                'confidence': abs(scores[0])
            }
        
        # 保存结果
        self.results_db.save_result(image_path, result)
        
        return result
    
    def detect_batch(self, image_paths):
        """
        批量检测
        """
        results = []
        for img_path in image_paths:
            result = self.detect_single_image(img_path)
            results.append({'image_path': img_path, 'result': result})
        
        return results
    
    def detect_video_stream(self, video_source, callback=None):
        """
        实时视频流检测
        """
        import cv2
        
        cap = cv2.VideoCapture(video_source)
        
        while cap.isOpened():
            ret, frame = cap.read()
            if not ret:
                break
            
            # 预处理
            processed_frame = self.preprocessor.preprocess_frame(frame)
            
            # 检测
            result = self.detector.detect([processed_frame])[0]
            
            # 可视化结果
            if result['is_defective']:
                cv2.putText(frame, "DEFECT DETECTED!", (50, 50), 
                           cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
            else:
                cv2.putText(frame, "OK", (50, 50), 
                           cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            
            # 显示结果
            cv2.imshow('Defect Detection', frame)
            
            if callback:
                callback(result, frame)
            
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
        
        cap.release()
        cv2.destroyAllWindows()

class ImagePreprocessor:
    """
    图像预处理器
    """
    def __init__(self, target_size=(224, 224)):
        self.target_size = target_size
        self.transform = transforms.Compose([
            transforms.ToPILImage() if isinstance(target_size, tuple) else lambda x: x,
            transforms.Resize(target_size),
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406], 
                               std=[0.229, 0.224, 0.225])
        ])
    
    def preprocess_image(self, image_path):
        """
        预处理图像
        """
        image = cv2.imread(image_path)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        image = cv2.resize(image, self.target_size)
        return image
    
    def preprocess_frame(self, frame):
        """
        预处理视频帧
        """
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        frame = cv2.resize(frame, self.target_size)
        return frame

class ResultsDatabase:
    """
    结果数据库
    """
    def __init__(self, db_path="defect_detection_results.db"):
        self.db_path = db_path
        self.init_database()
    
    def init_database(self):
        """
        初始化数据库
        """
        import sqlite3
        
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS detection_results (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                image_path TEXT NOT NULL,
                is_defective BOOLEAN NOT NULL,
                confidence REAL,
                detection_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                reconstruction_error REAL
            )
        ''')
        
        conn.commit()
        conn.close()
    
    def save_result(self, image_path, result):
        """
        保存检测结果
        """
        import sqlite3
        from datetime import datetime
        
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            INSERT INTO detection_results 
            (image_path, is_defective, confidence, reconstruction_error)
            VALUES (?, ?, ?, ?)
        ''', (
            image_path,
            result.get('is_defective', False),
            result.get('confidence', 0.0),
            result.get('reconstruction_error', 0.0)
        ))
        
        conn.commit()
        conn.close()

def system_usage_example():
    """
    系统使用示例
    """
    print("工业缺陷检测系统使用示例:")
    print("""
# 初始化系统
system = IndustrialDefectDetectionSystem(detection_method='autoencoder')

# 设置检测器
system.setup_detector(learning_rate=1e-4)

# 训练 (使用正常产品图像)
system.train(normal_images, epochs=50)

# 检测单张图像
result = system.detect_single_image('product_image.jpg')
if result['is_defective']:
    print("检测到缺陷!")
else:
    print("产品合格!")

# 批量检测
results = system.detect_batch(['img1.jpg', 'img2.jpg', 'img3.jpg'])

# 实时检测
system.detect_video_stream(0)  # 使用摄像头
""")

system_usage_example()

def model_optimization_strategies():
    """
    模型优化策略
    """
    strategies = [
        "模型量化: INT8量化减少模型大小和推理时间",
        "知识蒸馏: 用大模型训练小模型提高效率",
        "模型剪枝: 移除冗余连接减少计算量",
        "神经架构搜索: 自动设计高效网络结构",
        "硬件加速: 使用GPU、TPU、NPU加速推理",
        "批处理优化: 优化批处理大小提高吞吐量"
    ]
    
    print("模型优化策略:")
    for strategy in strategies:
        print(f"• {strategy}")

model_optimization_strategies()

def deployment_solutions():
    """
    部署方案
    """
    solutions = {
        "边缘设备": "树莓派、Jetson Nano等嵌入式设备",
        "工业PC": "工厂环境下的专用检测设备",
        "云端服务": "弹性扩展，适合大规模部署",
        "混合部署": "边缘+云端协同工作",
        "容器化": "Docker容器便于管理和扩展"
    }
    
    print("部署方案:")
    for solution, desc in solutions.items():
        print(f"• {solution}: {desc}")

deployment_solutions()

from sklearn.metrics import precision_score, recall_score, f1_score, confusion_matrix

def evaluation_metrics():
    """
    缺陷检测评估指标
    """
    metrics = {
        "准确率 (Accuracy)": "正确分类的样本占比",
        "精确率 (Precision)": "预测为缺陷中真正缺陷的比例",
        "召回率 (Recall)": "实际缺陷中被检出的比例", 
        "F1分数": "精确率和召回率的调和平均",
        "AUC-ROC": "受试者工作特征曲线下面积",
        "误报率 (FPR)": "正常样本被误判为缺陷的比例",
        "漏报率 (FNR)": "缺陷样本被漏检的比例"
    }
    
    print("缺陷检测评估指标:")
    for metric, desc in metrics.items():
        print(f"• {metric}: {desc}")

evaluation_metrics()

def calculate_metrics(y_true, y_pred):
    """
    计算评估指标
    """
    accuracy = (y_true == y_pred).mean()
    precision = precision_score(y_true, y_pred)
    recall = recall_score(y_true, y_pred)
    f1 = f1_score(y_true, y_pred)
    cm = confusion_matrix(y_true, y_pred)
    
    return {
        'accuracy': accuracy,
        'precision': precision,
        'recall': recall,
        'f1_score': f1,
        'confusion_matrix': cm
    }

def quality_control_measures():
    """
    质量控制措施
    """
    measures = [
        "数据质量: 确保训练数据质量和多样性",
        "模型验证: 使用交叉验证评估泛化能力",
        "A/B测试: 对比不同模型的效果",
        "持续监控: 监控模型性能变化",
        "反馈循环: 收集误检样本持续优化",
        "基准测试: 与人工检测结果对比验证"
    ]
    
    print("质量控制措施:")
    for measure in measures:
        print(f"• {measure}")

quality_control_measures()

def electronics_manufacturing_case():
    """
    电子制造缺陷检测案例
    """
    print("电子制造缺陷检测:")
    print("• PCB缺陷检测: 焊点不良、元件缺失、线路断裂")
    print("• 芯片外观检测: 表面划伤、封装缺陷")
    print("• 组装质量检测: 元件位置、焊接质量")
    print("• 挑战: 高精度要求、复杂纹理背景")

electronics_manufacturing_case()

def automotive_manufacturing_case():
    """
    汽车制造缺陷检测案例
    """
    print("汽车制造缺陷检测:")
    print("• 涂装质量检测: 划痕、气泡、色差")
    print("• 焊接质量检测: 焊缝缺陷、虚焊")
    print("• 零部件检测: 尺寸偏差、表面缺陷")
    print("• 挑战: 大尺寸检测、光照变化")

automotive_manufacturing_case()