记9（Torch

目录

  • 1、Troch

1、Troch

函数说明举例
torch.tensor()
torch.arange()		创建张量创建一个标量：torch.tensor(42)
创建一个一维张量：torch.tensor([1, 2, 3])
创建一个二维张量：torch.tensor([[1, 2], [3, 4]])
生成一维等差张量：语法：torch.arange(start=0, end, step=1, *, dtype=None, device=None, requires_grad=False)
torch.arange(3)就是tensor([0, 1, 2])
torch.view()改变张量的形状1行8列改2行4列：torch.arange(1, 9).view(2, 4)
torch.cat()指定维度拼接张量torch.cat((torch.tensor([[1, 2], [3, 4]]), torch.tensor([[5, 6]])), dim=0)
# tensor([[1, 2], [3, 4], [5, 6]])
索引与切片和numpy数组用法一致
tensor.t()张量转置torch.tensor([[1, 2, 3], [4, 5, 6]]).t()
tensor([[1, 4], [2, 5], [3, 6]])
torch.mm()矩阵乘法torch.mm(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[5, 6], [7, 8]]))
# tensor([[19, 22], [43, 50]])
torch.mul()元素级乘法torch.mul(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[5, 6], [7, 8]]))
# tensor([[ 5, 12], [21, 32]])
torch.sum()求和torch.sum(torch.tensor([[1, 2], [3, 4]])) # tensor(10)
torch.mean()求均值torch.mean(torch.tensor([[1.0, 2.0], [3.0, 4.0]])))
# tensor(2.5000)
torch.std()求标准差torch.std(torch.tensor([[1.0, 2.0], [3.0, 4.0]])))
# tensor(2.2910) 即：((1-2)**2 + (2-2)**2 + (3-2)**2 + (4-2)**2)**0.5
torch.max()
torch.min()		求最大值、最小值及其索引见下面代码（后面都见下面代码，不写了）
torch.abs()绝对值
torch.exp()指数运算，torch.exp(x)就是e^x
torch.log()对数运算，toch.log(2)就是ln2≈0.6931
torch.floor()
torch.ceil()		向下取整floor
向上取整ceil
nn.Linear(x, y)定义一个线性层，x行y列，总共x*y个weight神经元，y个bias神经元
optimizer.zero_grad()梯度清零，清空优化器跟踪的参数的梯度（即 model.parameters() 中注册的参数）
layer.weight.grad
layer.bias.grad		保存该层的 权重weight梯度信息 和 偏置bias梯度信息
model.named_parameters()通过迭代器 获取模型的所有参数（而不是某一层）及其梯度 [(n, p.grad) for n, p in model.named_parameters()]
torch.nn.utils.clip_grad_norm_()梯度裁剪,用于防止梯度爆炸的技术，通过对模型的梯度进行裁剪。
import torch, math
import torch.nn as nn
import torch.optim as optim# torch.tensor()
print(torch.tensor(42))             # 创建一个标量（零维张量），tensor(42)
print(torch.tensor([1,2,3]))        # 创建一个一维张量，tensor([1, 2, 3])
print(torch.tensor([[1,2],[3,4]]))  # 创建一个二维张量，tensor([[1, 2], [3, 4]])# torch.arange()，一维等差张量
print(torch.arange(1,5))            # tensor([2, 3, 4])
print(torch.arange(3))              # tensor([0, 1, 2])# tensor1.view()        改变形状
tensor1 = torch.arange(1, 9)        # tensor1 = tensor([1, 2, 3, 4, 5, 6, 7, 8])
print(tensor1.view(2, 4))           # 或者 tensor1.view(-1, 4)、tensor1.view(2, -1)：tensor([[1, 2, 3, 4], [5, 6, 7, 8]])# torch.cat()       拼接
print(torch.cat((torch.tensor([[1, 2], [3, 4]]), torch.tensor([[5, 6]])), dim=0))
# 上面就是按照第0个维度拼接（就是第1维度不变，例如[1,2]拼接前后一致）tensor([[1, 2], [3, 4], [5, 6]])# 索引和切片
tensor1 = torch.tensor([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]])
print(tensor1[0, :])            # 获取第一行：tensor([1, 2, 3, 4, 5, 6])
print(tensor1[0, 0:3])          # 获取第一行从索引0开始，到索引3（不包括3）的元素：tensor([1, 2, 3])
print(tensor1[0, 0:3:2])        # 获取第一行，且从索引0开始，到索引3（不包括3），步长为2的元素：tensor([1, 3])
print(tensor1[:, 0])            # 获取第一列：tensor([1, 7])
print(tensor1[1:, 1:])          # 获取子集：tensor([[ 8,  9, 10, 11, 12]])# torch.t()         转置
print(torch.tensor([[1, 2, 3], [4, 5, 6]]).t())     # tensor([[1, 4], [2, 5], [3, 6]])# torch.mm()        矩阵乘法
print(torch.mm(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[5, 6], [7, 8]]))) # tensor([[19, 22], [43, 50]])# torch.mul()        元素级乘法
print(torch.mul(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[5, 6], [7, 8]]))) # tensor([[ 5, 12], [21, 32]])# torch.sum()       求和
print(torch.sum(torch.tensor([[1, 2], [3, 4]])))    # tensor(10)# torch.mean()      求均值
print(torch.mean(torch.tensor([[1.0, 2.0], [3.0, 4.0]])))   # tensor(2.5000)# torch.std()       求标准差
print(torch.std(torch.tensor([[1.0, 2.0], [3.0, 4.0]])))    # tensor(2.2910) 即：((1-2)**2 + (2-2)**2 + (3-2)**2 + (4-2)**2)**0.5# torch.max()、torch.min()           求最大值、最小值及其索引
print(torch.max(torch.tensor([[1.0, 2.0], [3.0, 4.0]])))    # tensor(4.)
print(torch.max(torch.tensor([[1.0, 2.0], [3.0, 4.0]]), dim=1))     # torch.return_types.max( values=tensor([2., 4.]), indices=tensor([1, 1]))
print(torch.min(torch.tensor([[1.0, 2.0], [3.0, 4.0]])))    # tensor(1.)# torch.abs()       绝对值
print(torch.abs(torch.tensor([[-1, 2], [-3, 4]])))      # tensor([[1, 2], [3, 4]])# torch.exp()       指数运算，torch.exp(x)就是e^x
print(torch.exp(torch.tensor([[1.0, 2.0], [3.0, 4.0]])))    # tensor([[ 2.7183,  7.3891], [20.0855, 54.5981]])# torch.log()       对数运算，就是 ln2≈0.6931
print(torch.log(torch.tensor([[1.0, 2.0], [3.0, 4.0]])))    # tensor([[0.0000, 0.6931], [1.0986, 1.3863]])# torch.floor()、torch.ceil()    向下取整floor、向上取整ceil
print(torch.floor(torch.tensor([[1.2, 2.8], [3.5, 4.1]])))  # tensor([[1., 2.], [3., 4.]])
print(torch.ceil(torch.tensor([[1.2, 2.8], [3.5, 4.1]])))  # tensor([[2., 3.], [4., 5.]])# nn.Linear(x, y)       定义一个线性层，x行y列，总共x*y个weight神经元，y个bias神经元
layer1 = nn.Linear(3, 1)        # 定义一个线性层
print(f"layer1\t权重 W:{layer1.weight.shape}\t偏置 b:{layer1.bias.shape}")  # 查看权重和偏置：layer1	权重 W:torch.Size([1, 3])	偏置 b:torch.Size([1])
layer2 = nn.Linear(3, 2)        # 定义一个线性层
print(f"layer2\t权重 W:{layer2.weight.shape}\t偏置 b:{layer2.bias.shape}")  # 查看权重和偏置：layer2	权重 W:torch.Size([2, 3])	偏置 b:torch.Size([2])# 损失函数      可以调用类形式的损失函数(torch.nn)和函数形式的损失函数(torch.nn.functional)
#           torch.nn：需要实例化对象，可以初始化时固定参数
#           torch.nn.funcional：直接调用函数，每次调用显式传递所有参数
criterion = nn.CrossEntropyLoss(reduction="mean")  # 初始化时固定参数
outputs = torch.randn(3, 5)  # 模型输出（3个样本，5个类别）
labels = torch.tensor([2, 0, 4])  # 真实标签
loss1 = criterion(outputs, labels)  # 直接调用
import torch.nn.functional as F
loss2 = F.cross_entropy(outputs,labels,reduction="mean"  # 每次调用需显式传递参数
)# 优化器       torch.optim模块提供多种优化函数，例如随机梯度下降(SGD)、Adam
# optimizer.zero_grad()         梯度清零，清空优化器跟踪的参数的梯度（即 model.parameters() 中注册的参数）
# layer.weight.grad、layer.bias.grad     保存该层的 权重weight梯度信息 和 偏置bias梯度信息
# model.named_parameters()      通过迭代器 获取模型的所有参数（而不是某一层）及其梯度 [(n, p.grad) for n, p in model.named_parameters()]
torch.manual_seed(77)                               # 设置随机种子，77可以改为其他数字
model = nn.Linear(3, 1)                             # 定义模型：简单线性层，就是3行1列 个神经元
optimizer = optim.SGD(model.parameters(), lr=0.01)  # 定义优化器：随机梯度下降优化器
inputs = torch.randn(10, 3)                         # 模拟输入数据和标签：batch_size批量大小10，特征维度3（就是3行10列的张量，10个样品，每个样品）
labels = torch.randn(10, 1)                         # 对应标签
for epoch in range(2):                              # 训练循环optimizer.zero_grad()                   # 1. 梯度清零outputs = model(inputs)                 # 2. 前向传播计算损失loss = nn.MSELoss()(outputs, labels)print(f"计算epoch={epoch}的loss前：weight：{model.weight.grad}\tbias：{model.bias.grad}")loss.backward()                         # 3. 反向传播计算梯度print(f"计算epoch={epoch}的loss后：weight：{model.weight.grad}\tbias：{model.bias.grad}")optimizer.step()                        # 4. 优化器更新参数
# 计算epoch=0的loss前：weight：None	bias：None
# 计算epoch=0的loss后：weight：tensor([[-1.2573, -0.0045, -0.6926]])	bias：tensor([0.2520])
# 计算epoch=1的loss前：weight：tensor([[0., 0., 0.]])	bias：tensor([0.])
# 计算epoch=1的loss后：weight：tensor([[-1.2206, -0.0055, -0.6704]])	bias：tensor([0.2330])
# 如果注释掉optimizer.zero_grad()，可以对比bias变化，下面的 0.4849≈0.2520+0.2330
# 计算epoch=0的loss前：weight：None	bias：None
# 计算epoch=0的loss后：weight：tensor([[-1.2573, -0.0045, -0.6926]])	bias：tensor([0.2520])
# 计算epoch=1的loss前：weight：tensor([[-1.2573, -0.0045, -0.6926]])	bias：tensor([0.2520])
# 计算epoch=1的loss后：weight：tensor([[-2.4779, -0.0100, -1.3630]])	bias：tensor([0.4849])# torch.nn.utils.clip_grad_norm_()      梯度裁剪
torch.manual_seed(77)                               # 设置随机种子，77可以改为其他数字
model = nn.Linear(3, 1)
optimizer = optim.SGD(model.parameters(), lr=0.01)
input_data = torch.randn(10, 3)
output = model(input_data)                                          # 前向传播
loss = torch.nn.functional.mse_loss(output, torch.randn(10, 1))
loss.backward()                                                     # 反向传播
print(f"裁剪前梯度：weight.grad={model.weight.grad}\tbias.grad={model.bias.grad}")
grads = torch.cat([p.grad.flatten() for p in model.parameters()])   # grads = tensor([-1.2573, -0.0045, -0.6926,  0.2520])
weightGrad, biasGrad = model.weight.grad*1/torch.norm(grads), model.bias.grad*1/torch.norm(grads)
print(f"手动计算裁剪后梯度：weight.grad={weightGrad}\tbias.grad={biasGrad}")
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)            # 梯度裁剪
print(f"裁剪后梯度：{model.weight.grad}\tbias.grad={model.bias.grad}")
optimizer.step()
# 打印：
# 裁剪前梯度：weight.grad=tensor([[-1.2573, -0.0045, -0.6926]])	bias.grad=tensor([0.2520])
# 手动计算裁剪后梯度：weight.grad=tensor([[-0.8627, -0.0031, -0.4752]])	bias.grad=tensor([0.1729])
# 裁剪后梯度：tensor([[-0.8627, -0.0031, -0.4752]])	bias.grad=tensor([0.1729])
# 可见：-0.8627 = -1.2573 * 1 / math.sqrt((1.2573*1.2573 + 0.0045*0.0045 + 0.6926*0.6926 + 0.2520*0.2520))# DataLoader\Dataset        torch.utils.data提供了用于加载和处理数据的工具
# 例如：DataLoader(my_dataset, batch_size=2, shuffle=True):
#       创建一个数据加载器，my_dataset 必须继承自torch.utils.data.Dataset的自定义数据集对象
#       需要实现__len__()（返回数据集大小）和__getitem__()（根据索引返回样本和标签）方法。
#       batch_size=2：每个批次包含2个样本。例如，若数据集有1000个样本，则会生成500个批次（每个批次2个样本）。
#       shuffle=True：在每个epoch开始时打乱数据顺序（默认shuffle=False）。提升泛化能力
from torch.utils.data import DataLoader, Dataset
class CustomDataset(Dataset):           # 自定义数据集类def __init__(self, data):self.data = datadef __len__(self):return len(self.data)def __getitem__(self, index):return self.data[index]
my_dataset = CustomDataset([1, 2, 3, 4, 5])     # 创建自定义数据集实例
data_loader = DataLoader(my_dataset, batch_size=2, shuffle=True)    # 创建数据加载器
for batch in data_loader:       # 迭代数据加载器print("Batch:", batch)
# 打印
# Batch: tensor([2, 3])
# Batch: tensor([4, 5])
# Batch: tensor([1])# 学习率调度     .optim.lr_scheduler 模块提供了多种学习率调度器，例如学习率衰减等
from torch.optim.lr_scheduler import StepLR
torch.manual_seed(77)                               # 设置随机种子，77可以改为其他数字
model = nn.Linear(3, 1)                             # 定义模型：简单线性层，就是3行1列 个神经元
optimizer = optim.SGD(model.parameters(), lr=0.01)  # 定义优化器：随机梯度下降优化器
scheduler = StepLR(optimizer, step_size=5, gamma=0.1)   # 按照固定周期调整优化器的学习率：每隔 5 个epoch调整一次学习率，每次将学习率缩小10倍（乘0.1）
inputs = torch.randn(10, 3)                         # 模拟输入数据和标签：batch_size批量大小10，特征维度3（就是3行10列的张量，10个样品，每个样品）
labels = torch.randn(10, 1)                         # 对应标签
for epoch in range(20):                              # 训练循环optimizer.zero_grad()                   # 1. 梯度清零outputs = model(inputs)                 # 2. 前向传播计算损失loss = nn.MSELoss()(outputs, labels)print(f"计算epoch={epoch}的loss前：weight：{model.weight.grad}\tbias：{model.bias.grad}")loss.backward()                         # 3. 反向传播计算梯度print(f"计算epoch={epoch}的loss后：weight：{model.weight.grad}\tbias：{model.bias.grad}")optimizer.step()                        # 4. 优化器更新参数scheduler.step()                        # 5、更新学习率

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

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

