深度学习小样本图像分类实战：从零构建规范数据集

这次我们来看一个深度学习迁移学习的实战项目：如何用少量图片完成图像分类任务。这个主题的核心不是理论推导，而是解决一个非常实际的问题——当你只有几十张甚至十几张图片时，怎么训练一个能用的分类模型。迁移学习正是为此而生，它能将在大规模数据集（如ImageNet）上预训练好的模型知识，迁移到你的小数据集上，从而在数据稀缺的情况下获得不错的性能。

对于初学者或需要快速验证想法的开发者来说，这几乎是必经之路。本文将聚焦于实战流程中最关键的第一步：数据准备。我们会详细拆解如何为少量图片构建一个规范的、可供深度学习框架（如PyTorch或TensorFlow）直接使用的数据集。整个过程不涉及复杂的数学，重点是可操作的步骤、代码示例和避坑指南。如果你手头有一些图片，想快速搭建一个分类模型原型，那么这篇文章可以直接跟着操作。

1. 核心能力速览

在开始动手之前，我们先明确这个“少量图片图像分类”任务的核心要点和边界。

这个阶段的目标是产出“干净的数据”，这是后续模型能否成功训练的基础。数据质量比数据量更重要，尤其是在数据少的时候。

2. 适用场景与使用边界

2.1 适合谁用？

• 深度学习初学者：想通过一个完整的项目理解工作流程，数据准备是第一步。
• 算法工程师/研究员：面临新任务，但初期只有少量标注数据，需要快速搭建基线模型。
• 业务开发人员：需要针对特定场景（如识别某种特定花卉、检测某类产品缺陷）开发分类功能，但无法获取海量数据。

2.2 能解决什么问题？

核心是解决“小样本学习”的启动问题。通过系统化的数据收集、清洗、增强和划分，为迁移学习模型提供高质量的“燃料”，使得模型能够快速从预训练权重中学习到新任务的特征。

2.3 不适合什么场景？

• 海量数据训练：如果你有数百万张标注图片，数据管道需要更复杂的分布式和流式处理，本文的方法虽仍适用，但非最优。
• 无监督/自监督学习：本文聚焦于有监督分类任务的数据准备。
• 需要极高精度（>99%）的生产系统：少量数据本身是瓶颈，迁移学习能提升起点，但最终精度可能受限于数据规模，可能需要后续主动学习或数据扩充策略。

2.4 版权与合规提醒

至关重要！使用图片数据必须严格遵守法律法规和版权协议。

1. 合法来源：确保使用的图片来自公开数据集、已获得授权的来源或自己拍摄。切勿使用未经授权的网络爬取图片，尤其是涉及人物肖像、艺术品、商业产品的图片。
2. 隐私保护：如果图片包含人脸、车牌、个人信息等，必须进行脱敏处理或确保已获得使用许可。
3. 训练与测试：本文所有方法仅限于技术学习和研究验证。将模型用于实际业务前，必须全面评估数据合规性。

3. 环境准备与前置条件

数据准备阶段对计算资源要求极低，主要依赖Python环境和一些基础库。

3.1 软件环境清单

• 操作系统：Windows 10/11, Ubuntu 18.04+, macOS 均可。
• Python：推荐 3.8 或 3.9，这是多数深度学习框架兼容性较好的版本。
• 包管理工具：pip或conda。

3.2 核心Python库

我们将使用以下库，请通过pip安装：

# 基础数据处理与可视化 pip install numpy pandas matplotlib opencv-python pillow # 深度学习框架（二选一或都安装） # PyTorch 方案 (更常用) pip install torch torchvision # TensorFlow 方案 pip install tensorflow # 如果使用GPU，请安装对应版本的 tensorflow-gpu # 图像增强库（强力推荐） pip install albumentations

3.3 项目目录结构（建议）

在开始前，先建立一个清晰的目录结构，这能极大提升效率。

