PyTorch基础笔记

已于 2022-04-06 18:29:20 修改
阅读量1.5k 收藏
点赞数 2
分类专栏： pytorch 文章标签： pytorch python
于 2022-04-06 18:17:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45836123/article/details/123996489
版权

PyTorch

加载数据集&&Dataset类实战

from torch.utils.data import Dataset

torch工具区的dataset区引入抽象类Dataset

所有子类继承他 并需要重写_getitem_ _len_,

class MyData(Dataset):#继承
    def __init__(self,root_dir,label_dir):#初始化
        self.root_dir = root_dir
        self.label_dir = label_dir
        self.path = os.path.join(self.root_dir,self.label_dir)
        self.img_path = os.listdir(self.path)

    def __getitem__(self, idx):#重写 获取每个图片
        img_name = self.img_path[idx]
        img_item_path = os.path.join(self.root_dir,self.label_dir,img_name)
        img = Image.open(img_item_path)
        label = self.label_dir
        return img,label

    def __len__(self):#重写 图片数量
        return len(self.img_path)

引入os的包

  self.path = os.path.join(self.root_dir,self.label_dir)
  self.img_path = os.listdir(self.path)

os.path.join合并目录

os.listdir读取目录 返回一个列表

image-20220107160037203

image-20220107160013774 
from PIL import Image

读取图片的包&&展示图片

image-20220107160138571

image-20220107160152086

类实例化后的数据集可以合并

ants_dataset = MyData(root_dir,ants_label_dir)
bees_dataset = MyData(root_dir,bees_label_dir)
train_dataset= ants_dataset + bees_dataset
print(len(train_dataset))

tensorboard使用

from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter("logs")#实例化这个类 参数代表文件夹名字 文件夹里面是生成的事件

#简单例子 描绘y=5x 
for i in range(100):
    writer.add_scalar("y=5x",5*i,i)#参数： 题目 纵轴值 横轴值
writer.close()

image-20220109192046512

图片可查看很多东西

**http://localhost:6006/**为默认tensorboard网址

image-20220109192756643

后面加 --port=xxxx改端口号（保证与其他服务器不同）

import numpy as np
from PIL import Image
image_path = "datasets/train/ants_image/5650366_e22b7e1065.jpg"
image_path2="datasets/train/bees_image/16838648_415acd9e3f.jpg"
img = Image.open(image_path)
img2 = Image.open(image_path2)
img_array = np.array(img)
img_array2 = np.array(img2)
print(type(img_array))
print(img_array.shape)
writer = SummaryWriter("logs")
writer.add_image("bees",img_array2,1,dataformats='HWC')#add_image支持的图片类型有要求  dataformats保证图片格式与读取相同（高、宽、频道数）
writer.close()

image-20220109193411068

image-20220109193552629

使用同一标题 不同迭代次数的图片显示可滑动查看

常见transforms的使用

from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms
from PIL import Image
import cv2#opencv的包 可以直接以array的形式读取图片

ToTensor

##totensor
img_path = "datasets/train/bees_image/29494643_e3410f0d37.jpg"
img = Image.open(img_path)
tensor = transforms.ToTensor()
tensor_img = tensor(img)
print(tensor_img)

cv_img = cv2.imread(img_path)
print(type(cv_img))#opencv方式读入 转换同上
image-20220110121741841

Normalize

#normalize
trans_norm = transforms.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5])
img_norm = trans_norm(tensor_img)
writer = SummaryWriter("logs")
writer.add_image("tensor_img",tensor_img,1)
writer.add_image("norm_img",img_norm)
image-20220110122002199

初始化带上平均值和标准差（以列表形式） 列表的长度取决于图片的频道数

image-20220110122123325

效果如上 会改变色调

Resize

#resize
trans_resize = transforms.Resize((512,512))
img_resize = trans_resize(img)
img_resize = tensor(img_resize)
writer.add_image("resize",img_resize,0)
img_resize2 = trans_resize(tensor_img)
writer.add_image("resize2",img_resize2,0)

image-20220110122327732

改变图片尺寸 输入可以是PIL类型或直接输入tensor类型

初始化时可以是一个元组（即图片大小） 若只输入int星 可理解为等比缩放

image-20220110122603553

原图-》改变后的

Compose

