MindSpore框架学习项目-ResNet药物分类-数据增强
目录
1.数据增强
1.1设置运行环境
1.1.1数据预处理
数据预处理代码解析
1.1.2数据集划分
数据集划分代码说明
1.2数据增强
1.2.1创建带标签的可迭代对象
1.2.2数据预处理与格式化（ms的data格式）
从原始图像数据到 MindSpore 可训练 / 评估的数据集的完整构建流程
1.2.3加载数据
加载数据代码说明
1.2.4类别标签说明
1.3数据可视化
数据可视化代码说明
本项目可以在华为云modelart上租一个实例进行，也可以在配置至少为单卡3060的设备上进行
https://console.huaweicloud.com/modelarts/
Ascend环境也适用，但是注意修改device_target参数
需要本地编译器的一些代码传输、修改等可以勾上ssh远程开发
说明：项目使用的数据集来自华为云的数据资源。项目以深度学习任务构建的一般流程展开（数据导入、处理 > 模型选择、构建 > 模型训练 > 模型评估 > 模型优化）。
主线为‘一般流程’，同时代码中会标注出一些要点（# 要点1-1-1：设置使用的设备
）作为支线，帮助学习mindspore框架在进行深度学习任务时一些与pytorch的差异。
可以只看目录中带数字标签的部分来快速查阅代码。
1.数据增强
1.1设置运行环境
要求：设置执行设备为GPU mindspore还支持CPU/Ascend
import mindspore# 要点1-1-1：设置使用的设备
mindspore.set_context(device_target='GPU') # CPU/Ascend
print(mindspore.get_context(attr_key='device_target'))这里返回GPU
# 下载数据
!pip install download
from download import download
import os
url = "https://mindspore-courses.obs.cn-north-4.myhuaweicloud.com/ICT/zhongyiyao/dataset.zip"
if not os.path.exists("dataset"):
download(url, "dataset", kind="zip")
1.1.1数据预处理
原图片尺寸为4k比较大，预处理将图片resize到1000*1000
from PIL import Image
import numpy as np
data_dir = "dataset/zhongyiyao/zhongyiyao"
new_data_path = "dataset1/zhongyiyao"
if not os.path.exists(new_data_path):for path in ['train','test']:
data_path = data_dir + "/" + path
classes = os.listdir(data_path)for (i,class_name) in enumerate(classes):
floder_path = data_path+"/"+class_nameprint(f"正在处理{floder_path}...")for image_name in os.listdir(floder_path):try:
image = Image.open(floder_path + "/" + image_name)
image = image.resize((1000,1000))
target_dir = new_data_path+"/"+path+"/"+class_nameif not os.path.exists(target_dir):
os.makedirs(target_dir)if not os.path.exists(target_dir+"/"+image_name):
image.save(target_dir+"/"+image_name)except:pass
数据预处理代码解析
1. 核心功能
将原始数据集（dataset/zhongyiyao/zhongyiyao）中的图像按类别整理到新路径（dataset1/zhongyiyao），统一图像尺寸为1000×1000，并跳过损坏文件，为后续模型训练准备标准格式数据。
2. 关键代码说明
(1) 数据目录初始化
data_dir = "dataset/zhongyiyao/zhongyiyao" # 原始数据集根目录（含train/test子目录）
new_data_path = "dataset1/zhongyiyao" # 目标数据集根目录（整理后的数据存放路径）
作用：定义原始数据路径和目标路径，确保后续处理围绕固定目录展开。
项目意义：统一数据入口 / 出口路径，避免硬编码，方便后续数据集加载（如 MindSpore 的ds.ImageFolderDataset要求类别子目录结构）。
(2) 遍历原始数据目录
for path in ['train','test']: # 处理训练集和测试集
data_path = data_dir + "/" + path # 拼接原始数据路径（如dataset/zhongyiyao/zhongyiyao/train）
classes = os.listdir(data_path) # 获取类别目录（如"ph_sp"、"sz_bj"等中药材类别）
逻辑：按 “数据集类型（train/test）→ 类别→ 图像” 三级结构遍历，符合图像分类任务的标准数据组织格式（类别作为子目录）。
MindSpore 关联：MindSpore 的ds.ImageFolderDataset要求数据按[root]/[split]/[class]/[image]结构存储，此处代码直接生成该格式，便于后续数据集加载。
(3) 图像尺寸统一与保存
image = Image.open(floder_path + "/" + image_name) # 读取图像
image = image.resize((1000, 1000)) # 统一尺寸（模型输入预处理第一步）
target_dir = new_data_path+"/"+path+"/"+class_name # 目标路径（如dataset1/zhongyiyao/train/ph_sp）
os.makedirs(target_dir, exist_ok=True) # 创建目标类别目录（自动处理多级目录）
image.save(target_dir+"/"+image_name) # 保存处理后的图像
核心操作：尺寸统一：深度学习模型要求输入图像尺寸一致，先调整为 1000×1000（后续可在数据管道中进一步缩放到模型所需尺寸，如 224×224）。
目录创建：exist_ok=True避免重复创建目录报错，确保鲁棒性。
(4) 损坏文件处理
try:# 图像读取、处理、保存逻辑
except:pass # 跳过无法读取的损坏文件（数据清洗关键步骤）
作用：避免因个别损坏图像导致整个数据处理流程中断，确保数据集的可用性（训练时若遇到损坏文件会直接报错，预处理阶段清洗可提前规避）。
3. 在项目中的定位（深度学习流程）
阶段：数据导入与预处理（项目的基础环节，直接影响模型训练效果）。
目标：整理数据目录结构，适配 MindSpore 的ds.ImageFolderDataset加载格式。
统一图像尺寸，完成基础数据清洗（过滤损坏文件），为后续数据增强（如随机裁剪、翻转）和模型输入做准备。
4. 与 MindSpore 的关联（框架差异支线）
数据加载适配：
MindSpore 的数据集加载接口（如ds.ImageFolderDataset）依赖 “类别子目录” 结构，此处代码生成的dataset1/zhongyiyao/train/[class]格式可直接被识别，无需额外转换。预处理灵活性：
图像尺寸可在 MindSpore 数据管道中动态调整（如ds.vision.Resize((224, 224))），此处预处理阶段统一为 1000×1000 是为了标准化原始数据，后续可通过管道灵活处理。
1.1.2数据集划分
导入sklearn（机器学习库）的model_selection模块的数据集划分方法train_test_split；
shutil是 Python 的标准库，主要用于文件和目录的高级操作，如文件复制、移动、删除，以及目录的递归操作等。
from sklearn.model_selection import train_test_split
import shutil
定义数据集切分函数，符合python函数式编程的范式，也方便代码复用
def split_data(X, y, test_size=0.2, val_size=0.2, random_state=42):
"""将数据集划分为训练集、验证集和测试集
"""# 先以8：2的比例划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=random_state)# 再从训练集中抽取 25% 作为验证集
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=val_size/(1-test_size), random_state=random_state) return X_train, X_val, X_test, y_train, y_val, y_test
定义数据的目标路径和数据存储的结构
data_dir = "dataset1/zhongyiyao"
floders = os.listdir(data_dir)
target = ['train','test','valid']
判断不同情况下需要进行的文件系统操作
if set(floders) == set(target):pass
elif 'train' in floders:
floders = os.listdir(data_dir)
new_data_dir = os.path.join(data_dir,'train')
classes = os.listdir(new_data_dir)# 不要让ipython的缓存文件在数据集里，会影响到训练环节if '.ipynb_checkpoints' in classes:
classes.remove('.ipynb_checkpoints')# 图像识别项目 数据为图片imgs和标签labels
imgs = []
labels = []for (i,class_name) in enumerate(classes):
new_path = new_data_dir+"/"+class_name# 逐张添加图片、标签（保持两者的对应关系）for image_name in os.listdir(new_path):
imgs.append(image_name)
labels.append(class_name) imgs_train,imgs_val,labels_train,labels_val = X_train, X_test, y_train, y_test = train_test_split(imgs, labels, test_size=0.2, random_state=42)print("划分训练集图片数：",len(imgs_train))print("划分验证集图片数：",len(imgs_val)) target_data_dir = os.path.join(data_dir,'valid')if not os.path.exists(target_data_dir):
os.mkdir(target_data_dir)for (img,label) in zip(imgs_val,labels_val):
source_path = os.path.join(data_dir,'train',label)
target_path = os.path.join(data_dir,'valid',label)if not os.path.exists(target_path):
os.mkdir(target_path)
source_img = os.path.join(source_path,img)
target_img = os.path.join(target_path,img)
shutil.move(source_img,target_img)else:
phones = os.listdir(data_dir)
imgs = []
labels = []for phone in phones:
phone_data_dir = os.path.join(data_dir,phone)
yaowu_list = os.listdir(phone_data_dir)for yaowu in yaowu_list:
yaowu_data_dir = os.path.join(phone_data_dir,yaowu)
chengdu_list = os.listdir(yaowu_data_dir)for chengdu in chengdu_list:
chengdu_data_dir = os.path.join(yaowu_data_dir,chengdu)for img in os.listdir(chengdu_data_dir):
imgs.append(img)
label = ' '.join([phone,yaowu,chengdu])
labels.append(label)
imgs_train, imgs_val, imgs_test, labels_train, labels_val, labels_test = split_data(imgs, labels, test_size=0.2, val_size=0.2, random_state=42)
img_label_tuple_list = [(imgs_train,labels_train),(imgs_val,labels_val),(imgs_test,labels_test)]for (i,split) in enumerate(spilits):
target_data_dir = os.path.join(data_dir,split)if not os.path.exists(target_data_dir):
os.mkdir(target_data_dir)
imgs_list,labels_list = img_label_tuple_list[i]for (img,label) in zip(imgs_list,labels_list):
label_split = label.split(' ')
source_img = os.path.join(data_dir,label_split[0],label_split[1],label_split[2],img)
target_img_dir = os.path.join(target_data_dir,label_split[1]+"_"+label_split[2])if not os.path.exists(target_img_dir):
os.mkdir(target_img_dir)
target_img = os.path.join(target_img_dir,img)
shutil.move(source_img,target_img)
数据集划分代码说明
这段代码主要功能是将原始图片数据按比例划分为训练集（train）、验证集（valid）、测试集（test），并自动整理文件目录结构。
核心目标
将原始图片数据按比例（默认测试集20%、验证集20%）划分到`train`、`valid`、`test`三个子目录中，解决不同原始目录结构下的数据整理问题，方便后续机器学习模型的训练与评估
代码结构与关键逻辑
代码分为数据划分函数和目录结构处理逻辑两部分：
数据划分函数 `split_data`
def split_data(X, y, test_size=0.2, val_size=0.2, random_state=42):
"""将数据划分为训练集、验证集、测试集"""
# 第一步：划分训练集和测试集（test_size=0.2）
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=random_state)
# 第二步：从训练集中划分验证集（val_size/(1-test_size) 是因为验证集占原数据的20%，但此时训练集剩余80%）
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=val_size/(1-test_size), random_state=random_state)
return X_train, X_val, X_test, y_train, y_val, y_test
输入：特征数据`X`（图片路径列表）、标签数据`y`（标签列表）、测试集比例`test_size`（默认20%）、验证集比例`val_size`（默认20%）。
输出：训练集、验证集、测试集的特征与标签（共6个集合）。
逻辑：先划分出测试集（占整体20%），再从剩余训练集中划分验证集（占整体20%，因此实际从训练集的80%中取20%/80%=25%）。
实际比例计算：初始训练集占原数据的 80%（即1-test_size=0.8）。
第二次划分时，test_size=val_size/(1-test_size)=0.2/0.8=0.25，即从 80% 的训练集中再抽取 25% 作为验证集。
最终验证集占原数据的比例为：0.8×0.25=0.2（即 20%）。
因此，实际划分比例为 原数据的 60%（训练集）:20%（验证集），而非注释中的 “6:2”（60%:20% 是整体比例，而非 “训练集中的 6:2”）。
最终划分比例
正确比例：训练集：60%（原数据的 60%）
验证集：20%（原数据的 20%，来自第一次划分后的训练集）
测试集：20%（原数据的 20%）
目录结构处理逻辑
代码根据原始数据集的目录结构不同，分3种情况处理：
情况1：目录已包含标准划分（train/test/valid）
if set(floders) == set(target):
pass # 无需处理，直接跳过
如果原始目录`dataset1/zhongyiyao`下已经有`train`（训练集）、`test`（测试集）、`valid`（验证集）三个子目录，直接跳过处理
情况2：目录包含train但缺少valid/test
elif 'train' in floders:
# 步骤1：收集训练集中的所有图片和标签
new_data_dir = os.path.join(data_dir,'train') # 原始训练集路径
classes = os.listdir(new_data_dir) # 类别（如不同中药材）
classes.remove('.ipynb_checkpoints') # 移除Jupyter临时文件
imgs = [] # 存储所有图片名
labels = [] # 存储对应标签（类别名）
for class_name in classes:
class_path = os.path.join(new_data_dir, class_name)
for image_name in os.listdir(class_path):
imgs.append(image_name)
labels.append(class_name) # 步骤2：划分训练集和验证集（测试集可能已存在或需额外处理）
imgs_train, imgs_val, labels_train, labels_val = train_test_split(imgs, labels, test_size=0.2, random_state=42) # 步骤3：将验证集图片从原训练集目录移动到valid目录
target_data_dir = os.path.join(data_dir,'valid') # 验证集目标路径
if not os.path.exists(target_data_dir):
os.mkdir(target_data_dir)
for img, label in zip(imgs_val, labels_val):
# 原始路径：dataset1/zhongyiyao/train/[类别]/[图片]
source_path = os.path.join(data_dir, 'train', label, img)
# 目标路径：dataset1/zhongyiyao/valid/[类别]/[图片]
target_path = os.path.join(data_dir, 'valid', label)
if not os.path.exists(target_path):
os.mkdir(target_path)
shutil.move(source_path, os.path.join(target_path, img)) # 移动文件
场景：原始目录只有`train`子目录（可能测试集已单独存在，或需后续处理）。
操作：从`train`目录中提取所有图片和标签，按2:8划分出验证集（占原训练集的20%），并将验证集图片移动到新创建的`valid`目录下对应的类别子目录中。
情况3：原始目录是多层嵌套结构（未划分）
else:
# 步骤1：遍历多层嵌套目录，收集所有图片和标签
phones = os.listdir(data_dir) # 一级目录（如不同设备/场景，phone可能指拍摄设备）
imgs = [] # 存储所有图片名
labels = [] # 标签由多级目录组合：phone_yaowu_chengdu（设备_药材_程度）
for phone in phones:
phone_dir = os.path.join(data_dir, phone)
yaowu_list = os.listdir(phone_dir) # 二级目录（药材类型）
for yaowu in yaowu_list:
yaowu_dir = os.path.join(phone_dir, yaowu)
chengdu_list = os.listdir(yaowu_dir) # 三级目录（药材状态/程度，如“完整”“破损”）
for chengdu in chengdu_list:
chengdu_dir = os.path.join(yaowu_dir, chengdu)
for img in os.listdir(chengdu_dir):
imgs.append(img)
# 标签由三级目录组合（如 "phone1 当归 完整"）
labels.append(' '.join([phone, yaowu, chengdu])) # 步骤2：使用split_data函数划分训练集、验证集、测试集（各占60%、20%、20%）
imgs_train, imgs_val, imgs_test, labels_train, labels_val, labels_test = split_data(imgs, labels, test_size=0.2, val_size=0.2) # 步骤3：将划分后的图片移动到对应的train/valid/test目录
# 目标划分目录：train、valid、test（对应split）
splits = ['train','valid','test'] # 注意：原代码中变量名可能拼写错误（spilits应为splits）
img_label_tuple_list = [(imgs_train,labels_train), (imgs_val,labels_val), (imgs_test,labels_test)]
for i, split in enumerate(splits):
target_dir = os.path.join(data_dir, split) # 如 dataset1/zhongyiyao/train
if not os.path.exists(target_dir):
os.mkdir(target_dir)
imgs_list, labels_list = img_label_tuple_list[i]
for img, label in zip(imgs_list, labels_list):
# 解析标签：原标签是 "phone yaowu chengdu"，拆分后获取多级目录
label_parts = label.split(' ') # 如 ["phone1", "当归", "完整"]
# 原始图片路径：dataset1/zhongyiyao/phone1/当归/完整/[图片]
source_img = os.path.join(data_dir, label_parts, img) # label_parts解包为多级路径
# 目标类别目录：train/当归_完整（合并药材和程度作为新类别）
target_subdir = os.path.join(target_dir, f"{label_parts[1]}_{label_parts[2]}") # 如 "当归_完整"
if not os.path.exists(target_subdir):
os.mkdir(target_subdir)
# 移动图片到目标路径
shutil.move(source_img, os.path.join(target_subdir, img))
场景：原始目录是多层嵌套结构（如`phone（设备）→ yaowu（药材）→ chengdu（状态）`三级目录），未做任何划分。
操作：
1. 收集数据：遍历所有嵌套目录，提取所有图片路径，并生成复合标签（如`"phone1 当归 完整"`）。
2. 数据划分：使用`split_data`函数按6:2:2划分训练集、验证集、测试集。
3. 整理目录：为每个划分集（train/valid/test）创建目录，并将图片移动到对应目录下的新类别子目录（合并`yaowu`和`chengdu`作为类别名，如`当归_完整`），简化后续模型输入结构。
1.2数据增强
要求：
补充如下代码中的空白处
主要完成：
1. 使用GeneratorDataset接口将数据转换为Dataset
2. 定义相应的裁剪策略，对数据集进行裁剪操作
3. 定义通道变换操作，将输入图像的shape从 <H, W, C> 转换为 <C, H, W>
4. 输出数据集的size大小
1.2.1创建带标签的可迭代对象
导入GeneratorDataset接口将数据转换为Dataset
from mindspore.dataset import GeneratorDataset
import mindspore.dataset.vision as vision
import mindspore.dataset.transforms as transforms
from mindspore import dtype as mstype
数据加载与标签生成
class Iterable:
def __init__(self,data_path):
self._data = []
self._label = []
self._error_list = []
if data_path.endswith(('JPG','jpg','png','PNG')):
image = Image.open(data_path)
self._data.append(image)
self._label.append(0)
else:
classes = os.listdir(data_path)
if '.ipynb_checkpoints' in classes:
classes.remove('.ipynb_checkpoints')
for (i,class_name) in enumerate(classes):
new_path = data_path+"/"+class_name
for image_name in os.listdir(new_path):
try:
image = Image.open(new_path + "/" + image_name)
self._data.append(image)
self._label.append(i)
except:
pass def __getitem__(self, index):
return self._data[index], self._label[index] def __len__(self):
return len(self._data) def get_error_list(self,):
return self._error_list
1.2.2数据预处理与格式化（ms的data格式）
def create_dataset_zhongyao(dataset_dir,usage,resize,batch_size,workers):
data = Iterable(dataset_dir)
# 要点1-2-1：使用GeneratorDataset接口将数据转换为Dataset
data_set = GeneratorDataset(source=data, column_names=['image','label'])
trans = []
# 要点1-2-2：定义相应的裁剪策略，对数据集进行裁剪操作
# RandomCrop:
# 1.size (Union[int, Sequence[int]]) - 裁剪图像的输出尺寸大小。设置为700;
# 2.padding (Union[int, Sequence[int]], 可选) - 图像各边填充的像素数。设置为一个包含4个其值为4的元组。
# RandomHorizontalFlip:
# 1.prob (float, 可选) - 图像被翻转的概率设置为0.5
if usage == "train":
trans += [
vision.RandomCrop(size=700, padding=(4,4,4,4)),
vision.RandomHorizontalFlip(prob=0.5)
] trans += [
vision.Resize((resize,resize)),
vision.Rescale(1.0 / 255.0, 0.0),
vision.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]),
# 要点1-2-3：定义通道变换操作，将输入图像的shape从 <H, W, C> 转换为 <C, H, W>
vision.HWC2CHW()
] target_trans = transforms.TypeCast(mstype.int32)
data_set = data_set.map(
operations=trans,
input_columns='image',
num_parallel_workers=workers) data_set = data_set.map(
operations=target_trans,
input_columns='label',
num_parallel_workers=workers) data_set = data_set.batch(batch_size,drop_remainder=True) return data_set
从原始图像数据到 MindSpore 可训练 / 评估的数据集的完整构建流程
1. 数据加载与标签生成（Iterable类）
Iterable类作为数据迭代器，负责：
读取原始数据：支持两种输入格式：单个图像文件（如data_path="a.jpg"）：直接加载图像，标签默认设为 0。
类别目录（如data_path="train"，内部含class1/, class2/子目录）：按子目录遍历图像，标签为子目录的索引（如class1→0, class2→1）。
数据清洗：跳过无法读取的损坏图像（try-except），确保数据可靠性。
2. 数据预处理与格式化（create_dataset_zhongyao函数）
该函数将Iterable加载的原始数据转换为 MindSpore 的Dataset对象，并完成以下关键操作：
数据增强（训练模式）：
若usage="train"，添加随机裁剪（RandomCrop，尺寸 700，填充 4 像素）和随机水平翻转（RandomHorizontalFlip，概率 0.5），提升模型泛化能力。通用预处理：统一缩放到目标尺寸（resize，如 224×224）
像素归一化（Rescale：0-255→0-1；Normalize：按均值 / 标准差标准化）
通道转换（HWC2CHW）：将图像格式从[H, W, C]转为 MindSpore 要求的[C, H, W]
标签处理：将标签类型转换为int32（适配 MindSpore 计算）
分批处理：按batch_size打包数据，丢弃不足一批的剩余样本（drop_remainder=True）
一句话讲：Iterable类把还只是图片的数据先 -> 可迭代的(图片+1个对应标签)；数据预处理与格式化（create_dataset_zhongyao函数）把‘可迭代的(图片+1个对应标签)’转换成mindspore输入需要的数据格式(data_set = GeneratorDataset(source=data, column_names=['image','label']))
1.2.3加载数据
对数据集使用定义好的方式进行加载
import mindspore as ms
import random
经过1.2.2的处理，现在每一份数据（图片+1个标签）都是ms的支持数据类型，为此将数据放到我们需要的文件目录下（符合ms在进行训练时对数据的结构化提取范式）
data_dir = "dataset1/zhongyiyao"
train_dir = data_dir+"/"+"train"
valid_dir = data_dir+"/"+"valid"
test_dir = data_dir+"/"+"test"
batch_size = 32
image_size = 224
workers = 4
num_classes = 12
# 要点1-2-4:输出数据集的size大小
dataset_train = create_dataset_zhongyao(dataset_dir=train_dir,
usage="train",
resize=image_size,
batch_size=batch_size,
workers=workers)
step_size_train = dataset_train.get_batch_size() # 返回batch的数量dataset_val = create_dataset_zhongyao(dataset_dir=valid_dir,
usage="valid",
resize=image_size,
batch_size=batch_size,
workers=workers)
step_size_val = dataset_val.get_batch_size() # 返回batch的数量dataset_test = create_dataset_zhongyao(dataset_dir=test_dir,
usage="test",
resize=image_size,
batch_size=batch_size,
workers=workers)
step_size_test = dataset_test.get_batch_size() # 返回batch的数量print(f'训练集数据：{step_size_train*batch_size}\n')
print(f'验证集数据：{step_size_val*batch_size}\n')
print(f'测试集数据：{step_size_test*batch_size}\n')
ps：
代码功能：step_size_train * batch_size计算的是训练集总数据量（同理step_size_val * batch_size是验证集、step_size_test * batch_size是测试集），而非 “每个 epoch 的数据量”。每个 epoch 的数据量本身就是数据集总样本数，与代码计算的结果一致。
训练集、验证集、测试集数据量关系：
三者数据量无需相同，训练也不会因它们不同而 “出现问题”。例如，常见的划分比例（如 6:2:2）会使三者数据量不同，这是正常且合理的，分别用于模型训练、超参数调整和性能评估，功能不同，数据量无需一致。
加载数据代码说明
1. 创建数据集对象
通过create_dataset_zhongyao函数创建训练集、验证集、测试集的数据集对象：
dataset_train = create_dataset_zhongyao(dataset_dir=train_dir, usage="train", ...)
dataset_val = create_dataset_zhongyao(dataset_dir=valid_dir, usage="valid", ...)
dataset_test = create_dataset_zhongyao(dataset_dir=test_dir, usage="test", ...)
函数作用：假设create_dataset_zhongyao是一个自定义的数据加载函数，可能包含以下功能：从指定目录（如train_dir）加载图片和标签；
预处理（resize、归一化、数据增强等，usage="train"时可能包含随机翻转 / 裁剪等增强操作，验证集 / 测试集不增强）；
封装为可迭代的数据集对象（如 PyTorch 的DataLoader或 MindSpore 的Dataset），支持按批量输出数据。
2. 获取批量数量1epoch中step--batch，batch的数据容量--batch_size，数据量step*batch_szie
通过get_batch_size()方法获取每个数据集的批量数量（即每个 epoch 需要迭代的次数）：
# 训练集的批量数量
step_size_train = dataset_train.get_batch_size()
step_size_val = dataset_val.get_batch_size()
step_size_test = dataset_test.get_batch_size()
mindspore中get_batch_size()是返回batch的数量，和参数设置里‘batch_size = 32’的功能不相同，参数设置里的是每个batch的容量，数据总量=batch的数量*每个batch的容量
1.2.4类别标签说明
- ph-sp：蒲黄-生品
- ph_bj：蒲黄-不及
- ph_sz：蒲黄-适中
- ph_tg：蒲黄-太过
- sz_sp：山楂-生品
- sz_bj：山楂-不及
- sz_sz：山楂-适中
- sz_tg：山楂-太过
- wblx_sp：王不留行-生品
- wblx_bj：王不留行-不及
- wblx_sz：王不留行-适中
- wblx_tg：王不留行-太过
index_label_dict = {}
classes = os.listdir(train_dir)
if '.ipynb_checkpoints' in classes:
classes.remove('.ipynb_checkpoints')
for i,label in enumerate(classes):
index_label_dict[i] = labelindex_label_dict
初始化空字典 index_label_dict
index_label_dict = {}
创建一个空字典，用于存储 “整数索引 → 原始标签名称” 的映射关系（后续用于将模型输出的索引转换为实际标签）
获取训练集的类别目录列表
classes = os.listdir(train_dir)
train_dir是训练集的根目录（如"dataset1/zhongyiyao/train"）。
os.listdir(train_dir)会列出该目录下的所有子目录 / 文件，这里假设train_dir的子目录是类别目录（例如ph_sp、sz_bj等，每个目录存储对应类别的图片）。
移除 Jupyter 临时文件
if '.ipynb_checkpoints' in classes:
classes.remove('.ipynb_checkpoints')
.ipynb_checkpoints是 Jupyter Notebook 自动生成的临时文件目录，并非实际的类别目录。
若存在该目录，则从classes列表中移除，避免干扰后续类别标签的统计。
构建 “索引→原始标签” 映射字典
for i, label in enumerate(classes):
index_label_dict[i] = label
使用enumerate(classes)遍历类别列表，i是自动生成的整数索引（从 0 开始），label是类别名称（如ph_sp）。
最终index_label_dict的格式为：{0: 'ph_sp', 1: 'ph_bj', 2: 'ph_sz', ...}，即每个类别对应一个唯一的整数索引（模型中常用这种方式表示类别）。
定义 “原始标签→中文标签” 映射字典 label2chin
label2chin = {
'ph_sp':'蒲黄-生品', 'ph_bj':'蒲黄-不及', 'ph_sz':'蒲黄-适中', 'ph_tg':'蒲黄-太过',
'sz_sp':'山楂-生品', 'sz_bj':'山楂-不及', 'sz_sz':'山楂-适中', 'sz_tg':'山楂-太过',
'wblx_sp':'王不留行-生品', 'wblx_bj':'王不留行-不及', 'wblx_sz':'王不留行-适中', 'wblx_tg':'王不留行-太过'
}
键是原始标签（如ph_sp），值是对应的中文标签（如 “蒲黄 - 生品”）。
作用：将模型中使用的原始标签（可能是英文缩写）转换为更易理解的中文描述，方便后续可视化、报告生成或人工检查。
输出 index_label_dict
index_label_dict
直接输出该字典，展示索引与原始标签的对应关系
# 预设中文标签，方便后续可视化和人工检查
label2chin = {'ph_sp':'蒲黄-生品', 'ph_bj':'蒲黄-不及', 'ph_sz':'蒲黄-适中', 'ph_tg':'蒲黄-太过', 'sz_sp':'山楂-生品',
'sz_bj':'山楂-不及', 'sz_sz':'山楂-适中', 'sz_tg':'山楂-太过', 'wblx_sp':'王不留行-生品', 'wblx_bj':'王不留行-不及',
'wblx_sz':'王不留行-适中', 'wblx_tg':'王不留行-太过'}
1.3数据可视化
要求：
补充如下代码的空白处
主要完成：
1. 利用create_dict_iterator API创建数据迭代器，并打印label列表
2. 利用transpose接口将通道维度移动到最后：CHW -> HWC
- 反归一化操作：利用std和mean对image_trans进行反归一化运算
导入可视化库matplotlib.pyplot和科学计算库numpy
import matplotlib.pyplot as plt
import numpy as np
创建数据迭代器，并打印label列表
# 要点1-3-1:利用create_dict_iterator API创建数据迭代器，并打印label列表
data_iter = dataset_train.create_dict_iterator() batch = next(data_iter)
images = batch["image"].asnumpy()
labels = batch["label"].asnumpy()
print(f"Image shape: {images.shape}, Label: {labels}")
数据可视化，反归一化，matplotlib需要HWC格式呈现正常的图像数据（而AI框架一般为了性能和高效的数据处理需要图像数据为CHW）
plt.figure(figsize=(12, 5))
for i in range(24):
plt.subplot(3, 8, i+1)
# 要点1-3-2:利用transpose接口将通道维度移动到最后：CHW -> HWC
image_trans = np.transpose(images[i], (1,2,0))
mean = np.array([0.4914, 0.4822, 0.4465])
std = np.array([0.2023, 0.1994, 0.2010])
# 要点1-3-3:反归一化操作：利用std和mean对image_trans进行反归一化运算
image_trans = image_trans*std + mean
image_trans = np.clip(image_trans, 0, 1)
plt.title(index_label_dict[labels[i]])
plt.imshow(image_trans)
plt.axis("off")
plt.show()
ps:
重点说明：
归一化操作--图像数据预处理：image =（image-mean）/std
反归一化操作--重新回到原来的图像进行数据可视化：image = image*std + mean
数据可视化代码说明
1. 创建画布并设置尺寸
plt.figure(figsize=(12, 5))
功能：创建一个 Matplotlib 画布（figure），用于容纳后续的子图。
figsize=(12,5)：设置画布的宽度为 12 英寸，高度为 5 英寸（根据 24 张子图的布局调整尺寸，确保图像清晰）。
2. 循环绘制 24 张子图
for i in range(24):
plt.subplot(3, 8, i+1)
功能：在画布上划分 3 行 8 列的子图网格（共 3×8=24 个位置），循环遍历每个位置绘制一张图片。
plt.subplot(3,8,i+1)：指定当前子图的位置（第i+1个位置，索引从 1 开始）。例如，i=0时绘制第 1 个位置（第 1 行第 1 列），i=23时绘制第 24 个位置（第 3 行第 8 列）。
3. 调整图像通道维度顺序（CHW → HWC）
image_trans = np.transpose(images[i], (1,2,0))
背景：在深度学习框架（如 PyTorch）中，图像数据通常以[C, H, W]（通道数 × 高度 × 宽度）的格式存储（简称 CHW）；但 Matplotlib 的plt.imshow要求图像格式为[H, W, C]（高度 × 宽度 × 通道数，简称 HWC）。
操作：使用np.transpose调整维度顺序。(1,2,0)表示将原维度索引（假设images[i]的形状为(3, 224, 224)，即 C=3, H=224, W=224）的第 1 维（H）、第 2 维（W）、第 0 维（C）重新排列，得到(224, 224, 3)的 HWC 格式。
4. 反归一化恢复原始图像像素值
mean = np.array([0.4914, 0.4822, 0.4465])
std = np.array([0.2023, 0.1994, 0.2010])
image_trans = image_trans * std + mean
image_trans = np.clip(image_trans, 0, 1)
背景：在模型训练前，图像通常会进行归一化预处理（公式：(image - mean) / std），将像素值缩放到[0,1]区间并符合模型输入要求。但归一化后的图像无法直接可视化（像素值偏离真实颜色），因此需要反归一化恢复原始像素。
反归一化公式：image = image_normalized * std + mean（逆向操作归一化公式）。
np.clip(image_trans, 0, 1)：由于浮点运算误差，反归一化后的像素值可能略微超出[0,1]范围（如 - 0.001 或 1.002），使用clip将其限制在[0,1]内，避免显示异常（如颜色失真）。
5. 设置子图标题并显示图像
plt.title(index_label_dict[labels[i]])
plt.imshow(image_trans)
plt.axis("off")
plt.title(...)：设置子图的标题为当前图像的类别标签。labels[i]是图像的类别索引（如 0、1、2...），通过index_label_dict映射为实际类别名称（如ph_sp）。
plt.imshow(image_trans)：显示处理后的图像（HWC 格式，像素值已恢复）。
plt.axis("off")：关闭子图的坐标轴显示，使图像更整洁。
6. 显示最终画布
plt.show()
将所有子图绘制到画布上并显示（如在 Jupyter Notebook 中会直接渲染，在脚本中会弹出窗口）。
ps：前面数据处理-数据增强部分使用的图像归一化操作
数据增强部分（训练集专用）
if usage == "train":
trans += [
vision.RandomCrop(size=700, padding=(4,4,4,4)),
vision.RandomHorizontalFlip(prob=0.5)]
功能：这部分代码是专门针对训练集的数据增强操作。
详细解释：vision.RandomCrop(size=700, padding=(4,4,4,4))：对图像进行随机裁剪。首先在图像周围填充 4 个像素，然后随机裁剪出一个大小为 700x700 的区域。这样可以增加数据的多样性，使模型学习到不同位置的特征。
vision.RandomHorizontalFlip(prob=0.5)：以 0.5 的概率对图像进行水平翻转。这也是一种常见的数据增强方式，能让模型学习到图像在水平方向上的不同表现。
通用预处理部分
trans += [
vision.Resize((resize,resize)),
vision.Rescale(1.0 / 255.0, 0.0),
vision.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]),# 题目1-2-3：定义通道变换操作，将输入图像的shape从 <H, W, C> 转换为 <C, H, W>
vision.HWC2CHW()
]
功能：这部分代码是对所有数据集（训练集、验证集、测试集）都进行的通用预处理操作。
详细解释：
vision.Resize((resize,resize))：将图像的尺寸调整为 resize x resize 大小，确保所有输入图像的尺寸一致，以适应模型的输入要求。
vision.Rescale(1.0 / 255.0, 0.0)：将图像的像素值从 [0, 255] 范围缩放到 [0, 1] 范围。这是因为大多数深度学习模型更适合处理在 [0, 1] 范围内的输入数据。
vision.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010])：对图像进行归一化操作。通过减去均值 [0.4914, 0.4822, 0.4465] 并除以标准差 [0.2023, 0.1994, 0.2010]，将图像的像素值进一步标准化，有助于模型更快地收敛。
vision.HWC2CHW()：将图像的通道维度从 (H, W, C)（高度、宽度、通道数）转换为 (C, H, W)（通道数、高度、宽度）。这是因为很多深度学习框架（如 PyTorch）要求输入图像的格式为 (C, H, W)。