相关文章

flask开启https服务支持

flask开启https服务支持

目录 一、背景 二、开启https支持 三、自签名 1、安装openssl 2、验证安装 3、自签名 四、编写代码 五、访问https接口 一、背景 最近在做自动化业务，需要兼容现在主流的框架开发的前端页面，于是到github找到了几个项目，clone下来项目并…
阅读更多...
路由交换实验

路由交换实验

案例一：实施和配置RIPV2 1.给AR1配置接口 查看R1接口配置情况 2.配置三台路由的RIP协议，版本为version2 ，关闭自动汇总，通告所有的直连接口 案例二：配置多区域的OSPF协议 1.配置R1的接口IP地址参数 2.配置r2,r3的接口参…
阅读更多...
北斗导航 ｜ RTKLib中重难点技术，公式，代码

北斗导航 ｜ RTKLib中重难点技术，公式，代码

Rtklib 一、抗差自适应卡尔曼滤波1. **核心难点**2. **公式与代码实现**二、模糊度固定与LAMBDA算法1. **核心难点**2. **LAMBDA算法实现**3. **部分模糊度固定技术**三、伪距单点定位与误差修正1. **多系统多频点修正**2. **接收机钟差与系统间偏差**四、动态模型与周跳处理1.…
阅读更多...
RT-Thread 深入系列 Part 2：RT-Thread 内核核心机制深度剖析

