Pytorch学习整理笔记（一）

最新推荐文章于 2024-06-02 23:52:21 发布
最新推荐文章于 2024-06-02 23:52:21 发布
阅读量472 收藏 1
点赞数
分类专栏： pytorch 文章标签： pytorch python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43466788/article/details/132795931
版权

文章目录

数据处理Dataset

主要是对Dataset的使用：

  1. 继承 Dataset
  2. 实现init方法，主要是进行一些全局变量的定义，在对其初始化时需要赋值。
  3. 实现getitem方法，获取每个数据
  4. 实现len方法，获取数据size
from torch.utils.data import Dataset
from PIL import Image
import os


class MyData(Dataset):  # 继承 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.imge_path = os.listdir(self.path)  # 返回这个文件目录下所有文件名--list数组

    def __getitem__(self, index):  # 获取每一个图片
        img_name = self.imge_path[index]
        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.imge_path)


root_dir = "dataset/train"
ants_label_dir = "ants_image"
bees_label_dir = "bees_image"
ants_dataset = MyData(root_dir, ants_label_dir)
bees_dataset = MyData(root_dir, bees_label_dir)

train_dataset = ants_dataset + bees_dataset  # 可以直接用+整合两个数据集

img, label = train_dataset[0]  # 获取数据

Tensorboard使用

TensorBoard 是Google开发的一个机器学习可视化工具。其主要用于记录机器学习过程，例如：

  1. 记录损失变化、准确率变化等
  2. 记录图片变化、语音变化、文本变化等，例如在做GAN时，可以过一段时间记录一张生成的图片
  3. 绘制模型

主要是add_scalar和add_image的使用：

  1. 下载Tensorboard：pip install tensorboard
    在这里插入图片描述

  2. 运行检测一些有没有出错：tensorboard --logdir=logs --port=6007
    在这里插入图片描述如果报错例如：
    在这里插入图片描述

  3. add_scalar方法：记录损失变化、准确率变化。

  4. add_image方法：记录图形变化等。需要注意这个方法里面的参数是要求Tensor，ndarray等，并不是图片，需要进行转换。
    在这里插入图片描述转换成ndarray：
    在这里插入图片描述但是这个numpy数据的通道数是在最后，（高，宽，通道），而我们这是方法默认是（通道，高，宽），所以需要修改一下，具体参考下面代码。
    在这里插入图片描述

  5. 最后记得关闭close()

#   tensorboard ： loss函数的生成

from torch.utils.tensorboard import SummaryWriter
import numpy as np
from PIL import Image

writer = SummaryWriter("logs")  # 事件文件存储在logs下面
image_path = "dataset/train/bees_image/16838648_415acd9e3f.jpg"
img_PIL = Image.open(image_path)
img_array = np.array(img_PIL)

writer.add_image("test", img_array, 1, dataformats='HWC')  # 默认是通道在前，如果不是则需要dataformats进行设置，改变step进行图像变化

# x：scalar_value y: global_step tag: 标题
for i in range(100):
    writer.add_scalar("y=2*x", 2*i, i)


writer.close()

Transforms

可以将transforms理解为一个工具箱：图像预处理方法
例如方法：ToTensor可以将PIL Image or numpy.ndarray这些类型转化为tensor对象，方便后期使用。

import cv2
from PIL import Image
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms


# python的用法-》tensor数据类型
# 通过transforms.ToTensor去看两个问题 :pic (PIL Image or numpy.ndarray): Image to be converted to tensor.
# 1、transforms该如何使用(python)
# 2、为什么我们需要Tensor数据类型

# 创键一个PIL对象
img_path = "dataset/train/ants_image/0013035.jpg"
img = Image.open(img_path)

writer = SummaryWriter("logs")

#  将PIL对象转换为tensor
tensor_trans = transforms.ToTensor()
tensor_img = tensor_trans(img)

writer.add_image("Tensor_img", tensor_img)

# 创建一个numpy.ndarray对象
img_path2 = "dataset/train/ants_image/36439863_0bec9f554f.jpg"
cv_img = cv2.imread(img_path2)
#  将numpy.ndarray对象转换为tensor
tensor_img2 = tensor_trans(cv_img)

