中文文档
简单网络的建立
数据的加载
import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim import lr_scheduler
import numpy as np
import torchvision
from torchvision import datasets, models, transforms
import matplotlib.pyplot as plt
import time
import os
import copy
#数据处理
data_transforms = {
'train': transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
'val': transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
}
data_dir = 'data/hymenoptera_data'
#加载处理后数据
image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),
data_transforms[x])
for x in ['train', 'val']}
#创建数据加载器，每次往网络输入batch数据
dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4,
shuffle=True, num_workers=4)
for x in ['train', 'val']}
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
class_names = image_datasets['train'].classes
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
数据的显示
def imshow(inp, title=None):
"""Imshow for Tensor."""
inp = inp.numpy().transpose((1, 2, 0))
mean = np.array([0.485, 0.456, 0.406])
std = np.array([0.229, 0.224, 0.225])
inp = std * inp + mean
inp = np.clip(inp, 0, 1)
plt.imshow(inp)
if title is not None:
plt.title(title)
plt.pause(0.001) # pause a bit so that plots are updated
# Get a batch of training data
#迭代器和迭代对象 迭代器有next()方法，可迭代对象有列表等
#可通过iter()方法将可迭代对象变成迭代器，同时注意yield()方法
inputs, classes = next(iter(dataloaders['train']))
# Make a grid from batch将batch在一张图上显示
out = torchvision.utils.make_grid(inputs)
imshow(out, title=[class_names[x] for x in classes])
建立训练模型
#使用models下载vgg16神经网络，是CNN卷积网络中的一种，比较小，也好用
fmodel = models.vgg16(pretrained = True)
#冻结预训练网络中的参数，因为我们并不想更新这一部分的参数
for param in fmodel.parameters():
param.require_grad = False
from collections import OrderedDict
# 定义一个新的classifier，其中包含3个全连接隐藏层，层之间使用ReLU函数进行激活，最后输出使用LogSoftMax函数，因为这是一个多分类。
classifier = nn.Sequential(OrderedDict([
('fc1',nn.Linear(25088,4096)),
('relu1',nn.ReLU()),
('fc2',nn.Linear(4096,1000)),
('relu2',nn.ReLU()),
('fc3',nn.Linear(1000,102)),
('output',nn.LogSoftmax(dim=1))
]))
# 替换
fmodel.classifier = classifier
# 使用Negative Log Likelihood Loss作为误差函数
criterion = nn.NLLLoss()
# 使用Adam作为优化器，并且只对分类器的参数进行优化，也可以使用SDG，ADAM具有动量优化效果，设置学习速率为0.01，
optimizer = optim.Adam(fmodel.classifier.parameters(),lr=0.001
def accuracy_test(model,dataloader):
correct = 0
total = 0
model.cuda() # 将模型放入GPU计算，能极大加快运算速度
with torch.no_grad(): # 使用验证集时关闭梯度计算
for data in dataloader:
images,labels = data
images,labels = images.to('cuda'),labels.to('cuda')
outputs = model(images)
_, predicted = torch.max(outputs.data,1)
# torch.max返回输出结果中，按dim=1行排列的每一行最大数据及他的索引，丢弃数据，保留索引
total += labels.size(0)
correct += torch.sum(predicted==labels.data)
#将预测及标签两相同大小张量逐一比较各相同元素的个数
print('the accuracy is {:.4f}'.format(correct/total))
def deep_learning (model,trainloader,epochs,print_every,criterion,optimizer,device):
epochs = epochs #设置学习次数
print_every = print_every
steps = 0
model.to(deive)
for e in range(epochs):
running_loss = 0
for ii , (inputs,labels) in enumerate(trainloader):
steps += 1
inputs,labels = inputs.to(device),labels.to(device)
optimizer.zero_grad() # 优化器梯度清零
# 前馈及反馈
outputs = model(inputs) #数据前馈，正向传播
loss = criterion(outputs,labels) # 输出误差
loss.backward() #误差反馈
optimizer.step() #优化器更新参数
running_loss += loss.item()
if steps % print_every == 0:
#test the accuracy
print('EPOCHS : {}/{}'.format(e+1,epochs),
'Loss : {:.4f}'.format(running_loss/print_every))
accuracy_test(model,validloader)
deep_learning(fmodel,trainloader,3,40,criterion,optimizer,'cuda')
accuracy_test(testloader)
from PIL import Image # 使用image模块导入图片
def process_image(image):
''' 对图片进行缩放，建材，标准化，并输出一个NUMPY数组
'''
#调整图片大小
pic = Image.open(image)
if pic.size[0] < pic.size[1]:
ratio = float(256) / float(pic.size[0])
else:
ratio = float(256) / float(pic.size[1])
new_size = (int(pic.size[0]*ratio),int(pic.size[1]*ratio))
pic.thumbnail(new_size) # 缩放为等长等宽
#从图片中心抠出224 *224 的图像
pic = pic.crop([pic.size[0]/2-112,pic.size[1]/2-112,pic.size[0]/2+112,pic.size[1]/2+112])
#将图片转化为numpy数组
mean = [0.485,0.456,0.406]
std = [0.229,0.224,0.225]
np_image = np.array(pic)
np_image = np_image/255
for i in range(2): # 使用和训练集同样的参数对图片进行数值标准化
np_image[:,:,i] -= mean[i]
np_image[:,:,i] /= std[i]
np_image = np_image.transpose((2,0,1)) #PyTorch 要求颜色通道为第一个维度，但是在 PIL 图像和 Numpy 数组中是第三个维度，所以调整
np_image = torch.from_numpy(np_image) # 转化为张量
np_image = np_image.float()
print(np_image.type)
return np_image
def predict(image_path, model, topk=5):
''' 预测图片.
'''
img = process_image(image_path)
img = img.unsqueeze(0) # 将图片多增加一维
result = model(img.cuda()).topk(topk)
probs= []
classes = []
a = result[0] # 返回TOPK函数截取的排名前列的结果列表a
b = result[1].tolist() #返回TOPK函数截取的排名前列的概率索引列表b
for i in a[0]:
probs.append(torch.exp(i).tolist()) #将结果转化为实际概率
for n in b[0]:
classes.append(str(n+1)) # 将索引转化为实际编号
return(probs,classes)