RT-Thread 深入系列 Part 2：RT-Thread 内核核心机制深度剖析

摘要： 本文从线程管理、调度器原理、中断处理与上下文切换、IPC 同步机制、内存管理五大核心模块出发，深入剖析 RT-Thread 内核实现细节，并辅以源码解读、流程图、时序图与性能数据。 目录 线程管理与调度器原理 1.1 线程控制块（TCB）结构 1.2 就绪队列与优先级调度 1.3 时…
阅读更多...
STM32部分：3、STM32CubeMX 工程创建

STM32部分：3、STM32CubeMX 工程创建

飞书文档https://x509p6c8to.feishu.cn/wiki/LfMpwjktZiMAuMkayt6c0LGZnpx 1、打开STM32CUBEMX，选择File->New Project 如果首次使用，可能会自动下载一些依赖包，可以等待下载完成。 2、选择对应芯片 MCU/MPU Selector->输入“STM32F1…
阅读更多...
第十五章，SSL VPN

第十五章，SSL VPN

前言 IPSec 和 SSL 对比 IPSec远程接入场景---client提前安装软件，存在一定的兼容性问题 IPSec协议只能够对感兴趣的流量进行加密保护，意味着接入用户需要不停的调整策略，来适应IPSec隧道 IPSec协议对用户访问权限颗粒度划分的不够详细&…
阅读更多...
深度学习系统学习系列【4】之反向传播（BP)四个基本公式推导

