pytorch 基础

已于 2022-06-08 14:11:20 修改
阅读量244 收藏
点赞数
分类专栏： PyTorch 文章标签： pytorch
于 2021-06-27 15:57:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yukonjian/article/details/118051639
版权

1. 自定义dataset的获取

# import torch
from torch.utils.data import Dataset
from PIL import Image
import os


class MyDataset(Dataset):
    def __init__(self, root_path, image_dir):
        self.root_path = root_path
        self.image_dir = image_dir
        self.image_path = os.path.join(self.root_path, self.image_dir)
        self.image_list = os.listdir(self.image_path)

    def __getitem__(self, item):
        img = Image.open(os.path.join(self.image_path, self.image_list[item]))
        label = self.image_dir
        return img, label

    def __len__(self):
        return len(self.image_list)


if __name__ == "__main__":
    ants_dataset = MyDataset("dataset", "ants")
    bees_dataset = MyDataset("dataset", "bees")
    all_dataset = ants_dataset + bees_dataset
    print(len(all_dataset))
    image, label = all_dataset[55]
    print(label)
    image.show()

2. tensorboard

1. 安装tensorboard,如果无法使用tensorboard，请再次安装tensorboardX

pip install tensorboard

pip install tensorboardX

2. 将数据写入tensorboard

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

# 每次运行一次程序，均会向logs下写入数据；如果不想要以前的数据，在运行之前将logs目录下的文件删除
write = SummaryWriter("logs")
image_path = "dataset/ants/8124241_36b290d372.jpg"
image_pil = Image.open(image_path)
image_array = np.array(image_pil)

# 写入的图片数据是tensor或者numpy数据, 1表示该图片为全局第一张图片，dataformats指定为HWC,默认是CHW
write.add_image("ants", image_array, 1, dataformats="HWC")

for i in range(10):
    # y=x 为图的标题， 2*i为x轴的数据，i为y轴的数据
    write.add_scalar("y=x", 2*i, i)

write.close()

3. 使用web显示写入的数据

在终端输入：tensorboard --logdir=logs --port=6007  

port不指定默认为6006，如果多人使用服务器查看tensorboard，不指定则会冲突

输出如下，点击http://localhost:6007打开网页查看

在终端输入：tensorboard --logdir=logs --port=6007   --samples_per_plugin=images=100

在显示图片是可以显示100张图片，默认只能显示10张

3. 数据的transform

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

write = SummaryWriter("logs")
image_path = "dataset/ants/8398478_50ef10c47a.jpg"
img = Image.open(image_path)
# Convert a ``PIL Image`` or ``numpy.ndarray`` to tensor
# Converts a PIL Image or numpy.ndarray (H x W x C) in the range
# [0, 255] to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0]
trans_tensor = transforms.ToTensor()
tensor_img = trans_tensor(img)
write.add_image("tensor", tensor_img, 1)

# normalize
# output[channel] = (input[channel] - mean[channel]) / std[channel], 需要自己计算平均值和标准差带入
print(tensor_img[0][0][0])
trans_norm = transforms.Normalize([0, 0, 0], [1, 1, 1])
norm_img = trans_norm(tensor_img)
print(norm_img[0][0][0])
write.add_image("norm", norm_img, 2)

# resize
# input PIL image
trans_resize = transforms.Resize((512, 512))
resize_img = trans_resize(img)
resize_img = trans_tensor(resize_img)
write.add_image("resize", resize_img, 0)

# compose
trans_cmp = transforms.Compose([transforms.Resize(512), transforms.ToTensor()])
cmp_img = trans_cmp(img)
write.add_image("resize", cmp_img, 1)

write.close()

4. pytorch提供的数据集的使用，例如cifar

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

transform = transforms.Compose([transforms.ToTensor()])

cifar10_train = torchvision.datasets.CIFAR10("./cifar10", transform=transform, train=True, download=True)
cifar10_test = torchvision.datasets.CIFAR10("./cifar10", transform=transform, train=False, download=True)

