卷积神经网络(CNN)初步学习（参考小土堆）

（如有侵权，联系作者马上删除）

一.前情提要

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()

（说实话，写的很不怎么样，如果学习小土堆，可以勉强利用一下，不喜勿喷）