计算机视觉入门实战：图像处理与 CNN 图像分类

灰度图: 224 × 224 × 1（0-255 亮度）
彩色图: 224 × 224 × 3（RGB 三通道）

import numpy as np
from PIL import Image

# PIL 打开 → numpy 数组 (H, W, C)
img = np.array(Image.open('cat.jpg'))   # (224, 224, 3), 0-255
print(img.shape, img.dtype)

# 归一化到 [0,1]（模型输入习惯）
img_norm = img / 255.0

# 通道顺序：PIL/OpenCV 是 HWC，PyTorch 要 CHW
img_chw = img.transpose(2, 0, 1)   # (3, 224, 224)

import cv2

# 读取与缩放
img = cv2.imread('cat.jpg')              # BGR 顺序！(与 RGB 相反)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)   # 转 RGB
img = cv2.resize(img, (224, 224))        # 统一尺寸

# 灰度/二值化（传统 CV）
gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
_, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

# 模糊/边缘
blur = cv2.GaussianBlur(img, (5, 5), 0)
edges = cv2.Canny(gray, 100, 200)

# 仿射变换/裁剪
M = cv2.getRotationMatrix2D((112, 112), 30, 1.0)   # 旋转 30°
rot = cv2.warpAffine(img, M, (224, 224))

from torchvision import transforms

train_tf = transforms.Compose([
    transforms.RandomResizedCrop(224, scale=(0.8, 1.0)),  # 随机裁剪缩放
    transforms.RandomHorizontalFlip(p=0.5),               # 随机翻转
    transforms.RandomRotation(10),                        # 随机旋转
    transforms.ColorJitter(brightness=0.2, contrast=0.2), # 颜色抖动
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406],           # ImageNet 均值方差
                         [0.229, 0.224, 0.225]),
])

# 验证/测试：只做标准化，不做增强
val_tf = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406],
                         [0.229, 0.224, 0.225]),
])

普通块:  y = F(x)              # 深层难训练
残差块:  y = F(x) + x          # 学"残差"，退化网络保底 = 恒等映射

import torch.nn as nn

class BasicBlock(nn.Module):
    def __init__(self, in_c, out_c):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(in_c, out_c, 3, padding=1),
            nn.BatchNorm2d(out_c), nn.ReLU(),
            nn.Conv2d(out_c, out_c, 3, padding=1),
            nn.BatchNorm2d(out_c),
        )
        self.shortcut = nn.Identity() if in_c == out_c else \
            nn.Conv2d(in_c, out_c, 1)
        self.relu = nn.ReLU()

    def forward(self, x):
        return self.relu(self.conv(x) + self.shortcut(x))   # 残差相加

import torch, torch.nn as nn, torchvision
from torchvision import datasets, transforms
import torchvision.models as models

# 1. 数据（增强 + 归一化）
tf = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.RandomCrop(32, padding=4),
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465),
                         (0.2470, 0.2435, 0.2616)),
])
trainset = datasets.CIFAR10(root='./data', train=True, download=True, transform=tf)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

# 2. 模型（用 torchvision 现成 ResNet18）
model = models.resnet18(num_classes=10)

# 3. 训练
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)
criterion = nn.CrossEntropyLoss()

for epoch in range(20):
    model.train()
    for images, labels in trainloader:
        optimizer.zero_grad()
        loss = criterion(model(images), labels)
        loss.backward()
        optimizer.step()
    print(f'epoch {epoch}: loss={loss.item():.3f}')

# 4. 评估
model.eval()
correct = total = 0
with torch.no_grad():
    for images, labels in torch.utils.data.DataLoader(
            datasets.CIFAR10(root='./data', train=False, download=True,
                             transform=transforms.ToTensor()), batch_size=64):
        correct += (model(images).argmax(1) == labels).sum().item()
        total += labels.size(0)
print(f'准确率: {correct/total:.4f}')

import torchvision.models as models

# 加载 ImageNet 预训练
model = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1)

# 冻结主干
for param in model.parameters():
    param.requires_grad = False

# 替换分类头 → 你的 N 类
model.fc = nn.Linear(model.fc.in_features, num_classes)

# 只训分类头（数据 <1k 时）；数据多再解冻微调深层
optimizer = torch.optim.AdamW(model.fc.parameters(), lr=1e-3)

# 用 Ultralytics YOLO（极简）
from ultralytics import YOLO

model = YOLO('yolov8n.pt')          # 预训练
results = model('test.jpg')         # 检测
for r in results:
    print(r.boxes.xyxy, r.boxes.cls, r.boxes.conf)

# 经典 OCR 工具链
import pytesseract, cv2
from PIL import Image

img = Image.open('receipt.jpg')
text = pytesseract.image_to_string(img, lang='chi_sim+eng')
print(text)

# 工业级：PaddleOCR（中文强、版式好）
from paddleocr import PaddleOCR
ocr = PaddleOCR(use_angle_cls=True, lang='ch')
result = ocr.ocr('scan.jpg', cls=True)

# 导出 ONNX（跨框架部署）
import torch

dummy = torch.randn(1, 3, 224, 224)
torch.onnx.export(model, dummy, 'model.onnx',
                  input_names=['input'], output_names=['output'])