深度学习系统学习系列【4】之反向传播（BP)四个基本公式推导

文章目录 补充知识：∇ 和 ⊙ 运算符详解∇ (nabla) 运算符⊙ (圆圈点) 运算符 反向传播基本公式计算图和基本定义BP1：输出层误差推导BP1公式的重要性实际例子BP2第 l l l层误差推导BP3 ：损失函数关于偏置(b)偏导的推导BP4： 损失函…
阅读更多...
极狐Gitlab 如何创建并使用子群组？

极狐Gitlab 如何创建并使用子群组？

极狐GitLab 是 GitLab 在中国的发行版，关于中文参考文档和资料有： 极狐GitLab 中文文档极狐GitLab 中文论坛极狐GitLab 官网 子群组 (BASIC ALL) 您可以将极狐GitLab 群组组织成子群组。您可以使用子群组： 内部和外部组织分开。因为每个子…
阅读更多...
HarmonyOS基本的应用的配置

HarmonyOS基本的应用的配置

鸿蒙HarmonyOS组建页面 1、创建ets文件并配置2、修改main_pages.json文件3、修改EntryAbility.ets文件（启动时加载的页面） 1、创建ets文件并配置 Index.ets是创建项目自动构建生成的，我们可以将其删除掉，并重新在page文件夹下创建…
阅读更多...
强化学习三大基本方法-DP、MC、TD

