李沐深度学习笔记———实战Kaggle项目Cifar-10
文章目录
前言
这堂课学了四天才弄清楚了一点，在此拿博客记录一下大佬的代码。
并且我将完整的数据集都跑了一遍。
一、数据预处理
1.读入labels，标签
1.我将cifar-10文件下载到了服务器上，并且解压成功。
2.read_csv_labels函数将csv文件按行读出，并且排列组合将其按字典返回。
3.这里labels就将训练集的标号和对应的类别拿到了。
4. set(labels.values())将labels的values的类别拿到了，这里为10
data_dir = '/root/autodl-tmp/cifar-10'
def read_csv_labels(fname):
with open(fname,'r') as f:
lines = f.readlines()[1:]
tokens = [l.rstrip().split(',') for l in lines]
return dict(((name,label) for name,label in tokens))
labels = read_csv_labels(os.path.join(data_dir,'trainLabels.csv'))
print('# 训练样本 :', len(labels))
print('# 类别 :', len(set(labels.values())))
2.处理train，valid，test数据集
由于这里test数据集没有标签，所以我们要从训练集中来选取数据当作测试集，来防止过拟合。
1.copyfile函数
将filename文件复制到target_dir地址下。首先运用os.makedirs开辟出一个文件夹，exist_ok=True表示若文件夹已经存在也不会报错.然后运用shutil.copy函数将文件copy过来。
def copyfile(filename, target_dir):
"""将文件复制到目标目录"""
os.makedirs(target_dir, exist_ok=True)
shutil.copy(filename, target_dir)
2.train_valid,train,valid数据集的划分
首先使用n将训练集中各个类别中最少的图片数量拿到。（使用collections.Counter(labels.values()）对其排序，[-1]拿到最少的那个，[1]拿到了数量）
然后n_valid_per_label表示一个验证集中图片的个数(math.floor()表示向下取整)
然后依次遍历每个文件，label拿到对应文件的类别，然后将其copy到对应路径。
然后如果这个label第一次碰到或者数量还不够，就将其放到验证集，并让label_count值+1（label_count.get(label, 0) + 1 表示第一次为0，后面这个0参数就没用了），反之就将其放到训练集
def reorg_train_valid(data_dir, labels, valid_ratio):
"""将验证集从原始的训练集中拆分出来"""
# 训练数据集中样本最少的类别中的样本数
n = collections.Counter(labels.values()).most_common()[-1][1]
# 验证集中每个类别的样本数
n_valid_per_label = max(1, math.floor(n * valid_ratio))
label_count = {}
for train_file in os.listdir(os.path.join(data_dir, 'train')):
label = labels[train_file.split('.')[0]]
fname = os.path.join(data_dir, 'train', train_file)
copyfile(fname, os.path.join(data_dir, 'train_valid_test',
'train_valid', label))
if label not in label_count or label_count[label] < n_valid_per_label:
copyfile(fname, os.path.join(data_dir, 'train_valid_test',
'valid', label))
label_count[label] = label_count.get(label, 0) + 1
else:
copyfile(fname, os.path.join(data_dir, 'train_valid_test',
'train', label))
return n_valid_per_label
3.完成测试集的分类
#@save
def reorg_test(data_dir):
"""在预测期间整理测试集，以方便读取"""
for test_file in os.listdir(os.path.join(data_dir, 'test')):
copyfile(os.path.join(data_dir, 'test', test_file),
os.path.join(data_dir, 'train_valid_test', 'test',
'unknown'))
def reorg_cifar10_data(data_dir, valid_ratio):
labels = read_csv_labels(os.path.join(data_dir, 'trainLabels.csv'))
reorg_train_valid(data_dir, labels, valid_ratio)
reorg_test(data_dir)
这里我们要跑整个数据集，所以让batch_size=128
batch_size = 128
valid_ratio = 0.1
reorg_cifar10_data(data_dir, valid_ratio)
二、定义数据迭代器
1.图片增广
训练集
transform_train = torchvision.transforms.Compose([
# 在高度和宽度上将图像放大到40像素的正方形
torchvision.transforms.Resize(40),
# 随机裁剪出一个高度和宽度均为40像素的正方形图像，
# 生成一个面积为原始图像面积0.64～1倍的小正方形，
# 然后将其缩放为高度和宽度均为32像素的正方形
torchvision.transforms.RandomResizedCrop(32, scale=(0.64, 1.0),
ratio=(1.0, 1.0)),
torchvision.transforms.RandomHorizontalFlip(),
torchvision.transforms.ToTensor(),
# 标准化图像的每个通道
torchvision.transforms.Normalize([0.4914, 0.4822, 0.4465],
[0.2023, 0.1994, 0.2010])])
测试集
transform_test = torchvision.transforms.Compose([
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize([0.4914, 0.4822, 0.4465],
[0.2023, 0.1994, 0.2010])])
2.读取数据
同类别的在一文件夹下，使用ImageFolder方法
train_ds, train_valid_ds = [torchvision.datasets.ImageFolder(
os.path.join(data_dir, 'train_valid_test', folder),
transform=transform_train) for folder in ['train', 'train_valid']]
valid_ds, test_ds = [torchvision.datasets.ImageFolder(
os.path.join(data_dir, 'train_valid_test', folder),
transform=transform_test) for folder in ['valid', 'test']]
train_iter, train_valid_iter = [torch.utils.data.DataLoader(
dataset, batch_size, shuffle=True, drop_last=True)
for dataset in (train_ds, train_valid_ds)]
valid_iter = torch.utils.data.DataLoader(valid_ds, batch_size, shuffle=False,
drop_last=True)
test_iter = torch.utils.data.DataLoader(test_ds, batch_size, shuffle=False,
drop_last=False)
三、定义模型
1.定义网络
由于我调用d2l包的resnet模型总是报错
所以这里我用torchvision里的resnet18，最后将线性层的输出变为10即可
def get_net():
net = torchvision.models.resnet18()
num_in = net.fc.in_features
net.fc = nn.Linear(num_in, 176)
return net
2.定义训练函数
def train(net, train_iter, valid_iter, num_epochs, lr, wd, devices, lr_period,
lr_decay):
trainer = torch.optim.SGD(net.parameters(), lr=lr, momentum=0.9,
weight_decay=wd)
scheduler = torch.optim.lr_scheduler.StepLR(trainer, lr_period, lr_decay)
num_batches, timer = len(train_iter), d2l.Timer()
legend = ['train loss', 'train acc']
if valid_iter is not None:
legend.append('valid acc')
animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
legend=legend)
net = nn.DataParallel(net, device_ids=devices).to(devices[0])
for epoch in range(num_epochs):
net.train()
metric = d2l.Accumulator(3)
for i, (features, labels) in enumerate(train_iter):
timer.start()
l, acc = d2l.train_batch_ch13(net, features, labels,
loss, trainer, devices)
metric.add(l, acc, labels.shape[0])
timer.stop()
if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1:
animator.add(epoch + (i + 1) / num_batches,
(metric[0] / metric[2], metric[1] / metric[2],
None))
if valid_iter is not None:
valid_acc = d2l.evaluate_accuracy_gpu(net, valid_iter)
animator.add(epoch + 1, (None, None, valid_acc))
scheduler.step()
measures = (f'train loss {metric[0] / metric[2]:.3f}, '
f'train acc {metric[1] / metric[2]:.3f}')
if valid_iter is not None:
measures += f', valid acc {valid_acc:.3f}'
print(measures + f'\n{metric[2] * num_epochs / timer.sum():.1f}'
f' examples/sec on {str(devices)}')
3.开始训练
devices, num_epochs, lr, wd = d2l.try_all_gpus(), 20, 2e-4, 5e-4
lr_period, lr_decay, net = 4, 0.9, get_net()
train(net, train_iter, valid_iter, num_epochs, lr, wd, devices, lr_period,
lr_decay)
4.保存参数
首先在完整数据集上跑一遍看一下精度
然后在test_iter上取出数据，在网络预测，将预测结果中值最大的 下标存到preds里面。
然后定义一个sorted_ids的列表，值从1-test的长度
然后将其按字符串比较大小，排序。（‘10’<‘2’)
然后运用pandas建立一个DataFrame的表格对象。
id：来自sorted_ids,label来自labels
然后将df里的label的值 换为对应的类别名（例如0表示飞机）
net, preds = get_net(), []
train(net, train_valid_iter, None, num_epochs, lr, wd, devices, lr_period,
lr_decay)
for X, _ in test_iter:
y_hat = net(X.to(devices[0]))
preds.extend(y_hat.argmax(dim=1).type(torch.int32).cpu().numpy())
sorted_ids = list(range(1, len(test_ds) + 1))
sorted_ids.sort(key=lambda x: str(x))
df = pd.DataFrame({'id': sorted_ids, 'label': preds})
df['label'] = df['label'].apply(lambda x: train_valid_ds.classes[x])
df.to_csv('submission.csv', index=False)
四、结果
1.训练集结果
由于手误问题，后面我将epoch调到了25，但是我不小心删了，所以这里拿第一次跑的来代替。（跑一次10几分钟不想花钱了）
train loss 0.303, train acc 0.895, valid acc 0.761
2.测试集结果
train loss 0.304, train acc 0.895
3.提交结果
四、总结
李沐大佬的这节课让我学习到了很多的知识，很多的函数。
以及加强了我的自主解决bug能力，希望接下来能够继续加油。
扫一扫
586
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
