Pytorch学习笔记（四）

一、损失函数与反向传播

1、L1Loss

结果为输出与标签之间的差的和平均值或是和

inputs = torch.tensor([1,2,3], dtype = torch.float32)
targets = torch.tensor([1,2,5],dtype = torch.float32)

inputs = torch.reshape(inputs, (1,1,1,3))
targets = torch.reshape(targets, (1,1,1,3))

loss = L1Loss(reduction='sum')  #reduction决定是和的平均值还是和
result = loss(inputs,targets)

print(result)

输出为2 = 0 + 0 + 2

2、MSELoss

结果为输出与标签之间差平方的和平均值或是和

loss_mse = nn.MESLoss(reduction='sum')
result_mse = loss_mse(inputs, targets)

print(result_mse)

输出为4 = 0 + 0 + 2^2

3、CrossEntropyLoss

要求分类问题，并且输出为每个类别的概率，而标签为类别的序号

x = torch.tensor([0.1, 0.2, 0.3])
y = torch.tensor([1])
x = torch.reshape(x, (1, 3))
loss_cross = loss_cross(x, y)
print(result_cross)

输出为1.1019 = -0.2 + ln(exp(0.1) + exp(0.2) + exp(0.3))

4、将loss应用到神经网络中

dataset = torchvision.datasets.CIFAR10("./dataset", train=False, transform=torchvision.transform.ToTensor(), download=True)
dataloader = DataLoader(dataset,batch_size=64)

class Test(nn.Module):
	def __init__(self):
		super(Test, self).__init__()
		#使用Sequential提高代码的简洁可读性
		self.model1 = Sequential{
			Conv2d(3, 32, 5, padding=2),
			MaxPool2d(2),
			Conv2d(32, 64, 5, padding=2),
			MaxPool2d(2),
			Conv2d(32, 64, 5, padding=2),
			MaxPool2d(2),
			Flatten(),
			Linear(1024, 64),
			Linear(64, 10)
		)

	def forward(self, x):
		x = self.model1(x)
		return x

loss = nn.CrossEntropyLoss()

test = Test()
for data in datloader:
	imgs, targets = data
	outputs = test(imgs)
	result_loss = loss(outputs, targets)
	result_loss.backward()  #反向传播，此时查看节点的参数，grad中发现梯度数据

5、反向传播优化器

优化器根据梯度调整参数，达到降低误差的作用
主要参数：params和lr（学习速率）

dataset = torchvision.datasets.CIFAR10("./dataset", train=False, transform=torchvision.transform.ToTensor(), download=True)
dataloader = DataLoader(dataset,batch_size=64)

class Test(nn.Module):
	def __init__(self):
		super(Test, self).__init__()
		#使用Sequential提高代码的简洁可读性
		self.model1 = Sequential{
			Conv2d(3, 32, 5, padding=2),
			MaxPool2d(2),
			Conv2d(32, 64, 5, padding=2),
			MaxPool2d(2),
			Conv2d(32, 64, 5, padding=2),
			MaxPool2d(2),
			Flatten(),
			Linear(1024, 64),
			Linear(64, 10)
		)

	def forward(self, x):
		x = self.model1(x)
		return x

loss = nn.CrossEntropyLoss()

test = Test()
optim = torch.optim.SGD(test.parameters(), lr=0.01)  #创建优化器
for epoch in range(20):  #迭代优化
	for data in datloader:
		imgs, targets = data
		outputs = test(imgs)
		result_loss = loss(outputs, targets)
		optim.zero_grad()  #优化器中的参数清零，必不可少！
		result_loss.backward()  #反向传播，此时查看节点的参数，grad中发现梯度数据 
		optim.step()  #使用优化器更新参数
	

二、网络模型

1、现有网络模型的使用和修改

主要使用VGG模型来进行讲解
参数：
pretrained（bool）：下载的网络模型参数是否在数据集中训练好，即为true时模型中的参数为训练好的，而false时参数为初始化的参数
progress（bool）：是否显示下载记录条

