#计算机视觉（CV）面试与实战红宝书

import cv2
import numpy as np
import matplotlib.pyplot as plt

def color_space_conversion():
    """
    颜色空间转换示例
    """
    # 读取图像
    image = cv2.imread('sample.jpg')
    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # RGB颜色空间
    # 基于三原色叠加，符合显示器原理，但通道间耦合度高，不适合提取特征
    rgb_channels = cv2.split(image_rgb)
    
    # HSV颜色空间
    # 色调（H）、饱和度（S）、亮度（V）
    # 常用场景：通过H通道进行颜色分割（如识别绿幕、红色交通标志）
    hsv_image = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2HSV)
    h, s, v = cv2.split(hsv_image)
    
    # 灰度图
    # 单通道，去除色彩干扰，保留结构和亮度信息，降低计算量
    gray_image = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2GRAY)
    
    print("颜色空间转换完成")
    print(f"RGB形状: {image_rgb.shape}")
    print(f"HSV形状: {hsv_image.shape}")
    print(f"灰度图形状: {gray_image.shape}")

color_space_conversion()

def color_segmentation_example():
    """
    基于HSV的颜色分割示例
    """
    image = cv2.imread('traffic_sign.jpg')
    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    hsv = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2HSV)
    
    # 定义红色范围
    lower_red = np.array([0, 50, 50])
    upper_red = np.array([10, 255, 255])
    mask1 = cv2.inRange(hsv, lower_red, upper_red)
    
    # 定义红色范围（环绕0度）
    lower_red = np.array([170, 50, 50])
    upper_red = np.array([180, 255, 255])
    mask2 = cv2.inRange(hsv, lower_red, upper_red)
    
    # 合并掩码
    mask = mask1 + mask2
    
    # 应用掩码
    result = cv2.bitwise_and(image_rgb, image_rgb, mask=mask)
    
    return result

print("颜色分割示例完成")

def histogram_equalization():
    """
    直方图均衡化原理与实现
    """
    image = cv2.imread('low_contrast.jpg', 0)  # 灰度图
    
    # 传统直方图均衡化
    equalized = cv2.equalizeHist(image)
    
    # 自适应直方图均衡化 (CLAHE)
    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
    adaptive_equalized = clahe.apply(image)
    
    print("直方图均衡化完成")
    print(f"原始图像形状: {image.shape}")
    print(f"均衡化后图像形状: {equalized.shape}")
    
    # 原理：通过累积分布函数（CDF）将分布集中的直方图拉伸，
    # 使其在[0, 255]范围内均匀分布
    # 作用：增强图像对比度，尤其是处理过暗或过亮的场景

histogram_equalization()

def filtering_techniques():
    """
    三种主要滤波技术
    """
    image = cv2.imread('noisy_image.jpg')
    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # 高斯滤波：权重符合高斯分布，平滑图像
    # 缺点：会模糊边缘
    gaussian_filtered = cv2.GaussianBlur(image_rgb, (15, 15), 0)
    
    # 中值滤波：取窗口中值
    # 特长：完美去除椒盐噪声，保护边缘能力强
    median_filtered = cv2.medianBlur(image_rgb, 15)
    
    # 双边滤波：不仅考虑空间距离，还考虑像素值差异
    # 特长：保边去噪（磨皮美颜的核心算法）
    bilateral_filtered = cv2.bilateralFilter(image_rgb, 9, 75, 75)
    
    print("滤波技术应用完成")
    
    # 不同噪声类型对应不同滤波器
    def add_salt_pepper_noise(image, prob=0.01):
        """添加椒盐噪声"""
        output = np.copy(image)
        noise_prob = prob / 2
        
        # 椒盐噪声
        salt_coords = [np.random.randint(0, i - 1, int(noise_prob * image.size))
                      for i in image.shape]
        output[salt_coords[0], salt_coords[1], :] = 255
        
        pepper_coords = [np.random.randint(0, i - 1, int(noise_prob * image.size))
                        for i in image.shape]
        output[pepper_coords[0], pepper_coords[1], :] = 0
        
        return output
    
    def add_gaussian_noise(image, mean=0, var=0.01):
        """添加高斯噪声"""
        row, col, ch = image.shape
        sigma = var**0.5
        gauss = np.random.normal(mean, sigma, (row, col, ch))
        gauss = gauss.reshape(row, col, ch)
        noisy = image + gauss
        return np.clip(noisy, 0, 255).astype(np.uint8)