write = SummaryWriter("logs")

for i in range(10):
    image, label = cifar10_train[i]
    write.add_image("cifar10", image, i)

write.close()

5. 数据的加载DataLoader

import torchvision
from torch.utils.data import DataLoader
from torchvision import transforms
from torch.utils.tensorboard import SummaryWriter

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

# num_works：使用多少个子线程加载数据；0表示只使用主进程加载。
# drop_last：True表示，如果最后一次加载数据大小没有达到batch_size，则这次加载将丢弃
data_loader = DataLoader(dataset_test, batch_size=64, shuffle=True, num_workers=0, drop_last=True)

writer = SummaryWriter("logs")

step = 0
for data in data_loader:
    images, labels = data
    writer.add_images("cifar10_drop_T", images, step)
    step = step + 1

writer.close()

6. 网络模型的框架

import torch
from torch import nn

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

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

model = MyModel()
input = torch.tensor(1.0)
output = model(input)
print(output)

7. 卷积初体验

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

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

data_loader = DataLoader(dataset_test, batch_size=64, drop_last=True)

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)

    def forward(self, input):
        return self.conv1(input)

model = MyModel()

writer = SummaryWriter("logs")

step = 0
for data in data_loader:
    images, labels = data
    writer.add_images("input_img", images, step)
    out_images = model(images)
    out_images = out_images.reshape((-1, 3, 30, 30))
    print(out_images.shape)
    writer.add_images("output_img", out_images, step)
    step = step + 1

writer.close()

8. sequential的使用

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

train_data = torchvision.datasets.CIFAR10("cifar10", train=False, transform=transforms.ToTensor, download=True)

train_load = DataLoader(train_data, batch_size=64)

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.seq1 = Sequential(nn.Conv2d(3, 64, kernel_size=3, stride=1),
                               nn.Flatten(),
                               nn.Linear(57600, 10)
                               )

    def forward(self, x):
        x = self.seq1(x)
        return x


writer = SummaryWriter("logs")
mymodel = MyModel()
print(mymodel)
input = torch.ones((64, 3, 32, 32))

print(input.shape)
out_data = mymodel(input)
print(out_data.shape)
writer.add_graph(mymodel, input)

writer.close()

9. loss函数的计算

import torch
from torch.nn import L1Loss

in_data = torch.tensor(
    [[2, 2],
     [3, 3]], dtype=torch.float32
)

target = torch.tensor(
    [[3, 3],
     [3, 4]], dtype=torch.float32
)

# reduction="mean",默认参数，所有元素相减，再求和，在除以元素个数（该计算中元素个数为4）
# reduction="sum",默认参数，所有元素相减，再求和
loss = L1Loss(reduction="mean")
output = loss(in_data, target)
print(output.shape)
print(output)

10. 完整的训练过程

import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
import time
import os

data_transform = torchvision.transforms.ToTensor()
train_data = torchvision.datasets.CIFAR10("./cifar10", train=True, transform=data_transform, download=True)
test_data = torchvision.datasets.CIFAR10("./cifar10", train=False, transform=data_transform, download=True)

train_dataloader = DataLoader(train_data, batch_size=64, shuffle=True, drop_last=True)
test_dataloader = DataLoader(test_data, batch_size=64, shuffle=True, drop_last=True)

if not os.path.exists("./weights"):
    os.mkdir("./weights")

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Device useing: {}".format(device))

