数据增强过程

17 Mar 2025 | 4 分钟阅读

之前，我们看到模型准确度有显著提高。我们的模型有效地训练了分类训练数据。它对验证数据的泛化效果不佳，无法解决过度拟合的问题。现在，让我们讨论另一种改进模型训练过程的技术。这种技术被称为数据增强。它是我们为模型在训练过程中使用而创建新数据的过程。

这是通过获取我们现有的数据集并以有用的方式转换或更改图像来创建新图像来完成的。

应用转换后，新创建的图像被称为增强图像，因为它们本质上允许我们通过向数据集中添加新数据来增强我们的数据集。数据增强技术很有用，因为它允许我们的模型从各种不同的角度查看我们数据集中的每个图像。这允许我们的模型更准确地提取相关特征，并从每个训练图像中获取更多与特征相关的数据。

现在我们最大的问题是如何使用这种增强来减少过拟合。当我们的模型过于拟合训练集时，就会发生过拟合。

无需开始收集新图像并将它们添加到我们的数据集中。我们可以使用数据增强，它对我们现有数据集引入了细微的改变，例如更暗的阴影、翻转、缩放、旋转或平移。我们的模型会将它们解释为单独的图像。它不仅会减少过度拟合，而且还能防止我们的网络学习无关的模式并提高整体性能。我们有以下步骤来执行数据增强

步骤 1

要在训练数据集上执行数据增强，我们必须创建一个单独的变换语句。对于验证数据集，变换将保持不变。所以我们首先复制我们的transform1语句，并将其视为transform_train，例如

transform_train=transforms.Compose([transforms.Resize((32,32)),transforms.ToTensor(),transforms.Normalize((0.5,),(0.5,))])

步骤 2

现在，我们将在transform_train语句中添加修改。修改将是 RandomHorizontalFlip、RandomRotation，它用于以某个角度旋转图像，该角度将作为参数传递。

transform_train=transforms.Compose([transforms.Resize((32,32)),
		transform.RandomHorizontalFlip(),
		transform.RandomRotation(),
		transforms.ToTensor(),
		transforms.Normalize((0.5,),(0.5,))])

为了给我们的数据集增加更多多样性，我们将使用精细类型转换。精细转换代表保留直线和平面的简单转换，以及对象。缩放、平移、剪切和缩放是属于此类别的一种转换。

transform_train=transforms.Compose([transforms.Resize((32,32)),
		transform.RandomHorizontalFlip(),
		transform.RandomRotation(),
		transform.RandomAffine(0,shear=10,scale=(0.8,1.2)),
		transforms.ToTensor(),
		transforms.Normalize((0.5,),(0.5,))])

在 RandomAffine() 中，第一个参数是 decrease，我们将其设置为零以停用旋转，第二个参数是剪切变换，最后一个是缩放变换，并使用 topple 来定义我们所需的缩放范围。我们定义了 0.8 和 1.2 的上下限，将图像缩放到其大小的 80% 或 120%。

步骤 3

现在，我们继续我们的下一个增强，以创建具有各种随机亮度、对比度和饱和度的新增强图像。我们将添加另一个转换，即 ColorJitter，例如

transform_train=transforms.Compose([transforms.Resize((32,32)),
		transform.RandomHorizontalFlip(),
		transform.RandomRotation(10),
		transform.RandomAffine(0,shear=10,scale=(0.8,1.2)),
		transform.ColorJitter(brightness=0.2,contrast=0.2,saturation=0.2)
		transforms.ToTensor(),
		transforms.Normalize((0.5,),(0.5,))])

步骤 4

在执行我们的代码之前，我们必须更改 training_dataset 语句，因为现在我们有另一个用于训练数据集的转换。所以

training_dataset=datasets.CIFAR10(root='./data',train=True,download=True,transform=transform_train)

现在，我们将执行我们的代码，并且在执行之后，它将为我们提供预期的输出以及正确的预测。

完整代码

import torch
import matplotlib.pyplot as plt
import numpy as np
import torch.nn.functional as func
import PIL.ImageOps
from torch import nn
from torchvision import datasets,transforms 
import requests
from PIL import Image
device=torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
transform_train=transforms.Compose([transforms.Resize((32,32)),
                               transforms.RandomHorizontalFlip(),
                               transforms.RandomRotation(10),
                               transforms.RandomAffine(0,shear=10,scale=(0.8,1.2)),
                               transforms.ColorJitter(brightness=0.2,contrast=0.2,saturation=0.2),
                               transforms.ToTensor(),
                               transforms.Normalize((0.5,),(0.5,))])
