图像分类：从传统方法到深度学习-平芜编程栈

图像分类：从传统方法到深度学习

1. 技术分析

1.1 图像分类技术演进

图像分类经历了从传统方法到深度学习的演进：

图像分类技术路线 传统方法: SIFT/SURF + SVM 深度学习: AlexNet → ResNet → ViT

1.2 分类方法对比

方法	特征提取	模型	效果	适用场景
SIFT + SVM	手工特征	传统模型	中	小规模
AlexNet	CNN	深度学习	高	中等规模
ResNet	残差CNN	深度学习	很高	大规模
ViT	Transformer	预训练	极高	大规模

1.3 图像分类指标

图像分类评估指标 Top-1 准确率: 最可能类别正确比例 Top-5 准确率: 前5个预测中包含正确类别 Confusion Matrix: 混淆矩阵

2. 核心功能实现

2.1 传统图像分类

import cv2 import numpy as np from sklearn.svm import SVC from sklearn.preprocessing import StandardScaler class SIFTClassifier: def __init__(self): self.sift = cv2.SIFT_create() self.svm = SVC() self.scaler = StandardScaler() def extract_features(self, image): gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) keypoints, descriptors = self.sift.detectAndCompute(gray, None) if descriptors is not None: return descriptors.mean(axis=0) else: return np.zeros(128) def train(self, images, labels): features = [self.extract_features(img) for img in images] features = np.array(features) features = self.scaler.fit_transform(features) self.svm.fit(features, labels) def predict(self, image): features = self.extract_features(image) features = self.scaler.transform([features]) return self.svm.predict(features)[0] class HOGClassifier: def __init__(self): self.hog = cv2.HOGDescriptor() self.svm = SVC() def extract_features(self, image): gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) features = self.hog.compute(gray) return features.flatten() def train(self, images, labels): features = [self.extract_features(img) for img in images] features = np.array(features) self.svm.fit(features, labels) def predict(self, image): features = self.extract_features(image) return self.svm.predict([features])[0]

2.2 CNN 图像分类

import torch import torch.nn as nn import torch.nn.functional as F class SimpleCNN(nn.Module): def __init__(self, num_classes=10): super().__init__() self.conv_layers = nn.Sequential( nn.Conv2d(3, 32, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(2, 2), nn.Conv2d(32, 64, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(2, 2), nn.Conv2d(64, 128, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(2, 2) ) self.fc_layers = nn.Sequential( nn.Linear(128 * 4 * 4, 512), nn.ReLU(), nn.Linear(512, num_classes) ) def forward(self, x): x = self.conv_layers(x) x = x.view(-1, 128 * 4 * 4) x = self.fc_layers(x) return x class AlexNet(nn.Module): def __init__(self, num_classes=1000): super().__init__() self.features = nn.Sequential( nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(64, 192, kernel_size=5, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(192, 384, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(256, 256, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2) ) self.classifier = nn.Sequential( nn.Dropout(), nn.Linear(256 * 6 * 6, 4096), nn.ReLU(inplace=True), nn.Dropout(), nn.Linear(4096, 4096), nn.ReLU(inplace=True), nn.Linear(4096, num_classes) ) def forward(self, x): x = self.features(x) x = x.view(-1, 256 * 6 * 6) x = self.classifier(x) return x

2.3 Vision Transformer 实现

class PatchEmbedding(nn.Module): def __init__(self, img_size=224, patch_size=16, in_channels=3, embed_dim=768): super().__init__() self.img_size = img_size self.patch_size = patch_size self.num_patches = (img_size // patch_size) ** 2 self.proj = nn.Conv2d(in_channels, embed_dim, kernel_size=patch_size, stride=patch_size) def forward(self, x): x = self.proj(x) x = x.flatten(2).transpose(1, 2) return x class TransformerBlock(nn.Module): def __init__(self, embed_dim, num_heads, mlp_ratio=4.0): super().__init__() self.norm1 = nn.LayerNorm(embed_dim) self.attn = nn.MultiheadAttention(embed_dim, num_heads) self.norm2 = nn.LayerNorm(embed_dim) mlp_dim = int(embed_dim * mlp_ratio) self.mlp = nn.Sequential( nn.Linear(embed_dim, mlp_dim), nn.GELU(), nn.Linear(mlp_dim, embed_dim) ) def forward(self, x): x = x + self.attn(self.norm1(x), self.norm1(x), self.norm1(x))[0] x = x + self.mlp(self.norm2(x)) return x class ViT(nn.Module): def __init__(self, img_size=224, patch_size=16, in_channels=3, embed_dim=768, num_heads=12, num_layers=12, num_classes=1000): super().__init__() self.patch_embed = PatchEmbedding(img_size, patch_size, in_channels, embed_dim) self.cls_token = nn.Parameter(torch.randn(1, 1, embed_dim)) num_patches = self.patch_embed.num_patches self.pos_embed = nn.Parameter(torch.randn(1, num_patches + 1, embed_dim)) self.blocks = nn.Sequential(*[ TransformerBlock(embed_dim, num_heads) for _ in range(num_layers) ]) self.norm = nn.LayerNorm(embed_dim) self.head = nn.Linear(embed_dim, num_classes) def forward(self, x): x = self.patch_embed(x) cls_tokens = self.cls_token.expand(x.size(0), -1, -1) x = torch.cat([cls_tokens, x], dim=1) x = x + self.pos_embed x = self.blocks(x) x = self.norm(x) return self.head(x[:, 0])

3. 性能对比

3.1 图像分类方法对比

方法	Top-1	Top-5	模型大小	推理速度
SIFT + SVM	60%	80%	小	快
AlexNet	83%	97%	240MB	中
ResNet-50	76%	93%	98MB	快
ViT-Base	85%	98%	340MB	中
ViT-Large	87%	99%	1.2GB	慢

3.2 不同数据集表现

数据集	SIFT+SVM	AlexNet	ResNet-50	ViT
CIFAR-10	75%	92%	95%	97%
ImageNet	60%	83%	76%	85%
MNIST	98%	99%	99.7%	99.8%

3.3 数据增强效果

增强方式	准确率提升	计算开销
随机裁剪	+2%	低
随机翻转	+1%	低
色彩抖动	+1%	低
MixUp	+2%	中
CutMix	+2%	中

4. 最佳实践

4.1 图像分类模型选择

def select_classifier(task_type, data_size): if data_size < 1000: return SIFTClassifier() elif data_size < 10000: return SimpleCNN(num_classes=10) else: return ViT(num_classes=10) class ClassifierFactory: @staticmethod def create(config): if config['type'] == 'traditional': return SIFTClassifier() elif config['type'] == 'cnn': return SimpleCNN(**config['params']) elif config['type'] == 'vit': return ViT(**config['params'])

4.2 图像分类训练流程

class ImageClassificationTrainer: def __init__(self, model, optimizer, scheduler, loss_fn, device='cuda'): self.model = model.to(device) self.optimizer = optimizer self.scheduler = scheduler self.loss_fn = loss_fn self.device = device def train_step(self, images, labels): self.optimizer.zero_grad() images = images.to(self.device) labels = labels.to(self.device) outputs = self.model(images) loss = self.loss_fn(outputs, labels) loss.backward() self.optimizer.step() self.scheduler.step() return loss.item() def evaluate(self, dataloader): self.model.eval() correct = 0 total = 0 with torch.no_grad(): for images, labels in dataloader: images = images.to(self.device) labels = labels.to(self.device) outputs = self.model(images) predictions = torch.argmax(outputs, dim=1) correct += (predictions == labels).sum().item() total += labels.size(0) return correct / total