Pytorch入门学习笔记（四）

tryflyhigh tryflyhigh 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 800+累计阅读 815平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄3年
关注
原创 最新推荐文章于 2026-04-21 04:35:05 发布 815 阅读 AI 写同款· GEO 优化 ›
Pytorch学习笔记（一）——pytorch环境搭建配置 目录前言与前期准备一、Anaconda的安装1.1.Anaconda介绍1.2.Anaconda的下载安装1.3.Anaconda的配置下载源1.4.Anaconda的如何切换不同版本的pytorch（以cpu和gpu版本之间切换为例）二、Pytorch的安装2.1.Pytorch介绍2.2.Anaconda的下在线安装Pytorch2.3.Anaconda的下在线、离线混合安装Pytorch三、CUDA3.1.CUDA介绍3.2.CUDA版本的选择3.3.CUDA的安装3.4.CUDA版本安装错误怎么卸载 阅读详情

本文结合小土堆的教学视频PyTorch深度学习快速入门教程进行学习

一、损失函数 Loss Functions 与反向传播 backward

功能实现：用来计算模型实际输出的真实值和目标预测值之间的差距，损失函数越小，模型的鲁棒性越好；为我们更新输出提供一定的依据（反向传播），在进行反向传播时每一个节点都会求出一个对应的梯度 grad，模型将根据 grad 对各个参数进行优化，从而降低真实值和预测值之间的损失值

1. torch.nn.L1Loss

计算公式：l(x,y)=L={\{l_1,\cdots,l_N\}}^T , l_n=|x_n-y_n|，其中 N 表示 batch_size

l(x,y)=\begin{cases} mean(L),\ \ if\ reduction='mean' \\ sum(L), \ \ \ \ if\ reduction='sum' \end{cases}

reduction 的默认值为 mean，即求对应的 input 和 target 之差的绝对值之和再取平均

具体代码实现如下（reduction 取默认值 mean）

import torch
from torch.nn import L1Loss

inputs = torch.tensor([1,2,3],dtype=torch.float32)
targets = torch.tensor([1,2,5],dtype=torch.float32)

inputs = torch.reshape(inputs,(1,1,1,3))
targets = torch.reshape(targets,(1,1,1,3))

# L1Loss类
loss = L1Loss()
result = loss(inputs,targets)

print(result)

程序运行结果为  tensor(0.6667) 

具体代码实现如下（reduction 取 sum）

import torch
from torch.nn import L1Loss
inputs = torch.tensor([1,2,3],dtype=torch.float32)
targets = torch.tensor([1,2,5],dtype=torch.float32)

inputs = torch.reshape(inputs,(1,1,1,3))
targets = torch.reshape(targets,(1,1,1,3))

# L1Loss类
loss = L1Loss(reduction='sum')
result = loss(inputs,targets)

print(result)

程序运行结果为  tensor(2.) 

2. torch.nn.MSELoss

计算公式：l(x,y)=L={\{l_1,\cdots,l_N\}}^T , l_n={(x_n-y_n)}^2，其中 N 表示 batch_size

l(x,y)=\begin{cases} mean(L),\ \ if\ reduction='mean' \\ sum(L), \ \ \ \ if\ reduction='sum' \end{cases}

reduction 的默认值为 mean，即求对应的 input 和 target 之差的平方之和再取平均

具体代码实现如下（reduction 取默认值 mean）

import torch
from torch.nn import MSELoss
inputs = torch.tensor([1,2,3],dtype=torch.float32)
targets = torch.tensor([1,2,5],dtype=torch.float32)

inputs = torch.reshape(inputs,(1,1,1,3))
targets = torch.reshape(targets,(1,1,1,3))

# MSELoss类
loss_mse = MSELoss()
result_mse = loss_mse(inputs,targets)

print(result_mse)

程序运行结果为  tensor(1.3333) 

3. torch.nn.CrossEntropyLoss

计算公式：l(x,y)=L={\{l_1,\cdots,l_N\}}^T  ,  l_n=-w_{y_{n}}log{\frac{exp(x_n,y_n)}{\sum_{C=1}^{C}exp(x_n,C)}}\cdot1\{y_n\neq ignore_index\}

其中 x 是 input，y 是 target，w 是权重，C 是种类的数量

具体代码实现如下（reduction 取默认值 mean）

import torch
from torch.nn import CrossEntropyLoss

x = torch.tensor([0.1,0.2,0.3])
y = torch.tensor([1])
x = torch.reshape(x,(1,3))

loss_cross = CrossEntropyLoss()
result_cross = loss_cross(x,y)
print(result_cross)