class CifarModel(nn.Module):
    def __init__(self):
        super(CifarModel, self).__init__()
        self.model = nn.Sequential(
            # in:3*32*32    out:32*32*32
            nn.Conv2d(3, 32, kernel_size=5, stride=1, padding=2),
            nn.ReLU(),
            # in:32*32*32    out:32*16*16
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
            # in:32*16*16    out:64*16*16
            nn.Conv2d(32, 64, kernel_size=5, stride=1, padding=2),
            nn.ReLU(),
            # in:64*16*16    out:64*8*8
            nn.AvgPool2d(kernel_size=3, stride=2, padding=1),
            # in:64*8*8    out:128*8*8
            nn.Conv2d(64, 128, kernel_size=5, stride=1, padding=2),
            nn.ReLU(),
            # in:128*8*8    out:128*4*4
            nn.AvgPool2d(kernel_size=3, stride=2, padding=1),
            # in:128*4*4    out:2048
            nn.Flatten(),
            nn.Linear(2048, 10)
        )

    def forward(self, x):
        x = self.model(x)
        return x

cifar_model = CifarModel()
cifar_model.to(device)
# print(cifar_model)

# in_data = torch.ones((64, 3, 32, 32))
# print(in_data.shape)
# out_data = cifar_model(in_data)
# print(out_data.shape)

# 定义损失函数，和优化器
loss_fn = nn.CrossEntropyLoss()
loss_fn.to(device)
optimizer = torch.optim.SGD(cifar_model.parameters(), lr=0.01)

writer = SummaryWriter("./logs")
train_epoch = 1
train_total_step = 0
test_total_step = 0

for i in range(train_epoch):
    print("-----------start epoch {} train -------------".format(i+1))
    # 记入训练开始时间
    start_time = time.time()
    # 开始训练
    cifar_model.train()
    for imgs, targets in train_dataloader:
        # 前向传播
        imgs = imgs.to(device)
        targets = targets.to(device)
        outputs = cifar_model(imgs)
        loss = loss_fn(outputs, targets)

        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        train_total_step = train_total_step + 1
        if train_total_step % 100 == 0:
            print("train step:{}, loss:{}".format(train_total_step, loss.item()))
            writer.add_scalar("train loss", loss.item(), train_total_step)

    # 开始验证
    cifar_model.eval()
    test_total_loss = 0
    test_total_accuracy = 0
    test_total_num = 0
    with torch.no_grad():
        for imgs, targets in test_dataloader:
            imgs = imgs.to(device)
            targets = targets.to(device)
            outputs = cifar_model(imgs)
            loss = loss_fn(outputs, targets)

            # 计算正确率
            accuracy = (torch.argmax(outputs, 1) == targets).sum()
            test_total_loss = test_total_loss + loss.item()
            test_total_accuracy = test_total_accuracy + accuracy
            test_total_num = test_total_num + len(targets)

    test_total_step = test_total_step + 1
    print("test accuracy:{}; test loss:{};".format(test_total_accuracy/test_total_num, test_total_loss))
    writer.add_scalar("test accuracy:{}", test_total_accuracy/test_total_num, test_total_step)
    writer.add_scalar("test accuracy:{}", test_total_loss, test_total_step)

    # 保存模型
    torch.save(cifar_model, "./weights/cifar_{}.pth".format(test_total_step))

    # 计算一个epoch的花费时间
    end_time = time.time()
    print("cost time:{}".format(end_time - start_time))
writer.close()

11. 完整的测试过程

import torch
import torchvision
from PIL import Image
from torch import nn


class CifarModel(nn.Module):
    def __init__(self):
        super(CifarModel, self).__init__()
        self.model = nn.Sequential(
            # in:3*32*32    out:32*32*32
            nn.Conv2d(3, 32, kernel_size=5, stride=1, padding=2),
            nn.ReLU(),
            # in:32*32*32    out:32*16*16
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
            # in:32*16*16    out:64*16*16
            nn.Conv2d(32, 64, kernel_size=5, stride=1, padding=2),
            nn.ReLU(),
            # in:64*16*16    out:64*8*8
            nn.AvgPool2d(kernel_size=3, stride=2, padding=1),
            # in:64*8*8    out:128*8*8
            nn.Conv2d(64, 128, kernel_size=5, stride=1, padding=2),
            nn.ReLU(),
            # in:128*8*8    out:128*4*4
            nn.AvgPool2d(kernel_size=3, stride=2, padding=1),
            # in:128*4*4    out:2048
            nn.Flatten(),
            nn.Linear(2048, 10)
        )

    def forward(self, x):
        x = self.model(x)
        return x