vgg16 = torchvision.models.vgg16(pretrained=True)

dataset = torchvision.datasets.CIFAR10("./dataset", train=True, transform=torchvision.transform.ToTensor(), download=True)

vgg16.add_module('add_linear', nn.Linear(1000, 10))  #在VGG16最后添加一个线性层

vgg16.classifier[6] = nn.Linear(4096, 10)  #修改vgg16中classifier中的第六层

2、网络模型的保存与读取

vgg16 = torchvision.models.vgg16(pretrained=False)
#保存方式1 不仅保存了模型，同时保存了模型的参数
torch.save(vgg16, "vgg16_method1.pth")  #模型保存名称，后缀最好使用.pth

#保存方式2(官方推荐) 将vgg网络模型的参数保存成字典形式
torch.save(vgg16.state_dict(),"vgg16_method2.pth")

#加载模型-》保存方式1
model = torch.load("vgg16_method1.pth")

#加载模型-》保存方式2
vgg16 = torchvision.models.vgg16(pretrained=False)
vgg16.load_state_dict(torch.load("vgg16_method2.pth"))

完整的模型训练套路

#准备数据集
train_data = torchvision.datasets.CIFAR10(root="./dataset", train=True, transform=torchvision.transforms.ToTensor(), download=True)
test_data = torchvision.datasets.CIFAR10(root="./dataset", train=False, transform=torchvision.transforms.ToTensor(), download=True)

#加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

#搭建神经网络，可以将这一部分的代码单独放到一个model的python中，model文件应该和本文件在一个文件夹下
class Test(nn.Module):
	def __init__(self):
		super(Test, self).__init__()
		#使用Sequential提高代码的简洁可读性
		self.model1 = Sequential{
			Conv2d(3, 32, 5, padding=2),
			MaxPool2d(2),
			Conv2d(32, 64, 5, padding=2),
			MaxPool2d(2),
			Conv2d(32, 64, 5, padding=2),
			MaxPool2d(2),
			Flatten(),
			Linear(1024, 64),
			Linear(64, 10)
		)

	def forward(self, x):
		x = self.model1(x)
		return x

#创建网络模型
test = Test()

#损失函数
loss_fn = nn.CrossEntropyLoss()

#优化器
learning_rate = 0.01  #或为1e-2
optimizer = torch.optim.SGD(test.parameters(), lr = learning_rate)

#设置训练网络的参数
total_train_step = 0  #记录训练的次数
total_test_step = 0  #记录测试的次数
epoch = 10  #训练的迭代次数

for i in range(epoch):
	print("---------第{}轮训练开始----------".format(i+1))
	#训练步骤开始
	test.train()  #只对某些特定的层有作用
	for data in train_dataloader:
		imgs, targets = data
		outputs = test(imgs)
		loss = loss_fn(outputs, targets)
		#优化器优化模型
		optimizer.zero_grad()
		loss.backward()
		optimizer.step()

		total_train_setp = total_train_step + 1
		if total_train_step % 100 == 0
			print("训练次数：{}， loss：{}".format(total_train_step, loss.item()))

	#测试步骤开始
	test.eval()  #只对某些特定的层有作用
	total_test_loss = 0
	total_accuracy = 0
	with torch.no_grad():
		for data in test_dataloader:
			imgs, targets = data
			outputs = test(imgs)
			loss = loss_fn(outputs, targets)
			total_test_loss = total_test_loss + loss.item()
			accuracy = (outputs.argmax(1) == targets).sum()  #argmax将输出的概率值转化成1/0
			total_accuacy = total_accuracy + accuracy
			
	print("整体测试集上的Loss：{}".format(total_test_loss))
	print("整体测试集上的正确率：{}".format(total_accuracy/len(test_data)))
	
	torch.save(test, "test_{}.pth".format(i))