计算机视觉基础、模型架构与实战开发指南

2.2 图像增强与滤波

为了提升模型效果，往往需要对图像进行增强。直方图均衡化能有效改善对比度不足的问题；而平滑滤波（如均值、高斯、中值滤波）则是去除噪声的标准手段。

边缘检测也是滤波的重要应用，Sobel 算子和 Canny 算法能精准定位物体轮廓。

import cv2
import numpy as np

def histogram_equalization(image):
    """直方图均衡化"""
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    equalized_image = cv2.equalizeHist(gray_image)
    return equalized_image

def mean_filter(image, kernel_size=3):
    """均值滤波"""
    blurred_image = cv2.blur(image, (kernel_size, kernel_size))
    return blurred_image

def gaussian_filter(image, kernel_size=3, sigma=0):
    """高斯滤波"""
    blurred_image = cv2.GaussianBlur(image, (kernel_size, kernel_size), sigma)
    return blurred_image

def median_filter(image, kernel_size=3):
    """中值滤波"""
    blurred_image = cv2.medianBlur(image, kernel_size)
    return blurred_image

def sobel_edge_detection(image):
    """Sobel 边缘检测"""
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    sobel_x = cv2.Sobel(gray_image, cv2.CV_64F, 1, 0, ksize=3)
    sobel_y = cv2.Sobel(gray_image, cv2.CV_64F, 0, 1, ksize=3)
    sobel_combined = np.sqrt(sobel_x**2 + sobel_y**2)
    sobel_combined = np.uint8(sobel_combined / np.max(sobel_combined) * 255)
    return sobel_combined

def canny_edge_detection(image, threshold1=100, threshold2=200):
    """Canny 边缘检测"""
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    edges = cv2.Canny(gray_image, threshold1, threshold2)
    return edges

三、特征提取方法

在深度学习普及之前，传统特征提取依然有其价值。HOG（方向梯度直方图）、SIFT（尺度不变特征变换）和 ORB（快速 FAST 与 BRIEF）是三大经典算法。

它们各自擅长不同的场景：HOG 对人形检测效果好，SIFT 具有旋转和尺度不变性，而 ORB 则胜在速度快且免费（专利问题）。

import cv2
import numpy as np

def extract_hog_features(image):
    """HOG 特征提取"""
    hog = cv2.HOGDescriptor()
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    features = hog.compute(gray_image)
    return features

def extract_sift_features(image):
    """SIFT 特征提取"""
    sift = cv2.SIFT_create()
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    keypoints, descriptors = sift.detectAndCompute(gray_image, None)
    return keypoints, descriptors

def extract_orb_features(image):
    """ORB 特征提取"""
    orb = cv2.ORB_create()
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    keypoints, descriptors = orb.detectAndCompute(gray_image, None)
    return keypoints, descriptors

四、主流模型架构演进

从早期的 LeNet 到如今强大的 YOLO 系列，深度学习模型不断迭代。

• LeNet/AlexNet/VGG：奠定了卷积神经网络的基础。
• ResNet：引入残差连接，解决了深层网络梯度消失问题，让网络可以更深。
• YOLO：实现了单阶段目标检测，速度极快，适合实时应用。

训练一个 ResNet 模型通常涉及数据加载、模型微调、损失函数优化等步骤。以下是一个基于 PyTorch 的完整训练流程示例：

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

def train_resnet_model(data_dir, num_classes=2, batch_size=32, num_epochs=10, lr=0.001):
    # 数据预处理
    data_transforms = {
        'train': transforms.Compose([
            transforms.RandomResizedCrop(224),
            transforms.RandomHorizontalFlip(),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ]),
        'val': transforms.Compose([
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ])
    }

    # 加载数据
    image_datasets = {x: datasets.ImageFolder(f'{data_dir}/{x}', data_transforms[x]) for x in ['train', 'val']}
    dataloaders = {x: DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True, num_workers=4) for x in ['train', 'val']}
    dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
    class_names = image_datasets['train'].classes

    # 加载模型
    model = models.resnet18(pretrained=True)
    num_ftrs = model.fc.in_features
    model.fc = nn.Linear(num_ftrs, num_classes)

    # 定义损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9)
    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)

    # 训练模型
    for epoch in range(num_epochs):
        print(f'Epoch {epoch}/{num_epochs - 1}')
        print('-' * 10)
        for phase in ['train', 'val']:
            if phase == 'train':
                model.train()
            else:
                model.eval()
            
            running_loss = 0.0
            running_corrects = 0
            
            for inputs, labels in dataloaders[phase]:
                optimizer.zero_grad()
                
                with torch.set_grad_enabled(phase == 'train'):
                    outputs = model(inputs)
                    _, preds = torch.max(outputs, 1)
                    loss = criterion(outputs, labels)
                    
                    if phase == 'train':
                        loss.backward()
                        optimizer.step()
            
            running_loss += loss.item() * inputs.size(0)
            running_corrects += torch.sum(preds == labels.data)
        
        if phase == 'train':
            scheduler.step()
        
        epoch_loss = running_loss / dataset_sizes[phase]
        epoch_acc = running_corrects.double() / dataset_sizes[phase]
        print(f'{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')
    
    print('Training complete')
    return model