程序运行结果为  tensor(1.1019)

二、优化器

功能实现：调整模型的权重和偏置，以最小化损失函数，提高模型准确性

具体代码实现如下（结合CIFAR10）

import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

# 加载数据集
dataset = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
dataloader = DataLoader(dataset,batch_size=64)

# 定义网络模型
class Model(nn.Module):
    def __init__(self) -> None:
        super(Model,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

model = Model()
loss = nn.CrossEntropyLoss()    #定义损失函数
optim = torch.optim.SGD(model.parameters(),lr=0.01)    # 定义SGD优化器
for epoch in range(5):
    running_loss = 0.0
    for data in dataloader:
        imgs,targets = data
        outputs = model(imgs)
        result_loss = loss(outputs,targets)
        optim.zero_grad()   # 将参数梯度清0
        result_loss.backward()   # 反向传播
        optim.step()    # 对模型参数进行调优
        running_loss +=result_loss
    print(running_loss)    # 打印每一轮的损失值之和

程序运行结果如下，可以看到每一轮的损失值之和都在减小

Files already downloaded and verified
tensor(360.8781, grad_fn=<AddBackward0>)
tensor(358.0172, grad_fn=<AddBackward0>)
tensor(348.5996, grad_fn=<AddBackward0>)
tensor(327.8814, grad_fn=<AddBackward0>)
tensor(314.3346, grad_fn=<AddBackward0>)

三、现有网络模型的使用及修改

通过对VGG16神经网络模型的使用及其修改来实现

具体代码实现如下

import torchvision
from torch import nn

# 使用VGG16网络模型
vgg16_false = torchvision.models.vgg16(pretrained=False)    # 参数未经过训练
vgg16_true = torchvision.models.vgg16(pretrained=True)      # 参数经过预训练

# 在现有的网络模型中添加结构
print(vgg16_true)
vgg16_true.classifier.add_module('add_linear',nn.Linear(1000,10))   # 将输出的1000转化为输出10
print(vgg16_true)

# 在现有的网络模型中修改结构
print(vgg16_false)
vgg16_false.classifier[6] = nn.Linear(4096,10)  # 直接将输出改为10
print(vgg16_false)

程序运行结果如下

参数经过预训练的VGG16网络模型，结构未经过添加或修改，显示如下

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)

参数经过预训练的VGG16网络模型，结构经过添加，显示如下

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
    (add_linear): Linear(in_features=1000, out_features=10, bias=True)
  )
)

参数未经过训练的VGG16网络模型，结构未经过添加或修改，显示如下

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)

参数未经过训练的VGG16网络模型，结构经过修改，显示如下

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=10, bias=True)
  )
)

四、网络模型的保存与读取

两种方式下的保存与加载，具体代码实现如下

# 在model_save.py文件下
import torchvision
import torch

vgg16 = torchvision.models.vgg16(pretrained=False)    # 加载网络模型

# 保存方式1，直接保存网络模型结构+模型参数
torch.save(vgg16,"vgg16_method1.pth")

# 保存方式2，保存网络模型中的模型参数（字典格式），官方推荐，文件所占内存较小
torch.save(vgg16.state_dict(),"vgg16_method2.pth")
# 在model_loader.py文件下
import torch
import torchvision

# 加载方式1(->保存方式1)
model1 = torch.load("vgg16_method1.pth")
print(model1)

# 加载方式2(->保存方式2)
model2 = torch.load("vgg16_method2.pth")    # 此时为字典模式
print(model2)
# 恢复成网络模型
vgg16 = torchvision.models.vgg16(pretrained=False)
vgg16.load_state_dict(torch.load("vgg16_method2.pth"))
print(vgg16)

方式1情况下可能会出现的陷阱，具体代码实现如下

# 在model_save.py文件下
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d

# 陷阱
# 自定义网络模型
class Model(nn.Module):
    def __init__(self) -> None:
        super(Model,self).__init__()
        self.conv1 = Conv2d(3,32,3,padding=2)
        self.maxpool1 = MaxPool2d(2)

    # 前向传播
    def forward(self,x):
        x = self.model1(x)
        return x

model = Model()
torch.save(model,"model_method1.pth")
# 在model_loader.py文件下
import torch

# 陷阱
model3 = torch.load("model_method1.pth")
print(model3)

运行程序后出现了报错：  AttributeError: Can't get attribute 'Model' on <module '__main__' from 'd:/pytorch_train/model_loader.py'> ，解决该报错的方法是使得程序能够访问到要加载的自定义模型，具体代码如下

import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d

# 解决陷阱->使得程序能够访问到自定义的模型

