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

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

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

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

相关内容：

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

目录

一、层和块

二、参数管理

三、自定义层

四、模型保存和读取

正片开始！！！

一、层和块

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

自定义块

对块进行实例化

顺序块

正向传播

混合块

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

import torch
from torch import nn
from torch.nn import functional as Fnet = nn.Sequential(nn.Linear(20, 256),nn.ReLU(),nn.Linear(256, 10))x = torch.rand(4, 20) # 这里必须是20 对应第一个 Linear 的20
print('x:', x)
print('x.shape:', x.shape)
output = net(x)
print('output:', output)# 自定义块
print('--------------------------------------')
class MLP(nn.Module):def __init__(self):super(MLP, self).__init__()  # 调用父类的__init__函数self.hidden = nn.Linear(20, 256)self.output = nn.Linear(256, 10)self.relu = nn.ReLU()def forward(self, x):x = self.hidden(x)x = self.relu(x)x = self.output(x)return x# 实例化多层感知机的层 然后在每次调用正向传播函数调用这些层
net = MLP()
x = torch.rand(2, 20)
output = net(x)
print('output:', output)# 顺序块
print('- - - - - - - - - - - - - - - - - - - - - -')
class MySequential(nn.Module):def __init__(self, *args):super(MySequential, self).__init__()for block in args:self._modules[block] = block  # block 本身作为它的key  存在_modules里面的为层，以字典的形式def forward(self, x):for block in self._modules.values():print('block:', block)x = block(x)return xnet = MySequential(nn.Linear(20, 256),nn.ReLU(),nn.Linear(256, 10))
x = torch.rand(2, 20)
output = net(x)
print('output:', output)# 正向传播
# 在正向传播中执行代码
print('-----------------------------------------')
class FixeHidden(nn.Module):def __init__(self):super(FixeHidden, self).__init__()self.rand_weight = torch.rand((20, 20), requires_grad = True)self.linear = nn.Linear(20, 20)def forward(self, x):x = self.linear(x)x = F.relu(torch.mm(x, self.rand_weight + 1))x = self.linear(x)while x.abs().sum() > 1:x /= 2return x.sum()net = FixeHidden()
a = torch.rand(2, 20)
y = net(a)
print('y:', y)# 混合组合块
print('------------------------------------------------------------------')
class Mixmodel(nn.Module):def __init__(self):super(Mixmodel, self).__init__()self.net = nn.Sequential(nn.Linear(20, 64),nn.ReLU(),nn.Linear(64, 16),nn.ReLU())self.linear = nn.Linear(16, 32)def forward(self, xx):xx = self.net(xx)xx = self.linear(xx)return xxmixnet = nn.Sequential(Mixmodel(),nn.Linear(32, 20),MySequential())
aa = torch.rand(3, 20)
out1 = mixnet(aa)
print('out1:', out1)

二、参数管理

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

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