filtering_techniques()

def edge_detection_and_features():
    """
    边缘检测和传统特征提取
    """
    image = cv2.imread('edge_sample.jpg', 0)
    
    # Canny边缘检测步骤：
    # 1. 高斯去噪 → 2. 计算梯度方向 → 3. 非极大值抑制（变瘦） → 4. 双阈值检测（滞后阈值连接边缘）
    canny_edges = cv2.Canny(image, 50, 150)
    
    # SIFT vs ORB 特征比较
    def compare_features():
        """
        SIFT vs ORB 特征提取比较
        """
        img = cv2.imread('feature_sample.jpg')
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        
        # SIFT特征：具有旋转、尺度、亮度不变性，精度高
        # 缺点：速度慢、有专利
        try:
            sift = cv2.SIFT_create()
            kp_sift, des_sift = sift.detectAndCompute(gray, None)
            print(f"SIFT特征点数量: {len(kp_sift) if kp_sift is not None else 0}")
        except:
            print("SIFT不可用（可能因专利问题）")
        
        # ORB特征：FAST特征点 + BRIEF描述子
        # 优点：速度极快（实时），开源
        # 缺点：对尺度缩放稍弱
        orb = cv2.ORB_create()
        kp_orb, des_orb = orb.detectAndCompute(gray, None)
        print(f"ORB特征点数量: {len(kp_orb) if kp_orb is not None else 0}")
        
        # RANSAC（随机采样一致性）：在特征匹配中，通过不断随机抽样
        # 排除误匹配点（离群点），计算出最稳健的单应矩阵
        def ransac_homography_demo():
            """
            RANSAC单应性矩阵计算示例
            """
            # 这里简化示例，实际应用中需要特征匹配
            pass
        
        ransac_homography_demo()
    
    compare_features()
    
    print("边缘检测和特征提取完成")

edge_detection_and_features()

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

class CNNBasics:
    """
    CNN基础原理实现
    """
    
    def convolution_principle(self):
        """
        卷积的作用：局部感知、参数共享
        提取的是局部空间特征（由浅入深：边缘 → 纹理 → 目标）
        """
        # 模拟卷积操作
        input_tensor = torch.randn(1, 3, 32, 32)  # (batch, channels, height, width)
        conv_layer = nn.Conv2d(3, 16, kernel_size=3, padding=1)  # 16个3x3卷积核
        
        output = conv_layer(input_tensor)
        print(f"输入形状: {input_tensor.shape}")
        print(f"输出形状: {output.shape}")
        print("卷积层参数数量:", sum(p.numel() for p in conv_layer.parameters()))
    
    def one_by_one_convolution(self):
        """
        1×1 卷积：跨通道特征融合、改变通道数（降维/升维）、增加非线性
        """
        input_tensor = torch.randn(1, 64, 32, 32)
        
        # 降维：64通道 -> 16通道
        reduce_conv = nn.Conv2d(64, 16, kernel_size=1)
        reduced = reduce_conv(input_tensor)
        
        # 升维：16通道 -> 128通道
        expand_conv = nn.Conv2d(16, 128, kernel_size=1)
        expanded = expand_conv(reduced)
        
        print(f"1x1卷积 - 降维: {input_tensor.shape} -> {reduced.shape}")
        print(f"1x1卷积 - 升维: {reduced.shape} -> {expanded.shape}")
    
    def batch_normalization_demo(self):
        """
        BatchNorm (BN)：将每一层输入标准化为均值0方差1
        作用：防止梯度消失、加快收敛、允许更大的学习率
        """
        input_tensor = torch.randn(32, 64, 28, 28)  # (batch, channels, height, width)
        bn_layer = nn.BatchNorm2d(64)
        
        output = bn_layer(input_tensor)
        print(f"BN前后形状: {input_tensor.shape} -> {output.shape}")
        print(f"BN前均值: {input_tensor.mean():.4f}, 标准差: {input_tensor.std():.4f}")
        print(f"BN后均值: {output.mean():.4f}, 标准差: {output.std():.4f}")