writer.add_image("Tensor_img", tensor_img2, 2)

writer.close()

其他一些常用的：缩放，裁剪，归一等

from PIL import Image
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms

writer = SummaryWriter("logs")

#  ToTensor
img = Image.open("dataset/train/ants_image/6743948_2b8c096dda.jpg")

trans_totensor = transforms.ToTensor()
img_tenser = trans_totensor(img)
writer.add_image("ToTensor", img_tenser)

#  Normalize  标准化
trans_norm = transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])  # 均值 标准差 图片是3个
img_norm = trans_norm(img_tenser)
#  output[channel] = (input[channel] - mean[channel]) / std[channel]
#  (input-0.5)/0.5 = 2*input - 1
#  if input[0,1] => output[-1,1]
writer.add_image("Normalize", img_norm)

# Resize
trans_resize = transforms.Resize((512, 512))  # 把size 修改为512x512
img_resize = trans_resize(img)  # 直接传PIL对象，返回的还是修改了size的PIL对象
img_resize = trans_totensor(img_resize)  # 将PIL对象转换为tensor
writer.add_image("Resize", img_resize)

# Compose - resize -2 第二种改变size的方式
trans_compose = transforms.Compose([transforms.Resize((32, 32)),  # 缩放
                                    transforms.ToTensor()  # 图片转张量，同时归一化操作，0-255=》0-1
                                    ])
img_resize_2 = trans_compose(img)
writer.add_image("Resize2", img_resize_2, 1)

# RandomCrop 随机裁剪
trans_compose_2 = transforms.Compose([transforms.RandomCrop(32, padding=4),  # 随机裁剪
                                      transforms.ToTensor()  # 图片转张量，同时归一化操作，0-255=》0-1])
                                      ])
for i in range(10):
    img_crop = trans_compose_2(img)
    writer.add_image("Random-crop", img_crop, i)

writer.close()

torchvision数据集使用

  1. CIFAR10数据集：相关介绍：https://www.cs.toronto.edu/~kriz/cifar.html
  2. 下载与测试：
    在这里插入图片描述具体代码：
import torchvision
# download 下载 train 训练 root 下载地址
train_set = torchvision.datasets.CIFAR10(root="./dataset", train=True, download=True)
test_set = torchvision.datasets.CIFAR10(root="./dataset", train=False, download=True)

print(test_set[0])
print(test_set.classes)
img, target = test_set[0]
print(img)
print(target)
print(test_set.classes[target])
img.show()

上面生成的数据类型并不是tensor，可以使用transforms对其进行转换：
在这里插入图片描述

import torchvision

dataset_transfroms = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor(),  # 转换为张量并归一
    #  还可以添加其他操作，裁剪，缩放等
])

train_set = torchvision.datasets.CIFAR10(root="./dataset", train=True, transform=dataset_transfroms, download=True)
test_set = torchvision.datasets.CIFAR10(root="./dataset", train=False, transform=dataset_transfroms, download=True)
print(test_set[0])
  1. 结合tensorboard使用：
    在这里插入图片描述在这里插入图片描述
import torchvision
from torch.utils.tensorboard import SummaryWriter

dataset_transfroms = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor(),  # 转换为张量并归一
    #  还可以添加其他操作，裁剪，缩放等
])

train_set = torchvision.datasets.CIFAR10(root="./dataset", train=True, transform=dataset_transfroms, download=True)
test_set = torchvision.datasets.CIFAR10(root="./dataset", train=False, transform=dataset_transfroms, download=True)

writer = SummaryWriter("logs")
for i in range(20):
    img, target = test_set[i]
    writer.add_image("test_set", img, i)


writer.close()

DataLoader使用

  1. Dataset：抽象类可以创建数据集，但是抽象类不能实例化，所以需要构建这个抽象类的子类来创建数据集，并且我们还可以定义自己的继承和重写方法。其中最重要的是len和getitem这两个函数，len能够给出数据集的大小，getitem用于查找数据和标签。（参考最前面dataset部分）
  2. DataLoader:处理模型输入数据的一个工具类，可以实现batch和shuffle的读取。
  3. 具体代码操作：
