PyTorch 11—简单图像定位

常见图像处理的任务

(1)分类

给定一幅图像,我们用计算机模型预测图片中有什么对象 。

PyTorch 11—简单图像定位_第1张图片

(2)分类加定位

不仅需要我们知道图片中的对象是什么,还要在对象的附近画一个边框,确定该对象所处的位置。

PyTorch 11—简单图像定位_第2张图片

(3)语义分割

区分到图中每一个像素点,而不仅仅是矩形框框住。PyTorch 11—简单图像定位_第3张图片

(4)目标检测 

目标检测简单来说就是回答图片里面有什么?分别在哪里?(把它们用矩形框框住)。

PyTorch 11—简单图像定位_第4张图片

(5)实例分割 

实例分割是目标检测和语义分割的结合。相对目标检测的边界框,实例分割可精确到物体的边缘;相对语义分割,实例分割需要标注出图上同一物体的不同个体

PyTorch 11—简单图像定位_第5张图片

 图像定位

对于单纯的分类问题,比较容易理解,给定一幅图片,我们输出一个标签类别,我们已经跟熟悉。

而定位有点复杂,需要输出四个数字(x,y,w,h),图像中某一个点的坐标(x,y),以及图像的宽度和高度,有了这四个数字,我们可以很容易地找到物体的边框。

简单定位网络架构

PyTorch 11—简单图像定位_第6张图片

本质是回归问题,使用L2损失进行优化。

Oxford-IIIT数据集

The Oxford-IIIT Pet Dataset是一个宠物图像数据集,包含37种宠物,每种宠物200张左右宠物图片,该数据集同时包含宠物分类、头部轮廓标注和语义分割信息

PyTorch 11—简单图像定位_第7张图片

代码实战

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils import data
import numpy as np
import matplotlib.pyplot as plt
import torchvision
from torchvision import transforms
import os
from lxml import etree  # etree网页解析模块
from matplotlib.patches import Rectangle    # Rectangle画矩形
import glob # 获取所有路径
from PIL import Image   # 读取图像

单张图片演示

BATCH_SIZE = 8
print('一、图片解析演示')
pil_img = Image.open(r'dataset/images/Abyssinian_1.jpg')
np_img = np.array(pil_img)  # 转换成ndarray形式
print(np_img.shape)
plt.imshow(np_img)
plt.show()

# 打开对应的xml图像定位信息文件
xml = open(r'dataset/annotations/xmls/Abyssinian_1.xml').read()
# 使用Etree库解析xml文件
sel = etree.HTML(xml)   # 首先创建一个解析对象
width = sel.xpath('//size/width/text()')[0]   # 使用xpath方法获取它的位置。
# //表示从根目录查找,width/text()表示查找width标签里的文本,返回对象是一个列表,所以要切片处理
height = sel.xpath('//size/height/text()')[0]
print(width,' ',height)

# 查找头部所在的像素位置
xmin = sel.xpath('//bndbox/xmin/text()')[0]
ymin = sel.xpath('//bndbox/ymin/text()')[0]
xmax = sel.xpath('//bndbox/xmax/text()')[0]
ymax = sel.xpath('//bndbox/ymax/text()')[0]

# 将获取到的文本转换成整数。
#转换数据类型,因为matplotlib只能接受整形标注它的位置
width = int(width)
height = int(height)
xmin = int(xmin)
ymin = int(ymin)
xmax = int(xmax)
ymax = int(ymax)

plt.imshow(np_img)
rect = Rectangle((xmin, ymin), (xmax-xmin), (ymax-ymin), fill=False, color='blue')   # 实例化Rectangle对象,需要标注它的一些位置
# 参数1是xy,即最小值所在的点;第二、三个参数是width、height;fill=False表示不需要填充矩形。
ax = plt.gca()  # 获取当前坐标系
ax.axes.add_patch(rect) # 在当前坐标系上添加矩形框。
plt.show()

PyTorch 11—简单图像定位_第8张图片

PyTorch 11—简单图像定位_第9张图片


在原始数据集中,各张图片大小不一,我们在输入模型时,想要把它变成固定的大小。但是,图像改变尺寸后,对应的xmin和ymin就不对了,因为xmin和ymin是相对于原先图片的大小。实际上,我们可以将它转换为一个比值就可以了

# 例如:
img = pil_img.resize((224,224))
xmin = (xmin/width)*224
ymin = (ymin/height)*224
xmax = (xmax/width)*224
ymax = (ymax/height)*224