def activation_functions_comparison():
    """
    激活函数比较
    """
    x = torch.linspace(-3, 3, 100)
    
    # ReLU：解决梯度消失，计算快，但会导致神经元"坏死"（Dead ReLU）
    relu_output = F.relu(x)
    
    # LeakyReLU：给负半轴一点点斜率，防止死区
    leaky_relu_output = F.leaky_relu(x, negative_slope=0.01)
    
    # GELU：引入了随机性思想，Transformer模型标配
    gelu_output = F.gelu(x)
    
    print("激活函数比较完成")
    print("ReLU特点: 计算简单，梯度恒定，但负半轴梯度为0")
    print("LeakyReLU特点: 解决ReLU死区问题")
    print("GELU特点: 结合了ReLU和Dropout的思想，性能优秀")

cnn_basics = CNNBasics()
cnn_basics.convolution_principle()
cnn_basics.one_by_one_convolution()
cnn_basics.batch_normalization_demo()
activation_functions_comparison()

class ResBlock(nn.Module):
    """
    ResNet残差块：解决深层网络训练时的退化问题
    Identity Mapping保证网络至少不比前一层差
    """
    def __init__(self, in_channels, out_channels, stride=1):
        super(ResBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, 
                              stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, 
                              padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)
        
        # 跳跃连接
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=1, 
                         stride=stride, bias=False),
                nn.BatchNorm2d(out_channels)
            )
    
    def forward(self, x):
        residual = self.shortcut(x)
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out += residual  # 残差连接
        out = F.relu(out)
        return out

class DepthwiseSeparableConv(nn.Module):
    """
    MobileNet设计：采用深度可分离卷积（Depthwise + Pointwise）
    将计算量降至常规卷积的约1/9
    """
    def __init__(self, in_channels, out_channels, stride=1):
        super(DepthwiseSeparableConv, self).__init__()
        
        # 深度卷积：每个输入通道单独卷积
        self.depthwise = nn.Conv2d(in_channels, in_channels, kernel_size=3, 
                                  stride=stride, padding=1, groups=in_channels, bias=False)
        self.bn1 = nn.BatchNorm2d(in_channels)
        
        # 点卷积：1x1卷积融合通道信息
        self.pointwise = nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)
    
    def forward(self, x):
        x = F.relu(self.bn1(self.depthwise(x)))
        x = F.relu(self.bn2(self.pointwise(x)))
        return x

class InceptionModule(nn.Module):
    """
    Inception：通过多尺度卷积核（1x1, 3x3, 5x5）并行
    让网络决定哪种感受野更重要
    """
    def __init__(self, in_channels, out_1x1, red_3x3, out_3x3, red_5x5, out_5x5, pool_proj):
        super(InceptionModule, self).__init__()
        
        # 1x1卷积
        self.branch1 = nn.Conv2d(in_channels, out_1x1, kernel_size=1)
        
        # 1x1卷积 + 3x3卷积
        self.branch2 = nn.Sequential(
            nn.Conv2d(in_channels, red_3x3, kernel_size=1),
            nn.Conv2d(red_3x3, out_3x3, kernel_size=3, padding=1)
        )
        
        # 1x1卷积 + 5x5卷积
        self.branch3 = nn.Sequential(
            nn.Conv2d(in_channels, red_5x5, kernel_size=1),
            nn.Conv2d(red_5x5, out_5x5, kernel_size=5, padding=2)
        )
        
        # 池化 + 1x1卷积
        self.branch4 = nn.Sequential(
            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
            nn.Conv2d(in_channels, pool_proj, kernel_size=1)
        )
    
    def forward(self, x):
        branch1 = F.relu(self.branch1(x))
        branch2 = F.relu(self.branch2(x))
        branch3 = F.relu(self.branch3(x))
        branch4 = F.relu(self.branch4(x))
        
        return torch.cat([branch1, branch2, branch3, branch4], 1)