import torchvision
from torch.utils.data import DataLoader

# 准备测试数据集
test_data = torchvision.datasets.CIFAR10(root="./dataset", train=False, transform=torchvision.transforms.ToTensor())

# batch_size 每个数据块的大小 drop_last 舍弃最后不足数据块大小的数据  shuffle 乱序 num_workers 0默认主线程
test_loader = DataLoader(dataset=test_data, batch_size=4, shuffle=True, num_workers=0, drop_last=False)

# 测试数据集第一张大小
img, target = test_data[0]
print(img.shape)
print(target)

# 每一个DataLoader是有batch_size个数据的 imgs和targets
for data in test_loader:
    imgs, targets = data
    print(imgs.shape)
    print(targets)

在这里插入图片描述主要是DataLoader()里面参数的理解：

  • dataset: 传入的数据集
  • batch_size: 每个batch有多少个样本
  • shuffle: 在每个epoch开始的时候，对数据进行重新排序
  • num_workers : 这个参数决定了有几个进程来处理data loading。0意味着所有的数据都会被load进主进程。（默认为0）
  • drop_last: 如果设置为True：这个是对最后的未完成的batch来说的，比如你的batch_size设置为64，而一个epoch只有100个样本，那么训练的时候后面的36个就被 扔掉了…如果为False（默认），那么会继续正常执行，只是最后的batch_size会小一点。

nn.Module的使用

  1. 官方使用文档：https://pytorch.org/docs/stable/index.html
    在这里插入图片描述
  2. 理解什么是卷积操作：没时间整理，可自行搜索或参考官方文档https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md

输入图像（5x5) 与卷积核（3x3）的卷积操作代码：调整每次移动的步长

import torch
import torch.nn.functional as F

input = 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]])

# 卷积核
kernel = torch.tensor([[1, 2, 1],
                       [0, 1, 0],
                       [2, 1, 0]])

#  input tensor of shape (minibatch,in_channels,iH,iW)(minibatch,in_channels,iH,iW)
#  input shape是需要有4个参数，我们上面那个矩阵只有两个，需要reshape
input = torch.reshape(input, (1, 1, 5, 5))
kernel = torch.reshape(kernel, (1, 1, 3, 3))

# 修改步长stride
output = F.conv2d(input, kernel, stride=1)
output2 = F.conv2d(input, kernel, stride=2)
output3 = F.conv2d(input, kernel, stride=(1, 2))
print(output)
print(output2)
print(output3)

# 修改填充padding
output4 = F.conv2d(input, kernel, stride=1, padding=1)
print(output4)

输出：

tensor([[[[10, 12, 12],
          [18, 16, 16],
          [13,  9,  3]]]])
tensor([[[[10, 12],
          [13,  3]]]])
tensor([[[[10, 12],
          [18, 16],
          [13,  3]]]])
tensor([[[[ 1,  3,  4, 10,  8],
          [ 5, 10, 12, 12,  6],
          [ 7, 18, 16, 16,  8],
          [11, 13,  9,  3,  4],
          [14, 13,  9,  7,  4]]]])
  1. 一些函数中Parameters参数的理解
  • stride (int or tuple, optional) –移动的步长，默认1，表示横向和纵向都是1，可以是元组分别控制横向和纵向移动的步长。
  • padding —对输入进行填充，默认是0，也就是不填充，1表示填充一圈（上下左右各填充1行/列）且默认填充数值为0，

神经网络

  1. 卷积层

相关参数理解：
在这里插入图片描述搭建简单的卷积操作：

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

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


# 搭建神经网络
class NN(nn.Module):
    def __init__(self):
        super(NN, self).__init__()
        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


# NN((conv1): Conv2d(3, 6, kernel_size=(3, 3), stride=(1, 1) )
writer = SummaryWriter("logs")
nnn = NN()
step = 0
for data in dataloader:
    imgs, target = data
    output = nnn(imgs)
    print(output.shape)
    #  torch.Size([64, 6, 30, 30])
    writer.add_images("input", imgs, step)
    # 修改通道数 6-》3 自己计算块
    output = torch.reshape(output, (-1, 3, 30, 30))
    writer.add_images("output", output, step)
    step = step + 1
    
