猫狗大战谁会赢
VGG实现猫狗分类
1、导入数据和解压数据
! wget http://fenggao-image.stor.sinaapp.com/dogscats.zip! unzip dogscats.zip ! wget https://static.leiphone.com/cat_dog.rar! unrar x cat_dog.rar分别导入AI研习社的数据和老师给的数据，本来想本地导入，由于太卡，上传了一个小时没上传到google网盘，网盘还一直掉线，因此放弃，下载了两组数据。dogscats数据中的train和val分别有cat和dog的文件夹，因此选用dogscats的数据做实验。
2、设置transform函数，将AI研习社的test文件夹提取到同一个文件夹下，用ImageFolder提取相应路径下的数据并设置bitch_size，考虑到VGG的输入为224*224，所以要将图片裁剪为224*224；提取数据长度dest_sizes，存储类别信息train_classes。
#组合多个函数
transform=transforms.Compose([
transforms.CenterCrop(224),#考虑到VGG的输入为224*224，对原始图片进行裁剪
#transforms.RandomHorizontalFlip(),#随机左右翻转
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225])])#!ls "/content/cat_dog/train"
#print(os.listdir())
#训练时可以打乱顺序增加多样性，测试时没有必要，所以shuffle=Falsedataset={x:datasets.ImageFolder(root=os.path.join('dogscats',x),transform=transform) for x in ['train','val','test']}
trainloader=torch.utils.data.DataLoader(dataset=dataset['train'],batch_size=64,shuffle=True,num_workers=6)
valloader=torch.utils.data.DataLoader(dataset=dataset['val'],batch_size=64,shuffle=False,num_workers=6)
testloader=torch.utils.data.DataLoader(dataset=dataset['test'],batch_size=64,shuffle=False,num_workers=6)
dset_sizes ={x:len(dataset[x]) for x in ['train','val','test']}
train_classes=dataset['train'].classes
3、下载ImageNet的json文件，使用训练好的VGG16模型进行预测，最后用softmax进行处理。使用json.load()来读取imagenet文件，将输入数据model后再softmax，展示识别结果，由于我的batch_size设置为64，图片也就小了点，结果也就多了点。
!wget https://s3.amazonaws.com/deep-learning-models/image-models/imagenet_class_index.json
model_vgg=models.vgg16(pretrained=True)
#找到这个结果预测的是哪个类别，最简单的可以找向量中最大的那个值，然后找出所对应的类别：
with open('./imagenet_class_index.json') as f:
#print(json.load(f))
class_dict = json.load(f)
print(class_dict)
dic_imagenet = [class_dict[str(i)][1] for i in range(len(class_dict))]
inputs_try,labels_try = inputs_try.to(device),labels_try.to(device)
model_vgg = model_vgg.to(device)
outputs_try = model_vgg(inputs_try)
print(outputs_try)
print(outputs_try.shape)m_softm = nn.Softmax(dim=1)
probs = m_softm(outputs_try)
vals_try,pred_try = torch.max(probs,dim=1)
print( 'prob sum: ', torch.sum(probs,1))
print( 'vals_try: ', vals_try)
print( 'pred_try: ', pred_try)
print([dic_imagenet[i] for i in pred_try.data])
imshow(torchvision.utils.make_grid(inputs_try.data.cpu()),
title=[train_classes[x] for x in labels_try.data.cpu()])
4、在这里使用 nn.Linear 层将结果的1000类替换为2类，model_vgg_new.parameters()是返回一个每次生成的是Tensor类型的数据的迭代器，设置 required_grad=False冻结前面层的参数。定义优化模型和损失函数。vgg.features是取出vgg16网络中的features大层。其中vgg网络可以分为3大层，一层是（features），一层是（avgpool），最后一层是（classifier），vgg.classifiwe._modules是将取出来的网络转为字典显示。
print(model_vgg)
model_vgg_new = model_vgg;
for param in model_vgg_new.parameters():
param.requires_grad = False
model_vgg_new.classifier._modules['6'] = nn.Linear(4096, 2)
model_vgg_new.classifier._modules['7'] = torch.nn.LogSoftmax(dim = 1)
model_vgg_new = model_vgg_new.to(device)
print(model_vgg_new.classifier)
criterion=nn.NLLLoss()
lr = 0.001
# 随机梯度下降
optimizer_vgg = torch.optim.SGD(model_vgg_new.classifier[6].parameters(),lr = lr)
5、训练模型
def train_model(model,dataloader,size,epochs,optimizer):
model.train()
for epoch in range(epochs):
running_loss = 0.0
running_corrects = 0
count = 0
for inputs,classes in dataloader:
inputs = inputs.to(device)
classes = classes.to(device)
outputs = model(inputs)
loss = criterion(outputs,classes)
optimizer = optimizer
optimizer.zero_grad()
loss.backward()
optimizer.step()
_,preds = torch.max(outputs.data,1)
# statistics
running_loss += loss.data.item()
running_corrects += torch.sum(preds == classes.data)
count += len(inputs)
print('Training: No. ', count, ' process ... total: ', size)
epoch_loss = running_loss / size
epoch_acc = running_corrects.data.item() / size
print('Loss: {:.4f} Acc: {:.4f}'.format(epoch_loss, epoch_acc))
# 模型训练
train_model(model_vgg_new,trainloader,size=dset_sizes['train'], epochs=1,
optimizer=optimizer_vgg)训练结果：
6、测试val
def test_model(model,dataloader,size):
model.eval（)
predictions = np.zeros(size)
all_classes = np.zeros(size)
all_proba = np.zeros((size,2))
i = 0
running_loss = 0.0
running_corrects = 0
for inputs,classes in dataloader:
inputs = inputs.to(device)
classes = classes.to(device)
outputs = model(inputs)
loss = criterion(outputs,classes)
_,preds = torch.max(outputs.data,1)
# statistics
running_loss += loss.data.item()
running_corrects += torch.sum(preds == classes.data)
predictions[i:i+len(classes)] = preds.to('cpu').numpy()
all_classes[i:i+len(classes)] = classes.to('cpu').numpy()
all_proba[i:i+len(classes),:] = outputs.data.to('cpu').numpy()
i += len(classes)
print('Testing: No. ', i, ' process ... total: ', size)
epoch_loss = running_loss / size
epoch_acc = running_corrects.data.item() / size
print('Loss: {:.4f} Acc: {:.4f}'.format(epoch_loss, epoch_acc))
return predictions, all_proba, all_classes
predictions, all_proba, all_classes = test_model(model_vgg_new,valloader,size=dset_sizes['val'])测试结果：
7、测试test
predictions2,all_proba2,all_classes2=test_model(model_vgg_new,testloader,size=dset_sizes['test'])测试结果：此处的0.4870不能看做是test的准确率，因为test里面没有cat和dog的标签，所以这个数值是不准确的。
将图片序号和预测结果导入为csv文件后再进行排序，在AI研习社的结果为：
8、遇到问题：
（1）导入AI研习社下载链接后，使用unzip解压失败，针对.rar压缩文件应该使用unrar
（2）读取文件时出现找不到子文件的错误，但是路径格式我确定自己没有填写错误，后来发现ImageFolder的root针对的格式是这样的：如果路径是cat_dog/train/1.jpg，填写的路径要是cat_dog才是正确答案。我导入的大赛的数据有三个文件夹train、test、val，每个文件夹下面没有更多的文件夹，直接是图片，这就导致按照正确格式读取只能将三个文件夹的数据一起读取。通过纠结考虑只有两个办法：①在每个文件夹下面分别建cat和dog文件夹，才能分别读取train、test、val；②换个下载路径。更换下载路径后代码正确。
（3）源代码中训练函数的参数是固定的，不利于后期的修改，尤其是optimizer没有使用设置好的梯度下降优化函数
（4）下载csv提交时，出现正确率为50%的情况。原因是我没有意识到图片序号的重要性，直接按照图片在test下的顺序设置了range序列，这样的结果是不正确的。
那为什么结果是50%左右呢？由于test里面没有cat和dog的分类，所以分类的标签为0，也就是说测试集中猫是正确，狗是错误，50%的意思是统计了猫在数据集中的数量占比
9、优化
（1）提高训练次数
（2）使用Adam函数，提高学习率
