├── train                   # 訓練集
├── G0                  # 手勢0
├── IMG_1118.jpg    # 手勢0的圖片
├──...
├── G1                  # 手勢1
├── IMG_1119.jpg
├──...
├──...
├── G9                  # 手勢9
├──test# 測試集
├── G0
├──...
├── G9

# 讀取gestures\train\G0目錄下的所有圖片路徑，添加至list中
import os
import random
import numpy as np
import cv2


defload_img_label(train_root):
    img_train =[]
    label_train =[]
for label in os.listdir(train_root):
        label_path = os.path.join(train_root, label)
# 排除掉.開頭的文件
if label.startswith('.'):
continue
for img_name in os.listdir(label_path):
            img_path = os.path.join(label_path, img_name)
            img_train.append(img_path)
            label_train.append(label)
return img_train, label_train

# 1，讀取基圖像的本信息
root ="gestures"

# 1,訓練集
train_root = os.path.join(root,'train')
train_img, train_label = load_img_label(train_root)


# 2,測試集
test_root = os.path.join(root,'test')
test_img, test_label = load_img_label(test_root)

lable_list =list(set(train_label))
lable_list.sort()

# 3,構建標簽字典
label2idx ={label: idx for idx, label inenumerate(lable_list)}
idx2label ={idx: label for idx, label inenumerate(lable_list)}
print(label2idx)
print(idx2label)

import torch
from torch.utils.data importDataset

classGesturesDataset(Dataset):
"""
    自定義數據集
    """
def__init__(self, X, y):
        self.X = X
        self.y = y

def__len__(self):
returnlen(self.X)

def__getitem__(self, idx):
        img_path = self.X[idx]
        img_label = self.y[idx]

# 1,讀取圖像
        img = cv2.imread(img_path)

# 2,圖像轉為32*32
        img = cv2.resize(img,(32,32))

# 3,圖像轉為numpy數組
        img = np.array(img)

# 4,數據規范化到 [-1, 1]
        img = img /255.0
        img =(img -0.5)/0.5

# 5,數據轉為torch張量
        img = torch.tensor(img, dtype=torch.float32)

# 6,數據轉維度 [H, W, C]
        img = img.permute(2,0,1)

# 7,標簽轉為數字
        label = label2idx[img_label]
        label = torch.tensor(label, dtype=torch.long)

return img, label

import torch
from torch import nn


classConvBlock(nn.Module):
"""
        一層卷積：
            - 卷積層
            - 批規范化層
            - 激活層
    """
def__init__(self, in_channels, out_channels, 
                 kernel_size=3, stride=1, padding=1):
super().__init__()
        self.conv = nn.Conv2d(in_channels=in_channels, out_channels=out_channels,
                             kernel_size=kernel_size, stride=stride,padding=padding)
        self.bn = nn.BatchNorm2d(num_features=out_channels)
        self.relu = nn.ReLU()

defforward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        x = self.relu(x)
return x

classLeNet(nn.Module):
def__init__(self, num_classes=10):
super().__init__()
# 1, 特征抽取部分
        self.feature_extractor = nn.Sequential(
# 卷積層1
ConvBlock(in_channels=3,
                      out_channels=6,
                      kernel_size=5,
                      stride=1,
                      padding=0),

# 亞采樣（池化）
            nn.MaxPool2d(kernel_size=2, stride=2, padding=0),

# 卷積層2
ConvBlock(in_channels=6,
                      out_channels=16,
                      kernel_size=5,
                      stride=1,
                      padding=0),

# 亞采樣（池化）
            nn.MaxPool2d(kernel_size=2, stride=2, padding=0),

)

# 2, 分類
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(in_features=400, out_features=120),
            nn.ReLU(),
            nn.Linear(in_features=120, out_features=84),
            nn.ReLU(),
            nn.Linear(in_features=84, out_features=num_classes)
)

defforward(self, x):
# 1, 提取特征
        x = self.feature_extractor(x)
# 2， 分類輸出
        x = self.classifier(x)
return x

# 檢測是否有可用的CUDA設備，如果有則使用第一個可用的CUDA設備，否則使用CPU
device ="cuda:0"if torch.cuda.is_available()else"cpu"

# 將模型移動到指定的設備（CUDA或CPU）
model.to(device=device)

# 設置訓練的總輪數
epochs =80

# 設置學習率
lr =1e-3

# 定義損失函數為交叉熵損失
loss_fn = nn.CrossEntropyLoss()

# 定義優化器為隨機梯度下降（SGD），傳入模型的參數和學習率
optimizer = torch.optim.SGD(params=model.parameters(), lr=lr)

# 準確率計算
defget_acc(data_loader):
    accs =[]
    model.eval()
with torch.no_grad():
for X, y in data_loader:
            X = X.to(device=device)
            y = y.to(device=device)
            y_pred = model(X)
            y_pred = y_pred.argmax(dim=-1)
            acc =(y_pred == y).to(torch.float32).mean().item()
            accs.append(acc)
    final_acc =round(number=sum(accs)/len(accs), ndigits=5)
return final_acc