writer.close()

在这里插入图片描述

  1. 最大池化：保留输入特征，减少数据量。https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html#torch.nn.MaxPool2d
    卷积是做卷积后所有的和，最大池化是直接取最大值，当池化核遇到不足以全部覆盖时，ceil_mode为true时保留，false舍弃
    在这里插入图片描述
import torch
from torch import nn
from torch.nn import MaxPool2d

input = 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.float32)

#  Input: (N,C,Hin,Win) 修改shape满足输入要求
input = torch.reshape(input, (-1, 1, 5, 5))


class NN(nn.Module):
    def __init__(self):
        super(NN, self).__init__()
        self.maxpool1 = MaxPool2d(3, ceil_mode=True)

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


nnn = NN()
output = nnn(input)
print(output)

控制台打印：

tensor([[[[2., 3.],
          [5., 1.]]]])

具体数据集：

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

dataset = torchvision.datasets.CIFAR10("./data", train=False, download=True,
                                       transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, batch_size=64)


class NN(nn.Module):
    def __init__(self):
        super(NN, self).__init__()
        self.maxpool1 = MaxPool2d(3, ceil_mode=True)

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


nnn = NN()

writer = SummaryWriter("logs")
step = 0
for data in dataloader:
    imgs, target = data
    writer.add_images("input", imgs, step)
    output = nnn(imgs)
    writer.add_images("output", output, step)
    step = step + 1


writer.close()

在这里插入图片描述

  1. 非线性激活
    常见函数：
    在这里插入图片描述
    在这里插入图片描述ReLU函数使用：
import torch
from torch import nn
from torch.nn import ReLU

input = torch.tensor([[1, -0.5],
                      [-1, 3]])

# 指定batch_size
input = torch.reshape(input, (-1, 1, 2, 2))

class NN(nn.Module):
    def __init__(self):
        super(NN, self).__init__()
        self.relu1 = ReLU(inplace=False)   # inplace:是否把输出的结果替换掉输入input，默认False可不指定
        
    def forward(self, input):
        output = self.relu1(input)
        return output

nnn = NN()
output = nnn(input)
print(output)

输出：

tensor([[[[1., 0.],
          [0., 3.]]]])

Sigmoid的使用：

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

