今天继续学习食物分类
图片分类的模型最重要的就是设计维度变化
优化器
Adam和AdamW——SGD
1.梯度的改变
SGD只看当前点的梯度
2.学习率的改变
Adam会自动调整学习率，是动态调整的过程，相对与SGD较难出现模型坍塌、梯度爆炸的问题。Adam的鲁棒性和稳定性通常优于SGD。
AdamW，W就是weight decay，权重衰减
optimzer = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-4) #优化器
训练函数
#训练函数
def train_val(model, train_loader, val_loader, device, epochs, optimizer, loss, save_path):
model = model.to(device)
plt_train_loss = [] #记录所有轮次的loss
plt_val_loss = []
plt_train_acc = [] #记录准确率
plt_val_acc = []
max_acc = 0.0 #保存准确率最高的模型
for epoch in range(epochs): #冲锋的号角
train_loss = 0.0
val_loss = 0.0
train_acc = 0.0
val_acc = 0.0
start_time = time.time()
model.train() #模型调为训练模式
for batch_x, batch_y in train_loader:
x, target = batch_x.to(device), batch_y.to(device)
pred = model(x)
train_bat_loss = loss(pred, target)
train_bat_loss.backward()
optimizer.step() #更新模型的作用
optimizer.zero_grad()
train_loss += train_bat_loss.cpu().item()
train_acc += np.sum(np.argmax(pred.detach().cpu().numpy(), axis=1) == target.cpu().numpy())
plt_train_loss.append(train_loss / train_loader.__len__())
plt_train_acc.append(train_acc / train_loader.dataset.__len__()) #记录准确率
model.eval()
with torch.no_grad():
for batch_x, batch_y in val_loader:
x, target = batch_x.to(device), batch_y.to(device)
pred = model(x)
val_bat_loss = loss(pred, target)
val_loss += val_bat_loss.cpu().item()
val_acc += np.sum(np.argmax(pred.detach().cpu().numpy(), axis=1) == target.cpu().numpy())
plt_val_loss.append(val_loss/ val_loader.__len__())
plt_val_acc.append(val_acc / val_loader.dataset.__len__())
if val_acc > max_acc:
torch.save(model, save_path)
max_acc = val_loss
print("[%03d/%03d] %2.2f sec(s) Trainloss: %.6f |Valloss: %.6f Trainacc: %.6f |Valacc: %.6f" % \
(epoch, epochs, time.time()-start_time, plt_train_loss[-1], plt_val_loss[-1], plt_train_acc[-1], plt_val_acc[-1]))
plt.plot(plt_train_loss)
plt.plot(plt_val_loss)
plt.title("loss")
plt.legend(["train", "val"])
plt.show()
plt.plot(plt_train_acc)
plt.plot(plt_val_acc)
plt.title("acc")
plt.legend(["train", "val"])
plt.show()
train_acc += np.sum(np.argmax(pred.detach().cpu().numpy(), axis=1) == target.cpu().numpy())
argmax()：取最大值的下标，axis=1：沿纵向求
sum之中的函数就是判断pred预测值与target的值是否相等，返回true/false的矩阵
np.sum()再对得出的true=1/false=0纵向求和
train_acc就是看每轮预测对的数量
迁移学习
数据量少时的最佳选择。
迁移学习（Transfer Learning）是一种强大的机器学习方法，其核心思想是将在一个任务（源任务）上学到的知识或模型迁移到另一个相关任务（目标任务）上，以提高新任务的性能。这种方法充分利用了已有的数据和模型资源，减少了目标任务对大量新数据的依赖，加快了模型训练速度，并提高了模型的泛化能力。
结束！
import random
import torch
import torch.nn as nn
import numpy as np
import os
from PIL import Image #读取文件数据
from torch.utils.data import Dataset, DataLoader
from tqdm import tqdm #查看读取进度
from torchvision import transforms
import time
import matplotlib.pyplot as plt
from model_utils.model import initialize_model
def seed_everything(seed):
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
random.seed(seed)
np.random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
#################################################################
seed_everything(0)
###############################################
HW = 224 #深度学习领域一般让图片大小为224，而文件中的图片是512*512
#读文件
def read_file(path):
for i in tqdm(range(11)):
file_dir = path + "/%02d"%i
file_list = os.listdir(file_dir) #列出文件夹下所有文件名字
xi = np.zeros((len(file_list),HW,HW,3), dtype=np.uint8) #读为整型
yi = np.zeros(len(file_list), dtype=np.uint8)
for j, img_name in enumerate(file_list): #enumerate()既可以读到下标，也可以读到内容
img_path = os.path.join(file_dir, img_name)
img = Image.open(img_path)
img = img.resize((HW,HW))
xi[j, ...] = img #...表示后面的维度表示一致,把图片放到第j个
yi[j] = i #标签
# 把所有的xi,yi在0维合并
if i == 0:
X = xi
Y = yi
else:
X = np.concatenate((X, xi), axis=0)
Y = np.concatenate((Y, yi), axis=0)
print("读到了%d个数据"%len(Y))
return X,Y
#数据变换 训练集和验证集的数据变换不同，验证和测试的时候要用原图，训练的时候才需要不同的数据变换进行训练
train_transform = transforms.Compose(
[
transforms.ToPILImage(), #图片为224*224*3，模型需要3*224*224
transforms.RandomResizedCrop(224), #对图片随机放大裁切
transforms.RandomRotation(50), #对图片50°以内随机旋转
transforms.ToTensor() #变为张量进行模型运行
]
)
val_transform = transforms.Compose(
[
transforms.ToPILImage(), #图片为224*224*3，模型需要3*224*224
transforms.ToTensor() #变为张量进行模型运行
]
)
#定义数据集
class food_Dataset(Dataset):
def __init__(self, path, mode="train"): #初始化，传入地址，得到数据集x和标签y
self.X, self.Y = read_file(path)
self.Y = torch.LongTensor(self.Y) #标签转为长整型
if mode == "train":
self.transform = train_transform #数据增广
else:
self.transform = val_transform
def __getitem__(self, item):
return self.transform(self.X[item]), self.Y[item]
def __len__(self):
return len(self.Y)
#模型
class myModel(nn.Module):
def __init__(self, num_class): #搭建模型框架
super(myModel, self).__init__()
#图片输入为3*224*224，要变为512*7*7，然后拉直、全连接、分类
self.conv1 = nn.Conv2d(3, 64, 3, 1, 1) #64*224*224
self.bn1 = nn.BatchNorm2d(64) #归一化
self.relu = nn.ReLU()
self.pool1 = nn.MaxPool2d(2) #64*112*112
self.layer1 = nn.Sequential( #这样合并更方便，且美观
nn.Conv2d(64, 128, 3, 1, 1), #128*112*112
nn.BatchNorm2d(128), #归一化
nn.ReLU(),
nn.MaxPool2d(2) #127*56*56
)
self.layer2 = nn.Sequential(
nn.Conv2d(128, 256, 3, 1, 1),
nn.BatchNorm2d(256),
nn.ReLU(),
nn.MaxPool2d(2) #256*28*28
)
self.layer3 = nn.Sequential(
nn.Conv2d(256, 512, 3, 1, 1),
nn.BatchNorm2d(512),
nn.ReLU(),
nn.MaxPool2d(2) #512*14*14
)
self.pool2 = nn.MaxPool2d(2) #512*7*7
self.fc1 = nn.Linear(25088, 1000) #卷积 25088->1000
self.relu2 = nn.ReLU()
self.fc2 = nn.Linear(1000, num_class) #1000->num_class(11)
def forward(self, x):
x = self.conv1(x)
x = self.bn1(x)
x = self.relu(x)
x = self.pool1(x)
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.pool2(x)
x = x.view(x.size()[0], -1) #拉直
x = self.fc1(x)
x = self.relu2(x)
x = self.fc2(x)
return x
#训练函数
def train_val(model, train_loader, val_loader, device, epochs, optimizer, loss, save_path):
model = model.to(device)
plt_train_loss = [] #记录所有轮次的loss
plt_val_loss = []
plt_train_acc = [] #记录准确率
plt_val_acc = []
max_acc = 0.0 #保存准确率最高的模型
for epoch in range(epochs): #冲锋的号角
train_loss = 0.0
val_loss = 0.0
train_acc = 0.0
val_acc = 0.0
start_time = time.time()
model.train() #模型调为训练模式
for batch_x, batch_y in train_loader:
x, target = batch_x.to(device), batch_y.to(device)
pred = model(x)
train_bat_loss = loss(pred, target)
train_bat_loss.backward()
optimizer.step() #更新模型的作用
optimizer.zero_grad()
train_loss += train_bat_loss.cpu().item()
train_acc += np.sum(np.argmax(pred.detach().cpu().numpy(), axis=1) == target.cpu().numpy())
plt_train_loss.append(train_loss / train_loader.__len__())
plt_train_acc.append(train_acc / train_loader.dataset.__len__()) #记录准确率
model.eval()
with torch.no_grad():
for batch_x, batch_y in val_loader:
x, target = batch_x.to(device), batch_y.to(device)
pred = model(x)
val_bat_loss = loss(pred, target)
val_loss += val_bat_loss.cpu().item()
val_acc += np.sum(np.argmax(pred.detach().cpu().numpy(), axis=1) == target.cpu().numpy())
plt_val_loss.append(val_loss/ val_loader.__len__())
plt_val_acc.append(val_acc / val_loader.dataset.__len__())
if val_acc > max_acc:
torch.save(model, save_path)
max_acc = val_loss
print("[%03d/%03d] %2.2f sec(s) Trainloss: %.6f |Valloss: %.6f Trainacc: %.6f |Valacc: %.6f" % \
(epoch, epochs, time.time()-start_time, plt_train_loss[-1], plt_val_loss[-1], plt_train_acc[-1], plt_val_acc[-1]))
plt.plot(plt_train_loss)
plt.plot(plt_val_loss)
plt.title("loss")
plt.legend(["train", "val"])
plt.show()
plt.plot(plt_train_acc)
plt.plot(plt_val_acc)
plt.title("acc")
plt.legend(["train", "val"])
plt.show()
# path = r"D:\大学\学习\深度学习\课程代码\第四五节_分类代码\food_classification\food-11\training\labeled" #训练数据的路径，r能去除转义字符的作用
# train_path = r"D:\大学\学习\深度学习\课程代码\第四五节_分类代码\food_classification\food-11\training\labeled"
# val_path = r"D:\大学\学习\深度学习\课程代码\第四五节_分类代码\food_classification\food-11\validation"
train_path = r"D:\大学\学习\深度学习\课程代码\第四五节_分类代码\food_classification\food-11_sample\training\labeled"
val_path = r"D:\大学\学习\深度学习\课程代码\第四五节_分类代码\food_classification\food-11_sample\validation"
#读数据集
train_set = food_Dataset(train_path, "train")
val_set = food_Dataset(val_path, "val")
train_loader = DataLoader(train_set, batch_size=16, shuffle=True) #train_loader把train_set变为一批数据
val_loader = DataLoader(val_set, batch_size=16, shuffle=True)
# model = myModel(11)
#用大佬们的模型
# from torchvision.models import resnet18
# model = resnet18(pretrained=True) #pretrained=True用架构和参数，=False时则从0开始训练
# in_features = model.fc.in_features #替换分类头
# model.fc = nn.Linear(in_features, 11) #把模型的分类头改为自己的输入维度11
#引用模型
model = initialize_model("resnet18", 11, use_pretrained=True)
lr = 0.001 #学习率
loss = nn.CrossEntropyLoss() #损失用交叉熵损失
optimizer = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-4) #优化器
device = "cuda" if torch.cuda.is_available() else "cpu" #设备
save_path = "model_save/best_model_zhou.pth" #保存最好的模型
epochs = 15 #训练轮次
train_val(model, train_loader, val_loader, device, epochs, optimizer, loss, save_path)
1661
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
