深度学习落地实战:手势识别

前言

大家好,我是机长

本专栏将持续收集整理市场上深度学习的相关项目,旨在为准备从事深度学习工作或相关科研活动的伙伴,储备、提升更多的实际开发经验,每个项目实例都可作为实际开发项目写入简历,且都附带完整的代码与数据集。可通过百度云盘进行获取,实现开箱即用

正在跟新中~

项目背景

(基于CNN实现手势识别)

在5G时代,随着网络速度的大幅提升和低延迟特性的普及,手势识别技术迎来了前所未有的发展机遇,特别是在视频直播、智能家居和智能驾驶等领域。这些应用场景都极大地依赖于用户与设备之间的高效、直观交互,而手势识别正是实现这一目标的关键技术之一。

项目环境

  • 平台:windows 10
  • 语言环境:python 3.8
  • 编辑器:PyCharm
  • PyThorch版本:1.8

1.创建并跳转到虚拟环境

python -m venv myenv

myenv\Scripts\activate.bat
  1. 虚拟环境pip命令安装其他工具包

    pip install torch torchvision torchaudio

注:此处只示范安装pytorch,其他工具包安装类似,可通过运行代码查看所确实包提示进行安装

3.pycharm 运行环境配置

进入pytcharm =》点击file =》点击settings=》点击Project:...=》点击 Python Interpreter,进入如下界面

点击add =》点击Existing environment =》 点击 ... =》选择第一步1创建虚拟环境目录myenv\Scripts\下的python.exe文件点击ok完成环境配置

数据集介绍

训练数据样式

数据集是一个包含手势识别信息的综合数据集,具体特点如下:

参与者数量:数据集由14个不同的个体(或"受试者")组成,每个人都在数据集中贡献了他们的手势数据。

手势种类:每个参与者执行了10种不同的手势,这些手势可能代表了特定的命令、符号或动作,具体取决于数据集的设计目的。

数据重复性:为了增加数据集的多样性和鲁棒性,每种手势都被每个参与者重复了10次。这意味着对于每个手势,数据集都包含了来自每个参与者的10个样本。

总数据量:综合以上信息,数据集总共包含了14(人)x 10(手势种类)x 10(重复次数)= 1400个手势样本。

数据来源:

Kinect数据:这些数据通过Microsoft Kinect传感器获取,可能包括深度图像、彩色图像、骨骼跟踪数据等。Kinect的校准参数也被提供,这对于确保数据的准确性和一致性至关重要。

Leap Motion数据:Leap Motion是一种小型的手部追踪设备,能够提供高精度的手部姿势和手指运动数据。Leap SDK(软件开发工具包)提供的所有相关参数都被包含在内,这些参数可能包括手掌位置、手指关节角度、指尖位置等。

训练数据获取:

私信博主获取

LeNet网络介绍

LeNet网络,由Yann LeCun及其团队在1990年代初期设计并优化,是卷积神经网络(CNN)领域的先驱之作。其最为人熟知的版本是LeNet-5,该网络在1998年被正式提出,主要用于手写数字识别,尤其是MINIST数据集上的表现尤为出色。

LeNet-5的结构相对简洁而高效,包括两个卷积层(C1、C3)、两个池化层(S2、S4)、两个全连接层(F6、OUTPUT)以及输入层和输出层。卷积层通过卷积核自动提取图像中的特征,池化层则通过下采样减少数据的空间尺寸,同时保留重要信息。全连接层则将提取的特征映射到最终的分类结果上。

LeNet网络的核心优势在于其自动提取特征的能力,这大大减少了传统图像识别方法中对手动设计特征的依赖。此外,其结构简单、计算量相对较小,使得在当时的硬件条件下也能实现较快的训练和推理速度。

然而,受限于当时的硬件条件和计算资源,LeNet网络的规模相对较小,难以处理更大规模或更复杂的图像识别任务。随着计算机硬件和深度学习技术的飞速发展,更加深层、更加复杂的卷积神经网络被设计出来,如AlexNet、VGG、ResNet等,它们在图像识别、分类、检测等领域取得了更加卓越的性能。

尽管如此,LeNet网络作为卷积神经网络的开山之作,其设计思想和基本结构仍然对后来的研究产生了深远的影响。它证明了卷积神经网络在图像识别领域的巨大潜力,并为后续的研究提供了宝贵的经验和启示。在今天,LeNet网络仍然被广泛应用于教学和科研领域,作为学习深度学习和卷积神经网络的基础模型之一。