强化学习三大基本方法-DP、MC、TD

强化学习进阶 本文主要讲解 动态规划法（Dynamic Programming DP）蒙特卡洛法（Monte Carlo MC）时序差分法（Temporal Difference TD） 1. 动态规划法 1.1 动态规划概念 动态规划核心思想： 其核心…
阅读更多...
《Spring Boot 3.0全新特性详解与实战案例》

《Spring Boot 3.0全新特性详解与实战案例》

大家好呀！今天让我们轻松掌握Spring Boot 3.0的所有新特性！🚀 📌 第一章：Spring Boot 3.0简介 1.1 什么是Spring Boot 3.0？ Spring Boot 3.0就像是Java开发者的"超级工具箱"🧰&…
阅读更多...
【推荐笔记工具】思源笔记 - 隐私优先的个人知识管理系统，支持 Markdown 排版、块级引用和双向链接

【推荐笔记工具】思源笔记 - 隐私优先的个人知识管理系统，支持 Markdown 排版、块级引用和双向链接

Typora 使用Typora好多年了，一直非常的喜欢这个简洁的Markdown编辑工具，低版本的免费且好用。 Typora官网地址： https://typora.io/ https://typoraio.cn/ Typora的文档树如下，细看后，总觉得差点意思! 思源笔记 今…
阅读更多...
虚拟文件系统

