【掌上心语】PaddlePaddle 3.0实现29类智能手语识别助力残障人士

# 数据集解压到work文件夹内!tar -xvf /home/aistudio/data/data292697/shouyu.tar -C work/

#分别读取train.txt和val.txt文件内的内容# 初始化一个空列表来存储文件内容train_list = []
val_list = []# 打开文件并读取每一行with open('/home/aistudio/work/iamges/train.txt', 'r') as file:    for line in file:        # 分割每行的图像路径和标签
        path, label = line.strip().split(' ')        # 将路径和标签作为列表添加到train_list中
        train_list.append([path, label])# 打开文件并读取每一行with open('/home/aistudio/work/iamges/val.txt', 'r') as file:    for line in file:        # 分割每行的图像路径和标签
        path, label = line.strip().split(' ')        # 将路径和标签作为列表添加到val_list中
        val_list.append([path, label])# 打印列表内容print(train_list)# 打印列表内容print(val_list)

# 对数据集处理，将路径添加到前缀，并统计每个数据集的类别数量prefix = 'work/iamges'train_list = [[f'{prefix}/{item[0]}',item[1]] for item in train_list]
val_list = [[f'{prefix}/{item[0]}',item[1]] for item in val_list]# 打印新的列表以验证print(train_list[10])print(val_list[10])print(type(train_list[10]))print(type(val_list[10]))print("训练集样本数量是：{}".format(len(train_list)))print("验证集样本数量是：{}".format(len(val_list)))

import matplotlib.pyplot as plt# 假设这是从文件中读取的数据列表train_data = train_list
val_data = val_list# 初始化字典来存储每个数据集的类别数量train_category_counts = {str(i): 0 for i in range(29)}  # 假设有0-28共29个类别val_category_counts = {str(i): 0 for i in range(29)}# 统计训练集每个类别的数量for item in train_data:
    category = item[1]
    train_category_counts[category] += 1# 统计验证集每个类别的数量for item in val_data:
    category = item[1]
    val_category_counts[category] += 1# 类别编号到标签的映射category_mapping = {    '0': 'A', '1': 'B', '2': 'C', '3': 'D', '4': 'del', '5': 'E', '6': 'F', '7': 'G', '8': 'H', '9': 'I',    '10': 'J', '11': 'K', '12': 'L', '13': 'M', '14': 'N', '15': 'nothing', '16': 'O', '17': 'P', '18': 'Q',    '19': 'R', '20': 'S', '21': 'space', '22': 'T', '23': 'U', '24': 'V', '25': 'W', '26': 'X', '27': 'Y', '28': 'Z'}# 使用映射更新类别计数字典的键train_category_counts = {category_mapping[key]: value for key, value in train_category_counts.items()}
val_category_counts = {category_mapping[key]: value for key, value in val_category_counts.items()}# 创建条形图plt.figure(figsize=(15, 8))
bar_width = 0.5index = list(range(len(train_category_counts)))  # 使用数值索引# 绘制训练集的条形图train_bars = plt.bar([i - bar_width/2 for i in index], list(train_category_counts.values()), bar_width, label='Train', color='skyblue')# 绘制验证集的条形图val_bars = plt.bar([i + bar_width/2 for i in index], list(val_category_counts.values()), bar_width, label='Validation', color='orange')# 添加类别标签category_labels = list(train_category_counts.keys())
plt.xticks([i for i in index], category_labels, rotation=45, ha='right')# 添加图表标题和轴标签plt.xlabel('label', fontsize=14, fontweight='bold')  # 设置 x 轴标签并加粗加大plt.ylabel('Count', fontsize=14, fontweight='bold')  # 设置 y 轴标签并加粗加大plt.title('Dataset visualization', fontsize=18, fontweight='bold')
plt.legend()# 在每个条形上添加数量标签for i in index:    # 训练集数量标签
    plt.text(i - bar_width/2, list(train_category_counts.values())[i] + 50, str(list(train_category_counts.values())[i]), ha='center', va='bottom', fontsize=8)    # 验证集数量标签
    plt.text(i + bar_width/2, list(val_category_counts.values())[i] + 50, str(list(val_category_counts.values())[i]), ha='center', va='bottom', fontsize=8)

plt.tight_layout()
plt.show()

import paddlefrom paddle.vision.transforms import Compose, Resize, Normalizefrom PIL import Imageimport numpy as npfrom paddle.io import Dataset# 自定义的数据预处理函数，输入原始图像，输出处理后的图像def preprocess(img):
    transform = Compose([
        Resize(size=(224, 224)),  # 调整图像大小为224x224
        Normalize(mean=[127.5, 127.5, 127.5], std=[127.5, 127.5, 127.5], data_format='HWC'),  # 标准化
    ])
    img = transform(img)
    img = np.array(img).transpose((2, 0, 1)).astype('float32')  # 转换数据格式从HWC到CHW
    img = paddle.to_tensor(img)  # 将numpy数组转换为paddle张量
    return img# 自定义数据读取器class Reader(Dataset):
    def __init__(self, data):
        super().__init__()
        self.samples = data  # 使用全部数据

    def __getitem__(self, idx):
        # 处理图像
        img_path = self.samples[idx][0]  # 获取图像路径
        img = Image.open(img_path)        if img.mode != 'RGB':
            img = img.convert('RGB')
        img = preprocess(img)  # 数据预处理

        # 处理标签
        label = self.samples[idx][1]  # 获取标签
        label = np.array([label], dtype='int64')  # 转换标签数据类型为int64
        return img, label    def __len__(self):
        # 返回数据集中图片的数量
        return len(self.samples)# 生成训练数据集实例train_dataset = Reader(train_list)# 生成验证数据集实例eval_dataset = Reader(val_list)# # 打印数据集大小# print(len(train_dataset))# print(len(eval_dataset))# # 打印一个训练样本的形状和标签# print(train_dataset[0][0].shape)# print(train_dataset[0][1])# print(type(train_dataset[0][1]))