# 参数管理
# 首先关注具有单隐藏层的多层感知机
import torch
from torch import nn
from torch.nn import functional as Fnet = nn.Sequential(nn.Linear(4, 8),nn.ReLU(),nn.Linear(8, 1))
x = torch.rand(size = (2, 4))
print('net(x):', net(x))
print('net[2].stat_dict:', net[2].state_dict())  # 访问参数  net[2]就是最后一个输出层
print('net[2].bias:', type(net[2].bias))   # 目标参数
print(net[2].bias)
print(net[2].bias.data)
print(net[2].weight.grad == None) # 还没进行反向计算   所以grad为None
print('------------', *[(name, param.shape) for name, param in net[0].named_parameters()])  # 一次性访问所有参数
print('- - - - - - - -', *[(name, param.shape) for name, param in net.named_parameters()])  # 0是第一层名字  1是ReLU  它没有参数
print('*************', net.state_dict()['2.bias'].data) # 通过名字获取参数# 嵌套块
# 从嵌套块收集参数
def block1():return nn.Sequential(nn.Linear(4, 8),nn.ReLU(),nn.Linear(8, 4),nn.ReLU())def block2():net = nn.Sequential()for i in range(4):net.add_module(f'block{i}', block1())  # f'block{i}' 可以传一个字符串名字过来   block2可以嵌套四个block1 return netregnet = nn.Sequential(block2(),nn.Linear(4, 1))
xx = torch.rand(size = (2, 4))
yy = torch.rand(2, 4)
print('xx:', xx)
print('yy:', yy)
print('regnet(xx):', regnet(xx))
print('regnet(yy):', regnet(yy))
print('regnet:', regnet)# 内置初始化
print('**********************************************************')
net1 = nn.Sequential(nn.Linear(4, 8),nn.ReLU(),nn.Linear(8, 4),nn.ReLU())
def init_normal(m):if type(m) == nn.Linear:nn.init.normal_(m.weight, mean = 0, std = 0.01) # 下划线表示把m.weight的值替换掉nn.init.zeros_(m.bias)net1.apply(init_normal)  # 会递归调用 直到所有层都初始化
print('net1[0].weight.data[0]:', net1[0].weight.data[0])
print('net1[0].bias.data[0]:', net1[0].bias.data[0])net2 = nn.Sequential(nn.Linear(4,8),nn.ReLU(),nn.Linear(8,1))def init_constant(m):if type(m) == nn.Linear:nn.init.constant_(m.weight, 1)nn.init.zeros_(m.bias)net2.apply(init_constant)
print('net2[0].weight.data[0]:', net2[0].weight.data[0]) 
print('net2[0].bias.data[0]:', net2[0].bias.data[0])# 对某些块应用不同的初始化
def xavier(m):if type(m) == nn.Linear:nn.init.xavier_uniform_(m.weight)def init_42(m):if type(m) == nn.Linear:nn.init.constant_(m.weight, 42)net1[0].apply(xavier)
net1[2].apply(init_42)
print('net1[0].weight.data[0]:', net1[0].weight.data[0])
print('net1[2].weight.data:', net1[2].weight.data)# 参数替换
# 自定义初始化
def my_init(m):if type(m) == nn.Linear:  print("Init",*[(name, param.shape) for name, param in m.named_parameters()][0])  # 打印名字是啥，形状是啥   nn.init.uniform_(m.weight, -10, 10)m.weight.data *= m.weight.data.abs() >= 5# 这里*=的代码相当于先计算一个布尔矩阵(先判断>=)  然后再用布尔矩阵的对应元素去乘以原始矩阵的每个元素  保留绝对值大于5的权重  不是的话就设为0net2.apply(my_init)
print('net2[0].weight[:2]:', net2[0].weight[:2])
net2[0].weight.data[:] += 1 # 参数替换
net2[0].weight.data[0, 0] = 42
print('net2[0].weight.data[0]:', net2[0].weight.data[0])# 参数绑定
shared = nn.Linear(8,8)
net3 = nn.Sequential(nn.Linear(4,8),nn.ReLU(), shared,nn.ReLU(), shared,nn.ReLU(),nn.Linear(8,1))  # 第2个隐藏层和第3个隐藏层是share权重的  第一个和第四个是自己的  
print(net3)
net3(torch.rand(2, 4))
print(net3[2].weight.data[0] == net3[4].weight.data[0])
net3[2].weight.data[0,0] = 100
print(net3[2].weight.data[0] == net3[4].weight.data[0])

三、自定义层

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