虚拟文件系统

虚拟文件系统（Virtual File System，VFS）是操作系统内核中的一个抽象层，它为不同的文件系统（如ext4、NTFS、FAT32等）提供统一的访问接口。通过VFS，用户和应用程序无需关心底层文件系统的具体差异…
阅读更多...
Kubernetes Gateway API 部署详解：从入门到实战

Kubernetes Gateway API 部署详解：从入门到实战

引言 在 Kubernetes 中管理网络流量一直是一个复杂而关键的任务。传统的 Ingress API 虽然广泛使用，但其功能有限且扩展性不足。Kubernetes Gateway API 作为新一代标准，提供了更强大的路由控制能力，支持多协议、跨命名空间路由和细粒度的流量管理。本文将带你从零开始部署…
阅读更多...
关于大数据的基础知识（二）——国内大数据产业链分布结构

关于大数据的基础知识（二）——国内大数据产业链分布结构

成长路上不孤单😊😊😊😊😊😊 【14后😊///计算机爱好者😊///持续分享所学😊///如有需要欢迎收藏转发///😊】 今日分享关于大数据的基础知识（二&a…
阅读更多...
py实现win自动化自动登陆qq

py实现win自动化自动登陆qq

系列文章目录 py实现win自动化自动登陆qq 文章目录 系列文章目录前言一、上代码？总结 前言 之前都是网页自动化感觉太容易了，就来尝尝win自动化，就先写了一个qq登陆的，这个是拿到className 然后进行点击等。 一、上代码&#xf…
阅读更多...
动态创建链表（头插法、尾插法）

动态创建链表（头插法、尾插法）

今天我们来学习动态创建链表！！！ 动态创建链表：分为头插法和尾插法 头插法（动态创建）： 头插法就是让新节点变成头 代码如下 吐血了：这边有个非常重要的知识点，这边第三…
阅读更多...
Dp通用套路(闫式)

Dp通用套路(闫式)

闫式dp分析法： 从集合角度来分析DP问题。 核心思想： DP是一种求有限集中的最值或者个数问题 由于集合中元素的数量都是指数级别的，直接用定义去求，把每种方案都用dfs暴力枚举一遍，时间复杂度很高，此时用…
阅读更多...
33、前台搜索功能怎么实现？

33、前台搜索功能怎么实现？

输入搜索的东西，如果为空 如果有 前端是提交表单，方式是 post 后端接受 调用 mybatisplus的categoryService.getById 用户在搜索框内输入关键字之后，执行 js 中的 load方法，前端提交表单， 后端 controller 中的loa…
阅读更多...
Spring Boot 框架概述

Spring Boot 框架概述

1. 简介 Spring Boot 是由 Pivotal 团队开发的一个用于简化 Spring 应用开发的框架。它通过提供默认配置、嵌入式服务器和自动配置等特性，让开发者能够更快速地构建独立的、生产级别的 Spring 应用。 Spring Boot 的主要特点包括： 快速创建独立的 Spri…
阅读更多...
最新文章

Copyright @ 2022~2023