image_path = "dataset/feiji.jpg"
image = Image.open(image_path)
image = image.convert("RGB")

transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32, 32)),
                                            torchvision.transforms.ToTensor()])

image = transform(image)
print(image.shape)

cifar_test = torch.load("./cifar_87.pth", map_location=torch.device("cpu"))

image = torch.reshape(image, (1, 3, 32, 32))

cifar_test.eval()
with torch.no_grad():
    output = cifar_test(image)

print(output)
print(torch.argmax(output, 1))

12. 网络的修改

from torch import nn


class CifarModel(nn.Module):
    def __init__(self):
        super(CifarModel, self).__init__()
        self.seq_model = nn.Sequential(
            # in:3*32*32    out:32*32*32
            nn.Conv2d(3, 32, kernel_size=5, stride=1, padding=2),
            nn.ReLU(),
            # in:32*32*32    out:32*16*16
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
            # in:32*16*16    out:64*16*16
            nn.Conv2d(32, 64, kernel_size=5, stride=1, padding=2),
            nn.ReLU(),
            # in:64*16*16    out:64*8*8
            nn.AvgPool2d(kernel_size=3, stride=2, padding=1),
            # in:64*8*8    out:128*8*8
            nn.Conv2d(64, 128, kernel_size=5, stride=1, padding=2),
            nn.ReLU(),
            # in:128*8*8    out:128*4*4
            nn.AvgPool2d(kernel_size=3, stride=2, padding=1),
            # in:128*4*4    out:2048
            nn.Flatten(),
            nn.Linear(2048, 10)
        )

    def forward(self, x):
        x = self.seq_model(x)
        return x

cifar = CifarModel()

# 在末尾添加一个网络层
cifar.add_module("add_linear", nn.Linear(10, 100))

cifar.add_linear = nn.Linear(10, 200)
for name, value in cifar.named_parameters():
    print("name:{}; value grade:{}".format(name, value.requires_grad))
    if name == "add_linear":
        value.requires_grad = False

# filter(lambda name, value: id(p) not in ignored_params, cifar.parameters())

12. 网络的参数

in:

cifar_model = CifarModel()
print(cifar_model)

 out:

CifarModel(
  (model): Sequential(
    (0): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
    (3): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (4): ReLU()
    (5): AvgPool2d(kernel_size=3, stride=2, padding=1)
    (6): Conv2d(64, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (7): ReLU()
    (8): AvgPool2d(kernel_size=3, stride=2, padding=1)
    (9): Flatten(start_dim=1, end_dim=-1)
    (10): Linear(in_features=2048, out_features=10, bias=True)
  )
)

 查看模型的参数

for name, value in cifar_model.named_parameters():
    print("name:{}; value grade:{}".format(name, value.requires_grad))

 

模型的两种保存方式

    # 保存模型结构和模型权重
    torch.save(cifar_model, "./weights/cifar_{}.pth".format(test_total_step))
    # 保存模型的权重
    torch.save(cifar_model.state_dict(), "./weights/cifar_dict_{}.pth".format(test_total_step))

模型的权重的两种加载方式

# 模型中保存了模型结构,直接加载
cifar_test = torch.load("./weights/cifar_1.pth")

# 模型中只有权重,torch.load只会加载生成顺序字典
cifar_weight = torch.load("./weights/cifar_dict_1.pth")
# 如果要修改模型参数,这里可以新建一个顺序字典并赋值需要的权重,然后传递给网络
cifar_test = CifarModel()
cifar_test.load_state_dict(cifar_weight)

# 顺序字典的使用
from collections import OrderedDict
target_state = OrderedDict()
for k, v in cifar_test.items():
  print(k)
  if k != 'classifier.weight' and k != 'classifier.bias':
  v.requires_grad = False
  target_state[k] = v

顺序字典的访问

in:
for k in cifar_test2:
    print(data)

out:
model.0.weight
model.0.bias
model.3.weight
model.3.bias
model.6.weight
model.6.bias
model.10.weight
model.10.bias

in:
for k,v in cifar_test2.items():
    print(k)
    print(v)

out:
model.0.weight
tensor([[[[-0.1044,  0.0435, -0.0030, -0.1005,  0.0612],
          [-0.0222,  0.0845, -0.0075,  0.0084, -0.0196],
          [ 0.0661, -0.1093,  0.0391, -0.1094,  0.0351],
          [ 0.0936,  0.0831,  0.0499, -0.0364,  0.0417],
          [-0.0943, -0.1099,  0.0055,  0.0313, -0.0098]],

         [[-0.0284, -0.0818, -0.0304, -0.1030, -0.0512],
          [ 0.0463,  0.0858,  0.0560,  0.0147, -0.0257],
          [ 0.0028,  0.0647,  0.0102, -0.0844,  0.0187],
          [-0.1099, -0.0358, -0.1116, -0.1080, -0.0171],
          [-0.0461, -0.0222, -0.0421, -0.0376, -0.0739]],

yukonjian
关注
专栏目录
PyTorch深度学习实战（2）——PyTorch基础
盼小辉丶的博客
06-04 4万+
PyTorch 是广泛应用于机器学习领域中的强大开源框架，因其易用性和高效性备受青睐。在本节中，将介绍使用 PyTorch 构建神经网络的基础知识。首先了解 PyTorch 的核心数据类型——张量对象。然后，我们将深入研究用于张量对象的各种操作。PyTorch 提供了许多帮助构建神经网络的高级方法及组件，并提供了利用 GPU 更快地训练神经网络的张量对象。
3.pytorch学习：conv2d——2d卷积
wzfafabga的博客
11-04 1169
3.pytorch学习：conv2d——2d卷积
PyTorch学习之torch.nn.Conv2d函数
最新发布
qq_46396470的博客
06-30 1028
是 PyTorch 中用于实现二维卷积层的类，这个类可以说是对的进一步封装，使其使用起来更加的傻瓜式。
（pytorch进阶之路三）conv2d
qq_19841133的博客
07-05 1118
但还是大致说一下，in_channel = 2，out_channel = 3，所以kernel的数量是6，输出的每个通道由输入的每个通道与各自的kernel进行卷积操作，每个输出通道再将卷积操作的矩阵再加起来，最后将所有输出通道的矩阵拼接。步长为1的情况下，输出大小 = 输入大小 - 核的大小 + 2*padding大小 + 1 所以我们要让输出和输入大小一致，根据公式可以计算出padding大小padding=‘same’ 自动计算大小比较简单，直接略过说明了 原......
pytorch的Conv2d参数详解
macan的博客
01-17 2872
pytorch的Conv2d参数详解 torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None) in_channels：输入维度，即你上一层特征图或者原始图片（3）的通道数 out_channels：你希望这一层输出多少层的特征图，或者说你希望有多少个
pytorch Conv2d参数解析
yjinyyzyq的博客
06-13 9137
目录文档：实例in_channels (int): Number of channels in the input imageout_channels (int): Number of channels produced by the convolutionkernel_size (int or tuple): Size of the convolving kernelstride (int or...
【PyTorch学习】PyTorch基础知识
12-21
【PyTorch学习】PyTorch基础知识 PyTorch是一个由Facebook开发的开源深度学习框架，它是基于Python的，提供了一种动态计算图机制。PyTorch起源于Torch7，但利用Python的便利性和丰富的生态系统，使得它更适合科研和...
pytorch基础学习笔记
03-13
### PyTorch基础学习笔记 #### 一、PyTorch简介及安装 ##### 1.1 PyTorch简介 PyTorch是由Facebook的人工智能研究实验室（FAIR）开发的一款开源机器学习库，专为利用GPU加速张量计算和深度学习而设计。PyTorch的...
pytorch基础教学简单实例
01-10
在这个"pytorch基础教学简单实例"中，我们将学习如何构建、训练和优化一个神经网络模型。 首先，我们要了解PyTorch中的核心概念：张量（Tensor）。张量是PyTorch的数据结构基础，类似于numpy数组，但可以在GPU上...
实验一 PyTorch基础
05-15
### PyTorch基础知识点 #### 一、实验目的与知识点概览 本次实验的主要目的是让学生理解和掌握PyTorch中张量的基本操作。具体包括以下几个方面： 1. **理解张量**：张量是PyTorch中的核心数据结构，类似于NumPy...
nn.Conv2d参数详解及输入特征图尺寸的计算
蜗牛在奔跑的博客
05-06 1万+
kernel_size：卷积核的大小，通常为正方形，可以是单个整数表示正方形大小，也可以是一个元组（tuple）表示不同宽度和高度的大小，如 (3, 5) 表示宽度为 3 个像素，高度为 5 个像素的卷积核；需要注意的是，卷积层的参数选择也会影响特征图的大小。比如，在使用大尺寸的卷积核进行卷积时，会使得特征图的尺寸减小，而使用小尺寸的卷积核则会使得特征图的尺寸增加。其中，W 表示输入特征图的宽度，H 表示输入特征图的高度，K 表示卷积核的大小，P 表示 padding 的大小，S 表示卷积核的步幅。
Pytorch二维卷积 conv2d 使用/源码/手写实现conv2d/手写向量内积实现conv2d/转置卷积实现——学习笔记
just
02-27 6826
Pytorch二维卷积 conv2d 使用/源码/手写实现conv2d/手写向量内积实现conv2d/转置卷积实现
pytorch【Conv2d参数介绍】
重剑无锋博客
01-18 2088
pytorch Conv2d参数介绍
CNN卷积函数Conv2D()各参数的含义及用法
热门推荐
魔法探戈
07-23 5万+
首先我们放出tf2.0关于tf.keras.layers.Conv2D()函数的官方文档，然后逐一对每个参数的含义和用法进行解释： tf.keras.layers.Conv2D( filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1), activation=None, use_bias=True, kernel_initializer='glorot_
直观的模型训练及测试效果
apple_53439775的博客
04-03 1840
在之前完整的训练模型中只是做到了成功训练，也有损失函数但是在大量数据集、多次训练的情况下，数据较多，并不直观，而且没有做测试。 在这里添加了测试模块，并且为了进一步直观的测试效果，添加了正确率 #测试 total_test_loss = 0 total_accuracy = 0 with torch.no_grad(): for data in test_dataloader: imgs, targets = data
动手学深度学习（一）
qq_45972771的博客
01-03 178
深度学习入门+实践
Conv2d和Conv3d详解
qq_53015609的博客
09-29 4384
解释一下，图中左边部分 groups=1，右边部分 groups=2，两边最终的结果大小和channel都相同。groups：就是分组的意思，按channel方向进行分组，所以in_channel和out_channel必须能够整除groups。特别的，当 groups=in_channel 时，每一个channel都有自己的 filters ，数量为：out_channel / in_channel。out_channels：输出通道数，由卷积核数量决定，也代表最终输出通道数。，只包括初始化参数部分。
土堆Pytorch学习笔记（三）
m0_47669787的博客
04-02 281
2023.04.02。
pytorch基础概念
08-18
- *1* [Pytorch基础学习（第一章-PyTorch基础概念）](https://blog.csdn.net/m0_45447650/article/details/123695161)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值