五、实战项目：桌面端 CV 应用开发

理论最终要服务于实践。这里我们构建一个简单的桌面应用，集成图像分类和目标检测功能。

5.1 环境准备

我们需要安装必要的库：

pip install opencv-python pillow torch torchvision tkinter

5.2 核心功能实现

界面部分使用 Tkinter，后端调用 PyTorch 模型。

图像输入模块负责文件选择和预览：

import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageTk

class ImageInputFrame(tk.Frame):
    def __init__(self, parent, on_image_selected):
        tk.Frame.__init__(self, parent)
        self.parent = parent
        self.on_image_selected = on_image_selected
        self.create_widgets()

    def create_widgets(self):
        self.image_label = tk.Label(self)
        self.image_label.pack(pady=10, padx=10, fill="both", expand=True)
        
        tk.Button(self, text="选择图像", command=self.select_image).pack(pady=10, padx=10)

    def select_image(self):
        file_path = filedialog.askopenfilename(filetypes=[("Image Files", "*.png *.jpg *.jpeg *.bmp")])
        if file_path:
            image = Image.open(file_path)
            image = image.resize((400, 300), Image.ANTIALIAS)
            photo = ImageTk.PhotoImage(image)
            self.image_label.configure(image=photo)
            self.image_label.image = photo
            self.on_image_selected(file_path)

图像分类逻辑：

import torch
from torchvision import transforms, models
from PIL import Image

def classify_image(image_path, model_path, class_names):
    data_transforms = transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ])
    
    image = Image.open(image_path)
    image = data_transforms(image)
    image = image.unsqueeze(0)
    
    model = models.resnet18()
    num_ftrs = model.fc.in_features
    model.fc = torch.nn.Linear(num_ftrs, len(class_names))
    model.load_state_dict(torch.load(model_path))
    model.eval()
    
    with torch.no_grad():
        outputs = model(image)
        _, preds = torch.max(outputs, 1)
    
    return class_names[preds[0]]

目标检测逻辑（以 Faster R-CNN 为例）：

import cv2
import numpy as np
import torch
from torchvision import transforms, models
from PIL import Image

def detect_objects(image_path, model_path, class_names):
    image = cv2.imread(image_path)
    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    image_pil = Image.fromarray(image_rgb)
    
    data_transforms = transforms.Compose([
        transforms.Resize((416, 416)),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ])
    
    image_tensor = data_transforms(image_pil)
    image_tensor = image_tensor.unsqueeze(0)
    
    model = models.detection.fasterrcnn_resnet50_fpn(pretrained=False)
    in_features = model.roi_heads.box_predictor.cls_score.in_features
    model.roi_heads.box_predictor = models.detection.faster_rcnn.FastRCNNPredictor(in_features, len(class_names))
    model.load_state_dict(torch.load(model_path))
    model.eval()
    
    with torch.no_grad():
        outputs = model(image_tensor)
    
    boxes = outputs[0]['boxes'].cpu().numpy()
    scores = outputs[0]['scores'].cpu().numpy()
    labels = outputs[0]['labels'].cpu().numpy()
    
    for i in range(len(boxes)):
        if scores[i] > 0.5:
            box = boxes[i].astype(int)
            label = class_names[labels[i]]
            score = scores[i]
            cv2.rectangle(image, (box[0], box[1]), (box[2], box[3]), (0, 255, 0), 2)
            cv2.putText(image, f"{label}: {score:.2f}", (box[0], box[1]-10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
    
    return image

结果展示与主程序： 将上述模块整合到一个 Tkinter 窗口中，即可实现完整的交互体验。用户只需选择图片、勾选功能（分类或检测），系统便会返回结果并可视化绘制框线。

六、总结

计算机视觉技术正在飞速发展。从传统的图像处理到现代深度学习，每一步都建立在扎实的数学与工程基础之上。通过本文的学习，希望你能掌握从数据预处理、特征提取到模型训练的全流程，并能独立搭建简单的视觉应用。

记住，最好的学习方式永远是动手实践。尝试修改上面的代码参数，加载你自己的数据集，你会发现更多有趣的细节。