your_project/ ├── data/ # 数据根目录 │ ├── raw/ # 存放原始收集的图片 │ │ ├── class_a/ # 类别A的图片 │ │ ├── class_b/ # 类别B的图片 │ │ └── ... # 其他类别 │ └── processed/ # 存放处理后的数据集（程序生成） │ ├── train/ # 训练集 │ │ ├── class_a/ │ │ ├── class_b/ │ │ └── ... │ ├── val/ # 验证集 │ │ ├── class_a/ │ │ ├── class_b/ │ │ └── ... │ └── test/ # 测试集（可选） │ ├── class_a/ │ ├── class_b/ │ └── ... ├── scripts/ # 存放数据处理脚本 │ ├── 01_data_explore.py # 数据探索 │ ├── 02_data_split.py # 数据划分 │ ├── 03_data_augment.py # 数据增强 │ └── 04_create_dataset.py # 创建Dataset └── README.md

4. 数据准备全流程详解

接下来，我们按照一个完整的流水线，一步步将杂乱无章的原始图片变成模型可用的数据。

4.1 第一步：数据收集与初步探索

假设你已经通过某种方式收集了图片，并按类别放入了data/raw/下的不同文件夹。

操作步骤：

1. 统计基本信息：编写一个脚本，快速了解数据全貌。

   # scripts/01_data_explore.py import os from pathlib import Path from PIL import Image import matplotlib.pyplot as plt data_raw_path = Path('./data/raw') classes = [d.name for d in data_raw_path.iterdir() if d.is_dir()] print(f"发现类别: {classes}") stats = {} for cls in classes: cls_path = data_raw_path / cls images = list(cls_path.glob('*.*')) # 匹配所有文件 # 简单过滤，只保留常见图片格式 valid_ext = {'.jpg', '.jpeg', '.png', '.bmp'} images = [img for img in images if img.suffix.lower() in valid_ext] stats[cls] = len(images) # 检查第一张图片的尺寸和模式 if images: with Image.open(images[0]) as img: print(f" 类别 '{cls}': 图片数 {len(images)}, 示例尺寸 {img.size}, 模式 {img.mode}") print(f"\n总计图片数: {sum(stats.values())}") print(f"各类别分布: {stats}") # 可视化类别分布 plt.bar(stats.keys(), stats.values()) plt.title('Raw Data Class Distribution') plt.xlabel('Class') plt.ylabel('Count') plt.xticks(rotation=45) plt.tight_layout() plt.savefig('./data/raw_class_dist.png') plt.show()

2. 检查数据质量：人工抽查部分图片，查看是否有损坏、标注错误（图片放错了文件夹）、或质量过低（模糊、无关内容）的情况。

关键点：

• 类别平衡：如果某个类别的图片数量远少于其他类别（例如，10张 vs 100张），需要特别注意。在少量数据场景下，严重不平衡会极大影响模型学习。后续可能需要通过数据增强重点补充少样本类别。
• 图片格式与尺寸：统一为常见的RGB格式。尺寸不一致是常态，后续预处理会统一调整。

4.2 第二步：数据清洗与整理

根据探索结果，进行清洗。

1. 删除问题图片：将损坏、完全无关的图片移出raw目录。
2. 统一命名（可选但推荐）：为图片赋予有规律的名称，便于管理。例如class_a_001.jpg。

   # 示例：重命名一个文件夹内的图片 import os from pathlib import Path cls_path = Path('./data/raw/class_a') images = list(cls_path.glob('*.*')) valid_ext = {'.jpg', '.jpeg', '.png', '.bmp'} images = [img for img in images if img.suffix.lower() in valid_ext] for idx, img_path in enumerate(images, start=1): new_name = f"class_a_{idx:03d}{img_path.suffix}" new_path = img_path.parent / new_name img_path.rename(new_path) print(f"Renamed {img_path.name} -> {new_name}")

3. 处理类别不平衡：如果差距不大（如2倍以内），可以暂时接受。如果差距很大，考虑：
   • 收集更多数据（首选）。
   • 使用数据增强（下一节重点）为少数类生成更多变体。
   • 在损失函数中设置类别权重（这是模型训练时的策略，在数据准备阶段先记下）。

4.3 第三步：数据划分（训练集、验证集、测试集）

这是至关重要的一步，直接影响模型评估的可靠性。对于小数据集，常见的划分比例是 70% 训练，15% 验证，15% 测试。如果数据极少（如每类只有10张），可以采用 80% 训练，20% 验证，并省略独立测试集，或使用交叉验证。

操作步骤：使用scikit-learn的train_test_split进行分层抽样，确保每个集合的类别比例与原始数据一致。