#resize2  compose
trans_resize2 = transforms.Resize(512)
trans_compose = transforms.Compose([trans_resize2,tensor])
img_resize3 = trans_compose(img)
writer.add_image("compose_resize",img_resize3,1)

image-20220110122747177

初始化以列表形式 列表里元素是transforms类型 （要按照执行顺序输入）

为等比例缩放后的图片 按顺序执行compose里的transform

RandomCrop

#randomcrop随即裁剪
trans_randomcrop = transforms.RandomCrop(50)
trans_compose2 = transforms.Compose([trans_randomcrop,tensor])
for i in range(10):
    img_crop = trans_compose2(img)
    writer.add_image("randomcrop",img_crop,i)
writer.close()

image-20220110123155582

随机裁剪 初始化的参数可以指定裁剪大小 或 int类型默认裁剪大小为（int * int）

image-20220110123326809

一部分 可以拖拽查看十个部分

其余方法 可查看官方文档 获取输入输出信息及格式 按住CTRL进入即可

torchvision中数据集使用

官网找torchvision.datasets

image-20220113143155193

以CIFAR数据集为例

dataset_transform = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor()
]
)
train_set = torchvision.datasets.CIFAR10(root="./datasets_CIFAR10", train=True, transform=dataset_transform, download=True)
test_set = torchvision.datasets.CIFAR10(root="./datasets_CIFAR10", train=False, transform=dataset_transform, download=True)

参数：

  • root设定数据集路径
  • train 设置是否为训练集（反之则为测试集）
  • tranform 采取的一系列transform操作
  • download 是否下载
print(test_set[0])#返回图片和 tag
print(test_set.classes)#每一个测试集图片的标签集合

writer = SummaryWriter("datasets_transform")

for i in range(10):
    img, tag = test_set[i]
    writer.add_image("test_img_resize2", img, i)

writer.close()

image-20220113143933803

dataloader使用

image-20220113144104917 
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

test_set = torchvision.datasets.CIFAR10(root="./datasets_CIFAR10",train=False,transform=torchvision.transforms.ToTensor())
test_loader = DataLoader(dataset=test_set, batch_size=4, shuffle=True, num_workers=0, drop_last=True)

writer = SummaryWriter("dataloader")

for epoch in range(2):
    step = 0
    for data in test_loader:
        imgs, tags = data
        writer.add_images("eopch:{}".format(epoch),imgs, step)
        step=step+1
writer.close()

dataloader参数

  • dataset 选择的数据集
  • batch_size一批选择的数量
  • shuffle 多次选择是否洗牌（打乱顺序）
  • num_workers一般为0 表示线程工作数
  • drop_last 最后一页数量不够时是否取余或全部删除

image-20220113144506417

​ 说明shuffle

image-20220113144744801

​ drop_last对比

神经网络基本骨架nn.moudle

image-20220116165510672

import torch
from torch import nn

class Ssy(nn.Module):
    def __init__(self):
        super(Ssy, self).__init__()

    def forward(self, input):
        output = input * 2 +1
        return output

ssy = Ssy()
x = torch.tensor(341)
output = ssy(x)
print(output)

此处即把输入的tenso类型341 转换为341*2+1输出

即网络内部是（*2+1）的工作

卷积层

卷积层具体原理见机器学习

image-20220116170151741

image-20220116170311739

参数：

  • 输入频道数：一般为3（RGB三通道）
  • 输出频道数
  • 内核大小
  • 步长：一次走几步
  • 填充：默认为0
import torch
import torchvision
from torch import nn
from torch.nn import Conv2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

#下载数据集
test_set = torchvision.datasets.CIFAR10(root="./datasets_CIFAR10",train=False,transform=torchvision.transforms.ToTensor())
#调用dataloader
test_loader = DataLoader(dataset=test_set, batch_size=64, shuffle=True, num_workers=0, drop_last=False)

writer = SummaryWriter("conv2d")

class Ssy(nn.Module):
    def __init__(self):
        super(Ssy, self).__init__()
        #卷积操作 变为6通道 内核大小为3（具体矩阵会自动变化调整）
        self.conv1 = Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)

    def forward(self, x):#神经网络中实现卷积层
        x = self.conv1(x)
        return x