plt.imshow(img)
rect = Rectangle((xmin, ymin), (xmax-xmin), (ymax-ymin), fill=False, color='red')
ax = plt.gca()  # 获取当前坐标系
ax.axes.add_patch(rect) # 在当前坐标系上添加矩形框。
plt.show()

PyTorch 11—简单图像定位_第10张图片

 输出是比值,使用比值作为目标值。


创建输入

images = glob.glob('dataset/images/*.jpg')  # 返回类型是列表。返回在images目录下所有以 jpg 结尾的文件的路径
xmls = glob.glob('dataset/annotations/xmls/*.xml')

len(images) #7390
len(xmls) # 3686
# 这说明了数据集并没有对全部的图片进行标注

"""
我们不知道对哪些图片做了标注,为了取出标注的图片;
我们要将这些被标注数据的文件名 ;
也即'dataset/annotations/xmls\\Abyssinian_1.xml'中的Abyssinian_1取出来;
然后使用文件名对原有的图片进行一个筛选。
"""

xmls_names = [x.split('\\')[-1].split('.xml')[0] for x in xmls] # 获取到了所有被标注图片的文件名
# xmls_names = [x.split('\\')[-1].replace('.xml','') for x in xmls] 这种办法和上面的效果一样

len(xmls_names) # 3686

# 根据标注图片的文件名对所有图片进行一个筛选
imgs = [img for img in images if 
        img.split('\\')[-1].split('.jpg')[0] in xmls_names]
len(imgs) #3686

# 在创建输入之前,要保证图片和标注信息是一一对应的
print('len(imgs)==len(xmls_names)?:',len(imgs)==len(xmls_names))
print('imgs[:5]:\n',imgs[:5])
print('xmls[:5]:\n',xmls[:5])

将xml文件转换成标签的格式:下面我们需要将xml文件给它转换成标签的形式,在转换之前,我们首先要明确一点,我们的目标值不再是xmin这个实际的值,因为每一张图片的大小都是不一的,这个时候我们只是取出它的一个比例值。我们的预测值是头部宽高度所占的比值。

# 为了将xml列表文件里的数值解析出来,我们专门定义一个toLabel函数
def to_labels(path):
    xml = open(r'{}'.format(path)).read() # 用格式化形式,加r,防止转义。
    sel = etree.HTML(xml) # 创建选择器
    width = int(sel.xpath('//size/width/text()')[0]) 
    height = int(sel.xpath('//size/height/text()')[0])
    xmin = int(sel.xpath('//bndbox/xmin/text()')[0])
    ymin = int(sel.xpath('//bndbox/ymin/text()')[0])
    xmax = int(sel.xpath('//bndbox/xmax/text()')[0])
    ymax = int(sel.xpath('//bndbox/ymax/text()')[0])
    return [xmin/width, ymin/height, xmax/width, ymax/height]
labels = [to_labels(path) for path in xmls]
labels[0],type(labels)

# zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。
out1_label, out2_label, out3_label, out4_label = list(zip(*labels))

len(out1_label), len(out2_label), len(out3_label), len(out4_label)

 


 划分数据集

index = np.random.permutation(len(imgs))
# img和label都是一一对应的,但是顺序乱序了。
images = np.array(imgs)[index]
labels = np.array(labels)[index]
out1_label = np.array(out1_label).astype(np.float32).reshape(-1, 1)[index]
out2_label = np.array(out2_label).astype(np.float32).reshape(-1, 1)[index]
out3_label = np.array(out3_label).astype(np.float32).reshape(-1, 1)[index]
out4_label = np.array(out4_label).astype(np.float32).reshape(-1, 1)[index]

labels = labels.astype(np.float32) # 由于之前做了除法,最好转换成浮点型数据,这样有利于模型不报错
labels.shape # (3686,4)

"""
out1_label = out1_label.astype(np.float32)
out2_label = out2_label.astype(np.float32)
out3_label = out3_label.astype(np.float32)
out4_label = out4_label.astype(np.float32)
"""

i = int(len(imgs)*0.8) # 训练集比例

train_images = images[:i]
train_labels = labels[:i]
out1_train_label = out1_label[:i]
out2_train_label = out2_label[:i]
out3_train_label = out3_label[:i]
out4_train_label = out4_label[:i]