定义CNN网络

  • 卷积层:用于图像的高级特征

  • 输出层:将卷积提取出的特征进行分类

    class LeNet5(nn.Module):
    def init(self,num_class=10):
    super(LeNet5,self).init()
    self.conv1 = nn.Conv2d(3, 8, 5)
    self.pool1 = nn.AvgPool2d((2, 2))

          self.conv2 = nn.Conv2d(8, 16, 5)
          self.pool2 = nn.AvgPool2d((2, 2))
          
          self.conv3 = nn.Conv2d(16, 32, 5)
          
          self.relu = nn.ReLU()
    
          self.fc1 = nn.Linear(28800, 1024)
          self.fc2 = nn.Linear(1024, num_class)
          
      def forward(self, x):
          # x: torch.Size([32, 3, 150, 150])
          
          x = self.conv1(x) # torch.Size([32, 8, 146, 146])
          x = self.relu(x)
          x = self.pool1(x) # torch.Size([32, 8, 73, 73])
    
          x = self.conv2(x) # torch.Size([32, 16, 69, 69])
          x = self.relu(x)
          x = self.pool2(x) # torch.Size([32, 16, 34, 34])
    
          x = self.conv3(x) # torch.Size([32, 32, 30, 30])
          x = self.relu(x)
          
          x = x.flatten(start_dim=1) # torch.Size([32, 28800])
          
          x = self.fc1(x) # torch.Size([32, 2024])
          x = self.relu(x)
          x = self.fc2(x) # torch.Size([32, 4])
    
          return x
    

加载数据集

# 1.数据转换
data_transform = {
    # 训练中的数据增强和归一化
    'train': transforms.Compose([
        transforms.RandomResizedCrop(150), # 随机裁剪
        transforms.ToTensor(), # 均值方差归一化
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ])
}

# 2.形成训练集
train_dataset = datasets.ImageFolder(root=os.path.join(image_path),
                                     transform=data_transform['train'])


# 3.形成迭代器
train_loader = torch.utils.data.DataLoader(train_dataset,
                                           batch_size,
                                           True)

print('using {} images for training.'.format(len(train_dataset)))

测试代码

# 加载索引与标签映射字典
with open('class_dict.pk', 'rb') as f:
    class_dict = pickle.load(f)

# 数据变换
data_transform = transforms.Compose([
     transforms.CenterCrop(150),
     transforms.ToTensor(),
     transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])

# 图片路径
img_path = r'./data/000-one/gesture-one-2021-03-07_23-07-48-1_37388.jpg'

# 打开图像
img = Image.open(img_path)
print(np.array(img).shape)

# 对图像进行变换
img = data_transform(img)

plt.imshow(img.permute(1,2,0))
plt.show()


# 将图像升维,增加batch_size维度
img = torch.unsqueeze(img, dim=0)

# 获取预测结果
pred = class_dict[model(img).argmax(axis=1).item()]
print('【预测结果分类】:%s' % pred)

完整运行代码

import math
import pickle
import os

import numpy as np
import pandas as pd
import torch
import torch.nn as nn
from keras.preprocessing.sequence import pad_sequences
from sklearn.model_selection import train_test_split
from torch.utils.data import TensorDataset
from torchvision import transforms, datasets
from torch import optim
from torchnet import meter
from tqdm import tqdm
from PIL import Image

import matplotlib.pyplot as plt

# 模型输入参数,需要自己根据需要调整
num_class = 14 # 分类数
epochs = 20 # 迭代次数
batch_size = 64 # 每个批次样本大小
lr = 0.003 # 学习率
image_path = './data' # 图像数据路径
save_path = './best_model.pkl' # 模型保存路径
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') # 设备

# 1.数据转换
data_transform = {
    # 训练中的数据增强和归一化
    'train': transforms.Compose([
        transforms.RandomResizedCrop(150), # 随机裁剪
        transforms.ToTensor(), # 均值方差归一化
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ])
}

# 2.形成训练集
train_dataset = datasets.ImageFolder(root=os.path.join(image_path),
                                     transform=data_transform['train'])


# 3.形成迭代器
train_loader = torch.utils.data.DataLoader(train_dataset,
                                           batch_size,
                                           True)

print('using {} images for training.'.format(len(train_dataset)))

# 4.建立分类标签与索引的关系
cloth_list = train_dataset.class_to_idx
class_dict = {}
for key, val in cloth_list.items():
    class_dict[val] = key
with open('class_dict.pk', 'wb') as f:
    pickle.dump(class_dict, f)