transform1=transforms.Compose([transforms.Resize((32,32)),transforms.ToTensor(),transforms.Normalize((0.5,),(0.5,))])
training_dataset=datasets.CIFAR10(root='./data',train=True,download=True,transform=transform_train)
validation_dataset=datasets.CIFAR10(root='./data',train=False,download=True,transform=transform1)
training_loader=torch.utils.data.DataLoader(dataset=training_dataset,batch_size=100,shuffle=True)
validation_loader=torch.utils.data.DataLoader(dataset=validation_dataset,batch_size=100,shuffle=False)
def im_convert(tensor):
    image=tensor.cpu().clone().detach().numpy()
    image=image.transpose(1,2,0)
    print(image.shape)
    image=image*(np.array((0.5,0.5,0.5))+np.array((0.5,0.5,0.5)))
    image=image.clip(0,1)
    return image
classes=('plane','car','bird','cat','dear','dog','frog','horse','ship','truck')
dataiter=iter(training_loader)
images,labels=dataiter.next()
fig=plt.figure(figsize=(25,4))
for idx in np.arange(20):

    ax=fig.add_subplot(2,10,idx+1)
    plt.imshow(im_convert(images[idx]))
    ax.set_title(classes[labels[idx].item()])
class LeNet(nn.Module):
        def __init__(self):
            super().__init__()
            self.conv1=nn.Conv2d(3,16,3,1, padding=1)
            self.conv2=nn.Conv2d(16,32,3,1, padding=1)
            self.conv3=nn.Conv2d(32,64,3,1, padding=1)   
            self.fully1=nn.Linear(4*4*64,500)
            self.dropout1=nn.Dropout(0.5) 
            self.fully2=nn.Linear(500,10)
        def forward(self,x):
            x=func.relu(self.conv1(x))
            x=func.max_pool2d(x,2,2)
            x=func.relu(self.conv2(x))
            x=func.max_pool2d(x,2,2)
            x=func.relu(self.conv3(x))
            x=func.max_pool2d(x,2,2)
            x=x.view(-1,4*4*64)	#Reshaping the output into desired shape
            x=func.relu(self.fully1(x))	#Applying relu activation function to our first fully connected layer
            x=self.dropout1(x)
            x=self.fully2(x)	#We will not apply activation function here because we are dealing with multiclass dataset
            return x    
model=LeNet().to(device)
criteron=nn.CrossEntropyLoss()
optimizer=torch.optim.Adam(model.parameters(),lr=0.001)
epochs=12
loss_history=[]
correct_history=[]
val_loss_history=[]
val_correct_history=[]
for e in range(epochs):
    loss=0.0
    correct=0.0
    val_loss=0.0
    val_correct=0.0
    for input,labels in training_loader:
        input=input.to(device)
        labels=labels.to(device)
        outputs=model(input)
        loss1=criteron(outputs,labels)
        optimizer.zero_grad()
        loss1.backward()
        optimizer.step()
        _,preds=torch.max(outputs,1)
        loss+=loss1.item()
        correct+=torch.sum(preds==labels.data)
    else:
        with torch.no_grad():
            for val_input,val_labels in validation_loader:
                val_input=val_input.to(device)
                val_labels=val_labels.to(device)
                val_outputs=model(val_input)
                val_loss1=criteron(val_outputs,val_labels) 
                _,val_preds=torch.max(val_outputs,1)
                val_loss+=val_loss1.item()
                val_correct+=torch.sum(val_preds==val_labels.data)
        epoch_loss=loss/len(training_loader)
        epoch_acc=correct.float()/len(training_loader)
        loss_history.append(epoch_loss)
        correct_history.append(epoch_acc)
        val_epoch_loss=val_loss/len(validation_loader)
        val_epoch_acc=val_correct.float()/len(validation_loader)
        val_loss_history.append(val_epoch_loss)
        val_correct_history.append(val_epoch_acc)
        print('training_loss:{:.4f},{:.4f}'.format(epoch_loss,epoch_acc.item()))
        print('validation_loss:{:.4f},{:.4f}'.format(val_epoch_loss,val_epoch_acc.item()))

url='https://akm-img-a-in.tosshub.com/indiatoday/images/story/201810/white_stork.jpeg?B2LINO47jclcIb3QCW.Bj9nto934Lox4'
response=requests.get(url,stream=True)
img=Image.open(response.raw)
img=transform1(img)   
image1=img.to(device).unsqueeze(0)
output=model(image1)
_,pred=torch.max(output,1)
print(classes[pred.item()])

dataiter=iter(validation_loader)  
images,labels=dataiter.next()  
images_=images.to(device)  
labels=labels.to(device)  
output=model(images_)  
_,preds=torch.max(output,1)  
fig=plt.figure(figsize=(25,4))  
for idx in np.arange(20):  
      ax=fig.add_subplot(2,10,idx+1,xticks=[],yticks=[])   
      plt.imshow(im_convert(images[idx]))    
ax.set_title("{}({})".format(str(classes[preds[idx].item()]),str(classes[labels[idx].item()]),color=("green" if classes[preds[idx]]==classes[labels[idx]] else "red")))
plt.show()