test_images = images[i:]
test_labels = labels[i:]
out1_test_label = out1_label[i: ]
out2_test_label = out2_label[i: ]
out3_test_label = out3_label[i: ]
out4_test_label = out4_label[i: ]


创建输入模型 

 

transform = transforms.Compose([
                    transforms.Resize((224, 224)),
                    transforms.ToTensor(),
])

# 创建一个DataSet类
class Oxford_dataset(data.Dataset):
    def __init__(self, img_paths, out1_label, out2_label,
                 out3_label, out4_label, transform):
        self.imgs = img_paths
        self.out1_label = out1_label
        self.out2_label = out2_label
        self.out3_label = out3_label
        self.out4_label = out4_label
        self.transforms = transform

    def __getitem__(self, index):
        img = self.imgs[index]  # 切出来是一条路径
        out1_label = self.out1_label[index]
        out2_label = self.out2_label[index]
        out3_label = self.out3_label[index]
        out4_label = self.out4_label[index]
        pil_img = Image.open(img)
        imgs_data = np.asarray(pil_img, dtype=np.uint8)
        if len(imgs_data.shape) == 2: # 如果不是rgb图像,就多增加一个维度
            imgs_data = np.repeat(imgs_data[:, :, np.newaxis], 3, axis=2)
            img_tensor = self.transforms(Image.fromarray(imgs_data))
        else:
            img_tensor = self.transforms(pil_img)
        return (img_tensor,
                out1_label,
                out2_label,
                out3_label,
                out4_label)

    def __len__(self):
        return len(self.imgs)


train_dataset = Oxford_dataset(train_images, out1_train_label,
                               out2_train_label, out3_train_label,
                               out4_train_label, transform)


test_dataset = Oxford_dataset(test_images, out1_test_label,
                               out2_test_label, out3_test_label,
                               out4_test_label, transform)

train_dl = data.DataLoader(
                      train_dataset,
                      batch_size=BATCH_SIZE,
                      shuffle=True,
)

test_dl = data.DataLoader(
                      test_dataset,
                      batch_size=BATCH_SIZE,
)

(imgs_batch, 
out1_batch, 
out2_batch, 
out3_batch, 
out4_batch) = next(iter(train_dl))

imgs_batch.shape, out1_batch.shape

 

plt.figure(figsize=(12, 8))
for i,(img, label1, label2,
            label3,label4,) in enumerate(zip(imgs_batch[:2],
                                             out1_batch[:2], 
                                             out2_batch[:2], 
                                             out3_batch[:2], 
                                             out4_batch[:2])):
    img = (img.permute(1,2,0).numpy() + 1)/2  # permute交换维度。
    plt.subplot(2, 3, i+1)
    plt.imshow(img)
    xmin, ymin, xmax, ymax = label1*224, label2*224, label3*224, label4*224, 
    rect = Rectangle((xmin, ymin), (xmax-xmin), (ymax-ymin), fill=False, color='red')
    ax = plt.gca()
    ax.axes.add_patch(rect)

PyTorch 11—简单图像定位_第11张图片


创建定位模型 

resnet = torchvision.models.resnet101(pretrained=True)  # 使用卷积基提取特征。使用预训练参数作为初始化参数
"""
resnet101里面包含很多层,conv、batch.........
最后是avgpool和fc全连接层。
avgpool之前的层都是我们需要的

"""

in_f = resnet.fc.in_features    # 全连接层的输入
print(in_f) #2048

resnet.children()   # 会返回所有层的生成器
list(resnet.children()) # 使用list将它返回
print(len(list(resnet.children()))) # 一共包含10个子层
print(list(resnet.children())[-1])  # 看看最后一层
list(resnet.children())[:-1]    # 这些层才是我们需要的,帮助我们提取特征。
conv_base = nn.Sequential(*list(resnet.children())) # *代表解包。这样相当于每一层都列在了Sequential里面

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__() # 继承父类属性
        self.conv_base = nn.Sequential(*list(resnet.children())[:-1])
        # 使用全连接模型。分别输出4个坐标值
        self.fc1 = nn.Linear(in_f, 1)   # 输出是1,因为我们要输出一个标量值。
        self.fc2 = nn.Linear(in_f, 1)
        self.fc3 = nn.Linear(in_f, 1)
        self.fc4 = nn.Linear(in_f, 1)

    def forward(self, x):
        x = self.conv_base(x)   # 提取特征
        x = x.view(x.size(0), -1)
        x1 = self.fc1(x)
        x2 = self.fc2(x)
        x3 = self.fc3(x)
        x4 = self.fc4(x)
        return x1, x2, x3, x4