class LeNet5(nn.Module):
    def __init__(self,num_class=10):
        super(LeNet5,self).__init__()
        self.conv1 = nn.Conv2d(3, 8, 5)
        self.pool1 = nn.AvgPool2d((2, 2))
        
        self.conv2 = nn.Conv2d(8, 16, 5)
        self.pool2 = nn.AvgPool2d((2, 2))
        
        self.conv3 = nn.Conv2d(16, 32, 5)
        
        self.relu = nn.ReLU()

        self.fc1 = nn.Linear(28800, 1024)
        self.fc2 = nn.Linear(1024, num_class)
        
    def forward(self, x):
        # x: torch.Size([32, 3, 150, 150])
        
        x = self.conv1(x) # torch.Size([32, 8, 146, 146])
        x = self.relu(x)
        x = self.pool1(x) # torch.Size([32, 8, 73, 73])

        x = self.conv2(x) # torch.Size([32, 16, 69, 69])
        x = self.relu(x)
        x = self.pool2(x) # torch.Size([32, 16, 34, 34])

        x = self.conv3(x) # torch.Size([32, 32, 30, 30])
        x = self.relu(x)
        
        x = x.flatten(start_dim=1) # torch.Size([32, 28800])
        
        x = self.fc1(x) # torch.Size([32, 2024])
        x = self.relu(x)
        x = self.fc2(x) # torch.Size([32, 4])

        return x

# 6.模型训练
model = LeNet5(num_class)
model = model.to('cpu')
criterion = nn.CrossEntropyLoss() # 损失函数
optimizer = torch.optim.Adam(model.parameters(), lr=lr) # 优化器

best_acc = 0 # 最优精确率
best_model = None # 最优模型参数

for epoch in range(epochs):
    model.train()
    running_loss = 0 # 损失
    epoch_acc = 0  # 每个epoch的准确率
    epoch_acc_count = 0  # 每个epoch训练的样本数
    train_count = 0  # 用于计算总的样本数,方便求准确率
    train_bar = tqdm(train_loader)
    for data in train_bar:
        images, labels = data
        optimizer.zero_grad()
        output = model(images.to(device))
        loss = criterion(output, labels.to(device))
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
                                                                 epochs,
                                                                 loss)
        # 计算每个epoch正确的个数
        epoch_acc_count += (output.argmax(axis=1) == labels.view(-1)).sum()
        train_count += len(images)

    # 每个epoch对应的准确率
    epoch_acc = epoch_acc_count / train_count

    # 打印信息
    print("【EPOCH: 】%s" % str(epoch + 1))
    print("训练损失为%s" % str(running_loss))
    print("训练精度为%s" % (str(epoch_acc.item() * 100)[:5]) + '%')

    if epoch_acc > best_acc:
        best_acc = epoch_acc
        best_model = model.state_dict()

    # 在训练结束保存最优的模型参数
    if epoch == epochs - 1:
        # 保存模型
        torch.save(best_model, save_path)

print('Finished Training')

# 加载索引与标签映射字典
with open('class_dict.pk', 'rb') as f:
    class_dict = pickle.load(f)

# 数据变换
data_transform = transforms.Compose([
     transforms.CenterCrop(150),
     transforms.ToTensor(),
     transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])

# 图片路径
img_path = r'./data/000-one/gesture-one-2021-03-07_23-07-48-1_37388.jpg'

# 打开图像
img = Image.open(img_path)
print(np.array(img).shape)

# 对图像进行变换
img = data_transform(img)

plt.imshow(img.permute(1,2,0))
plt.show()


# 将图像升维,增加batch_size维度
img = torch.unsqueeze(img, dim=0)

# 获取预测结果
pred = class_dict[model(img).argmax(axis=1).item()]
print('【预测结果分类】:%s' % pred)
相关推荐
用户6915811416528 分钟前
Ascend Extension for PyTorch的源码解析
人工智能
-Nemophilist-1 小时前
机器学习与深度学习-1-线性回归从零开始实现
深度学习·机器学习·线性回归
成富1 小时前
文本转SQL(Text-to-SQL),场景介绍与 Spring AI 实现
数据库·人工智能·sql·spring·oracle
CSDN云计算2 小时前
如何以开源加速AI企业落地,红帽带来新解法
人工智能·开源·openshift·红帽·instructlab
艾派森2 小时前
大数据分析案例-基于随机森林算法的智能手机价格预测模型
人工智能·python·随机森林·机器学习·数据挖掘
hairenjing11232 小时前
在 Android 手机上从SD 卡恢复数据的 6 个有效应用程序
android·人工智能·windows·macos·智能手机
小蜗子2 小时前
Multi‐modal knowledge graph inference via media convergenceand logic rule
人工智能·知识图谱
SpikeKing2 小时前
LLM - 使用 LLaMA-Factory 微调大模型 环境配置与训练推理 教程 (1)
人工智能·llm·大语言模型·llama·环境配置·llamafactory·训练框架
黄焖鸡能干四碗3 小时前
信息化运维方案,实施方案,开发方案,信息中心安全运维资料(软件资料word)
大数据·人工智能·软件需求·设计规范·规格说明书
3 小时前
开源竞争-数据驱动成长-11/05-大专生的思考
人工智能·笔记·学习·算法·机器学习