def architecture_comparison():
    """
    经典架构比较
    """
    print("ResNet特点:")
    print("- 提出残差结构，解决深层网络退化问题")
    print("- Identity Mapping保证网络至少不比前一层差")
    
    print("\nMobileNet特点:")
    print("- 采用深度可分离卷积，大幅减少参数量")
    print("- 计算量约为常规卷积的1/9")
    print("- 适合移动端部署")
    
    print("\nInception特点:")
    print("- 多尺度卷积核并行处理")
    print("- 让网络自适应选择最佳感受野")
    print("- 通过1x1卷积降维减少计算量")

architecture_comparison()

def object_detection_concepts():
    """
    目标检测核心概念
    """
    print("目标检测方法分类:")
    print("One-stage (YOLO/SSD): 直接回归，速度快，适合移动端部署")
    print("Two-stage (Faster R-CNN): 先找候选框（RPN），再分类，精度高，适合医疗、精密分析")
    
    print("\nNMS (非极大值抑制):")
    print("- 按得分排序，抑制与最高分框IOU过大的冗余框")
    print("- 缺点：密集物体遮挡时会误删真实目标")
    print("- 改进方案：Soft-NMS")
    
    print("\nmAP (mean Average Precision):")
    print("- 所有类别的平均准确率（Average Precision）的平均值")
    print("- 是目标检测的主要评价指标")

def nms_implementation():
    """
    NMS算法实现
    """
    def nms(boxes, scores, threshold):
        """
        非极大值抑制实现
        """
        # 按置信度排序
        indices = torch.argsort(scores, descending=True)
        
        keep = []
        while len(indices) > 0:
            # 保留置信度最高的框
            current = indices[0]
            keep.append(current)
            
            if len(indices) == 1:
                break
            
            # 计算其余框与当前框的IoU
            remaining = indices[1:]
            ious = compute_iou(boxes[current], boxes[remaining])
            
            # 删除IoU大于阈值的框
            indices = remaining[ious <= threshold]
        
        return torch.tensor(keep)
    
    def compute_iou(box, boxes):
        """
        计算IoU
        """
        # 计算交集
        xmin = torch.max(box[0], boxes[:, 0])
        ymin = torch.max(box[1], boxes[:, 1])
        xmax = torch.min(box[2], boxes[:, 2])
        ymax = torch.min(box[3], boxes[:, 3])
        
        intersection = torch.clamp(xmax - xmin, min=0) * torch.clamp(ymax - ymin, min=0)
        
        # 计算并集
        area_box = (box[2] - box[0]) * (box[3] - box[1])
        area_boxes = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
        union = area_box + area_boxes - intersection
        
        return intersection / union
    
    print("NMS算法实现完成")

object_detection_concepts()
nms_implementation()

def loss_functions_detailed():
    """
    损失函数详解
    """
    print("Focal Loss:")
    print("- 解决样本不平衡问题")
    print("- 通过降低易分类样本权重，让模型专注于难分类样本")
    print("- 目标检测中背景通常远多于前景")
    
    def focal_loss(inputs, targets, alpha=0.25, gamma=2.0):
        """
        Focal Loss实现
        """
        ce_loss = F.cross_entropy(inputs, targets, reduction='none')
        pt = torch.exp(-ce_loss)
        focal_loss = alpha * (1 - pt) ** gamma * ce_loss
        return focal_loss.mean()
    
    print("\nDice Loss:")
    print("- 专门用于语义分割")
    print("- 直接优化IOU，缓解前景像素占比过小的问题")
    
    def dice_loss(pred, target, smooth=1e-5):
        """
        Dice Loss实现
        """
        pred_flat = pred.view(-1)
        target_flat = target.view(-1)
        
        intersection = (pred_flat * target_flat).sum()
        dice_coeff = (2. * intersection + smooth) / (pred_flat.sum() + target_flat.sum() + smooth)
        return 1 - dice_coeff

def optimizer_comparison():
    """
    优化器比较
    """
    print("优化器选择:")
    print("SGD: 稳定但慢，容易陷入局部最优")
    print("Adam: 自适应学习率，收敛极快，通常是新手练手的首选")
    
    # 优化器参数设置示例
    model = nn.Linear(10, 1)
    
    # SGD优化器
    sgd_optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
    
    # Adam优化器
    adam_optimizer = torch.optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999))

loss_functions_detailed()
optimizer_comparison()

