神经网络的基本结构

卷积层

  • Conv2d()函数：
  • in_channels : 输入数据通道数
  • out_channels : 输出数据通道数
  • kernel_size : 卷积核的大小
  • stride : 步长
  • padding : 填充大小
  • 示例代码：
  1. import torch
  2. import torchvision
  3. from torch.utils.data import DataLoader
  4. from torch import nn
  5. from torch.nn import Conv2d
  6. from torch.utils.tensorboard import SummaryWriter
  8. test_dataset = torchvision.datasets.CIFAR10(root="./download_data",
  9.                                             train=False,transform=torchvision.transforms.ToTensor(),download=True)
  10. dataloader = DataLoader(test_dataset,batch_size=64)
  12. class SecondTime(nn.Module):
  13.     def __init__(self):
  14.         super().__init__()
  15.         self.conv1 = Conv2d(in_channels=3,out_channels=6,kernel_size=3,stride=1,padding=0)
  17.     def forward(self,input):
  18.         input = self.conv1(input)
  19.         return input
  21. second = SecondTime()
  22. # print(second)
  23. writer = SummaryWriter("logs")
  25. step = 0
  26. for data in dataloader:
  27.     img,label = data
  28.     output = second(img)
  30.     for i in range(10):
  31.         output = torch.reshape(img, (-1,3,32,32))   # 第一个参数不知道该如何设置时可以设置为-1
  32.         output =second(output)
  34.     # img = torch.reshape(img,(-1,3,32,32))
  35.     print(img.shape)    # torch.Size([64, 3, 32, 32])
  36.     writer.add_images("input",img,step)
  38.     output = torch.reshape(img, (-1,3,32,32))   # 第一个参数不知道该如何设置时可以设置为-1
  39.     print(output.shape) # torch.Size([64, 6, 30, 30])
  40.     writer.add_images("output",output,step)
  41.     # 因为conv2d中设置了不同的channel数，所以channel改变为6
  43.     step+=1

池化层

  • 池化类似于卷积，也是输入图像后利用池化核进行矩阵运算
  • MaxPool2d
  • stride : 默认值等于池化核的大小，类似于步长
  • padding : 和卷积层一样
  • dilation : 具体GIF图演示：GIF图演示
  • 池化层的作用：保留数据的特征并且减少数据量，为了提高计算速度
    一个通俗的解释：视频的输入格式为1080p输出为720p就类似于一个池化过程，
    减少了数据量，加速了数据的传播
  • 示例代码：
  1. import torch
  2. import torchvision
  3. from torch import nn
  4. from torch.nn import modules, MaxPool2d
  5. from torch.utils.data import DataLoader
  6. from torch.utils.tensorboard import SummaryWriter
  8. test_dataset = torchvision.datasets.CIFAR10(root="./download_data",train=False,
  9.                                             transform=torchvision.transforms.ToTensor(),download=True)
  10. dataloader = DataLoader(test_dataset,batch_size=64)
  12. input = torch.tensor([[1,2,0,3,1],
  13.                      [0,1,2,3,1],
  14.                      [1,2,1,0,0],
  15.                      [5,2,3,1,1],
  16.                      [2,1,0,1,1]],dtype=torch.float32) # 要加上float32类型，否则会报类型错误
  18. input = torch.reshape(input,(-1,1,5,5)) # channel=1，h=5，w=5
  19. print(input.shape)
  21. class max_pool(nn.Module):
  22.     def __init__(self):
  23.         super(max_pool,self).__init__()
  24.         # self.maxpool1 = MaxPool2d(kernel_size=3,ceil_mode=True)
  25.         self.maxpool1 = MaxPool2d(kernel_size=3,ceil_mode=False)
  26.         # ceil_mode 的用处自己去查
  28.     def forward(self,input):
  29.         output = self.maxpool1(input)
  30.         return output
  32. test_pool = max_pool()
  33. # output = test_pool(input)
  34. # print(output)
  36. writer = SummaryWriter("logs")
  38. step = 0
  39. for data in dataloader:
  40.     img,label = data
  41.     # img = torch.reshape(img,(-1,1,32,32))
  42.     writer.add_images("pool",img,step)
  43.     output = test_pool(img)
  44.     writer.add_images("pool_after",output,step)
  45.     # 可以看到输出效果，图片被马赛克处理了一般
  47.     step += 1
  49. writer.close()

非线性激活

ReLU(inplace = bool)

  • inplace=True时，不对原变量进行替换，直接更改原变量的值
  • inplace=False时，对原变量进行替换，生成一个新的变量
  • ReLU示例代码：
  1. import torch
  2. from torch import nn
  3. from torch.nn import ReLU
  5. input = torch.tensor([[1,-0.5],
  6.                       [-1,3]])
  7. input = torch.reshape(input,(-1,1,2,2))
  8. print(input)
  10. class nn_relu(nn.ReLU):
  11.     def __init__(self):
  12.         super(nn_relu,self).__init__()
  13.         self.relu = ReLU(inplace=True)
  14.     def forward(self,input):
  15.        input = self.relu(input)
  16.        return input
  18. nn = nn_relu()
  19. output = nn(input)
  20. print(output)

