刚从Keras转Pytorch没多久，一边看着文档一边Google完成这比赛的baseline。
比赛地址
本次由2019-nCoV病毒引发的肺炎疫情仍在持续，AI研习社重启肺炎赛题，希望大家尽量减少外出，安心在家打比赛拿奖金，勤洗手，多戴口罩。全国人民上下一心，共抗疫情。
数据集：训练集20013张，测试集 6671张。图片大小102410243
任务：训练模型正确识别肺炎X光病灶数量
实验室断电了，淘宝租了2080ti，一天60块。T_T
jupyter lab+Python3.6+Pytorch 1.0.1
# 查看csv数据
import pandas as pd
from collections import Counter
csv=pd.read_csv("train.csv",header=None)
print(csv)
0 1
0 0 0
1 1 0
2 2 0
3 3 0
4 4 0
... ... ..
20008 20008 0
20009 20009 0
20010 20010 0
20011 20011 1
20012 20012 1
[20013 rows x 2 columns]
20013张图片，0列代表图片id，1列为标签
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
# 分布情况
cases_count = csv[1].value_counts()
print(cases_count)
# 画图
plt.figure(figsize=(6,3))
sns.barplot(x=cases_count.index, y= cases_count.values)
plt.title('Number of cases', fontsize=14)
plt.xlabel('Case type', fontsize=12)
plt.ylabel('Count', fontsize=12)
plt.xticks(range(len(cases_count.index)), ['0', '1','2','3'])
plt.show()
0 15503
2 2450
1 1960
3 89
4 10
Name: 0.1, dtype: int64
这有数据集有点欺负人了，严重的类别不均衡，第一类占了75%，第三，四类可以放弃了。稍后可以扩充看看效果。没服务器跑的话直接全按0提交吧。(逃)
导入图片查看肺炎ct长怎样，kaggle上学到的方法。
from PIL import Image
images=csv[1].values
labels=csv[0].values
paths="train/"
imgs0=(csv[csv[1]==0][0].iloc[:5]).tolist()
imgs1=(csv[csv[1]==1][0].iloc[:5]).tolist()
imgs2=(csv[csv[1]==2][0].iloc[:5]).tolist()
imgs3=(csv[csv[1]==3][0].iloc[:5]).tolist()
imgs4=(csv[csv[1]==4][0].iloc[:5]).tolist()
imgs=imgs0+imgs1+imgs2+imgs3+imgs4
f, ax = plt.subplots(5,5, figsize=(8,8))
for i in range(25):
img_path=paths+str(imgs[i])+'.jpg'
img=Image.open(img_path).convert('RGB')
ax[i//5, i%5].imshow(img)
ax[i//5, i%5].set_title(i//5)
ax[i//5, i%5].axis('off')
ax[i//5, i%5].set_aspect('auto')
plt.show()
我觉得是个检测任务，检测病灶的数量。但我打算先当成多分类试试看。
import pandas as pd
import numpy as np
import os
from PIL import Image
from torch.utils.data import Dataset
class MyDataSet(Dataset):
def __init__(self,image_path,csv_path,transforms,phrase):
# 读取csv
csv=pd.read_csv(csv_path,header=None)
# 读取第一列,组合成完整的图片地址
self.imgs=[image_path+str(k)+".jpg" for k in csv[0].values]
self.phrase=phrase
if self.phrase!="test":
self.labels=np.asarray([k for k in csv[1].values])
self.transforms=transforms
def __getitem__(self, index):
img_path = self.imgs[index]
pil_img = Image.open(img_path).convert("RGB")
if self.transforms:
data = self.transforms(pil_img)
else:
pil_img = np.asarray(pil_img)
data = torch.from_numpy(pil_img)
if self.phrase!="test":
label=self.labels[index]
sample = (data,label)
else:
sample=data
return sample
def __len__(self):
return len(self.imgs)
训练集随机裁剪然后中心裁剪成224224，随机翻转，随机亮度对比度，随机旋转15度，标准化。验证集测试集只裁剪为224224。
from torchvision import transforms
# 数据增强
data_transforms={
"train":
transforms.Compose([
transforms.RandomResizedCrop(size=256, scale=(0.8, 1.0)),
transforms.CenterCrop(size=224),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(brightness=0.2, contrast=0.2),
transforms.RandomRotation(15),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
"val":
transforms.Compose([
transforms.RandomResizedCrop(size=256, scale=(0.8, 1.0)),
transforms.CenterCrop(size=224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
"test":
transforms.Compose([
transforms.RandomResizedCrop(size=256, scale=(0.8, 1.0)),
transforms.CenterCrop(size=224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
}
from torch.utils.data import DataLoader,SubsetRandomSampler
from load_data import MyDataSet
import numpy as np
batch_size=64
dataset=MyDataSet("train/","train.csv",data_transforms["train"],"train")
# 验证集比例
validation_split = .2
shuffle_dataset = True
random_seed= 42
batch_size=128
dataset_size = len(dataset)
indices = list(range(dataset_size))
split = int(np.floor(validation_split * dataset_size))
if shuffle_dataset :
np.random.seed(random_seed)
np.random.shuffle(indices)
train_indices, val_indices = indices[split:], indices[:split]
# 创建sampler
train_sampler = SubsetRandomSampler(train_indices)
valid_sampler = SubsetRandomSampler(val_indices)
train_loader = DataLoader(dataset, batch_size=batch_size, shuffle=shuffle_dataset,num_workers=4)
val_loader=DataLoader(dataset, batch_size=batch_size, shuffle=shuffle_dataset,num_workers=4)
resnet34,imagenet预训练模型迁移学习
from torchvision import models
from torch import nn
import sys
# 冻结最初几层网络
def set_parameter_requires_grad(model, feature_extracting):
if feature_extracting:
for i, para in enumerate(model.parameters()):
if i < 50:
para.requires_grad = False
else:
para.requires_grad = True
def initialize_model(model_name, num_classes, feature_extract, use_pretrained=False):
model_ft = None
input_size = 0
model_ft = models.resnet34(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Sequential(nn.Linear(num_ftrs, num_classes))
input_size = 224
return model_ft, input_size
from model import initialize_model
num_classes=5
model_name="resnet34"
feature_extract=True
model,input_size=initialize_model(model_name=model_name,num_classes=num_classes,feature_extract=feature_extract, use_pretrained=True)
参考官方文档的训练过程
import copy
import time
import torch
import matplotlib.pyplot as plt
def train_model(model, device,dataloaders, criterion, optimizer, num_epochs, is_inception=False):
since = time.time()
val_acc_history = []
train_acc_history=[]
val_loss_history = []
train_loss_history=[]
best_model_wts = copy.deepcopy(model.state_dict())
best_acc = 0.0
for epoch in range(num_epochs):
print('Epoch {}/{}'.format(epoch, num_epochs - 1))
print('-' * 10)
# Each epoch has a training and validation phase
for phase in ['train', 'val']:
if phase == 'train':
model.train() # Set model to training mode
else:
model.eval() # Set model to evaluate mode
running_loss = 0.0
running_corrects = 0
# Iterate over data.
for inputs, labels in dataloaders[phase]:
inputs = inputs.to(device)
labels = labels.to(device)
# zero the parameter gradients
optimizer.zero_grad()
# forward
# track history if only in train
with torch.set_grad_enabled(phase == 'train'):
outputs = model(inputs)
loss = criterion(outputs, labels)
_, preds = torch.max(outputs, 1)
# backward + optimize only if in training phase
if phase == 'train':
loss.backward()
optimizer.step()
# statistics
running_loss += loss.item() * inputs.size(0)
running_corrects += torch.sum(preds == labels.data)
epoch_loss = running_loss / len(dataloaders[phase].dataset)
epoch_acc = running_corrects.double() / len(dataloaders[phase].dataset)
print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc))
# deep copy the model
if phase == 'val' and epoch_acc > best_acc:
best_acc = epoch_acc
best_model_wts = copy.deepcopy(model.state_dict())
if phase == 'val':
val_acc_history.append(epoch_acc)
val_loss_history.append(epoch_loss)
if phase=="train":
train_acc_history.append(epoch_acc)
train_loss_history.append(epoch_loss)
print()
his=[train_acc_history,val_acc_history,train_loss_history,val_loss_history]
time_elapsed = time.time() - since
print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))
print('Best val Acc: {:4f}'.format(best_acc))
# load best model weights
model.load_state_dict(best_model_wts)
torch.save(model,"model_{}.pkl".format(best_acc))
return model, his
训练20轮，损失函数交叉熵，优化adam，学习率0.001
from train import train_model
from torch import nn,optim
epoch=20
import torch
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = model.to(device)
criterion = nn.CrossEntropyLoss()
# optimizer=optim.SGD(params_to_update, lr=0.01, momentum=0.9)
optimizer = optim.Adam(params_to_update,lr=0.001,)
model,his=train_model(model, device,dataloader, criterion, optimizer, num_epochs=epoch, is_inception=False)
Epoch 0/19
----------
train Loss: 0.5685 Acc: 0.7956
val Loss: 0.5189 Acc: 0.8125
Epoch 1/19
----------
train Loss: 0.5186 Acc: 0.8106
val Loss: 0.5188 Acc: 0.8058
Epoch 2/19
----------
train Loss: 0.5061 Acc: 0.8116
val Loss: 0.4857 Acc: 0.8204
Epoch 3/19
----------
train Loss: 0.4996 Acc: 0.8152
val Loss: 0.4822 Acc: 0.8215
Epoch 4/19
----------
train Loss: 0.4967 Acc: 0.8183
val Loss: 0.4853 Acc: 0.8145
Epoch 5/19
----------
train Loss: 0.4891 Acc: 0.8187
val Loss: 0.4733 Acc: 0.8215
Epoch 6/19
----------
train Loss: 0.4824 Acc: 0.8197
val Loss: 0.5399 Acc: 0.7997
Epoch 7/19
----------
train Loss: 0.4837 Acc: 0.8209
val Loss: 0.4696 Acc: 0.8246
Epoch 8/19
----------
train Loss: 0.4783 Acc: 0.8210
val Loss: 0.4666 Acc: 0.8253
Epoch 9/19
----------
train Loss: 0.4755 Acc: 0.8232
val Loss: 0.4616 Acc: 0.8270
Epoch 10/19
----------
train Loss: 0.4711 Acc: 0.8227
val Loss: 0.4693 Acc: 0.8250
Epoch 11/19
----------
train Loss: 0.4683 Acc: 0.8231
val Loss: 0.4571 Acc: 0.8289
Epoch 12/19
----------
train Loss: 0.4634 Acc: 0.8247
val Loss: 0.4644 Acc: 0.8299
Epoch 13/19
----------
train Loss: 0.4613 Acc: 0.8286
val Loss: 0.4404 Acc: 0.8329
Epoch 14/19
----------
train Loss: 0.4582 Acc: 0.8281
val Loss: 0.4535 Acc: 0.8323
Epoch 15/19
----------
train Loss: 0.4556 Acc: 0.8265
val Loss: 0.4553 Acc: 0.8256
Epoch 16/19
----------
train Loss: 0.4508 Acc: 0.8305
val Loss: 0.4375 Acc: 0.8361
Epoch 17/19
----------
train Loss: 0.4453 Acc: 0.8316
val Loss: 0.4301 Acc: 0.8377
Epoch 18/19
----------
train Loss: 0.4473 Acc: 0.8323
val Loss: 0.4267 Acc: 0.8396
Epoch 19/19
----------
train Loss: 0.4391 Acc: 0.8330
val Loss: 0.4140 Acc: 0.8431
Training complete in 56m 33s
Best val Acc: 0.843094
画图
import numpy as np
train_acc = [h.cpu().numpy() for h in his[0]]
val_acc = [h.cpu().numpy() for h in his[1]]
plt.title("Accuracy vs Number of Training Epochs")
plt.xlabel("Training Epochs")
plt.ylabel("Accuracy")
plt.plot(range(1,epoch+1),train_acc,label="training")
plt.plot(range(1,epoch+1),val_acc,label="val")
plt.ylim((0,1.))
plt.xticks(np.arange(1, epoch+1, 1.0))
plt.legend()
plt.savefig("acc.png")
plt.show()
plt.close('all')
train_loss = [h for h in his[2]]
val_loss = [h for h in his[3]]
plt.title("Loss vs Number of Training Epochs")
plt.xlabel("Training Epochs")
plt.ylabel("Accuracy")
plt.plot(range(1,epoch+1),train_loss,label="training")
plt.plot(range(1,epoch+1),val_loss,label="val")
plt.xticks(np.arange(1, epoch+1, 1.0))
plt.legend()
plt.savefig("loss.png")
plt.show()
大部分情况下验证集准确率都大于训练集准确率，且loss也优于训练集，个人理解是训练集做了数据增强，而验证集测试集并没有处理，使得训练集数据分布变得更加广泛，变得难以训练，从而使模型变得泛化能力增强。在大型数据集中往往都会出现这种情况。
手动新建了csv，序号从0到6670
import torch
from load_data import MyDataSet
from torch.utils.data import DataLoader
model=torch.load("model_0.84.pkl")
# 读取测试集
dataset=MyDataSet("test/","upload.csv",data_transforms["test"],"test")
testdata=DataLoader(dataset,batch_size=32, shuffle=False,num_workers=4)
print(dataset.__len__())
6671
# 输出学习了[Nin7a](https://blog.csdn.net/Nin7a/article/details/104057441)大佬的blog
import pandas as pd
model.eval()
predicted_labels_list=[]
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
for batch_id,(features) in enumerate(testdata):
features = features.to(device)
probas = model(features)
_, predicted_labels = torch.max(probas, 1)
for label in predicted_labels:
predicted_labels_list.append(label.cpu().item())
dict={'label':predicted_labels_list}
df=pd.DataFrame(dict)
df.to_csv('upload.csv',header=False,index=True)
目前新榜单，暂时排名第十
看了提交的csv，果然一个3和4也没有，全不是预测为0，1，2类，下一步可能会学习一下处理类别不均衡的问题。