# scripts/02_data_split.py import os import shutil from pathlib import Path from sklearn.model_selection import train_test_split def split_data(raw_dir='./data/raw', output_dir='./data/processed', test_size=0.15, val_size=0.1765, seed=42): """ raw_dir: 原始数据目录，内部按类别分文件夹 output_dir: 输出目录，将创建 train/val/test 子目录 test_size: 测试集占总体的比例 val_size: 验证集占 **训练部分** 的比例 (计算方式：val_ratio = val_size / (1-test_size)) 例如：test_size=0.15, val_size=0.1765, 则最终：训练集0.7，验证集0.15，测试集0.15 seed: 随机种子，保证结果可复现 """ raw_path = Path(raw_dir) output_path = Path(output_dir) classes = [d.name for d in raw_path.iterdir() if d.is_dir()] for split in ['train', 'val', 'test']: (output_path / split).mkdir(parents=True, exist_ok=True) for cls in classes: (output_path / split / cls).mkdir(parents=True, exist_ok=True) for cls in classes: cls_path = raw_path / cls images = list(cls_path.glob('*.*')) valid_ext = {'.jpg', '.jpeg', '.png', '.bmp'} images = [img for img in images if img.suffix.lower() in valid_ext] # 先分出测试集 train_val_imgs, test_imgs = train_test_split(images, test_size=test_size, random_state=seed, shuffle=True) # 再从剩余部分分出验证集 # 注意：val_size 参数是针对 train_val_imgs 的比例 train_imgs, val_imgs = train_test_split(train_val_imgs, test_size=val_size, random_state=seed, shuffle=True) # 复制文件到对应目录 for img in train_imgs: shutil.copy(img, output_path / 'train' / cls / img.name) for img in val_imgs: shutil.copy(img, output_path / 'val' / cls / img.name) for img in test_imgs: shutil.copy(img, output_path / 'test' / cls / img.name) print(f"Class '{cls}': Train {len(train_imgs)}, Val {len(val_imgs)}, Test {len(test_imgs)}") print(f"\n数据划分完成，结果保存在: {output_dir}") if __name__ == '__main__': split_data()

运行此脚本后，你的data/processed/目录下就会生成结构清晰的train,val,test文件夹。

4.4 第四步：数据增强（Data Augmentation）

对于少量图片，数据增强是救命稻草。它通过对原始图片进行随机变换（旋转、翻转、裁剪、颜色抖动等），生成新的、多样化的训练样本，从而增加数据量、提升模型泛化能力、防止过拟合。

重要原则：增强通常只应用于训练集。验证集和测试集必须使用原始或仅做标准化等确定性变换，用于公平评估模型。

我们使用功能强大的albumentations库来定义增强管道。

# scripts/03_data_augment.py (定义增强策略) import albumentations as A from albumentations.pytorch import ToTensorV2 import cv2 def get_train_transform(img_size=224): """训练集的数据增强变换""" return A.Compose([ A.RandomResizedCrop(height=img_size, width=img_size, scale=(0.8, 1.0)), # 随机缩放裁剪 A.HorizontalFlip(p=0.5), # 水平翻转 A.RandomRotate90(p=0.5), # 90度随机旋转 A.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1, p=0.5), # 颜色抖动 A.GaussianBlur(blur_limit=(3, 7), p=0.2), # 高斯模糊 A.CoarseDropout(max_holes=8, max_height=img_size//10, max_width=img_size//10, fill_value=0, p=0.3), # 随机遮挡 A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), # ImageNet标准化 ToTensorV2(), # 转为PyTorch Tensor ]) def get_val_transform(img_size=224): """验证集/测试集的变换（仅包含确定性的Resize和标准化）""" return A.Compose([ A.Resize(height=img_size, width=img_size), A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ToTensorV2(), ]) # 使用示例 if __name__ == '__main__': # 读取一张图片 img_path = './data/processed/train/class_a/001.jpg' image = cv2.imread(img_path) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) # OpenCV默认BGR，转为RGB transform = get_train_transform() augmented = transform(image=image) augmented_image = augmented['image'] # 这是PyTorch Tensor [C, H, W] # 可视化增强效果（需要将Tensor转换回numpy） import matplotlib.pyplot as plt # 注意：需要反标准化和转换维度才能显示 mean = [0.485, 0.456, 0.406] std = [0.229, 0.224, 0.225] img_np = augmented_image.numpy().transpose(1, 2, 0) img_np = std * img_np + mean img_np = np.clip(img_np, 0, 1) plt.imshow(img_np) plt.axis('off') plt.show()