# 自定义层
# 构造一个没有任何参数的自定义层
import torch
import torch.nn.functional as F
from torch import nn
class MyLayer(nn.Module):def __init__(self):super(MyLayer, self).__init__()def forward(self, x):return x - x.mean()net = MyLayer()
z = torch.tensor([1, 2, 3, 4, 5], dtype = torch.float32)
print('net(z):', net(z))# 将层作为组件合并到构建更复杂的模型中
net1 = nn.Sequential(nn.Linear(8, 128),MyLayer())
zz = torch.rand(4, 8)
print('net1(zz):', net1(zz))
print('net1(zz).mean:', net1(zz).mean())# 带参数的图层
class MyLinear(nn.Module):def __init__(self, in_units, units):super().__init__()self.weight = nn.Parameter(torch.randn(in_units,units)) # nn.Parameter使得这些参数加上了梯度    self.bias = nn.Parameter(torch.randn(units,))def forward(self, X):linear = torch.matmul(X, self.weight.data) + self.bias.datareturn F.relu(linear)dense = MyLinear(5,3)
print('dense.weight', dense.weight)# 使用自定义层直接执行正向传播计算
print('dense(torch.rand(2,5))', dense(torch.rand(2,5)))
# 使用自定义层构建模型
net = nn.Sequential(MyLinear(64,8),MyLinear(8,1))
print('net(torch.rand(2,64))', net(torch.rand(2,64)))

四、模型保存和读取

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

代码如下：

# 读写文件
# 加载和保存张量
import torch
from torch import nn
from torch.nn import functional as Fx = torch.arange(4)
torch.save(x, 'x_file')
x1 = torch.load('x_file')
print('x1:', x1)#存储一个张量列表   然后把它们读回内存
y = torch.zeros(4)
torch.save([x, y], 'x-file')
x2, y2 = torch.load('x-file')
print('x2:', x2)
print('y2:', y2)# 写入或读取从字符串映射到张量的字典
mydict = {'x':x, 'y':y}
torch.save(mydict, 'mydict')
mydict1 = torch.load('mydict')
print('mydict1:', mydict1)

加载和保存模型参数

# 加载和保存模型参数
import torch
from torch import nn
from torch.nn import functional as Fclass MLP(nn.Module):def __init__(self):super(MLP, self).__init__()  # 调用父类的__init__函数self.hidden = nn.Linear(20, 256)self.output = nn.Linear(256, 10)self.relu = nn.ReLU()def forward(self, x):x = self.hidden(x)x = self.relu(x)x = self.output(x)return x# 实例化多层感知机的层 然后在每次调用正向传播函数调用这些层
net = MLP()
x = torch.rand(2, 20)
output = net(x)
print('output:', output)# 将模型的参数存储为一个叫做"mlp.params"的文件
torch.save(net.state_dict(), 'MLP.params')# 实例化了原始多层感知机模型的一个备份。直接读取文件中存储的参数
clone = MLP() # 必须要先声明一下，才能导入参数
clone.load_state_dict(torch.load('MLP.params'))
print('MLP eval', clone.eval())  # eval()是进入测试模式output_clone = clone(x)
print(output_clone == output)

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/860689.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

全景vr交互微课视频开发让学习变得更加有趣、高效

全景vr交互微课视频开发让学习变得更加有趣、高效

在数字化教育的浪潮中，3D虚拟微课系统操作平台以其独特的魅力和创新的功能，成为吸引学生目光的焦点。这个平台不仅提供了引人入胜的画面和内容丰富的课件，更通过技术革新和制作方式的探索，将课程制作推向了一个全新的高度。 随着技…
阅读更多...
HarmonyOS NEXT Developer Beta1配套相关说明

HarmonyOS NEXT Developer Beta1配套相关说明

一、版本概述 2024华为开发者大会，HarmonyOS NEXT终于在万千开发者的期待下从幕后走向台前。 HarmonyOS NEXT采用全新升级的系统架构，贯穿HarmonyOS全场景体验的底层优化，系统更流畅，隐私安全能力更强大，将给您带来更高…
阅读更多...
基于Cisco的校园网络拓扑搭建

基于Cisco的校园网络拓扑搭建

特此说明：请先看评论区留言哦~ 一、基础配置 1.新建拓扑图 2.服务器配置 3.PC端配置 4.核心交换机配置 a.CORE-S1 Switch>enable Switch#configure terminal Switch(config)#hostname CORE-S1 CORE-S1(config)#vlan 10 CORE-S1(config-vlan)#vlan 20 CO…
阅读更多...
【zabbix】zabbix 自动发现与自动注册、proxy代理

【zabbix】zabbix 自动发现与自动注册、proxy代理

