CIFAR-10-ObjectRecognition
作为一个古老年代的数据集，用ResNet来练一下手也是不错的。
比赛链接：CIFAR-10 - Object Recognition in Images | Kaggle
1. 预设置处理
创建各类超参数，其中如果是在Kaggle上训练的话batch_size是可以达到4096的。
同时对于CIFAR-10数据集中含有10个类别，通过字典与反字典生成相应映射。
'''
**************************************************
@File ：kaggle -> ResNet
@IDE ：PyCharm
@Author ：TheOnlyMan
@Date ：2023/4/14 23:06
**************************************************
'''
seed = 998244353
torch.manual_seed(seed)
np.random.seed(seed)
random.seed(seed)
torch.cuda.manual_seed_all(seed)
# torch.autograd.set_detect_anomaly(True) 检测梯度计算失败位置
class ArgParse:
def __init__(self) -> None:
self.batch_size = 16
self.lr = 0.001
self.epochs = 10
self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
args = ArgParse()
dic = {"airplane": 0, "automobile": 1, "bird": 2, "cat": 3, "deer": 4,
"dog": 5, "frog": 6, "horse": 7, "ship": 8, "truck": 9}
rev_dic = {0: "airplane", 1: "automobile", 2: "bird", 3: "cat", 4: "deer",
5: "dog", 6: "frog", 7: "horse", 8: "ship", 9: "truck"}
2. 创建Dataset
对于CIFAR-10数据集而言，图片的大小为（3，32，32），若是采用ResNet的话也不必要重新插值生成（224，224）尺寸的图像， 目前觉得好像（32，32）会更好点，而且模型体量更小点。
由于数据集是比较大的，可以不采用一次性读入内存的形式，在需要时在读取。
最后对于正确标签而言，采用onehot编码的形式，将正确标签概率设置为1，因此模型的输出只需要判断概率问题即可，较为经典的多分类问题。
class DataSet(Dataset):
def __init__(self, flag='train') -> None:
self.flag = flag
self.trans = transforms.Compose([
# trans.Resize((224, 224)),
transforms.RandomHorizontalFlip(p=0.5),
trans.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
assert flag in ['train', 'test'], 'not implement'
if self.flag == 'train':
self.path = "dataset/cifar-10/train"
self.dtf = pd.read_csv("dataset/cifar-10/trainLabels.csv")
else:
self.path = "dataset/cifar-10/test"
self.dtf = None
self.len = len(os.listdir(self.path))
def __getitem__(self, item):
image = Image.open(os.path.join(self.path, f"{item + 1}.png"))
if self.flag == 'train':
label = [0 for _ in range(10)]
label[dic.get(self.dtf.iloc[item, 1], -1)] = 1
return self.trans(image), torch.tensor(label, dtype=torch.float)
else:
return self.trans(image), torch.tensor(item, dtype=torch.int32)
def __len__(self):
return self.len
3. 模型
CNN
采取类似VGG架构，卷积核均为3，通道数在卷积层由3>8>16>32>64>128，在全连接层则是由一层512节点数构成，最后的输出层10采用Softmax函数进行多分类处理。（注：nn.Softmax()中dim需要设定为1）
训练轮数只有5-10轮，提交上去后有百分之73的准确率，对于一个较为少层的神经网络来说效果还是不错的，轻量级，同时如果训练轮数在多点应该也可以到达较高的准确率。
相比ResNet50而言，在训练10轮之后可以很快达到60%多的准确率。
10-20轮次CNN趋于稳定，验证集准确率不再上升。
可能是设置的参数与第一次设置的不同，从20-50轮次的训练中，CNN的效果也并没有什么起色，应该是已经达到了该网络的上限。已经无法稳定地突破70%的准确率。
class CNN(nn.Module):
def __init__(self):
super(CNN, self).__init__()
self.conv = nn.Sequential(
nn.Conv2d(
in_channels=3, out_channels=8, kernel_size=3, stride=1, padding=1
),
nn.BatchNorm2d(8), nn.ReLU(), nn.MaxPool2d(2),
nn.Conv2d(
in_channels=8, out_channels=16, kernel_size=3, stride=1, padding=1
),
nn.BatchNorm2d(16), nn.ReLU(), nn.MaxPool2d(2),
nn.Conv2d(
in_channels=16, out_channels=32, kernel_size=3, stride=1, padding=1
),
nn.BatchNorm2d(32), nn.ReLU(),
nn.Conv2d(
in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1
),
nn.BatchNorm2d(64), nn.ReLU(), nn.MaxPool2d(2),
nn.Conv2d(
in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=1
),
nn.BatchNorm2d(128), nn.ReLU(),
)
self.layer = nn.Sequential(
nn.Linear(4 * 4 * 128, 512),
nn.BatchNorm1d(512),
nn.ReLU(),
nn.Linear(512, 10),
nn.Softmax(dim=1)
)
def forward(self, x):
x = self.conv(x)
x = x.view(x.size(0), -1)
x = self.layer(x)
return x
ResNet50
采用由torchvision中包含的resnet50模型进行训练，同时去除掉resnet50的全连接层直接由卷积层连向输出层。
训练50轮次后可以达到82.7%的准确率。应该是轮次不足，或是仅仅使用原ResNet网络模型的效果无法达到90%以上等。其中采用20层初始预训练，经过微调后继续30层训练。感觉是还有上升的余地的，把训练轮数再翻倍应该可以达到85%以上准确率。
class ResNet50(nn.Module):
def __init__(self):
super(ResNet50, self).__init__()
self.model = torchvision.models.resnet50(pretrained=True)
in_channel = self.model.fc.in_features
self.model.fc = nn.Linear(in_channel, 10)
self.layer = nn.Sequential(
nn.Softmax(dim=1)
)
def forward(self, x):
x = self.model(x)
return self.layer(x)
MyResNet50
参考另一篇博客：ResNet残差网络
对于该模型而言，训练其50轮。
在20轮时的并没有20轮的CNN效果好。不过CNN本身参数虽然少，但是其效果之直逼ResNet50。
当对MyResNet50训练到第50轮时，其准确率并没有达到ResNet源码的效果，只在72%附近徘徊（比CNN略好一点，上限略高一点），因为MyResNet只是个简化的版本。这就使得网络比较浅的CNN效果和深层网络ResNet效果类似。
尝试再此基础上再次进行50轮次训练，并将学习率减少为原来的一半。此时验证集准确率已经到达极限，无法上升。
4. train
模型的创建或者加载由以上三个模型进行确定。
def train(pretrain=None):
dataset = DataSet('train')
train_size = int(len(dataset) * 0.95)
valid_size = len(dataset) - train_size
train_dataset, valid_dataset = random_split(dataset, [train_size, valid_size])
train_loader = DataLoader(dataset=train_dataset, batch_size=args.batch_size, shuffle=True)
valid_loader = DataLoader(dataset=valid_dataset, batch_size=args.batch_size, shuffle=True)
model = ResNet(Bottleneck, [3, 4, 6, 3], 10).to(args.device)
if pretrain:
model.load_state_dict(torch.load(pretrain))
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
train_epochs_loss = []
valid_epochs_loss = []
train_acc = []
valid_acc = []
for epoch in tqdm(range(args.epochs)):
model.train()
train_epoch_loss = []
acct, numst = 0, 0
for inputs, labels in tqdm(train_loader):
inputs = inputs.to(args.device)
labels = labels.to(args.device)
outputs = model(inputs)
optimizer.zero_grad()
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
train_epoch_loss.append(loss.item())
acct += sum(outputs.max(axis=1)[1] == labels.max(axis=1)[1]).cpu()
numst += labels.size()[0]
train_epochs_loss.append(np.average(train_epoch_loss))
train_acc.append(100 * acct / numst)
with torch.no_grad():
model.eval()
val_epoch_loss = []
acc, nums = 0, 0
for inputs, labels in tqdm(valid_loader):
inputs = inputs.to(args.device)
labels = labels.to(args.device)
outputs = model(inputs)
loss = criterion(outputs, labels)
val_epoch_loss.append(loss.item())
acc += sum(outputs.max(axis=1)[1] == labels.max(axis=1)[1]).cpu()
nums += labels.size()[0]
valid_epochs_loss.append(np.average(val_epoch_loss))
valid_acc.append(100 * acc / nums)
print("train acc = {:.3f}%, loss = {}".format(100 * acct / numst, np.average(train_epoch_loss)))
print("epoch = {}, valid acc = {:.2f}%, loss = {}".format(epoch, 100 * acc / nums,
np.average(val_epoch_loss)))
plt.figure(figsize=(12, 4))
plt.subplot(121)
plt.plot(train_acc, '-o', label="train_acc")
plt.plot(valid_acc, '-o', label="valid_acc")
plt.title("epochs_acc")
plt.subplot(122)
plt.plot(train_epochs_loss, '-o', label="train_loss")
plt.plot(valid_epochs_loss, '-o', label="valid_loss")
plt.title("epochs_loss")
plt.legend()
plt.show()
torch.save(model.state_dict(), 'model.pth')
5. predict
最后预测将其生成指定submission.csv文件即可进行提交。
def pred():
model = ResNet50().to(args.device)
model.load_state_dict(torch.load('model.pth'))
model.eval()
test_data = DataSet('test')
test_loader = DataLoader(dataset=test_data, batch_size=args.batch_size, shuffle=False)
data = []
for inputs, labels in tqdm(test_loader):
ans = model(inputs.to(args.device)).cpu()
ans = ans.max(axis=1)[1].numpy()
for number, res in zip(labels, ans):
data.append([number + 1, rev_dic.get(res)])
dtf = pd.DataFrame(data, columns=['id', 'label'])
dtf['id'] = dtf['id'].astype(np.int64)
dtf.sort_values(by='id', ascending=True)
print(dtf.info())
dtf.to_csv('submission.csv', index=False)
843
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