import matplotlib.pyplot as pltimport numpy as npfrom paddle.io import Dataset# 定义一个函数来显示图像和标签def visualize_data(dataset, num_images=16):
    plt.figure(figsize=(15, 15))  # 设置整个图像的大小
    indices = np.random.choice(len(dataset), num_images, replace=False)  # 随机选择索引
    for i, idx in enumerate(indices):        # 获取一个样本
        image, label = dataset[idx]        # 获取标签名称
        label_name = category_mapping[str(label[0])]  # 确保标签是字符串格式
        # 将图像数据重新缩放回 [0, 1] 范围
        image = (image.numpy().transpose((1, 2, 0)) + 1) / 2
        # 绘制图像
        plt.subplot(4, 4, i+1)  # 创建4x4网格中的子图
        plt.imshow(image)
        plt.title(f'Label: {label_name}')
        plt.axis('off')
    plt.show()# 确保 category_mapping 已经定义category_mapping = {    '0': 'A', '1': 'B', '2': 'C', '3': 'D', '4': 'del', '5': 'E', '6': 'F', '7': 'G', '8': 'H', '9': 'I',    '10': 'J', '11': 'K', '12': 'L', '13': 'M', '14': 'N', '15': 'nothing', '16': 'O', '17': 'P', '18': 'Q',    '19': 'R', '20': 'S', '21': 'space', '22': 'T', '23': 'U', '24': 'V', '25': 'W', '26': 'X', '27': 'Y', '28': 'Z'}# 显示训练集中随机抽取的16张图像visualize_data(train_dataset)

#定义模型class MyNet(paddle.nn.Layer):
    def __init__(self):
        super(MyNet,self).__init__()
        self.layer=paddle.vision.models.resnet50(pretrained=True)
        self.fc = paddle.nn.Linear(1000, 29)    #网络的前向计算过程
    def forward(self,x):
        x=self.layer(x)
        x=self.fc(x)        return x

# 定义输入input_define = paddle.static.InputSpec(shape=[-1,3,224,224], dtype="float32", name="img")
label_define = paddle.static.InputSpec(shape=[-1,1], dtype="int64",name="label")# 实例化网络对象并定义优化器等训练逻辑model = MyNet()
model = paddle.Model(model,inputs=input_define,labels=label_define) # 用Paddle.Model()对模型进行封装

optimizer = paddle.optimizer.Adam(learning_rate=0.01, parameters=model.parameters())# 上述优化器中的学习率(learning_rate)参数很重要。要是训练过程中得到的准确率呈震荡状态，忽大忽小，可以试试进一步把学习率调低。place = paddle.CUDAPlace(0)  # 使用第一个GPU设备model.prepare(optimizer=optimizer, # 指定优化器
              loss=paddle.nn.CrossEntropyLoss(), # 指定损失函数
              metrics=paddle.metric.Accuracy()) # 指定评估方法model.fit(train_data=train_dataset,     # 训练数据集
          eval_data=eval_dataset,         # 测试数据集
          batch_size=128,                  # 一个批次的样本数量
          epochs=5,                      # 迭代轮次
          save_dir="model/", # 把模型参数、优化器参数保存至自定义的文件夹
          save_freq=1,                    # 设定每隔多少个epoch保存模型参数及优化器参数
          log_freq=500,                    # 打印日志的频率)

最终验证集测试结果为

step 136/136 - loss: 0.0440 - acc: 0.9778 - 458ms/step

Eval samples: 17400

准确率高达97.8%

class InferDataset(Dataset):
    def __init__(self, img_path=None):
        """
        数据读取Reader(推理)
        :param img_path: 推理单张图片
        """
        super().__init__()        if img_path:
            self.img_paths = [img_path]        else:            raise Exception("请指定需要预测对应图片路径")    def __getitem__(self, index):
        # 获取图像路径
        img_path = self.img_paths[index]        # 使用Pillow来读取图像数据并转成Numpy格式
        img = Image.open(img_path)        if img.mode != 'RGB': 
            img = img.convert('RGB') 
        img = preprocess(img) #数据预处理--这里仅包括简单数据预处理，没有用到数据增强
        return img    def __len__(self):
        return len(self.img_paths)#实例化推理模型model = paddle.Model(MyNet(),inputs=input_define)#读取刚刚训练好的参数model.load('model/final')#准备模型model.prepare()#利用训练好的模型进行预测infer_path='/home/aistudio/work/iamges/train/E/E1000.jpg'# print(infer_path)infer_data = InferDataset(infer_path)

result = model.predict(test_data=infer_data)[0] 
# 关键代码，实现预测功能result = paddle.to_tensor(result)
result = np.argmax(result.numpy()) 
# 获得最大值所在的序号category_mapping = {    '0': 'A', '1': 'B', '2': 'C', '3': 'D', '4': 'del', '5': 'E', '6': 'F', '7': 'G', '8': 'H', '9': 'I',    '10': 'J', '11': 'K', '12': 'L', '13': 'M', '14': 'N', '15': 'nothing', '16': 'O', '17': 'P', '18': 'Q',    '19': 'R', '20': 'S', '21': 'space', '22': 'T', '23': 'U', '24': 'V', '25': 'W', '26': 'X', '27': 'Y', '28': 'Z'}print(category_mapping[str(result)])