ssy = Ssy()
step=0
for data in test_loader:
    imgs, target = data
    output = ssy(imgs)
    print(imgs.shape)
    print(output.shape)

    writer.add_images("imgs",imgs,step)
#需要把卷积后的图像重新变为3通道 否则不能显示
    output = torch.reshape(output,(-1,3,30,30))
    writer.add_images("imgs_conv2d",output,step)
    step=step+1

writer.close()

image-20220116170814942

由于3通道变为6通道 一页显示了128个图片

池化层

image-20220117214320130

image-20220117214338303

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p1JpfQHS-1649240049324)(https://cdn.jsdelivr.net/gh/girlsdontget341/image@master/img/202201172200524.png)]

参数：

  • 内核大小

  • 步长：默认为内核大小

  • 填充

  • 空洞大小 详见

  • ceilmode：选择是否舍弃

池化原理

image-20220117215439360

image-20220117215518562

即 内核类似卷积操作覆盖输入矩阵上元素 并选出最大的作为输出

与卷积不同的是 池化的步长默认为内核大小

当遇到如上情况 ceil_mode=True即不舍弃残缺的矩阵 从中选择最大的

ceil_mode=False 即舍弃矩阵 内核继续向下移动

image-20220117215834265

import  torch
import torchvision
from torch import nn
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

data = torchvision.datasets.CIFAR10("./datasets_CIFAR10", train=False, transform= torchvision.transforms.ToTensor() )

dataloader= DataLoader(data,batch_size=64 )

matrix_in = torch.tensor([[1, 2, 0, 3, 1],
                          [0, 1, 2, 3, 1],
                          [1, 2, 1, 0, 0],
                          [5, 2, 3, 1, 1],
                          [2, 1, 0, 1, 1]], dtype= torch.float)

input = torch.reshape(matrix_in, (-1,1,5,5))#注意输入的格式
                                            #-1表示模糊 即函数自适应调整大小

writer = SummaryWriter("max_pool")

class Ssy(nn.Module):
    def __init__(self):
        super(Ssy, self).__init__()
        self.maxpool = MaxPool2d(kernel_size=3, ceil_mode=True)

    def forward(self, input):
        output = self.maxpool(input)
        return output

ssy = Ssy()
step = 0
for data in dataloader:
    img, tag = data
    writer.add_images("input", img, step)
    output = ssy(img)
    writer.add_images("output", output,step)
    step = step+1

writer.close()

image-20220117220221068

image-20220117220238106

显而易见，池化后图片变模糊了，神经网络中常用池化层减少输入数据量，保留必要纹理信息，加快训练速度。

非线性激活

ReLU

image-20220119201946145

inplace为true即输出直接替换输入

置为false生成一个新的变量输出

在这里插入图片描述

import  torch
import torchvision
from torch import nn
from torch.nn import ReLU, Sigmoid
from torch.utils.data import DataLoader

input = torch.tensor([[1,-1],
                     [-25,100.2]],dtype=torch.float)

input= torch.reshape(input,(-1,1,2,2))

class Ssy(nn.Module):
    def __init__(self):
        super(Ssy, self).__init__()
        self.relu1 = ReLU()
        #self.sigmoid = Sigmoid()

    def forward(self,input):
        output = self.relu1(input)
        return output

ssy = Ssy()
output = ssy(input)
print(output)

image-20220119202233849

很明显结果与截断函数一致

Sigmoid

在这里插入图片描述

image-20220119202401836

import  torch
import torchvision
from torch import nn
from torch.nn import ReLU, Sigmoid
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

data = torchvision.datasets.CIFAR10("./datasets_CIFAR10", train=False, transform=torchvision.transforms.ToTensor())

dataloader = DataLoader(data, batch_size=64)

class Ssy(nn.Module):
    def __init__(self):
        super(Ssy, self).__init__()
        self.relu1 = ReLU()
        self.sigmoid = Sigmoid()

    def forward(self,input):
        output = self.sigmoid(input)
        return output

ssy = Ssy()

writer = SummaryWriter("sigmoid")

step = 0
for data in dataloader:
    imgs, tags = data
    writer.add_images("imgs",imgs,step)
    imgs_sigmoid = ssy(imgs)
    writer.add_images(("imgs_sigmoid"), imgs_sigmoid,step)
    step =step +1

writer.close()

image-20220119203244227

image-20220119203302536

目的是增加一些非线性特征便于训练

正则化层

image-20220126120301483

image-20220126120346719

image-20220126120500105

（详见官方文档）

Recurrent Layer

多用于文字识别等

详见官方文档

线性层

在这里插入图片描述

image-20220126124124912

目的是把5*5—>1*25—>1*10

import torch
import torchvision
from torch import nn
from torch.nn import Linear
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10(root="../dataset_/datasets_CIFAR10", train=False, transform= torchvision.transforms.ToTensor())

dataloader = DataLoader(dataset,batch_size= 64, drop_last=True)

class SSY(nn.Module):
    def __init__(self):
        super(SSY, self).__init__()
        self.linear1 = Linear(196608, 10)

    def forward(self, input):
        output = self.linear1(input)
        return output

ssy = SSY()

for data in dataloader:
    imgs, tag = data
    print(imgs.shape)
    # imgs = torch.reshape(imgs, (1, 1, 1, -1))
    imgs = torch.flatten(imgs)#flatten即展平 作用与上相同
    print(imgs.shape)
    output = ssy(imgs)
    print(output.shape)

image-20220304112103630

Sequential

image-20220307163649019

有点类似于transforms中的Compose。。

实例

Structure-of-CIFAR10-quick-model.png

网络搭建根据图片顺序（卷积-池化-卷积-池化-卷积-池化-展平-线性层-线性层）

计算卷积层stride与padding大小

  • 根据公式

    image-20220307164323532

  • 经验

    为了保持卷积后大小不会发生变化

    一般来说，在stride为1的情况下，padding等于奇数内核大小 一半的向下取整即（x-1）/2

import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.tensorboard import SummaryWriter

#网络中注释和非注释内容执行效果一致
class SSY(nn.Module):
    def __init__(self):
        super(SSY, self).__init__()
        # self.conv1 = Conv2d(3,32,5,padding=2)
        # self.maxpool1 = MaxPool2d(2)
        # self.conv2 = Conv2d(32,32,5,padding=2)
        # self.maxpool2 = MaxPool2d(2)
        # self.conv3 = Conv2d(32,64,5,padding=2)
        # self.maxpool3 = MaxPool2d(2)
        # self.flatten = Flatten()
        # self.linear1 = Linear(1024,64)
        # self.linear2 = Linear(64,10)
        self.model1 = nn.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.conv1(x)
        # x = self.maxpool1(x)
        # x = self.conv2(x)
        # x = self.maxpool2(x)
        # x = self.conv3(x)
        # x = self.maxpool3(x)
        # x = self.flatten(x)
        # x = self.linear1(x)
        # x = self.linear2(x)
        x = self.model1(x)
        return x

ssy = SSY()
print(ssy)

#一般为了检查网络构建参数是否正确
input = torch.ones((64, 3, 32, 32))
output = ssy(input)
print(output.shape)

writer = SummaryWriter("../tensorboard_dirs/logs_seq")
writer.add_graph(ssy, input)
writer.close()
image-20220307164933023 image-20220307165027508 image-20220307165137299

使用tensorboard可以查看网络搭建具体情况，路线上会显示传输数据的大小

Loss Function

image-20220307230114908 image-20220307230232939 
import torch
from torch import nn

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

# input = torch.reshape(input,(1,1,1,3))
# targets = torch.reshape(targets,(1,1,1,3))

loss = nn.L1Loss()
result = loss(input, targets)

loss_mse = nn.MSELoss()
resu_mse = loss_mse(input, targets)

print(result)##6.5/3
print(resu_mse)#19.25/3

交叉熵

image-20220307231532686

input = torch.tensor([1,3,5], dtype=torch.float32)
loss_cro = nn.CrossEntropyLoss()
print(input.shape)
input2 = torch.reshape(input,(1,3))##直接使用input会报错，input的shape为[3]需要转变为[1,3]
print(input2.shape)
y = torch.tensor([1])
res_cro = loss_cro(input2, y)


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

dataset = torchvision.datasets.CIFAR10("../dataset_/datasets_CIFAR10",train=False,transform=torchvision.transforms.ToTensor(),download=False)

dataloader = DataLoader(dataset,batch_size=1)

class SSY(nn.Module):
    def __init__(self):
        super(SSY, self).__init__()
        self.model1 = nn.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

ssy = SSY()

loss_ = nn.CrossEntropyLoss()

for data in dataloader:
    imgs, tag = data
    output = ssy(imgs)
    res = loss_(output,tag)
    # print(res)
    res.backward()#利用反向传播确定梯度权重 如下图

image-20220307232004242

image-20220307232025394

优化器

优化器

ssy = SSY()

loss_ = nn.CrossEntropyLoss()
optim = torch.optim.SGD(ssy.parameters(), lr=0.01)

for epoch in range(5):
    running_loss = 0.00
    for data in dataloader:
        imgs, tag = data
        output = ssy(imgs)
        res = loss_(output,tag)
        # print(res)
        optim.zero_grad()#梯度置0
        res.backward()#反向传播确定梯度参数
        optim.step()#更新参数（优化）
        running_loss += res
    print(running_loss)
YのRegistro
关注
专栏目录
Pytorch Dataset类的使用（个人学习笔记）
weixin_46355597的博客
03-03 6955
dataset类个人学习笔记
深度学习（PyTorch）——torchvision中的数据集使用方法
qq_42233059的博客
09-01 1347
深度学习（PyTorch）——torchvision中的数据集使用方法
PyTorch深度学习笔记（十）torchvision中的数据集使用
浅汐入梦的博客
02-16 835
课程学习笔记
torch.nn.MaxPool2d详解
热门推荐
Medlen
11-22 8万+
注意：这里展示的是本篇博文写时的版本最新的实现，但是后续会代码可能会迭代更新，建议对照官方文档进行学习。 先来看源码： # 这个类是是许多池化类的基类，这里有必要了解一下 class _MaxPoolNd(Module): __constants__ = ['kernel_size', 'stride', 'padding', 'dilation', 'return_indices', 'ceil_mode'] return_indices: boo
花书-卷积神经网络
qq_31244453的博客
04-21 649
知识框架 卷积 池化（引入了平移不变性，） 全局连接层（多层感知机） 卷积神经网络 应用(分类上) 图像分类大赛(ResNEt网络比人类识别图像的性能还要好，深度也越来越深) 各大CNN模型 重难点 参考资料：(CNN祖爷爷-LeNet,ResNet) 本章的目的是说明卷积网络提供的各种工具。 9卷积网络 9.1卷积运算 卷积神经网络，是一种用来处理具有类似网络结构的数据的神经网络。例如时间序列(认为是在时间轴上有规律地采样形成的一维
python-pytorch基础笔记
随笔
07-19 96
python-pytorch基础笔记
【pytorch基础笔记四】基于DCGAN人脸图片生成
Fred's Note
07-19 1857
【参考资料】 【1】https://pytorch.org/tutorials/beginner/dcgan_faces_tutorial.html 【2】https://pytorch-cn.readthedocs.io/zh/latest/ DCGAN与基础GAN框架完全一致，只是将生成器和判别器换成了卷积网络。采用文献1数据集，结果如下：上图为原始真实图片，下图为生成图片 - 训练环境为带GPU的笔记本，训练时间约4小时 Epoch[18/999] import numpy as np impor
pytorch学习笔记
欢迎来到我的学习笔记薄
10-11 785
PyTorch 是一个流行的深度学习框架，具有动态计算图的特性，广泛应用于研究和生产环境。它的灵活性、简单的接口和与 Python 的深度集成使其成为构建机器学习模型的理想工具。PyTorch 是一个灵活、强大的深度学习框架，广泛应用于研究和实际生产中。它提供了动态计算图、GPU 加速、易用的 API 和丰富的社区资源，适合从初学者到专家的各种需求。通过 PyTorch，你可以轻松构建、训练和优化各种复杂的神经网络模型。
pytorch自学笔记
qq_41597915的博客
03-31 4139
这本笔记是关于pytorch的全面学习资料，基本包括了pytorch使用的方方面面。并且在几乎每一个重要的使用场景都给出了代码示例。现把它记录在此，可以作为我的pytorch的使用手册。
pytorch基础学习笔记
03-13
### PyTorch基础学习笔记 #### 一、PyTorch简介及安装 ##### 1.1 PyTorch简介 PyTorch是由Facebook的人工智能研究实验室（FAIR）开发的一款开源机器学习库，专为利用GPU加速张量计算和深度学习而设计。PyTorch的...
笔记pytorch学习笔记
07-20
【PyTorch学习笔记概述】 PyTorch是Facebook开源的一款深度学习框架，它以其灵活性、易用性和强大的计算能力在学术界和工业界都受到了广泛的欢迎。本笔记将基于B站牛二大人的讲解，深入探讨PyTorch的核心概念、基本...
pytorch 学习笔记 part8 卷积神经网络基础
01-20
卷积层的实现 主要参数： 1.in_channels (python:int) – Number of channels in the input imag 2.out_channels (python:int) – Number of channels produced by the convolution 3.kernel_size (python:int or ...
PyTorch学习笔记-1.PyTorch基础概念
ruoqi23的博客
08-02 900
1.PyTorch基础概念 1.1.PyTorch简介与安装 1.1.1.PyTorch简介 2017年1月，FAIR（Facebook AI Research）发布PyTorch PyTorch是在Torch基础上用python语言重新打造的一款深度学习框架 Torch是采用Lua语言为接口的机器学习框架，但因Lua语言较为小众，导致Torch知名度不高 PyTorch发展 • 2017年1月正式发布PyTorch • 2018年4月更新0.4.0版，支持W indows系统，ca..
PyTorch学习笔记（四）：PyTorch基础实战
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
03-18 8744
本章以PyTorch基础实战为主，以FashionMNIST时装分类为例进行深度学习训练 往期学习资料推荐： 1.Pytorch实战笔记_GoAI的博客-CSDN博客 2.Pytorch入门教程_GoAI的博客-CSDN博客 本系列目录： PyTorch学习笔记（一）：简介与基础知识_GoAI的博客-CSDN博客 PyTorch学习笔记（二）：PyTorch主要组成模块_GoAI的博客-CSDN博客
线性层（全连接层）pytorch
2302_79795489的博客
10-14 572
通常，线性层后面会接一个非线性激活函数。这样，网络先做一次简单的转换（线性），然后用激活函数（非线性）添加一些复杂性。（即 output = activation(linear(input)) ）2、在实践中，两者常常被视作同义词。FalseTrue（默认True，自动学习并添加偏置参数）这里，input_tensor形状为（3，4），意味着有3个样本（batch_size），每个样本有4个特征（输入张量的每一列通常代表一个特征）
【pytorch深度学习】CIFAR10图像分类
qq_42761751的博客
10-14 253
通过简单的自定义神经网络，实现CIFAR10数据集图像分类任务。
梯度下降算法优化—随机梯度下降、小批次、动量、Adagrad等方法pytorch实现
最新发布
写代码的小阿帆的博客
10-17 460
本文介绍了几种梯度下降优化算法，包括其原理和代码实现，但并不一定说最好的算法就一定产生最好的结果，每种算法都有其适应的领域，在实际中还是要具体问题具体分析。
Pytorch nn.Module register_buffer
qq_36396406的博客
10-14 217
方法可以用来将张量注册为模型的缓冲区（buffer），它们不会作为模型的可训练参数参与反向传播，但会跟随模型一起移动到相应的设备，如 CPU 或 GPU。这通常用于存储模型中的状态信息，如均值、方差、或某些需要保留但不更新的中间结果。以下是一个简单的例子，说明如何使用。
更改huggingface和pytorch的断点的默认下载位置
weixin_44151034的博客
10-11 508
读入了，也能避免默认下载到系统盘但。更改了默认下载位置，我们就。同样和上面类似，这里只举出。
龙良曲pytorch学习笔记
05-12
龙良曲是一位深度学习爱好者和资深程序员，他在学习深度学习和PyTorch的过程中整理了一系列的学习笔记，被称为“龙良曲PyTorch学习笔记”。这个学习笔记包含了从基础的张量操作到深度学习模型的实现等内容，适合初学者和进阶者阅读。其中，每个知识点都有详细的代码示例和解释，方便读者理解。 如果你想更深入地了解PyTorch和深度学习，可以参考龙良曲的学习笔记。同时，他还有许多深度学习相关的博客和视频教程，也可以在网上找到。如果你有任何相关问题，可以随时向我提问哦！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值