(如有侵权,联系作者马上删除)
一.前情提要
1.本文是笔记记在代码附近,交互,并不利于阅读,还是参考小土堆学习代码可以简单运用,或者简单看部分CNN的笔记
2.本文是通过学习B站up主小土堆整理的初步笔记(深度学习入门如下,建议阅读完整),网址如下:PyTorch深度学习快速入门教程(绝对通俗易懂!)【小土堆】_哔哩哔哩_bilibili
3.①本文代码内容偏多,理论较少,如需理论知识可以阅读以下视频【什么是CNN?】浙大大佬教你怎么卷CNN,卷积神经网络CNN从入门到实战,通俗易懂草履虫听了都点头(人工智能、深度学习、机器学习、计算机视觉)_哔哩哔哩_bilibili
②部分CNN笔记
卷积神经网络
1.计算方法
2.基本概念
二.笔记
1.
import torch.nn as nn
import torch
class Tudui(nn.Module):
def __init__(self):
super(Tudui,self).__init__()
def forward(self, x):
output=input+1
return output
#tudui=Tudui()中神经网络是tudui,调用了Tudui()
tudui=Tudui()
x=torch.tensor(1.0)
output=tudui(x)
print(output)
2.
import torch
import torch.nn.functional as F
#()内两个[]说明是二元
input=torch.tensor([[1,2,0,3,1],
[0,1,2,3,1],
[1,2,1,0,0],
[5,2,3,1,1],
[2,1,0,1,1]])
kernel=torch.tensor([[1,2,1],
[0,1,0],
[2,1,0]])
#input是一个形状为 (5, 5) 的2D张量,通过 torch.reshape(input, (1, 1, 5, 5)) 将其形状改变为 (1, 1, 5, 5)。
#这表示将 input 张量转换为一个4D张量,其中第一维表示批次大小为1,第二维表示输入通道数为1,第三维和第四维表示高度和宽度都为5的图像
input=torch.reshape(input,(1,1,5,5))
#为了将其作为 F.conv2d 函数的输入,需要先将其转换为一个四维张量,使其符合 F.conv2d 函数的输入要求
kernel=torch.reshape(kernel,(1,1,3,3))
output=F.conv2d(input,kernel,stride=1,padding=1)
print(output)
3.
import torch
import torchvision
from torch import nn
from torch.nn import Conv2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
dataset=torchvision.datasets.CIFAR10('../data',train=False,transform=torchvision.transforms.ToTensor(),download=True)
dataloader=DataLoader(dataset,batch_size=64)
class Tudui(nn.Module):
def __init__(self):
super().__init__()
self.conv1=Conv2d(in_channels=3,out_channels=6,kernel_size=3,stride=1,padding=0)
def forward(self, x):
x=self.conv1(x)
return x
tudui=Tudui()
#../ 代表和代码同一文件夹下
writer=SummaryWriter('../logs')
step=0
for data in dataloader:
imgs,targets=data
output=tudui(imgs)
print(imgs.shape)
#torch.Size([64,3,32,32])
print(output.shape)
# torch.Size([64,6,30,30])->[xxx,3,30,30]
#-1:这个数字表示自动计算该维度的大小。在这里,它将根据其他维度的大小自动计算出第一个维度的大小。
torch.reshape(output,(-1,3,30,30))
writer.add_images('input',imgs,step)
step=step+1
4.
from PIL import Image
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms
#创建一个SummaryWriter对象,指定日志文件保存路径为'logs'目录
writer=SummaryWriter('logs')
#使用PIL库中的open()函数打开一个图像文件,需要在括号内填入图像的路径
img=Image.open('')
print(img)#格式是PIL与张量(tensor)形式不一样
#创建一个transforms模块中的ToTensor对象,用于将图像转换为张量(tensor)形式
trans_totensor=transforms.ToTensor
#使用ToTensor对象的__call__()方法将图像转换为张量形式,存储在img_tensor变量中
img_tensor=trans_totensor(img)
#将转换后的张量图像添加到TensorBoard中,第一个参数是显示名称,第二个参数是图像张量
writer.add_image('Totensor',img_tensor)
#打印张量图像的第一个像素点的值,即红色通道的值
print(img_tensor[0][0][0])
#创建一个transforms模块中的Normalize对象,用于对张量图像进行归一化处理
trans_norm=transforms.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5])
#在transforms.Normalize函数中,[0.5, 0.5, 0.5]是用于指定图像的均值(mean)参数,而[0.5, 0.5, 0.5]是用于指定图像的标准差(standard deviation)参数。
#在图像处理中,归一化是一种常见的预处理操作,用于将图像的像素值缩放到特定的范围。常见的归一化方法之一是将像素值减去均值,然后除以标准差,以使得图像的像素值分布在接近零的范围内。
# 对于RGB图像,每个颜色通道(红、绿、蓝)都有自己的均值和标准差。在这里,[0.5, 0.5, 0.5]作为均值参数,表示将每个颜色通道的像素值减去0.5;同样地,[0.5, 0.5, 0.5]作为标准差参数,表示将每个颜色通道的像素值除以0.5。
# 为什么选择0.5作为归一化的均值和标准差取决于具体的数据集和应用场景。在某些情况下,将均值和标准差设置为0.5可以将图像的像素值约束在-1到1的范围内。这种范围的好处是可以更好地适应某些深度学习模型的输入要求,例如使用Tanh激活函数的模型。
# 需要注意的是,归一化参数的选择可能会因数据集和任务的不同而有所变化,具体的值需要根据实际情况进行调整和优化。
#使用Normalize对象的__call__()方法对张量图像进行归一化处理,存储在img_norm变量中
img_norm=trans_norm(img_tensor)
print(img_norm[0][0][0])
writer.add_image("Normalize",img_norm,2)
#Resize方式裁剪(512,512)是裁剪的大小
print(img.size)
#这个操作不是简单地缩放图像,而是通过裁剪和缩放来实现
trans_resize=transforms.Resize((512,512))
#PIL格式裁剪后仍是PIL格式
img_resize=trans_resize(img)
#PIL->totensor->tensor
img_resize=trans_totensor(img_resize)
writer.add_image('Resize',img_resize,0)
print(img_resize)
#Compose-resize-2
trans_resize_2=transforms.Resize(512)
#PIL->PIL->tensor,图像首先被调整为最小边长为512的正方形,然后转换为Tensor格式。这个复合操作被称为trans_compose
trans_compose=transforms.Compose([trans_resize_2,trans_totensor])
for i in range(10):
img_crop=trans_compose(img)
writer.add_image('RandomCrop',img_crop,i)
writer.close()
5.
import torch
from torch.nn import L1Loss
from torch import nn
inputs=torch.tensor([1,2,3],dtype=torch.float32)
targets=torch.tensor([1,2,5],dtype=torch.float32)
#最外层的三个1代表批次、通道和高度,而最后一个3表示宽度,即数据的维度
inputs=torch.reshape(inputs,(1,1,1,3))
targets=torch.reshape(targets,(1,1,1,3))
#一.L1Loss()
#在PyTorch的L1Loss中,如果不指定reduction参数,默认为"mean",表示计算所有差的绝对值的平均值作为最终的损失值。
#reduction参数被设置为'sum',L1损失是指预测值与目标值之间的差的绝对值的总和
loss=L1Loss(reduction='sum')
result=loss(inputs,targets)
#二.MSELoss()
loss_mse=nn.MSELoss()
result_mse=loss_mse(inputs,targets)
print(result)
#三.CrossEntropyLoss()
x=torch.tensor([0.1,0.2,0.3])
y=torch.tensor([1])
loss_cross=nn.CrossEntropyLoss()
result_cross=loss_cross(x,y)
print(result_cross)
#MSELoss适用于回归问题,对异常值比较敏感。CrossEntropyLoss适用于多类别分类问题。L1Loss适用于回归问题,相对于MSELoss对异常值不太敏感。
6.
#多循环几次可以优化:eg:epoch
for epoch in range(20):
runing_loss=0.0#可以直观表现每一lu轮loss减小
for data in dataloader:
imgs, targets = data
output = tudui(imgs)
result_loss=loss(output,targets)
optim.zero_grad()
result_loss.backward()
optim.step()
print(runing_loss)
7.
import torchvision.models
from torch import nn
#vgg16_false是一个没有预训练权重的VGG16模型,而vgg16_true是一个加载了预训练权重的VGG16模型
vgg16_false=torchvision.models.vgg16(pretrained=False)
vgg16_true=torchvision.models.vgg16(pretrained=True)
#添加
train_data=torchvision.datasets.CIFAR10('../data',train=True,transform=torchvision.transforms.ToTensor(),download=True)
#整体加一个
vgg16_true.add_module('add_linear',nn.Linear(1000,10))
#具体位置加一个
vgg16_true.classifier.add_module('add_linear',nn.Linear(1000,10))
#修改
vgg16_false.classifier[6]=nn.Linear(4096,10)
8.
import torch
import torchvision
from torch import nn
# from CNN building11 import * 方式一要引入模型定义的方式
vgg16=torchvision.models.vgg16(pretrained=False)
#保存方法
#保存方式1 模型结构+模型参数
torch.save(vgg16,'vgg16_method1.pth')#''内是保存路径
#加载模型
model=torch.load('vgg16_method1.pth')
#保存方式2 模型参数(官方推荐)
torch.save(vgg16.state_dict(),'vgg16_method2.pth')#''内是保存路径
#加载模型
vgg16=torchvision.models.vgg16(pretrained=False)
vgg16.load_state_dict(torch.load('vgg16_method2.pth'))
9.
import torch
outputs=torch.tensor([[0.1,0.2],
[0.3,0.4]])
print(outputs.argmax(1))
preds=outputs.argmax(1)
targets=torch.tensor([0,1])
print((preds==targets).sum())
#当你有一个张量表示的数据集合,你可能会想要找到每行或者每列中最大值所在的位置。
# argmax() 方法就是用来做这个事情的。
10.一个完整的代码示例
import torch.optim
import torchvision
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
import time
# 准备数据集
train_dataset = torchvision.datasets.CIFAR10('../data', train=True, transform=torchvision.transforms.ToTensor(),
download=True)
test_dataset = torchvision.datasets.CIFAR10('../data', train=False, transform=torchvision.transforms.ToTensor(),
download=True)
#定义训练的设备
device=torch.device('cpu')
# 长度
train_dataset_size = len(train_dataset)
test_datase_size = len(test_dataset)
print('训练数据集的长度为:{}'.format(train_dataset_size))
print('测试数据集的长度为:{}'.format(test_datase_size))
# 利用Dataloader来加载数据集
train_dataloader = DataLoader(train_dataset, batch_size=64)
test_dataloader = DataLoader(train_dataset, batch_size=64)
# 创建网络模型
class Tudui(nn.Module):
def __init__(self):
super(Tudui,self).__init__()
self.model1=Sequential(
Conv2d(3,32,5,padding=2),
MaxPool2d(2),
Conv2d(32, 32, 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
tudui = Tudui()
tudui=tudui.to(device)
# if torch.cuda.is_available():
# tudui=tudui.cuda()
# 损失函数
loss_fn = nn.CrossEntropyLoss
# if torch.cuda.is_available():
# loss_fn =loss_fn.cuda()
loss_fn=loss_fn.to(device)
# 优化器
learning_rate = 1e-2
optimizer = torch.optim.SGD(tudui.parameters(), lr=learning_rate)
# 设置网络训练的一些参数
# 记录训练次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 10
# 添加tensorboard
writer = SummaryWriter('../logs_train')
statart_time=time.time()
for i in range(epoch):
print('------第{}轮训练-------'.format(i + 1))
# 训练步骤开始
tudui.train()
for data in train_dataloader:
imgs, targets = data
# if torch.cuda.is_available():
# imgs = imgs.cuda()
# targets = targets.cuda()
imgs=imgs.to(device)
targets = targets.to(device)
output = tudui(imgs)
loss = loss_fn(output, targets)
# 优化器优化模型
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_train_step = total_train_step + 1
if total_train_step % 100 == 0:
end_time = time.time()
print(end_time-statart_time)
print('训练次数:{},Loss:{}'.format(total_test_step, loss.item()))
# item(),如果是tensor数据类型会有tenser(),加上item()可以去除tensor()
writer.add_scalar('train_loss', loss.item(), total_train_step)
# 测试步骤开始
tudui.eval()
total_test_step = 0
total_accuracy = 0
with torch.no_grad():
for data in test_dataloader:
imgs, targets = data
# if torch.cuda.is_available():
# imgs=imgs.cuda()
# targets=targets.cuda()
imgs = imgs.to(device)
targets = targets.to(device)
outputs = tudui(imgs)
loss = loss_fn(outputs, targets)
total_test_loss = total_test_step + loss.item()
accuracy = (outputs.argmax(1) == targets).sum()
total_accuracy = total_accuracy + accuracy
print('整体测试集上的Loss:{}'.format(total_test_loss))
print('整体测试集上的正确率:{}'.format(total_accuracy / test_datase_size))
writer.add_scalar('test_accuracy', total_accuracy / test_datase_size, total_test_step)
writer.add_scalar('test_loss', total_test_loss, total_test_step)
total_test_step = total_test_step + 1
torch.save(tudui, 'tudui_{}.pth'.format(i))
print('模型已保存')
writer.close()
11.
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
#准备的测试数据集
test_data=torchvision.datasets.CIFAR10('./dataset',train=False,transform=torchvision.transforms.ToTensor())
#上面是准备test_data,下面test_loader是加载
test_loader=DataLoader(dataset=test_data,batch_size=4,shuffle=True,num_workers=0,drop_last=False)
#dataset参数传入了之前创建的test_data数据集,batch_size参数指定了每个批次的样本数量,
# shuffle参数设置为True,表示在每个epoch开始时随机打乱数据集顺序,num_workers参数设置为0表示使用主进程加载数据集,(windows系统下>0可能会报错),
# drop_last参数设置为False,表示当无法整除batch_size时不丢弃最后一个batch
#测试数据集第一张图片及target
img,target=test_data[0]
#如果img是一个三通道的RGB彩色图像,那么它的shape应该是一个长度为3的元组,分别代表图像的高度、宽度和通道数,
# 即(Height, Width, Channels)。例如,如果img的shape为(32, 32, 3),则表示它是一个高32像素、宽32像素、通道数为3的彩色图像。
print(img.shape)
print(target)
writer=SummaryWriter('datalodaer')
#外层的for epoch in range(2)表示进行两个训练周期(或称为两次完整的数据遍历)。每个训练周期中,模型将对整个数据集进行一次完整的训练
for epoch in range(2):
step=0
#取出打包(打包即 batch_size=4)的数据->对应print(targets) print(imgs.shape)这几个代码
for data in test_loader:
imgs,targets=data
# print(imgs.shape) #得结果eg:torch.Size([4,3,32,32])是4张图片,3个通道,32*32的格式
# print(targets)
writer.add_images('test_data',imgs,step)
step=step+1
12.
#两个重要函数
#①dir()
#作用:打开
#help()
#作用:说明书
from torch.utils.data import Dataset
from PIL import Image
import os
#读取图片
img_path=r'D:\CODE\code1\笔记\hymenoptera_data\train\ants\5650366_e22b7e1065.jpg'
img=Image.open(img_path)
img.show()
#读取整个文件夹
dir_path=r'笔记\hymenoptera_data\train\ants'
img_path_list=os.listdir(dir_path)#将文件夹下所有东西变成列表,dir是文件夹的意思
#将路径加起来
root_dir='笔记/hymenoptera_data/train'
label_dir='ants'
path=os.path.join(root_dir,label_dir)
13.
from torch.utils.tensorboard import SummaryWriter
writer=SummaryWriter('logs')#存储地址
#实例y=2x
for i in range(100):
writer.add_scalar('y=x',i,i)
#使用writer对象的add_scalar方法,将名为'y=x'的标量数据写入TensorBoard日志。第一个参数是数据的标签或名称,第二个参数是数据的值,第三个参数是当前循环迭代的步数,也可以理解为X轴的值
writer.close()
14.
from torch.utils.tensorboard import SummaryWriter
import numpy as np
from PIL import Image
writer=SummaryWriter('logs')
#指定图片位置
image_path=r'hymenoptera_data\train\ants\0013035.jpg'
#打开文件
img_PIL=Image.open(image_path)
#将图片文件转化为numpy格式
img_array=np.array(img_PIL)
#HWC是nupy格式下的数据位置,需要调整
writer.add_image('test',img_array,1,dataformats='HWC')
writer.close()
15.
from PIL import Image
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms
#创建一个SummaryWriter对象,指定日志文件保存路径为'logs'目录
writer=SummaryWriter('logs')
#使用PIL库中的open()函数打开一个图像文件,需要在括号内填入图像的路径
img=Image.open('')
print(img)#格式是PIL与张量(tensor)形式不一样
#创建一个transforms模块中的ToTensor对象,用于将图像转换为张量(tensor)形式
trans_totensor=transforms.ToTensor
#使用ToTensor对象的__call__()方法将图像转换为张量形式,存储在img_tensor变量中
img_tensor=trans_totensor(img)
#将转换后的张量图像添加到TensorBoard中,第一个参数是显示名称,第二个参数是图像张量
writer.add_image('Totensor',img_tensor)
#打印张量图像的第一个像素点的值,即红色通道的值
print(img_tensor[0][0][0])
#创建一个transforms模块中的Normalize对象,用于对张量图像进行归一化处理
trans_norm=transforms.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5])
#在transforms.Normalize函数中,[0.5, 0.5, 0.5]是用于指定图像的均值(mean)参数,而[0.5, 0.5, 0.5]是用于指定图像的标准差(standard deviation)参数。
#在图像处理中,归一化是一种常见的预处理操作,用于将图像的像素值缩放到特定的范围。常见的归一化方法之一是将像素值减去均值,然后除以标准差,以使得图像的像素值分布在接近零的范围内。
# 对于RGB图像,每个颜色通道(红、绿、蓝)都有自己的均值和标准差。在这里,[0.5, 0.5, 0.5]作为均值参数,表示将每个颜色通道的像素值减去0.5;同样地,[0.5, 0.5, 0.5]作为标准差参数,表示将每个颜色通道的像素值除以0.5。
# 为什么选择0.5作为归一化的均值和标准差取决于具体的数据集和应用场景。在某些情况下,将均值和标准差设置为0.5可以将图像的像素值约束在-1到1的范围内。这种范围的好处是可以更好地适应某些深度学习模型的输入要求,例如使用Tanh激活函数的模型。
# 需要注意的是,归一化参数的选择可能会因数据集和任务的不同而有所变化,具体的值需要根据实际情况进行调整和优化。
#使用Normalize对象的__call__()方法对张量图像进行归一化处理,存储在img_norm变量中
img_norm=trans_norm(img_tensor)
print(img_norm[0][0][0])
writer.add_image("Normalize",img_norm,2)
#Resize方式裁剪(512,512)是裁剪的大小
print(img.size)
#这个操作不是简单地缩放图像,而是通过裁剪和缩放来实现
trans_resize=transforms.Resize((512,512))
#PIL格式裁剪后仍是PIL格式
img_resize=trans_resize(img)
#PIL->totensor->tensor
img_resize=trans_totensor(img_resize)
writer.add_image('Resize',img_resize,0)
print(img_resize)
#Compose-resize-2
trans_resize_2=transforms.Resize(512)
#PIL->PIL->tensor,图像首先被调整为最小边长为512的正方形,然后转换为Tensor格式。这个复合操作被称为trans_compose
trans_compose=transforms.Compose([trans_resize_2,trans_totensor])
for i in range(10):
img_crop=trans_compose(img)
writer.add_image('RandomCrop',img_crop,i)
writer.close()
(说实话,写的很不怎么样,如果学习小土堆,可以勉强利用一下,不喜勿喷)