1、配置zabbix自动发现，要求发现的主机不低于2台 zabbix 自动发现（对于 agent2 是被动模式） zabbix server 主动的去发现所有的客户端，然后将客户端的信息登记在服务端上。 缺点是如果定义的网段中的主机数量多，zabbi…
阅读更多...
第1章，物联网模式简介

第1章，物联网模式简介

物联网模式简介 物联网（IoT）在最近几年获得了巨大的吸引力，该领域在未来几年将呈指数级增长。这一增长将跨越所有主要领域/垂直行业，包括消费者、家庭、制造业、健康、旅游和运输。这本书将为那些想了解基本物联网模式以及如何混…
阅读更多...
俄罗斯Yandex广告(Yandex ads)怎么做?Yandex广告搭建与效果优化技巧设置终极指南

俄罗斯Yandex广告(Yandex ads)怎么做?Yandex广告搭建与效果优化技巧设置终极指南

您可以在Yandex推广中使用移动应用广告来覆盖数百万搜索和Yandex广告网络受众，从而提高应用的盈利能力。为了获得最佳效果，请在设置广告系列时遵循我们的建议。 入门 在 Yandex Direct 中创建广告活动。转到营销活动向导 → 应用安装和应用内转化&…
阅读更多...
三叉神经痛多发于哪些部位，手术治疗会引起颅内感染吗？

三叉神经痛多发于哪些部位，手术治疗会引起颅内感染吗？

三叉神经痛，一种突发的阵发性疾病，主要影响面部、口腔及下颌的特定区域。在日常无发作时期，患者与常人无异，但一旦发作，其疼痛之剧烈，常令人难以忍受。这种疼痛常表现为突发性的剧烈、短暂、如闪电般的抽痛…
阅读更多...
【C语言】--常见类型和概念

【C语言】--常见类型和概念

❤️个人主页: 起名字真南 &#x1f495;个人专栏:【数据结构初阶】 【C语言】 目录 第一个C语言程序main函数printf函数库函数关键字字符和ASCII码字符串和\0转义字符 第一个C语言程序 #include<stdio.h> int main() {printf("Hello World\n");return 0; }ma…
阅读更多...
React useId Hook

React useId Hook

React 中有一个 useId hook&#xff0c;可以生成一个唯一 ID&#xff0c;这个有什么用处呢&#xff0c;用个 UUID 是不是可以替代呢&#xff1f;如果我们只考虑客户端&#xff0c;那么生成唯一 Id 的方法比较简单&#xff0c;我们在 State 中保存一个计数器就好&#xff0c;但是…
阅读更多...
windows 安装 Kubernetes(k8s)

windows 安装 Kubernetes(k8s)

windows 安装 docker 详情见&#xff1a; https://blog.csdn.net/sinat_32502451/article/details/133026301 minikube Minikube 是一种轻量级的Kubernetes 实现&#xff0c;可在本地计算机上创建VM 并部署仅包含一个节点的简单集群。 下载地址&#xff1a;https://github.…
阅读更多...
GPT-5时代的曙光：AI技术引领未来工作与生活的新篇章

GPT-5时代的曙光：AI技术引领未来工作与生活的新篇章

前言 随着科技的飞速发展&#xff0c;人工智能&#xff08;AI&#xff09;已成为推动社会进步的强大引擎。作为AI领域的杰出代表&#xff0c;OpenAI的GPT系列模型不断刷新着人们对AI智能的认知。近日&#xff0c;OpenAI首席技术官米拉穆拉蒂在达特茅斯工程学院的采访中透露&am…
阅读更多...
深入理解装饰者模式（Decorator Pattern）及其实际应用

深入理解装饰者模式（Decorator Pattern）及其实际应用

引言 在软件开发中&#xff0c;我们经常需要向现有的类添加新功能&#xff0c;同时又不希望改变其结构。装饰者模式&#xff08;Decorator Pattern&#xff09;为这种需求提供了灵活且强大的解决方案。本篇文章将详细介绍装饰者模式的概念、应用场景、优缺点&#xff0c;并通过…
阅读更多...
Qt的学习之路