def model_acceleration_techniques():
    """
    模型加速技术详解
    """
    print("模型加速技术:")
    
    print("\n量化 (Quantization):")
    print("- 将FP32转为INT8")
    print("- 能极大提升推理速度，降低内存占用")
    print("- 实现示例:")
    
    def quantization_example():
        """
        量化示例
        """
        import torch.quantization as quant
        
        # 创建模型
        model = nn.Sequential(
            nn.Linear(100, 50),
            nn.ReLU(),
            nn.Linear(50, 10)
        )
        
        # 配置量化
        model.qconfig = quant.get_default_qconfig('fbgemm')
        
        # 准备量化
        model_prepared = quant.prepare(model, inplace=False)
        
        # 转换为量化模型
        model_quantized = quant.convert(model_prepared, inplace=False)
        
        print("量化模型转换完成")
        print(f"原模型大小: {sum(p.numel() for p in model.parameters()) * 4 / 1024 / 1024:.2f} MB")
        print(f"量化模型大小: {sum(p.numel() for p in model_quantized.parameters()) / 1024 / 1024:.2f} MB")
    
    print("\n知识蒸馏 (Knowledge Distillation):")
    print("- 教师模型（大模型）指导学生模型（小模型）")
    print("- 让小模型学会大模型的输出分布")
    
    def knowledge_distillation_example():
        """
        知识蒸馏示例
        """
        class TeacherModel(nn.Module):
            def __init__(self):
                super(TeacherModel, self).__init__()
                self.features = nn.Sequential(
                    nn.Linear(100, 256),
                    nn.ReLU(),
                    nn.Linear(256, 256),
                    nn.ReLU(),
                    nn.Linear(256, 128),
                    nn.ReLU()
                )
                self.classifier = nn.Linear(128, 10)
            
            def forward(self, x):
                x = self.features(x)
                return self.classifier(x)
        
        class StudentModel(nn.Module):
            def __init__(self):
                super(StudentModel, self).__init__()
                self.features = nn.Sequential(
                    nn.Linear(100, 64),
                    nn.ReLU(),
                    nn.Linear(64, 32),
                    nn.ReLU()
                )
                self.classifier = nn.Linear(32, 10)
            
            def forward(self, x):
                x = self.features(x)
                return self.classifier(x)
        
        print("知识蒸馏模型定义完成")
    
    print("\nTensorRT:")
    print("- NVIDIA闭源推理加速引擎")
    print("- 优化算子融合，是生产环境部署的标配")
    
    quantization_example()
    knowledge_distillation_example()

model_acceleration_techniques()

def performance_tuning():
    """
    性能调优指南
    """
    print("精度与速度定位:")
    
    print("\n速度慢问题排查:")
    print("- 检查IO瓶颈（图片预处理慢）")
    print("- 检查CPU预处理慢")
    print("- 检查GPU计算慢")
    print("- 检查频繁的数据搬运（cpu()和gpu()操作）")
    
    def speed_optimization_checklist():
        """
        速度优化检查清单
        """
        checklist = [
            "使用DataLoader的num_workers参数加速数据加载",
            "批量处理数据而不是单个处理",
            "减少CPU和GPU之间的数据传输",
            "使用更高效的图像处理库（如OpenCV而非PIL）",
            "考虑使用混合精度训练（fp16）"
        ]
        
        print("速度优化检查清单:")
        for item in checklist:
            print(f"• {item}")
    
    print("\n精度低问题排查:")
    print("- 检查数据增强是否过火")
    print("- 检查输入尺寸是否对齐训练尺寸")
    print("- 检查是否有严重的类别不平衡")
    
    def accuracy_improvement_checklist():
        """
        精度提升检查清单
        """
        checklist = [
            "检查数据预处理是否正确",
            "验证数据增强强度是否合适",
            "检查类别不平衡问题",
            "调整学习率和批次大小",
            "尝试不同的优化器和损失函数"
        ]
        
        print("精度提升检查清单:")
        for item in checklist:
            print(f"• {item}")
    
    speed_optimization_checklist()
    accuracy_improvement_checklist()

performance_tuning()

