开始接触深度学习
大语言模型火了之后，我也想过是否要加入深度学习的行业当中来，一开始的想法就是AI大模型肯定会被各大厂垄断，我们作为普通应用型软件工程师直接调用api就完事，另外对自己的学历也自卑(刚刚够线的二本）。因此有一段时间，专门尝试去折腾chatGPT的各种应用，不过始终觉得不够，有很多疑问： 这些通用的人工机器人是如何工作的呢？GPT4的1750亿参数到底是指什么？为何指定一个不同的prompt，相同的问题答案会差别这么大？为何它的代码能力这么强？我有太多的疑问，我觉得AI颠覆了我的认知，我从业10多年了，为何现在才开始接触AI呢？我想了解大模型背后的原理，我也想做这些cool的事情，10多年的CURD太没意思了。
那么问题来了，我该怎么入门深度学习呢？
在京东搜索深度学习，排名前2名的书籍是：《深度学习》和《动手学深度学习》，对比了下发现动手学深度学习是大神李沐编撰的，有对应的在线书籍，B站上有视频课程，github上有代码样例，这么高质量的作品，居然这一切都是免费的，还有什么理由不入坑呢，因此我果断加入深度学习的队列。
每天上一节课持续有1个多月了，目前学到30节课了，但目前我感觉还未真正上手，要掌握原理，需要的掌握背景知识太多了：微积分、线性代数、概率论等，毕业10多年后的我，自觉连初高中的数学都不一定能完全搞定，要学习起来真的觉得很痛苦。
实践比赛Classify Leaves
学完第二阶段开始第二次实践比赛，比赛题目是《Classify Leaves》给叶子图像分类，有了上一次的房价预测比赛实践之后，大致知道深度学习的流程：
- 读取数据预处理
- 设置超参数
- 训练和验证（验证用于进行超参数调整）
- 跑测试集后保存
图像分类与房价预测不同之处:
- 房价预测是表格数据，图像分类是图像数据
- 另外房价预测使用简单的线模型即可，图像预测需要使用卷积神经网络
- 房价预测对非熟知数据预处理对最后结果影响比较大，分类数据比较简单预处理简单。
查看数据格式
数据样例如下：包含3个文件和一个图片文件夹。
-
训练数据train.csv如下表格，包含了2列：image表示图片文件路径，label图片所属分类。
image| label
—|—
images/0.jpg|maclura_pomifera
images/1.jpg|maclura_pomifera
images/2.jpg|maclura_pomifera
images/3.jpg|maclura_pomifera
…|… -
sample_submission.csv 是提交样例，样例数据格式与训练数据集一样。
-
test.csv 是测试数据，训练好模型后，使用测试数据跑出结果提交，测试数据只有一列:image, label需要我们使用训练好的模型进行预测，然后提交预测后的结果。
导入包
from torch.utils.data import DataLoader
import torch
from torch import nn
from d2l import torch as d2l
import os
import pandas as pd
from torchvision.io import read_image
from torch.utils.data import Dataset
from torchvision import transforms
import matplotlib.pyplot as plt
from PIL import Image
import torchvision.models as models
from numpy import random
数据预处理
自定义数据读取
自己实现Dataset来读取图片分类数据
class CustomImageDataset(Dataset):
def __init__(self, annotations_file, img_dir, dict_label, transform=None, target_transform=None):
self.img_labels = pd.read_csv(annotations_file)
self.img_dir = img_dir
self.transform = transform
self.target_transform = target_transform
self.dict_label = dict_label
def __len__(self):
return len(self.img_labels)
def __getitem__(self, idx):
img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0])
image = Image.open(img_path)
if self.dict_label != None:
label = self.img_labels.iloc[idx, 1]
if self.transform:
image = self.transform(image)
if self.target_transform:
label = self.target_transform(label)
if self.dict_label != None: #通过这个来判断是否是测试数据的读取
return image, torch.tensor(self.dict_label[label],dtype=torch.long)
return image # 测试数据没有label
读取数据并初始化
# 直接读取csv列数据，用于处理列数据label的与处理，主要用于将数字分类和文本分类相互映像转换
train_data_csv = pd.read_csv('data/train.csv')
# 读取图片，用于输出提交结果
test_data_csv = pd.read_csv('data/test.csv')
# 读取所有文本分类
all_text_labels = train_data_csv['label']
# 去重
uni_text_labels = all_text_labels.unique()
# 数字映射文本分类字典
dict_num2text_labels = {}
# 文本映射数字分类字典
dict_text2num_labels = {}
# 分类打乱，有点多此一举
random.shuffle(uni_text_labels)
num_classes = 0 # 分类总数
# 相互映射
for label in uni_text_labels:
dict_num2text_labels[num_classes] = label
dict_text2num_labels[label] = num_classes
num_classes += 1
print(f"dict_num2text_labels:{dict_num2text_labels} ")
print(f"dict_text2num_labels:{num_classes} ")
# 训练集，图片转换成tensor
transform_train = transforms.Compose([
transforms.Resize((224, 224)),
transforms.RandomHorizontalFlip(p=0.5), #随机水平翻转 选择一个概率
transforms.ToTensor()
])
# 测试集，图片转换成tensor
transform_test = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor()
])
training_data = CustomImageDataset("data/train.csv", "data/", dict_text2num_labels,transform = transform_train)
test_data = CustomImageDataset("data/test.csv", "data/", None, transform = transform_test)
模型定义和超参数
使用深度学习神经网络框架定义
model = models.resnet34(pretrained=True)
model.eval()
# 设置输出分类数
model.fc = nn.Sequential(nn.Linear(model.fc.in_features, num_classes))
# 批次大小, 学习率，训练次数、权重
batch_size,lr, num_epochs,weight_decay = 32, 3e-4, 20, 1e-3
k折交叉训练
由于数据集合比较小，使用k折交叉读取数据训练
import time
from sklearn.model_selection import KFold
from torch.utils.data import DataLoader, Dataset, random_split, Subset
import torch.optim as optim
# 计算验证集
def evaluate_accuracy_gpu(net, data_iter, device=None):
"""Compute the accuracy for a model on a dataset using a GPU.
Defined in :numref:`sec_lenet`"""
if isinstance(net, nn.Module):
net.eval() # Set the model to evaluation mode
if not device:
device = next(iter(net.parameters())).device
# No. of correct predictions, no. of predictions
metric = d2l.Accumulator(2)
with torch.no_grad():
for X, y in data_iter:
if isinstance(X, list):
# Required for BERT Fine-tuning (to be covered later)
X = [x.to(device) for x in X]
else:
X = X.to(device)
y = y.to(device)
metric.add(d2l.accuracy(net(X), y), d2l.size(y))
return metric[0] / metric[1]
# 训练
def train_ch6(net, train_iter, test_iter, num_epochs, lr,weight_decay, device):
"""Train a model with a GPU (defined in Chapter 6).
Defined in :numref:`sec_lenet`"""
def init_weights(m):
if type(m) == nn.Linear or type(m) == nn.Conv2d:
nn.init.xavier_uniform_(m.weight)
net.apply(init_weights)
print('training on', device)
net.to(device)
optimizer = torch.optim.Adam(net.parameters(), lr=lr, weight_decay=weight_decay)
#optimizer = torch.optim.SGD(net.parameters(), lr=lr, weight_decay=weight_decay)
loss = nn.CrossEntropyLoss()
animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
legend=['train loss', 'train acc', 'test acc'])
timer, num_batches = d2l.Timer(), len(train_iter)
for epoch in range(num_epochs):
# Sum of training loss, sum of training accuracy, no. of examples
metric = d2l.Accumulator(3)
net.train()
for i, (X, y) in enumerate(train_iter):
timer.start()
optimizer.zero_grad()
X, y = X.to(device), y.to(device)
y_hat = net(X)
l = loss(y_hat, y)
l.backward()
optimizer.step()
with torch.no_grad():
metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])
timer.stop()
train_l = metric[0] / metric[2]
train_acc = metric[1] / metric[2]
if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1:
animator.add(epoch + (i + 1) / num_batches,
(train_l, train_acc, None))
test_acc = evaluate_accuracy_gpu(net, test_iter)
animator.add(epoch + 1, (None, None, test_acc))
print(f'loss {train_l:.3f}, train acc {train_acc:.3f}, '
f'test acc {test_acc:.3f}')
print(f'{metric[2] * num_epochs / timer.sum():.1f} examples/sec '
f'on {str(device)}')
# 定义 k 折交叉验证参数
k_folds = 5
kfold = KFold(n_splits=k_folds, shuffle=True)
for fold, (train_ids, val_ids) in enumerate(kfold.split(training_data)):
print(f'FOLD {fold}')
print('--------------------------------')
# 根据索引划分训练集和验证集
train_subsampler = Subset(training_data, train_ids)
val_subsampler = Subset(training_data, val_ids)
# 创建数据加载器
trainloader = DataLoader(train_subsampler, batch_size=64, shuffle=True, num_workers=2)
valloader = DataLoader(val_subsampler, batch_size=64, shuffle=False, num_workers=2)
# 训练模型
train_ch6(model, trainloader, valloader, num_epochs, lr, weight_decay, d2l.try_gpu())
# 保存模型
torch.save(model.state_dict(), f"data/resnet34_SGD_model.state_{time}.pth")
生产预测测试数据保存
# 加载保存到文件的模型
model = models.resnet34(pretrained=True)
model.load_state_dict(torch.load("data/resnet34_SGD_model.state_1685356838.1272397.pth"))
model.eval()
model.cuda()
test_dataloader = DataLoader(test_data, batch_size=batch_size, shuffle=False)
preds = []
with torch.no_grad():
for i, X in enumerate(test_dataloader):
X = X.to(d2l.try_gpu())
y_hat = model(X)
y_hat = torch.argmax(y_hat, axis=1) #获取最大分类
for num_label in y_hat:
label_str = dict_num2text_labels[num_label.item()]
preds.append(label_str)
# 将网络应用于测试集。
# 将其重新格式化以导出到Kaggle
test_data_csv['label'] = preds
submission = pd.concat([test_data_csv['image'], test_data_csv['label']], axis=1)
submission.to_csv('submission.csv', index=False)
使用GPT4的过程
在实现的过程中并不是一帆风顺，GPT4给了很大的帮助，下面是我们的对话。
输出分类参数错误
一开始读取分类标签的时候，转换成了tensor 的float类型，导致出现报错：
RuntimeError: “nll_loss_forward_reduce_cuda_kernel_2d_index” not implemented for ‘Float’
直接复制给GPT4，他清晰的告诉了我是因为nn.NLLLoss() 函数输出的是LongTensor类型。
怎么使用模型输出分类
不知道如何使用框架模型，直接提问题。
训练效果不好
深度神经网络训练集的准确率和验证集的差异比较大是什么原因
使用pandas输入问题
怎么使用pandas 加一个list数组加入输出csv文件的一列是上
如何使用k折交叉验证法
如何使用k折交叉方法训练图片分类，给定了一个数据集，如何进行k折分别选择测试集合和验证集数据
给出了非常详细的样例。