增强策略选择建议：

• 基础增强：随机水平翻转、小角度旋转（±15度）、随机裁剪。这些对大多数分类任务安全有效。
• 进阶增强：颜色抖动、高斯模糊、随机遮挡。需根据任务谨慎添加，例如识别颜色关键的任务不宜做颜色抖动。
• 核心思想：模拟现实世界中可能出现的图像变化。例如，物体识别可以加旋转、缩放；文字识别则不宜做几何形变。

4.5 第五步：创建PyTorch Dataset

数据准备好后，需要将其封装成PyTorch的Dataset类，以便DataLoader进行批量加载。

# scripts/04_create_dataset.py import torch from torch.utils.data import Dataset, DataLoader from pathlib import Path from PIL import Image import cv2 import albumentations as A from albumentations.pytorch import ToTensorV2 import numpy as np class CustomImageDataset(Dataset): """自定义图像分类数据集""" def __init__(self, data_dir, transform=None): """ data_dir: 数据目录，例如 './data/processed/train' 目录结构应为: data_dir/ class_a/ img1.jpg img2.jpg class_b/ ... transform: 数据增强/变换函数 """ self.data_dir = Path(data_dir) self.transform = transform # 获取所有图片路径和对应的标签 self.image_paths = [] self.labels = [] self.class_to_idx = {} # 类别名到数字索引的映射 classes = sorted([d.name for d in self.data_dir.iterdir() if d.is_dir()]) self.class_to_idx = {cls_name: i for i, cls_name in enumerate(classes)} for cls_name, idx in self.class_to_idx.items(): cls_dir = self.data_dir / cls_name # 遍历所有图片文件 for ext in ['*.jpg', '*.jpeg', '*.png', '*.bmp']: for img_path in cls_dir.glob(ext): self.image_paths.append(img_path) self.labels.append(idx) print(f"数据集 '{data_dir}' 加载完成，共 {len(self.image_paths)} 张图片，{len(classes)} 个类别。") def __len__(self): return len(self.image_paths) def __getitem__(self, idx): img_path = self.image_paths[idx] label = self.labels[idx] # 使用OpenCV读取，兼容albumentations image = cv2.imread(str(img_path)) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) # 转为RGB if self.transform: augmented = self.transform(image=image) image = augmented['image'] # 已经是Tensor了 else: # 如果没有transform，至少转为Tensor image = torch.from_numpy(image.transpose(2, 0, 1)).float() / 255.0 return image, label def get_class_names(self): """获取类别名称列表，顺序与class_to_idx对应""" return list(self.class_to_idx.keys()) # 使用示例：创建数据加载器 if __name__ == '__main__': from scripts/03_data_augment import get_train_transform, get_val_transform # 1. 定义变换 train_transform = get_train_transform(img_size=224) val_transform = get_val_transform(img_size=224) # 2. 创建Dataset实例 train_dataset = CustomImageDataset('./data/processed/train', transform=train_transform) val_dataset = CustomImageDataset('./data/processed/val', transform=val_transform) # test_dataset = CustomImageDataset('./data/processed/test', transform=val_transform) # 3. 创建DataLoader batch_size = 8 # 小数据集可以用小批量 train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=2, pin_memory=True) val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=2, pin_memory=True) # 4. 测试一个批次 for images, labels in train_loader: print(f"Batch image shape: {images.shape}") # [batch, channel, height, width] print(f"Batch label shape: {labels.shape}") # [batch] print(f"Labels: {labels}") break # 只看第一个批次

至此，一个规范的、可用于迁移学习训练的图像分类数据集就准备好了。DataLoader会负责在训练时按批次提供数据。

5. 功能测试与效果验证

数据准备完成后，必须进行验证，确保流程无误，数据能正常流入模型。

5.1 验证一：数据流测试

运行上面的04_create_dataset.py脚本，检查是否报错，并观察输出：