dataset = torchvision.datasets.CIFAR10("./data", train=False,
                                       transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader = DataLoader(dataset, batch_size=64)



class NN(nn.Module):
    def __init__(self):
        super(NN, self).__init__()
        self.relu1 = ReLU(inplace=False)   # inplace:是否把输出的结果替换掉输入input，默认False可不指定
        self.sigmoid1 = Sigmoid()

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

nnn = NN()

writer = SummaryWriter("logs")
step = 0
for data in dataloader:
    imgs, target = data
    writer.add_images("input", imgs, step)
    output = nnn(imgs)
    writer.add_images("output", output, step)
    step = step + 1

writer.close()

在这里插入图片描述

  1. 线性层
    在这里插入图片描述
import torch
import torchvision
from torch import nn
from torch.nn import Linear
from torch.utils.data import DataLoader

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

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


class NN(nn.Module):
    def __init__(self):
        super(NN, self).__init__()
        self.linear1 = Linear(196608, 10)  # in_features输入的神经元个数 out_features输出神经元个数 bias 是否包含偏置

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


nnn = NN()
for data in dataloader:
    imgs, target = data
    output = torch.reshape(imgs, (1, 1, 1, -1))  # 将形状展平，最后一个值语与linear的in_features对应
    # 上面等价与 torch.flatten(imgs)
    print(output.shape)
    output = nnn(output)
    print(output.shape)


Files already downloaded and verified
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([1, 1, 1, 196608])
torch.Size([1, 1, 1, 10])
torch.Size([1, 1, 1, 196608])
.....

其他部分可参考官方文档：
https://pytorch.org/docs/stable/nn.html#
在这里插入图片描述

  1. 小实战
    实现CIFAR 10 model
    在这里插入图片描述如何计算stride和padding这两个参数，其他参数都是已知的输入输出的channel数，以及这个卷积大小都是已知的，通过下图公式可求出两个参数

在这里插入图片描述stride=1和padding=2【padding = (kernel_size-1)/2 保持大小不变的话】

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


class NN(nn.Module):
    def __init__(self):
        super(NN, self).__init__()
        # self.conv1 = Conv2d(3, 32, kernel_size=5, stride=1, padding=2)
        # self.maxpool1 = MaxPool2d(2)
        # self.conv2 = Conv2d(32, 32, kernel_size=5, stride=1, padding=2)
        # self.maxpool2 = MaxPool2d(2)
        # self.conv3 = Conv2d(32, 64, kernel_size=5, stride=1, padding=2)
        # self.maxpool3 = MaxPool2d(2)
        # self.flatten = Flatten()  # 展平 64*4*4 = 1024个=》通过线性层转化为64=》再通过线性到输出的10
        # self.linear1 = Linear(1024, 64)
        # self.linear2 = Linear(64, 10)

        self.model1 = Sequential(
            Conv2d(3, 32, kernel_size=5, stride=1, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, kernel_size=5, stride=1, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, kernel_size=5, stride=1, 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


nnn = NN()
# 检查架构是否有错
input = torch.ones((64, 3, 32, 32))
output = nnn(input)
print(output.shape)

writer = SummaryWriter("logs")
writer.add_graph(nnn, input)
writer.close()

tensorboard 显示的模型：
在这里插入图片描述

高 朗
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Pytorch：torch.utils.tensorboard.SummaryWriter
weixin_42046845的博客
03-28 800
SummaryWriter 通常是指在TensorBoard日志记录库中的一个类，这是TensorFlow的一个组件，可以用于记录和展示神经网络训练过程中的各种参数。PyTorch也提供了与TensorBoard兼容的工具torch.utils.tensorboard.SummaryWriter。
Pytorch笔记.pdf
07-20
自己整理的pytorch学习资源 非常值得！
PyTorch学习整理笔记
03-21
PyTorch学习整理笔记，适合新手学习！ 例： ### 1 线性回归模型 调整线性回归模型停止条件以及y = 2*x + (5 + torch.randn(20, 1))中的斜率，训练一个线性回归模型 ### 1 张量与矩阵、向量、标量的关系是怎么样的？ 张量为一个多维数组，是标量、向量、矩阵的高维拓展。 Tensor（张量）类似于NumPy的ndarray，但还可以在GPU上使用来加速计算。 - 标量(Scalar)：0阶（$r=0$）张量 - 向量(Vector)：1阶（$r=1$）张量 - 矩阵(Matrix)：2阶（$r=2$）张量
pytorch张量索引切片等学习笔记
09-09
结合网上的相关教程整理的关于pytorch的有关张量，索引，切片以及与numpy相互转换使用的学习笔记，比较完整，有兴趣的可以下载！
pytorch-notes:pytorch学习笔记
04-29
PyTorch笔记 整理PyTorch相关问题，部分实现了对应的tensorflow版本。 updating...
NLP发展史和学习整理笔记
11-08
想学习nndl和nlp的同学可以看过来，本xmind主要是针对《二十三岁的有徳》博主的博客进行整理和个人总结的思维导图，主要目的是方便大家学习，同时希望有志同道合的同学可以一起学习，感恩，感谢！
pyTorch——基础学习笔记
zyz博客
08-16 1780
类似于Numpy但是能利用GPU加速一个非常灵活和快速用于深度学习的研究平台。目前学习深度学习一个好的框架十分的重要，现在主流的就是Pytorch和tf，今天让我们一起来学习pytorch。其实除了可以采用自动梯度方法，我们还可以通过构建一个继承了torch.nn.Module的新类，来完成对前向传播函数和后向传播函数的重写。在这个新类中，我们使用forward作为前向传播函数的关键字，使用backward作为后向传播函数的关键字。batch_n = 64#一个批次输入数据的数量。......
Pytorch学习笔记总结
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
11-10 7799
PyTorch学习笔记整理，内容参考多个多个优秀Pytorch学习资源，适合深度学习pytorch学习者学习。(开篇词)PyTorch 学习笔记 - PyTorch 学习笔记；动手学CV-Pytorch:动手学CV-Pytorch；Pytorch 中文文档：主页 - PyTorch中文文档；Pytorch Tutorials...
Pytorch 的数据处理 学习笔记
qq_64286820的博客
04-22 1239
数据处理过程的操作记录笔记
Pytorch学习笔记
LAT__的博客
09-30 218
一、PyTorch的安装 我使用的是Pycharm，直接在Python Packages里搜索Pytorch，选择pytorch-ignite进行安装。这个包应该是高配版的pytorch，里面多了一些大佬们写好的功能。我最初其实选择的是pytorch那个包进行安装，但是失败了，报错我也看不懂，所以就试了试ignite版，结果成了。 import torch 上述语句可以进行包的引用。 二、Tensor张量 类似于numpy，Pytorch有自己的一套管理矩阵的基本数据结构，名为tensor。使用
PyTorch学习笔记
weixin_45596153的博客
05-25 728
PyTorch学习笔记
pytorch学习笔记
weixin_51210777的博客
11-09 1461
一、张量 1）定义： 维度超过二的的数组叫张量 2） 在torch中张量有八种数据类型： 在torch中默认为32位浮点型的数据类型，可以通过torch.set_defoult_tensor_dtpype()更改默认的数据类型 import torch torch.tensor([1.2,3.4]).dtype out:torch.float32 更改类型： torch.set_defoult_tensor_dtpype(torch.DoubleTensor) torch..
PyTorch学习笔记 (一)
Messi-Q Blog
07-11 225
默认只有叶子节点才保持梯度，如： 1 A = Variable(torch.ones(2), requires_grad = True) 在中间节点可以设置保持梯度，如： 1 2 3 4 5 6 7 8 9 10 11 12 A = Variable(torch.ones(...
[PyTorch 学习笔记] 3.1 模型创建步骤与 nn.Module
张贤的博客
08-28 685
本章代码：https://github.com/zhangxiann/PyTorch_Practice/blob/master/lesson3/module_containers.py 这篇文章来看下 PyTorch 中网络模型的创建步骤。网络模型的内容如下，包括模型创建和权值初始化，这些内容都在nn.Module中有实现。 网络模型的创建步骤 创建模型有 2 个要素：构建子模块和拼接子模块。如 LeNet 里包含很多卷积层、池化层、全连接层，当我们构建好所有的子模块之后，按照一定的顺序拼接起来。.
pytorch onnx ncnn间的关系
最新发布
weixin_42605076的博客
06-02 294
PyTorch：用于模型开发和训练，提供强大的灵活性和丰富的库支持。ONNX：充当一个中间层格式，促进不同深度学习框架之间的模型互操作性和标准化。NCNN：专注于高效的模型推理，特别是在移动和嵌入式设备上。工作流程示例在 PyTorch 中开发和训练模型。将 PyTorch 模型导出为 ONNX 格式。使用 NCNN 工具将 ONNX 模型转换为 NCNN 格式。将 NCNN 模型部署到移动设备或嵌入式设备上进行高效推理。
pytorch笔记：topk
qq_40206371的博客
05-29 177
返回给定输入张量沿指定维度的最大的 k 个元素dimlargestFalsedimsortedTrue。
error: #error C++17 or later compatible compiler is required to use PyTorch.
YuQiao0303的博客
05-30 299
在安装wonder3d的时候要安装tinycudnn，
PyTorch中CrossEntropyLoss、BCELoss、BCEWithLogitsLoss的理解
u012374012的专栏
05-27 517
输出：
Pytorch反向传播算法（Back Propagation）
xiongmaowangd的博客
05-31 712
首先第一层计算的是w1*x+b1，假如说我们的输入x是一个n维的列向量，结果是一个m维的列向量，MM是矩阵相乘，那我们需要的w1是一个m*n的矩阵，相乘得到的结果是一个m维的列向量，需要b1也是一个m维的列向量，ADD表示相加，得到的结果可以看成这个层的输出，但其实这个值还需要放入到下一层进行第二层的运算，而两个的运算过程都差不多，大家可以自己看一下。大家看，在一个线性的运算中，其中不管有多少层，w1，w2都是可以通过计算放在一起的，那最后得到的结果也可以看出来，又是一个新的线性运算。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值