# 訓練過程
deftrain():

    train_accs =[]
    test_accs =[]
    cur_test_acc =0

# 1，訓練之前，檢測一下準確率
    train_acc = get_acc(data_loader=train_dataloader)
    test_acc = get_acc(data_loader=test_dataloader)
    train_accs.append(train_acc)
    test_accs.append(test_acc)

print(f"訓練之前：train_acc: {train_acc},test_acc: {test_acc}")

# 每一輪次
for epoch inrange(epochs):
# 模型設置為 train 模式
        model.train()
# 計時
        start_train = time.time()
# 每一批量
for X, y in train_dataloader:
# 數據搬家
            X = X.to(device=device)
            y = y.to(device=device)
# 1，正向傳播
            y_pred = model(X)
# 2，計算損失
            loss = loss_fn(y_pred, y)
# 3，反向傳播
            loss.backward()
# 4，優化一步
            optimizer.step()
# 5，清空梯度
            optimizer.zero_grad()
# 計時結束
        stop_train = time.time()
# 測試準確率
        train_acc = get_acc(data_loader=train_dataloader)
        test_acc = get_acc(data_loader=test_dataloader)
        train_accs.append(train_acc)
        test_accs.append(test_acc)
# 保存模型
if cur_test_acc < test_acc:
            cur_test_acc = test_acc
# 保存最好模型
            torch.save(obj=model.state_dict(), f="lenet_best.pt")
# 保存最后模型
        torch.save(obj=model.state_dict(), f="lenet_last.pt")

# 格式化輸出日志
print(f"""
        當前是第 {epoch + 1} 輪：
        ------------------------------------------------------------
        | 訓練準確率 (train_acc) | 測試準確率 (test_acc) | 運行時間 (elapsed_time) |
        ------------------------------------------------------------
        | {train_acc:<18} | {test_acc:<17} | {round(number=stop_train - start_train, ndigits=3)} 秒    |
        ------------------------------------------------------------
        """)
return train_accs, test_accs

train_accs, test_accs = train()

plt.plot(train_accs, label="train_acc")
plt.plot(test_accs, label="train_acc")
plt.legend()
plt.grid()
plt.xlabel(xlabel='epoch')
plt.ylabel(ylabel="acc")
plt.title(label="LeNet Training Process")

import streamlit
import torch
import os
import numpy as np
from PIL importImage
from models importLeNet


# 生成idx2label字典，用于顯示預測結果
idx2label ={
0:'G0',
1:'G1',
2:'G2',
3:'G3',
4:'G4',
5:'G5',
6:'G6',
7:'G7',
8:'G8',
9:'G9'
}

definfer(img_path, model, device, idx2label):
"""
        輸入：圖像地址
        輸出：預測類別
    """
# 1，讀取圖像
ifnot os.path.exists(img_path):
raiseFileNotFoundError("文件沒找到")

# 2, 判斷當前局部變量中是否有model
# if "m1" not in globals() or not isinstance(globals()["m1"], LeNet):
#     raise ValueError("m1模型不存在")

# 3，讀取圖像
    img =Image.open(fp=img_path)

# 4，預處理
    img = img.resize((32,32))
    img = np.array(img)
    img = img /255
    img =(img -0.5)/0.5

# 5, 轉張量
    img = torch.tensor(data=img, dtype=torch.float32)

# 6, 轉換維度
    img = img.permute(dims=(2,0,1))

# 7, 新增一個批量維度
    img = img.unsqueeze(dim=0)

# 8，數據搬家
    img = img.to(device=device)

# 9，模型設為評估模式
    model.eval()

# 10，無梯度環境
with torch.no_grad():
# 11，正向傳播
        y_pred = m1(img)

# 12, 解析結果
        y_pred = y_pred.argmax(dim=-1).item()

# 13，標簽轉換
        label = idx2label.get(y_pred)

# 14, 返回結果
return label

if __name__ =="__main__":
# 1, 顯示當前設備是GPU設備還是CPU
# 檢測設備
    device ="cuda"if torch.cuda.is_available()else"cpu"
    streamlit.write(f"當前設備是{device}設備")


# 2, 加載模型
    m1 =LeNet()
    m1.to(device=device)
# 加載權重
    m1.load_state_dict(state_dict=torch.load(f="lenet_best.pt", map_locatinotallow=device),
                    strict=False)
ifnotisinstance(m1,LeNet):
raiseValueError("模型加載失敗")

# 3, 上傳一張圖片
    img_path = streamlit.file_uploader(label="上傳一張圖片",type=["png","jpg","jpeg"])
# 3.1, 將上傳的圖像文件保存到臨時文件
if img_path:
withopen(file="temp_img.jpg", mode="wb")as f:
            f.write(img_path.getvalue())
        img_path ="temp_img.jpg"
# 4, 顯示上傳的圖片
if img_path:
        img =Image.open(fp=img_path)
        streamlit.image(image=img, captinotallow="上傳的圖片", use_column_width=True)

# 5, 加載本地的lenet_best.pt模型
if img_path:
        label = infer(img_path=img_path, model=m1, device=device, idx2label=idx2label)
        streamlit.write(f"預測結果是{label}")