• 是否正确统计了每个数据集的图片数量？
• DataLoader输出的image张量形状是否为[batch_size, 3, height, width]？
• label张量是否为整数类型？

5.2 验证二：可视化增强效果

编写一个简单的可视化脚本，确保数据增强按预期工作。

# visualize_augmentation.py import matplotlib.pyplot as plt import cv2 from pathlib import Path from scripts/03_data_augment import get_train_transform # 选择几张图片 img_dir = Path('./data/processed/train/class_a') img_paths = list(img_dir.glob('*.jpg'))[:3] transform = get_train_transform(img_size=224) fig, axes = plt.subplots(len(img_paths), 5, figsize=(15, 3*len(img_paths))) if len(img_paths) == 1: axes = axes.reshape(1, -1) for row, img_path in enumerate(img_paths): # 读取原图 image = cv2.imread(str(img_path)) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) axes[row, 0].imshow(image) axes[row, 0].set_title('Original') axes[row, 0].axis('off') # 展示4次不同的增强结果 for col in range(1, 5): augmented = transform(image=image) aug_img = augmented['image'].numpy().transpose(1, 2, 0) # 反标准化显示 mean = [0.485, 0.456, 0.406] std = [0.229, 0.224, 0.225] aug_img = std * aug_img + mean aug_img = np.clip(aug_img, 0, 1) axes[row, col].imshow(aug_img) axes[row, col].set_title(f'Aug {col}') axes[row, col].axis('off') plt.tight_layout() plt.savefig('./data/augmentation_samples.png', dpi=150) plt.show()

检查生成的图片，增强应具有随机性和多样性，但原始主体内容仍可辨识。

5.3 验证三：模拟一个训练循环

用一个极简的模型（甚至只是一个前向传播）测试整个数据管道。

# test_pipeline.py import torch import torch.nn as nn from torch.utils.data import DataLoader from scripts/04_create_dataset import CustomImageDataset from scripts/03_data_augment import get_train_transform # 1. 加载数据 train_dataset = CustomImageDataset('./data/processed/train', transform=get_train_transform()) train_loader = DataLoader(train_dataset, batch_size=4, shuffle=True) # 2. 定义一个最简单的模型（例如，用于测试的线性层） class DummyModel(nn.Module): def __init__(self, input_size=224*224*3, num_classes=len(train_dataset.class_to_idx)): super().__init__() self.flatten = nn.Flatten() self.linear = nn.Linear(input_size, num_classes) def forward(self, x): x = self.flatten(x) x = self.linear(x) return x model = DummyModel() criterion = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(model.parameters(), lr=0.001) # 3. 尝试一个训练步骤 model.train() for batch_idx, (images, labels) in enumerate(train_loader): print(f"Processing batch {batch_idx}, images shape: {images.shape}, labels: {labels}") # 前向传播 outputs = model(images) loss = criterion(outputs, labels) # 反向传播（仅测试，不实际更新） optimizer.zero_grad() loss.backward() print(f" Loss: {loss.item():.4f}") print(f" Gradient norm: {sum(p.grad.norm() for p in model.parameters() if p.grad is not None):.4f}") if batch_idx >= 1: # 只跑两个批次测试 break print("\n数据管道测试通过！可以开始真正的迁移学习训练了。")

如果这个脚本能顺利运行到结束，没有出现形状不匹配、内存溢出、数据加载错误等问题，说明你的数据准备流程是健全的。

6. 资源占用与性能观察

在数据准备阶段，资源占用主要集中在磁盘I/O和内存上，计算开销很小。

1. 磁盘空间：

   • 原始图片占用空间。
   • 处理后的数据集（processed/）是原始数据的副本，占用大致相同的空间。
   • 如果进行实时数据增强（推荐），则不会额外占用磁盘空间，增强在内存中完成。

2. 内存占用：

   • 使用DataLoader时，通过num_workers参数设置子进程数来预加载数据。num_workers=2或4通常足够，设置过高可能导致内存占用过多。
   • 批量大小batch_size直接影响单次加载到GPU显存的数据量。对于小图片（224x224），batch_size=32在大多数GPU上可行。如果显存不足，首先降低batch_size。