def calculation_formulas():
    """
    计算公式详解
    """
    print("输出尺寸计算公式:")
    print("H_out = floor((H_in + 2*P - K) / S) + 1")
    print("W_out = floor((W_in + 2*P - K) / S) + 1")
    print("(H:输入高, W:输入宽, P:填充, K:卷积核大小, S:步长)")
    
    def calculate_output_size(input_size, kernel_size, stride, padding):
        """
        计算输出尺寸
        """
        output_size = (input_size + 2 * padding - kernel_size) // stride + 1
        return output_size
    
    # 示例计算
    input_h, input_w = 224, 224
    kernel_size = 3
    stride = 1
    padding = 1
    
    output_h = calculate_output_size(input_h, kernel_size, stride, padding)
    output_w = calculate_output_size(input_w, kernel_size, stride, padding)
    
    print(f"\n示例计算:")
    print(f"输入尺寸: {input_h}x{input_w}")
    print(f"卷积核: {kernel_size}x{kernel_size}")
    print(f"步长: {stride}, 填充: {padding}")
    print(f"输出尺寸: {output_h}x{output_w}")
    
    print("\n感受野 (Receptive Field, RF):")
    print("- 层数越深，感受野越大")
    print("- 大的感受野有利于看清'全局大目标'")
    print("- 小的感受野有利于'局部细节'")
    
    def receptive_field_calculation():
        """
        感受野计算示例
        """
        # 计算多层卷积后的感受野
        # RF = 1 + sum((kernel_size - 1) * cumulative_stride)
        layer_configs = [
            {'kernel': 3, 'stride': 1, 'padding': 1},
            {'kernel': 3, 'stride': 1, 'padding': 1},
            {'kernel': 3, 'stride': 2, 'padding': 1},
            {'kernel': 3, 'stride': 1, 'padding': 1}
        ]
        
        rf = 1
        cumulative_stride = 1
        
        for i, config in enumerate(layer_configs):
            effective_kernel = config['kernel'] + (config['kernel'] - 1) * (cumulative_stride - 1)
            rf = rf + effective_kernel - 1
            cumulative_stride *= config['stride']
            
            print(f"第{i+1}层后 - 感受野: {rf}, 累积步长: {cumulative_stride}")
    
    receptive_field_calculation()
    
    print("\n噪声类型与处理方法:")
    print("椒盐噪声 vs 高斯噪声:")
    print("- 椒盐噪声：随机的黑白点，使用中值滤波")
    print("- 高斯噪声：像素值符合正态分布的波动，使用高斯滤波")

calculation_formulas()

def common_problem_solutions():
    """
    常见问题解决方案
    """
    problems = {
        "过拟合": {
            "症状": "训练集准确率很高，验证集准确率低",
            "解决方法": [
                "增加数据增强",
                "使用Dropout",
                "早停（Early Stopping）",
                "正则化（L1/L2）",
                "获取更多数据"
            ]
        },
        "欠拟合": {
            "症状": "训练集和验证集准确率都很低",
            "解决方法": [
                "增加模型复杂度",
                "减少正则化",
                "增加训练轮数",
                "调整学习率",
                "检查数据质量"
            ]
        },
        "梯度消失": {
            "症状": "深层网络难以训练，梯度接近零",
            "解决方法": [
                "使用残差连接",
                "使用Batch Normalization",
                "使用更好的激活函数（ReLU, GELU）",
                "梯度裁剪",
                "调整初始化方法"
            ]
        }
    }
    
    print("常见问题解决方案:")
    for problem, details in problems.items():
        print(f"\n{problem}:")
        print(f"  症状: {details['症状']}")
        print("  解决方法:")
        for method in details['解决方法']:
            print(f"    • {method}")

common_problem_solutions()

def deployment_best_practices():
    """
    模型部署最佳实践
    """
    practices = [
        "使用ONNX格式进行模型转换，提高跨平台兼容性",
        "采用模型量化技术减少模型大小和推理时间",
        "实现模型版本管理，便于回滚和实验追踪",
        "使用异步处理提高并发处理能力",
        "实现健康检查和监控机制",
        "考虑使用模型服务框架（如TensorFlow Serving、TorchServe）",
        "优化数据预处理流水线，减少I/O瓶颈"
    ]
    
    print("模型部署最佳实践:")
    for practice in practices:
        print(f"• {practice}")

deployment_best_practices()