# 方法1：直接import保存的文件
from model_save import *

# 方法2：将要加载的模型复制到当前文件下
class Model(nn.Module):
    def __init__(self) -> None:
        super(Model,self).__init__()
        self.conv1 = Conv2d(3,32,3,padding=2)
        self.maxpool1 = MaxPool2d(2)

    # 前向传播
    def forward(self,x):
        x = self.model1(x)
        return x

model3 = torch.load("model_method1.pth")
print(model3)

最终程序均能正常运行，运行结果显示如下

Model(
  (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2))
  (maxpool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
标签
#pytorch #学习 #笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
Pytorch入门学习笔记 定义两层卷积层 + 三层全连接层的神经网络： class Net(nn.Module): def __init__(self): # 定义神经网络结构 super(Net, self).__init__() # 第一层（卷积层） self.conv1 = nn.Conv2d(1,6,3) # 输入频道1，输出频道6，卷积大小3*3 ... 阅读详情

相关推荐

龙良曲pytorch基础课程学习笔记

什么是Pytorch? PyTorch 是一个基于 Python 的科学计算包，主要定位两类人群： NumPy 的替代品，可以利用 GPU 的性能进行计算 深度学习研究平台拥有足够的灵活性和速度 开始学习 tensor对象 在 TensorFlow 中，数据不是以整数，浮点数或者字符串形式存在的，而是被封装在一个叫做 tensor 的对象中。Tensor是张量的意思，张量包含了0到任意维度的量...

kexiaoleqq的博客 4047

PyTorch学习笔记6—PyTorch深度学习入门（四）—入门实例

PyTorch学习笔记6—PyTorch深度学习入门（四）—入门实例

北街末雨Yyg 815

Pytorch入门教程

Pytorch学习总结:1.张量Tensor 张量是一种特殊的数据结构，与数组和矩阵非常相似。在PyTorch中，我们使用张量对模型的输入和输出以及模型的参数进行编码。 张量类似于NumPy的ndarray，除了张量可以在 GPU 或其他硬件加速器上运行。事实上，张量和NumPy数组通常可以共享相同的底层内存，从而无需复制数据。...

专注大数据与人工智能技术分享，欢迎私信加群互相学习！ 4万+

人工智能入门学习笔记（四）(PyTorch)

人工智能入门学习笔记（四）项目：Purdue University BME595课程作业Homework04——Neural Networks - MNIST代码、输出结果、结果分析图代码结果输出：结果分析图：知识框架原理概述损失函数MSE(Mean Square Error) 均方误差CE(Cross Entropy) 交叉熵信息量熵相对熵（KL散度）交叉熵Back-PropagationGradient Descent程序详解前向传播反向传播总结 项目：Purdue University BME595课

m0_47302432的博客 535

Pytorch学习笔记总结

PyTorch学习笔记整理，内容参考多个多个优秀Pytorch学习资源，适合深度学习pytorch学习者学习。(开篇词)PyTorch 学习笔记 - PyTorch 学习笔记；动手学CV-Pytorch:动手学CV-Pytorch；Pytorch 中文文档：主页 - PyTorch中文文档；Pytorch Tutorials...

专注大数据与人工智能技术分享，欢迎私信加群互相学习！ 8751

PyTorch学习笔记（四）：PyTorch基础实战

本章以PyTorch基础实战为主，以FashionMNIST时装分类为例进行深度学习训练 往期学习资料推荐： 1.Pytorch实战笔记_GoAI的博客-优快云博客 2.Pytorch入门教程_GoAI的博客-优快云博客 本系列目录： PyTorch学习笔记（一）：简介与基础知识_GoAI的博客-优快云博客 PyTorch学习笔记（二）：PyTorch主要组成模块_GoAI的博客-优快云博客

专注大数据与人工智能技术分享，欢迎私信加群互相学习！ 9018

Pytorch学习笔记（四）-——《深度学习入门之pytorch》

图像增强的方法

越努力，越幸运 242

SSD盘符漂移导致OSD down场景模拟与恢复

运维团队反馈一个问题，现象是：某个OSD对应的cache分区发生了变化，比如原来cache使用的分区是/dev/sde,后来还是这块盘，但分区信息不知何故，变成了/dev/sdf（产品OSD设备并不是根据分区名称来map，而是根据partlabel），最终的现象是这个OSD down了，没法启动.接到这个现象的反馈后，记录一下这个问题在lab的复现方法。

Gavin Blog 938

Pytorch入门教程学习笔记（四）模型构造、参数访问初始化共享

目录4.1 模型构造4.1.1 继承Module构造模型4.1.2 Module子类4.1.2.1 Sequential4.1.2.2 ModuleList4.1.2.3 ModuleDict4.1.3 试着构建复杂模型4.2 模型参数相关4.2.1 访问参数4.2.2 初始化模型参数4.2.3 自定义初始化方法4.2.4 共享参数说明 4.1 模型构造 4.1.1 继承Module构造模型 Module类是nn模块里提供的一个模型构造类，是所有神经网络模块的基类，可以继承它来自定义模型。继承Module类

Younguys 521

CANOCO5.0实现冗余分析（RDA）最详细步骤

在地理及生态领域会常使用RDA分析，RDA的实现路径也有很多，今天介绍一下CANOCO软件的实现方法。1.不同样点和环境因子之间夹角是锐角 是正相关，是钝角是负相关。2.夹角越大 说明相关性较小，夹角越小，相关性越大。得有不同的物种或者样点数值，再加上环境因子数据。3.箭头越长 相关性越大。时间调整到2010年。

Along6的博客 1万+

VirtualBox 7.0.8 + Android-x86 9.0 保姆级安装教程（附图形界面卡顿解决方案）

本文提供VirtualBox 7.0.8与Android-x86 9.0的详细安装教程及性能优化方案，帮助开发者解决图形界面卡顿问题。从环境准备到高级配置，涵盖硬件要求、安装步骤、显存优化及ADB调试等实用技巧，显著提升虚拟机流畅度，适用于应用测试和开发调试。

weixin_29224309的博客 524

我在B站读大学-【小土堆】PyTorch深度学习快速入门教程学习笔记(四)

小土堆视频教程30-32笔记 这就是我记录的本系列视频的最后一个笔记了~ Pytorch入门选手的学习笔记 (序号与视频序号完全对应), 本文尽可能的在详细记录了自己的学习内容, 包括但不限于(加了详细注释的代码, 截图并补充了说明的插图, UP讲课时的关键内容),因为自己学习过程中看其他博主的笔记, 有所收获,. 希望我的笔记也可以帮助一起学习的小伙伴, 加油哇~

qq_41642036的博客 961

利用ArcGIS的模型构建器实现批量投影栅格和批量克里金插值

博主要批量投影几百个栅格，但是ArcGIS中的投影栅格的批处理工具需要手动一条条设置参数，还是麻烦，因此学习了使用模型构建器（ModelBuilder）来批量投影栅格，可以导入需投影栅格的文件夹，然后迭代投影，并按栅格原名逐个输出到指定目录。 1.在工具箱里构建模型 在arctool box里右键点击空白处，选择【添加工具箱】，点击ArcGIS默认工作目录的工具箱进行添加，然后Toolbox就会被添加到ArcToolbox页面，右键点击Toolbox，选择“新建”-“模型” 2.编写模型 （1）.

qq_36958801的博客 1万+

Pytorch入门教程学习笔记（四）自定义模型、模型读取和存储、GPU计算

目录4.4 自定义Layer4.4.1 不含参数的自定义4.4.2 含参数的自定义层4.5读取和存储4.5.1 读写Tensor4.5.2 读写Model4.5.2.1 state_dict4.5.2.2 保存和加载模型4.6 GPU计算4.6.1 计算设备4.6.2 Tensor的GPU计算4.6.3 Model的GPU计算说明 4.4 自定义Layer 本节将介绍如何使用Module来自定义层，从而可以被重复调用。 4.4.1 不含参数的自定义 自定义的CenteredLayer类通过继承Module类

Younguys 734

从SFF-8087到SFF-8643：详解服务器硬盘背板连接线缆的演变与实战接线

本文深度解析了服务器硬盘背板连接技术从SFF-8087到SFF-8643的演进历程，重点介绍了SAS、SATA和U.2接口的技术特点与实战接线方案。通过对比不同连接器标准的物理特性和电气规范，提供了混合环境下的线缆选择策略和常见故障排查指南，帮助IT专业人员优化存储系统性能与稳定性。

weixin_30603633的博客 276

Qwen2.5-Omni实战：5分钟搞定多模态AI模型本地部署（含Thinker-Talker架构解析）

本文详细介绍了Qwen2.5-Omni多模态AI模型的本地部署流程，包括硬件配置、环境准备和实战应用开发。特别解析了其创新的Thinker-Talker架构，该架构通过TMRoPE位置编码实现跨模态同步处理，大幅提升多模态任务效率。5分钟即可完成部署，适合开发者快速实现文本、图像和音频的联合处理。

weixin_29085865的博客 171

小土堆pytorch深度学习快速入门教程学习笔记（四）-transforms代码（一）

【代码】小土堆pytorch深度学习快速入门教程学习笔记（四）-transforms代码（一）

weixin_53885721的博客 182

5、AIX系统硬件管理与故障诊断全解析

本文全面解析了AIX系统的硬件管理与故障诊断方法，涵盖系统管理服务（SMS）的使用、设备兼容性配置、设备配置数据库结构、常用命令如cfgmgr、lsattr、smitty devices的操作详解，并深入介绍了错误日志管理机制，包括errdemon、errpt、errlogger等命令的应用。通过实际案例分析和流程图展示，帮助系统管理员掌握从问题怀疑到诊断执行再到日志清理的完整流程，同时提供注意事项与最佳实践，助力AIX系统的稳定运行与高效维护。

y2z3a4b5c的博客 62

【Pytorch入门】小土堆PyTorch入门教程完整学习笔记（详细笔记并附练习代码 ipynb文件）

【Pytorch入门】小土堆PyTorch入门教程完整学习笔记（详细笔记 文末附练习代码 ipynb文件）

几度热忱的博客 3万+

企业第三方应用开发概述_测试第三方应用对接企业_以及如何使用流程_Demo演示---企业微信开发002

那么第三方公司开发了应用,做为服务提供商,如果,一个企业想使用这个应用,我开发的这个应用的话,那么。其实就是给我们的应用,安装一个,使用他的企业,分配一共企业 允许这个企业使用我们的应用的功能,可以看到其实就是多了运营规范,因为,第三方应用,其实就相当于,是第三方公司开发的,程序,首先来看一下。然后再来看,这里我们选择这个公司,其实可以,选择到具体的,部门,或者是。然后我们使用一个企业的管理员账号进行,扫码,来授权,这个应用,可以。其实就是指定,我这个企业中,哪个部门,或者哪些员工,可以使用。

添柴程序猿的专栏 412

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章，有部分习题没有答案，全英文复分析阿尔福斯(Ahlfors) 第三版答案

PyTorch 入门学习笔记

PyTorch 简介、安装、语法、基本概念等。

Cappuccino0001的博客 2421

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件，这是C++版本的破解文件

pytorch基础入门教程/一小时学会pytorch

Pytorch一小时教程 pytorch是什么 它是一个基于python的科学计算库，致力于为两类用户提供服务： 一些想要找到Numpy搭建神经网络替代品的用户； 寻找一个可提供极强的可拓展性和运行速度的深度学习研究平台； 让我们开始干活吧！ 1. 张量的概念和生成     张量和Numpy中ndarrays的概念很相似，有了这个作为基础，张量也可以被运行在GPU上来加速计算，下面介绍如何创...

weixin_41070748的博客 8万+

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表，创建专业级图表以简化复杂的信息。

PyTorch 学习笔记（四）：权值初始化的十种方法

本文截取自一个github上千星的火爆教程——《PyTorch 模型训练实用教程》，教程内容主要为在 PyTorch 中训练一个模型所可能涉及到的方法及函数的详解等，本文为作者整理的学习笔记（四），pytorch在torch.nn.init中提供了常用的初始化方法函数，这里简单介绍，方便查询使用。后续会继续更新这个系列，欢迎关注。 项目代码：https://github.com/tensor-y...

公众号/知乎: AI算法札记，欢迎关注交流 3758

Pytorch 入门

我们首先定义一个Pytorch实现的神经网络#导入若干工具包importtorchimporttorch.nnasnnimporttorch.nn.functionalasF#定义一个简单的网络类classNet(nn.Module)模型中所有的可训练参数,可以通过net.parameters()来获得.假设图像的输入尺寸为32*32input=torch.randn(1,1,32,32)#4个维度依次为注意维度。...

mengxianglong123的博客 1万+

Pytorch入门实战学习笔记

Pytorch入门实战学习笔记 去发现同类优质开源项目:https://gitcode.com/ 这是一份基于b站pyTorch深度学习快速入门教程的学习笔记，旨在帮助初学者快速掌握Pytorch框架的使用。本笔记整理了教程中的关键知识点和代码实践，适合想要入门Pytorch的朋友学习和参考。 本资源包含以下内容： Pytorch基础概念介绍 常用函数与模块解析 实战案例分析与代码实现 在学习...

gitblog_06711的博客 265
上一篇： Pytorch入门学习笔记（三）—— 神经网络
下一篇： Pytorch入门学习笔记（五）
点赞 5
评论 0
书签 书签 6
tryflyhigh
tryflyhigh
博客等级 码龄3年 136粉丝 7原创
+ 关注
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值