Qt的学习之路

目录 一、信号槽机制 1.1 基本概念 1.2 特点 1.3 使用方法 1.4 信号槽连接类型 1.5 注意 二、元对象系统 2.1 基本概念 2.2 实现方式 2.3 主要特性 2.4 使用场景 三、国际化 3.1 标记可翻译的文本&#xff08;tr函数&#xff09; 3.2 生成翻译源文件&#xff08;…
阅读更多...
kotlin的null

kotlin的null

在 Kotlin 中&#xff0c;null 是一种特殊的值&#xff0c;它表示变量没有引用任何对象。 空指针&#xff08;null&#xff09;的空间占用 在 JVM 中&#xff0c;null 本质上不需要占用任何内存空间&#xff0c;因为它表示一个不存在的对象引用。具体来说&#xff1a; 在 32…
阅读更多...
高度内卷下，企业如何通过VOC（客户之声）做好竞争分析？

高度内卷下，企业如何通过VOC（客户之声）做好竞争分析？

VOC&#xff0c;即客户之声&#xff0c;是一种通过收集和分析客户反馈、需求和期望&#xff0c;来洞察市场趋势和竞争对手动态的方法。在高度内卷的市场环境下&#xff0c;VOC不仅能够帮助企业了解客户的真实需求&#xff0c;还能为企业提供宝贵的竞争情报&#xff0c;助力企业…
阅读更多...
构建家庭NAS之三：在TrueNAS SCALE上安装qBittorrent

构建家庭NAS之三：在TrueNAS SCALE上安装qBittorrent

本系列文章索引&#xff1a; 构建家庭NAS之一&#xff1a;用途和软硬件选型 构建家庭NAS之二&#xff1a;TrueNAS Scale规划、安装与配置 构建家庭NAS之三&#xff1a;在TrueNAS SCALE上安装qBittorrent 大部分家庭NAS用户应该都会装一个下载工具。本篇以qBittorrent为例&…
阅读更多...
VScode Python debug：hydra.run.dir 写入launch.json

VScode Python debug：hydra.run.dir 写入launch.json

记录一个debug时的经验&#xff1a; VS code extension名称版本Pythonv2028.8.1Python Debuggerv2024.6.0 我配置的project运行 train.py 时需要在 terminal 输入参数 hydra.run.dirxxx 我想用 vscode debug 查看内部代码&#xff0c;按以往的经验需要将args写入launch.json&…
阅读更多...
LabVIEW与PLC通讯方式及比较

LabVIEW与PLC通讯方式及比较

LabVIEW与PLC之间的通讯方式多样&#xff0c;包括使用MODBUS协议、OPC&#xff08;OLE for Process Control&#xff09;、Ethernet/IP以及串口通讯等。这些通讯方式各有特点&#xff0c;选择合适的通讯方式可以提高系统的效率和稳定性。以下将详细介绍每种通讯方式的特点、优点…
阅读更多...
从零开始：如何使用PHP和Selenium构建网络数据爬虫

从零开始：如何使用PHP和Selenium构建网络数据爬虫

随着互联网的发展&#xff0c;网络数据爬取越来越成为人们关注的焦点。网络数据爬虫可以从互联网中采集大量有用的数据&#xff0c;为企业、学术研究和个人分析提供支持。本文将介绍使用php和selenium构建网络数据爬虫的方法和步骤。 一、什么是网络数据爬虫&#xff1f; 网络…
阅读更多...
1.2-Redis系列-Reactor 线程模型详解

1.2-Redis系列-Reactor 线程模型详解

Reactor 线程模型详解 Reactor 线程模型是一种基于事件驱动的高效 I/O 处理模型&#xff0c;广泛应用于高性能网络服务器和事件驱动的应用程序。Reactor 模型通过将 I/O 操作和业务逻辑分离&#xff0c;以高效地处理并发连接。下面详细解释 Reactor 线程模型的概念、机制、实现…
阅读更多...
最新文章

Copyright @ 2022~2023