3. CPU使用率：

   • 数据增强（特别是复杂的增强）和图像解码会消耗CPU。如果训练时发现GPU利用率低（例如低于70%），而CPU很高，说明数据加载是瓶颈。此时可以：
     • 增加DataLoader的num_workers。
     • 使用更高效的图像库（如turbojpeg）。
     • 简化数据增强管道。
     • 将数据预处理成更快的格式（如TFRecord或LMDB），但这对于小数据集性价比不高。

性能观察命令：

• Linux/macOS: 在终端使用htop或top观察CPU和内存。
• Windows: 使用任务管理器查看性能标签页。
• 在Python脚本中：可以使用torch.cuda.max_memory_allocated()查看GPU显存峰值。

7. 常见问题与排查方法

8. 最佳实践与使用建议

1. 保持原始数据只读：所有处理（复制、增强）都应在processed/目录或其内存中进行，不要修改raw/下的原始文件。
2. 固定随机种子：在数据划分 (train_test_split) 和数据增强（如果支持）时设置固定的随机种子 (seed)，确保实验可复现。
3. 小数据集的增强策略：
   • 强度适中：过强的增强会破坏语义信息，让模型学不到有效特征。
   • 针对任务设计：识别数字，不做旋转180度；识别动物，可以做水平翻转。
   • 考虑使用 AutoAugment 或 RandAugment：这些是自动搜索增强策略的方法，但在小数据集上可能不如手动设计稳定。
4. 验证集的重要性：对于小数据集，验证集是判断模型是否过拟合的唯一可靠依据。切勿在验证集上做任何数据增强，也切勿根据测试集结果反复调整模型（会导致信息泄露）。
5. 数据准备脚本化：将本章所有步骤写成脚本（如prepare_data.py），并接受命令行参数（如数据路径、划分比例、图片尺寸）。这样，当数据更新时，可以一键重新生成数据集。
6. 记录数据版本：在data/processed/下创建一个dataset_info.json文件，记录数据来源、划分比例、增强策略、创建时间等元信息。这对于团队协作和实验回溯至关重要。
7. 为生产环境准备：如果最终要部署模型，需要确保线上推理时的数据预处理（Resize、Normalize）与训练时完全一致。最好将预处理代码封装成函数，在训练和推理中共享。

9. 总结与下一步

至此，你已经完成了迁移学习项目中最为基础但也最易出错的一环——数据准备。我们系统性地走完了从原始图片收集、探索、清洗、划分、增强到最终封装成Dataset的完整流程。这套流程不仅适用于“少量图片”场景，其规范化思想对任何规模的数据集都大有裨益。

最值得尝试的点：

• 快速验证想法：用不到100张图片，按本文流程准备好数据，你就可以在1小时内跑通一个迁移学习模型（例如使用torchvision.models.resnet18(pretrained=True)），看到初步的分类效果。
• 理解数据价值：亲手处理数据会让你深刻体会到“垃圾进，垃圾出”的含义。干净、规范的数据是模型成功的基石。

最先应该验证的功能：完成本文所有步骤后，立即运行test_pipeline.py（第5.3节），确保数据能顺利流入一个虚拟模型。这是通往成功训练的最后一道安检。

最容易踩的坑：

1. 路径错误：相对路径和绝对路径混用，导致脚本在别处无法运行。建议使用pathlib.Path并检查路径存在性。
2. 数据泄露：不小心让测试集图片参与了训练（例如，划分时随机种子不同，或文件复制错误）。务必仔细检查划分后各集合的图片是否有重复。
3. 预处理不一致：训练用了(0.485, 0.456, 0.406)的均值标准差做标准化，推理时忘了做，导致模型性能骤降。

后续方向：数据就绪后，下一步就是加载预训练模型，微调最后一层或全部层，开始真正的迁移学习训练。你可以选择：

1. PyTorch：使用torchvision.models中的预训练模型（如 ResNet, EfficientNet, Vision Transformer）。
2. TensorFlow/Keras：使用tf.keras.applications中的预训练模型。
3. Hugging Face Transformers：如果任务涉及更复杂的视觉模型（如 CLIP, DETR），可以探索这个强大的库。

记住，在深度学习中，数据工作往往占据80%的时间和精力。把这第一步走扎实，后面的模型训练和调优才会事半功倍。建议将本文的代码和目录结构保存为模板，在下一个图像分类项目中直接复用。