Sigmoid()

  • 无参数
  • 示例代码：
  1. import torch
  2. import torchvision
  3. from torch import nn
  4. from torch.nn import ReLU, Sigmoid
  5. from torch.utils.data import DataLoader
  6. from torch.utils.tensorboard import SummaryWriter
  8. '''
  9. input = torch.tensor([[1,-0.5],
  10.                       [-1,3]])
  11. input = torch.reshape(input,(-1,1,2,2))
  12. print(input)
  13. '''
  15. test_dataset = torchvision.datasets.CIFAR10(root="./download_data",train=False,
  16.                                             transform=torchvision.transforms.ToTensor(),download=True)
  17. dataloader = DataLoader(test_dataset,batch_size=64)
  19. class nn_relu(nn.ReLU):
  20.     def __init__(self):
  21.         super(nn_relu,self).__init__()
  22.         self.relu = ReLU(inplace=True)
  23.         self.sigmoid = Sigmoid()
  25.     def forward(self,input):
  26.        # input = self.relu(input)
  27.        input = self.sigmoid(input)
  28.        return input
  30. nn = nn_relu()
  32. writer = SummaryWriter("logs")
  34. step = 0
  35. for data in dataloader:
  36.     img,label = data
  37.     img = torch.reshape(img,(-1,3,32,32))
  38.     writer.add_images("sigmoid",img,step)
  39.     output = nn(img)
  40.     writer.add_images("sigmoid2",output,step)
  41.     # 注意是images
  42.     # 显示效果为：图片整体颜色变灰色
  44.     step += 1
  46. writer.close()

线性层LinearLayers

  • 线性变化，简单的形容就是把一个矩阵拉长成一条线

7_3.jpg

  • torch.flatten(img) : 把一个矩阵摊平
  • 示例代码：
  1. import torch
  2. import torchvision
  3. from torch import nn
  4. from torch.nn import ReLU, Sigmoid, Linear
  5. from torch.utils.data import DataLoader
  6. from torch.utils.tensorboard import SummaryWriter
  8. test_dataset = torchvision.datasets.CIFAR10(root="./download_data",train=False,
  9.                                             transform=torchvision.transforms.ToTensor(),download=True)
  10. dataloader = DataLoader(test_dataset,batch_size=64)
  12. class linear(nn.Module):
  13.     def __init__(self):
  14.         super(linear,self).__init__()
  15.         self.linear = Linear(196608,10)
  17.     def forward(self,input):
  18.         input = self.linear(input)
  19.         return input
  21. l = linear()
  23. for data in dataloader:
  24.     img,label = data
  25.     print(img.shape)
  26.     # img = torch.reshape(img,(1,1,1,-1))
  27.     output = torch.flatten(img)
  28.     print(output.shape)
  29.     output = l(output)
  30.     print(output.shape)
  32. '''
  33. 运行结果：
  34. torch.Size([64, 3, 32, 32])
  35. torch.Size([196608])
  36. torch.Size([10])
  37. 图片最后被拉平为10
  38. '''

Sequential 结合实战

  • 可以简化代码：
  1. import torch
  2. from torch import nn
  3. from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
  4. from torch.utils.tensorboard import SummaryWriter
  7. class Liucy(nn.Module):
  8.     def __init__(self):
  9.         super(Liucy,self).__init__()
  10.         '''
  11.         self.conv = Conv2d(3,32,5,padding=2)
  12.         self.max_pool = MaxPool2d(2)
  13.         self.conv2 = Conv2d(32,32,5,padding=2)
  14.         self.max_pool2 = MaxPool2d(2)
  15.         self.conv3 = Conv2d(64,32,5,padding=2)
  16.         self.max_pool3 = MaxPool2d(2)
  17.         self.flatten = Flatten()
  18.         self.linear1 = Linear(1024,64)
  19.         self.linear2 = Linear(64,10)
  20.         '''
  21.         self.modle = Sequential(
  22.             Conv2d(3, 32, 5, padding=2),
  23.             MaxPool2d(2),
  24.             Conv2d(32, 32, 5, padding=2),
  25.             MaxPool2d(2),
  26.             Conv2d(32, 64, 5, padding=2),
  27.             MaxPool2d(2),
  28.             Flatten(),
  29.             Linear(1024, 64),
  30.             Linear(64, 10)
  31.         )
  33.     def forward(self,x):
  34.         '''
  35.         x = self.conv(x)
  36.         x = self.max_pool(x)
  37.         x = self.conv2(x)
  38.         x = self.max_pool2(x)
  39.         x = self.conv3(x)
  40.         x = self.max_pool3(x)
  41.         x = self.flatten(x)
  42.         x = self.linear1(x)
  43.         x = self.linear2(x)
  44.         '''
  45.         x = self.modle(x)
  46.         return x
  48. liu = Liucy()
  49. print(liu)
  51. x = torch.ones((64,3,32,32))
  52. output = liu(x)
  53. print(output.shape)
  55. writer = SummaryWriter("logs")
  56. writer.add_graph(liu,x)
  57. writer.close()