• 由浅入深，走进深度学习（补充篇：神经网络基础）

    在编程实战中，基础是最重要的，所以为了巩固基础，哈哈哈~

    不说废话了，大家喜欢就往下看看，也是我自己的一些总结，方便以后自己看~

    我觉得还是动手敲一遍，会有不一样的感受~

    相关内容：

    由浅入深，走进深度学习（2）_卷积层-CSDN博客

    由浅入深，走进深度学习（补充篇：神经网络结构层基础）-CSDN博客

    目录

    一、层和块

    二、参数管理

    三、自定义层

    四、模型保存和读取

    正片开始！！！

    一、层和块

    这下面的代码中分别包括几个重要部分：

    自定义块

    对块进行实例化

    顺序块

    正向传播

    混合块

    代码和相关内容的解释，给大家放在下面了：

    1. import torch
    2. from torch import nn
    3. from torch.nn import functional as F
    4.  
    5. net = nn.Sequential(nn.Linear(20, 256),
    6.                     nn.ReLU(),
    7.                     nn.Linear(256, 10))
    8.  
    9. x = torch.rand(4, 20) # 这里必须是20 对应第一个 Linear 的20
    10. print('x:', x)
    11. print('x.shape:', x.shape)
    12. output = net(x)
    13. print('output:', output)
    14.  
    15. # 自定义块
    16. print('--------------------------------------')
    17. class MLP(nn.Module):
    18.     def __init__(self):
    19.         super(MLP, self).__init__()  # 调用父类的__init__函数
    20.         self.hidden = nn.Linear(20, 256)
    21.         self.output = nn.Linear(256, 10)
    22.         self.relu = nn.ReLU()
    23.  
    24.     def forward(self, x):
    25.         x = self.hidden(x)
    26.         x = self.relu(x)
    27.         x = self.output(x)
    28.         return x
    29.  
    30. # 实例化多层感知机的层 然后在每次调用正向传播函数调用这些层
    31. net = MLP()
    32. x = torch.rand(2, 20)
    33. output = net(x)
    34. print('output:', output)
    35.  
    36. # 顺序块
    37. print('- - - - - - - - - - - - - - - - - - - - - -')
    38. class MySequential(nn.Module):
    39.     def __init__(self, *args):
    40.         super(MySequential, self).__init__()
    41.         for block in args:
    42.             self._modules[block] = block  # block 本身作为它的key  存在_modules里面的为层，以字典的形式
    43.  
    44.     def forward(self, x):
    45.         for block in self._modules.values():
    46.             print('block:', block)
    47.             x = block(x)
    48.         return x
    49.  
    50. net = MySequential(nn.Linear(20, 256),
    51.                    nn.ReLU(),
    52.                    nn.Linear(256, 10))
    53. x = torch.rand(2, 20)
    54. output = net(x)
    55. print('output:', output)
    56.  
    57. # 正向传播
    58. # 在正向传播中执行代码
    59. print('-----------------------------------------')
    60. class FixeHidden(nn.Module):
    61.     def __init__(self):
    62.         super(FixeHidden, self).__init__()
    63.         self.rand_weight = torch.rand((20, 20), requires_grad = True)
    64.         self.linear = nn.Linear(20, 20)
    65.  
    66.     def forward(self, x):
    67.         x = self.linear(x)
    68.         x = F.relu(torch.mm(x, self.rand_weight + 1))
    69.         x = self.linear(x)
    70.         while x.abs().sum() > 1:
    71.             x /= 2
    72.         return x.sum()
    73.  
    74. net = FixeHidden()
    75. a = torch.rand(2, 20)
    76. y = net(a)
    77. print('y:', y)
    78.  
    79. # 混合组合块
    80. print('------------------------------------------------------------------')
    81. class Mixmodel(nn.Module):
    82.     def __init__(self):
    83.         super(Mixmodel, self).__init__()
    84.         self.net = nn.Sequential(nn.Linear(20, 64),
    85.                                  nn.ReLU(),
    86.                                  nn.Linear(64, 16),
    87.                                  nn.ReLU())
    88.         self.linear = nn.Linear(16, 32)
    89.  
    90.     def forward(self, xx):
    91.         xx = self.net(xx)
    92.         xx = self.linear(xx)
    93.         return xx
    94.  
    95. mixnet = nn.Sequential(Mixmodel(),
    96.                        nn.Linear(32, 20),
    97.                        MySequential())
    98. aa = torch.rand(3, 20)
    99. out1 = mixnet(aa)
    100. print('out1:', out1)

    二、参数管理

    在这个部分涉及到：参数管理、参数替换和参数绑定三部分内容

    具体代码和相关解释如下：

    1. # 参数管理
    2. # 首先关注具有单隐藏层的多层感知机
    3. import torch
    4. from torch import nn
    5. from torch.nn import functional as F
    6.  
    7. net = nn.Sequential(nn.Linear(4, 8),
    8.                     nn.ReLU(),
    9.                     nn.Linear(8, 1))
    10. x = torch.rand(size = (2, 4))
    11. print('net(x):', net(x))
    12. print('net[2].stat_dict:', net[2].state_dict())  # 访问参数  net[2]就是最后一个输出层
    13. print('net[2].bias:', type(net[2].bias))   # 目标参数
    14. print(net[2].bias)
    15. print(net[2].bias.data)
    16. print(net[2].weight.grad == None) # 还没进行反向计算   所以grad为None
    17. print('------------', *[(name, param.shape) for name, param in net[0].named_parameters()])  # 一次性访问所有参数
    18. print('- - - - - - - -', *[(name, param.shape) for name, param in net.named_parameters()])  # 0是第一层名字  1是ReLU  它没有参数
    19. print('*************', net.state_dict()['2.bias'].data) # 通过名字获取参数
    20.  
    21. # 嵌套块
    22. # 从嵌套块收集参数
    23. def block1():
    24.     return nn.Sequential(nn.Linear(4, 8),
    25.                          nn.ReLU(),
    26.                          nn.Linear(8, 4),
    27.                          nn.ReLU())
    28.  
    29. def block2():
    30.     net = nn.Sequential()
    31.     for i in range(4):
    32.         net.add_module(f'block{i}', block1())  # f'block{i}' 可以传一个字符串名字过来   block2可以嵌套四个block1 
    33.     return net
    34.  
    35. regnet = nn.Sequential(block2(),
    36.                        nn.Linear(4, 1))
    37. xx = torch.rand(size = (2, 4))
    38. yy = torch.rand(2, 4)
    39. print('xx:', xx)
    40. print('yy:', yy)
    41. print('regnet(xx):', regnet(xx))
    42. print('regnet(yy):', regnet(yy))
    43. print('regnet:', regnet)
    44.  
    45.  
    46. # 内置初始化
    47. print('**********************************************************')
    48. net1 = nn.Sequential(nn.Linear(4, 8),
    49.                      nn.ReLU(),
    50.                      nn.Linear(8, 4),
    51.                      nn.ReLU())
    52. def init_normal(m):
    53.     if type(m) == nn.Linear:
    54.         nn.init.normal_(m.weight, mean = 0, std = 0.01) # 下划线表示把m.weight的值替换掉
    55.         nn.init.zeros_(m.bias)
    56.  
    57. net1.apply(init_normal)  # 会递归调用 直到所有层都初始化
    58. print('net1[0].weight.data[0]:', net1[0].weight.data[0])
    59. print('net1[0].bias.data[0]:', net1[0].bias.data[0])
    60.  
    61. net2 = nn.Sequential(nn.Linear(4,8),
    62.                      nn.ReLU(),
    63.                      nn.Linear(8,1))
    64.  
    65. def init_constant(m):
    66.     if type(m) == nn.Linear:
    67.         nn.init.constant_(m.weight, 1)
    68.         nn.init.zeros_(m.bias)
    69.         
    70. net2.apply(init_constant)
    71. print('net2[0].weight.data[0]:', net2[0].weight.data[0]) 
    72. print('net2[0].bias.data[0]:', net2[0].bias.data[0])
    73.  
    74. # 对某些块应用不同的初始化
    75. def xavier(m):
    76.     if type(m) == nn.Linear:
    77.         nn.init.xavier_uniform_(m.weight)
    78.         
    79. def init_42(m):
    80.     if type(m) == nn.Linear:
    81.         nn.init.constant_(m.weight, 42)
    82.         
    83. net1[0].apply(xavier)
    84. net1[2].apply(init_42)
    85. print('net1[0].weight.data[0]:', net1[0].weight.data[0])
    86. print('net1[2].weight.data:', net1[2].weight.data)
    87.  
    88.  
    89. # 参数替换
    90. # 自定义初始化
    91. def my_init(m):
    92.     if type(m) == nn.Linear:  
    93.         print("Init",*[(name, param.shape) for name, param in m.named_parameters()][0])  # 打印名字是啥，形状是啥   
    94.         nn.init.uniform_(m.weight, -10, 10)
    95.         m.weight.data *= m.weight.data.abs() >= 5
    96.         # 这里*=的代码相当于先计算一个布尔矩阵(先判断>=)  然后再用布尔矩阵的对应元素去乘以原始矩阵的每个元素  保留绝对值大于5的权重  不是的话就设为0
    97.  
    98. net2.apply(my_init)
    99. print('net2[0].weight[:2]:', net2[0].weight[:2])
    100. net2[0].weight.data[:] += 1 # 参数替换
    101. net2[0].weight.data[0, 0] = 42
    102. print('net2[0].weight.data[0]:', net2[0].weight.data[0])
    103.  
    104.  
    105. # 参数绑定
    106. shared = nn.Linear(8,8)
    107. net3 = nn.Sequential(nn.Linear(4,8),
    108.                      nn.ReLU(), shared,
    109.                      nn.ReLU(), shared,
    110.                      nn.ReLU(),
    111.                      nn.Linear(8,1))  # 第2个隐藏层和第3个隐藏层是share权重的  第一个和第四个是自己的  
    112. print(net3)
    113. net3(torch.rand(2, 4))
    114. print(net3[2].weight.data[0] == net3[4].weight.data[0])
    115. net3[2].weight.data[0,0] = 100
    116. print(net3[2].weight.data[0] == net3[4].weight.data[0])

    三、自定义层

    在这部分，构造的时候：由非参数层和参数层

    1. # 自定义层
    2. # 构造一个没有任何参数的自定义层
    3. import torch
    4. import torch.nn.functional as F
    5. from torch import nn
    6. class MyLayer(nn.Module):
    7.     def __init__(self):
    8.         super(MyLayer, self).__init__()
    9.     def forward(self, x):
    10.         return x - x.mean()
    11.  
    12. net = MyLayer()
    13. z = torch.tensor([1, 2, 3, 4, 5], dtype = torch.float32)
    14. print('net(z):', net(z))
    15.  
    16. # 将层作为组件合并到构建更复杂的模型中
    17. net1 = nn.Sequential(nn.Linear(8, 128),
    18.                      MyLayer())
    19. zz = torch.rand(4, 8)
    20. print('net1(zz):', net1(zz))
    21. print('net1(zz).mean:', net1(zz).mean())
    22.  
    23. # 带参数的图层
    24. class MyLinear(nn.Module):
    25.     def __init__(self, in_units, units):
    26.         super().__init__()
    27.         self.weight = nn.Parameter(torch.randn(in_units,units)) # nn.Parameter使得这些参数加上了梯度    
    28.         self.bias = nn.Parameter(torch.randn(units,))
    29.  
    30.     def forward(self, X):
    31.         linear = torch.matmul(X, self.weight.data) + self.bias.data
    32.         return F.relu(linear)
    33.     
    34. dense = MyLinear(5,3)
    35. print('dense.weight', dense.weight)
    36.  
    37. # 使用自定义层直接执行正向传播计算
    38. print('dense(torch.rand(2,5))', dense(torch.rand(2,5)))
    39. # 使用自定义层构建模型
    40. net = nn.Sequential(MyLinear(64,8),
    41.                     MyLinear(8,1))
    42. print('net(torch.rand(2,64))', net(torch.rand(2,64)))

    四、模型保存和读取

    这里涉及使用torch保存和读取文件，然后就是在以后我们设计模型，训练的时候，我们可以通过这种方式，保存我们的模型，然后再最后测试的时候在调用模型！！！

    代码如下：

    1. # 读写文件
    2. # 加载和保存张量
    3. import torch
    4. from torch import nn
    5. from torch.nn import functional as F
    6.  
    7. x = torch.arange(4)
    8. torch.save(x, 'x_file')
    9. x1 = torch.load('x_file')
    10. print('x1:', x1)
    11.  
    12. #存储一个张量列表   然后把它们读回内存
    13. y = torch.zeros(4)
    14. torch.save([x, y], 'x-file')
    15. x2, y2 = torch.load('x-file')
    16. print('x2:', x2)
    17. print('y2:', y2)
    18.  
    19. # 写入或读取从字符串映射到张量的字典
    20. mydict = {'x':x, 'y':y}
    21. torch.save(mydict, 'mydict')
    22. mydict1 = torch.load('mydict')
    23. print('mydict1:', mydict1)

    加载和保存模型参数

    1. # 加载和保存模型参数
    2. import torch
    3. from torch import nn
    4. from torch.nn import functional as F
    5.  
    6. class MLP(nn.Module):
    7.     def __init__(self):
    8.         super(MLP, self).__init__()  # 调用父类的__init__函数
    9.         self.hidden = nn.Linear(20, 256)
    10.         self.output = nn.Linear(256, 10)
    11.         self.relu = nn.ReLU()
    12.  
    13.     def forward(self, x):
    14.         x = self.hidden(x)
    15.         x = self.relu(x)
    16.         x = self.output(x)
    17.         return x
    18.  
    19. # 实例化多层感知机的层 然后在每次调用正向传播函数调用这些层
    20. net = MLP()
    21. x = torch.rand(2, 20)
    22. output = net(x)
    23. print('output:', output)
    24.  
    25. # 将模型的参数存储为一个叫做"mlp.params"的文件
    26. torch.save(net.state_dict(), 'MLP.params')
    27.  
    28. # 实例化了原始多层感知机模型的一个备份。直接读取文件中存储的参数
    29. clone = MLP() # 必须要先声明一下，才能导入参数
    30. clone.load_state_dict(torch.load('MLP.params'))
    31. print('MLP eval', clone.eval())  # eval()是进入测试模式
    32.  
    33. output_clone = clone(x)
    34. print(output_clone == output)

    注：上述内容参考b站up主“我是土堆”的视频，参考吴恩达深度学习，机器学习内容，参考李沐动手学深度学习！！！

  • 相关阅读:
    【无标题】Open Verification Library Assertion检查
    SpringMVC的整合完成CRUD
    java基于ssm网上超市购物商城-计算机毕业设计
    antd 表格getCheckboxProps禁用
    Ansible--playbook 剧本
    C语言每日一题（21）删除排序数组中的重复项
    华为OD机试 - 判断一组不等式是否满足约束并输出最大差（Java 2023 B卷 100分）
    【LeetCode每日一题】——37.解数独
    讲座记录｜1024学科周讲座分享
    阿里P8大能倾力编撰的“Java 进阶面试手册”，助力跳槽外包毕业生秋招收获大厂offer
  • 原文地址：https://blog.csdn.net/weixin_45325693/article/details/139946949