model = Net()
if torch.cuda.is_available():
    model.to('cuda')
loss_fn = nn.MSELoss()  # 回归问题,并不是分类问题。误差函数取平均绝对误差,MSE损失函数




from torch.optim import lr_scheduler
optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)
exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)   #每次间隔7步,学习速率衰减0.1


def fit(epoch, model, trainloader, testloader):
    total = 0
    running_loss = 0
    
    model.train()
    for x, y1, y2, y3, y4 in trainloader:
        if torch.cuda.is_available():
            x, y1, y2, y3, y4 = (x.to('cuda'), 
                                 y1.to('cuda'), y2.to('cuda'),
                                 y3.to('cuda'), y4.to('cuda'))       
        y_pred1, y_pred2, y_pred3, y_pred4 = model(x)
        
        loss1 = loss_fn(y_pred1, y1)
        loss2 = loss_fn(y_pred2, y2)
        loss3 = loss_fn(y_pred3, y3)
        loss4 = loss_fn(y_pred4, y4)
        loss = loss1 + loss2 + loss3 + loss4
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        with torch.no_grad():
            running_loss += loss.item()
    exp_lr_scheduler.step()
    epoch_loss = running_loss / len(trainloader.dataset)
        
        
    test_total = 0
    test_running_loss = 0 
    
    model.eval()
    with torch.no_grad():
        for x, y1, y2, y3, y4 in testloader:
            if torch.cuda.is_available():
                x, y1, y2, y3, y4 = (x.to('cuda'), 
                                     y1.to('cuda'), y2.to('cuda'),
                                     y3.to('cuda'), y4.to('cuda'))
            y_pred1, y_pred2, y_pred3, y_pred4 = model(x)
            loss1 = loss_fn(y_pred1, y1)
            loss2 = loss_fn(y_pred2, y2)
            loss3 = loss_fn(y_pred3, y3)
            loss4 = loss_fn(y_pred4, y4)
            loss = loss1 + loss2 + loss3 + loss4
            test_running_loss += loss.item()
            
    epoch_test_loss = test_running_loss / len(testloader.dataset)
    
        
    print('epoch: ', epoch, 
          'loss: ', round(epoch_loss, 3),
          'test_loss: ', round(epoch_test_loss, 3),
             )
        
    return epoch_loss, epoch_test_loss

开始训练

epochs = 10 # 总共训练十次

train_loss = []
test_loss = []

for epoch in range(epochs):
    epoch_loss, epoch_test_loss = fit(epoch, model, train_dl, test_dl)
    train_loss.append(epoch_loss)
    test_loss.append(epoch_test_loss)

plt.figure()
plt.plot(range(1, len(train_loss)+1), train_loss, 'r', label='Training loss')
plt.plot(range(1, len(train_loss)+1), test_loss, 'bo', label='Validation loss')
plt.title('Training and Validation Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss Value')
plt.legend()
plt.show()

PyTorch 11—简单图像定位_第12张图片


模型保存 

PATH = 'location_model.pth'
torch.save(model.state_dict(), PATH) # 保存的是权重,可训练参数。

plt.figure(figsize=(8, 24))
imgs, _, _, _, _ = next(iter(test_dl))  # _占位符。意思是我不需要你实际的位置,我们要自己去预测。
imgs = imgs.to('cuda')  # 将图片添加到显卡
out1, out2, out3, out4 = model(imgs)    # 进行预测,返回四个坐标值(头部位置)
for i in range(6):
    plt.subplot(6, 1, i+1)
    plt.imshow(imgs[i].permute(1,2,0).cpu().numpy())    # 放到cpu上
    xmin, ymin, xmax, ymax = (out1[i].item()*224,   # out[i]代表第i个batch的第一个位置
                              out2[i].item()*224,
                              out3[i].item()*224,
                              out4[i].item()*224)
    rect = Rectangle((xmin, ymin), (xmax-xmin), (ymax-ymin), fill=False, color='red')
    ax = plt.gca()
    ax.axes.add_patch(rect)
    plt.show()

PyTorch 11—简单图像定位_第13张图片

PyTorch 11—简单图像定位_第14张图片 

你可能感兴趣的:(PyTorch笔记,深度学习,图像定位,Pytorch)