Pytorch快速入门

最新推荐文章于 2023-02-08 00:11:48 发布
最新推荐文章于 2023-02-08 00:11:48 发布
阅读量1k 收藏 1
点赞数
分类专栏： pytorch 深度学习 文章标签： python pytorch 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47177533/article/details/124190038
版权

Pytorch工具箱

加载数据

Dataset

提供一种方式去获取数据及其label

如何获取每一个数据及其label？

告诉我们总共有多少个数据？

from torch.utils.data import Dataset
from PIL import Image
import os
class Mydataset(Dataset):
    #init中可以存储一个img_path图片名称的数组，则可以在getitem中使用这个打开图片
    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)


root_dir = 'E:\\ml\\hymenoptera_data\\train'
ants_dir = 'ants'
bees_dir = 'bees'
ants_dataset = Mydataset(root_dir,ants_dir)
bees_dataset = Mydataset(root_dir,bees_dir)

img,label = bees_dataset[1]

TensorBoard

from tensorboardX import SummaryWriter
writter = SummaryWriter("../logs")
writter.add_images("input",imgs,step)
writter.add_images("output",output,step)
##打开:
tensorboard --logdir=logs

图像变换，transform的转变：

ToTensor 把一些数据转化为tensor的数据类型

import torchvision.transforms as transforms
from PIL import Image
#transforms如何使用
#tensor数据类型
img_path = 'E:\\ml\\hymenoptera_data\\train\\ants\\0013035.jpg'
img = Image.open(img_path)
print(img)
#创建具体的工具，result = tool(input)
tensor_trans = transforms.ToTensor()
tensor_img = tensor_trans(img)
print(tensor_img)

Normalize

#有两个参数，'mean' and 'std'
trans_norm = transforms.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5])
img_norm = trans_norm(tensor_img)
print(img_norm)

Resize

trans_resize = transforms.Resize((128,128))
#img PIL -> resize -> Normalize -> img_resize
img_resize = trans_resize(img_norm)
print(img_resize)

Compose

image-20211127170132929

Dataloader

dataloader = DataLoader(dataset,batch_size = 64)
for data in dataloader:
    imgs,targets = data

为后面的网络提供不同的数据形式

神经网络nn.module

channel的理解

  1. 对于最初输入图片样本的通道数 in_channels 取决于图片的类型，如果是彩色的，即RGB类型，这时候通道数固定为3，如果是灰色的，通道数为1。
  2. 卷积完成之后，输出的通道数 out_channels 取决于过滤器的数量。从这个方向理解，这里的 out_channels 设置的就是过滤器的数目。
  3. 对于第二层或者更多层的卷积，此时的 in_channels 就是上一层的 out_channels ， out_channels 还是取决于过滤器数目。

在第2条我用的是过滤器，而不是卷积核，跟原作者观点有些不同，因为我认为在这里用过滤器描述更合适。卷积核和过滤器的区别可以看我的这篇文章 卷积核（kernel）和过滤器（filter）的区别

对于第1点可以参考下图：
在这里插入图片描述

这里输入通道数是3，每个通道都需要跟一个卷积核做卷积运算，然后将结果相加得到一个特征图的输出，这里有4个过滤器，因此得到4个特征图的输出，输出通道数为4。

class Myren(nn.Module):
    def __init__(self):
        super().__init__()
    def forward(self,input):
        output = input + 1
        return output
myren = Myren()
x = torch.tensor(1.0)
output = myren(x)
print(output)
############################
#我们定义了一个自己的神经网络Myren,其的forward方法提供了+1的传递方式
tensor(2.)

image-20211128171208225

Conv2d

相关参数

  • in_channels (int) – Number of channels in the input image
  • out_channels (int) – Number of channels produced by the convolution
  • kernel_size (int or tuple) – Size of the convolving kernel
  • stride (int or tuple, optional) – Stride of the convolution. Default: 1
  • padding (int, tuple or str, optional) – Padding added to all four sides of the input. Default: 0
  • padding_mode (string*,* optional) – 'zeros', 'reflect', 'replicate' or 'circular'. Default: 'zeros'
  • dilation (int or tuple, optional) – Spacing between kernel elements. Default: 1
  • groups (int, optional) – Number of blocked connections from input channels to output channels. Default: 1
  • bias (bool, optional) – If True, adds a learnable bias to the output. Default: True
x = torch.randn(1,1,28,28)
'''
输入：[ batch_size, channels, height_1, width_1 ]
batch_size，一个batch中样本的个数 1
channels，通道数，也就是当前层的深度 1 一层就是黑白图像
height_1， 图片的高 28
width_1， 图片的宽 28
'''
conv = torch.nn.Conv2d(1,25,(3,3),1)
'''
in_channel，通道数，和上面保持一致，也就是当前层的深度 1
out_channel ，输出的深度 25【需要25个filter】 25个卷积核
height_2，卷积核的高 3
width_2，卷积核的宽 3
stride, 卷积的距离是1
'''
ans = conv(x)
print(len(ans))
print(len(ans[0]))
print(len(ans[0][0]))
print(len(ans[0][0][0]))
###################################
1
25
26
26

测试

import torchvision
from torch import nn
import torch
from torch.nn import Conv2d
from torch.utils.data import DataLoader
from tensorboardX import SummaryWriter
dataset = torchvision.datasets.CIFAR10('../data',train = False,transform = torchvision.transforms.ToTensor(),download = True)
dataloader = DataLoader(dataset,batch_size = 64)
class Myren(nn.Module):
    def __init__(self):
        super(Myren,self).__init__()
        #彩色图像是3层，6个kernel，3X3，1偏移,0,裁剪
        self.conv1 = Conv2d(3,6,3,1,0)
    def forward(self,x):
        x = self.conv1(x)
        return x
myren = Myren()
print(myren)
step = 0
writter = SummaryWriter("../logs")
for data in dataloader:
    imgs,targets = data
    output = myren.forward(imgs)
    print(imgs.shape)
    print(output.shape)
    #torch.Size([64, 3, 32, 32])
    writter.add_images("input",imgs,step)
    #torch.Size([64, 6, 30, 30]) -> [xxx,3,30,30]
    output = torch.reshape(output,(-1,3,30,30))
    writter.add_images("output",output,step)
    step = step + 1
##使用tensorboard --logdir=logs打开

image-20211129161833712

Max Pooling

相关参数

  • kernel_size – the size of the window to take a max over 池子的大小
  • stride – the stride of the window. Default value is kernel_size
  • padding – implicit zero padding to be added on both sides
  • dilation – a parameter that controls the stride of elements in the window
  • return_indices – if True, will return the max indices along with the outputs. Useful for torch.nn.MaxUnpool2d later
  • ceil_mode – when True, will use ceil instead of floor to compute the output shape 超界的时候是否算上
import torchvision
from torch import nn
import torch
from torch.nn import Conv2d
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from tensorboardX import SummaryWriter

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 = torch.reshape(input,(-1,1,5,5))
print(input.shape)

class Myren(nn.Module):
    def __init__(self):
        super().__init__()
        self.maxpool1 = MaxPool2d(kernel_size = 3,ceil_mode = True)
    def forward(self,x):
        output = self.maxpool1(x)
        return output

myren = Myren()
output = myren(input)
print(output)

测试

import torchvision
from torch import nn
import torch
from torch.nn import Conv2d
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from tensorboardX import SummaryWriter
dataset = torchvision.datasets.CIFAR10('../data',train = False,
                                       transform = torchvision.transforms.ToTensor(),download = True)
dataloader = DataLoader(dataset,batch_size = 64)

class Myren(nn.Module):
    def __init__(self):
        super().__init__()
        self.maxpool1 = MaxPool2d(kernel_size = 3,ceil_mode = True)
    def forward(self,x):
        output = self.maxpool1(x)
        return output

myren = Myren()
writer = SummaryWriter('../logs_maxpool')
step = 0
for data in dataloader:
    imgs,targets = data
    output = myren(imgs)
    #三维图像池化后也是三维的，不影响，不需要reshape
    writer.add_images('input',imgs,step)
    writer.add_images('output',output,step)
    step = step + 1

image-20211129165423015

非线性激活

Relu

ReLU(input,inplace = True)

inplace : True 的话，是否对原来变量进行一个替换

若input = -1

Relu(input,inplace = True)

input = 0

output = Relu(input,inplace = False)

output = 0 , 原数据不变

from torch.nn import ReLU
from torch import nn
import torch
input = torch.tensor([[1,-0.5],
                     [-1,3]])
input = torch.reshape(input,(-1,1,2,2))
class Myren(nn.Module):
    def __init__(self):
        super().__init__()
        self.relu1 = ReLU()
    def forward(self,input):
        output = self.relu1(input)
        return output
myren = Myren()
print(myren(input))
print(input)
###########################
tensor([[[[1., 0.],
          [0., 3.]]]])
tensor([[[[ 1.0000, -0.5000],
          [-1.0000,  3.0000]]]])

sigmoid

import torchvision
from torch import nn
import torch
from torch.nn import Conv2d
from torch.nn import MaxPool2d
from torch.nn import ReLU
from torch.nn import Sigmoid
from torch.utils.data import DataLoader
from tensorboardX import SummaryWriter

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

writer = SummaryWriter('../logs_relu')
class Myren(nn.Module):
    def __init__(self):
        super().__init__()
        self.relu1 = ReLU()
        self.sigmoid1 = Sigmoid()
    def forward(self,input):
        output = self.sigmoid1(input)
        return output
    
myren = Myren()
step = 0
for data in dataloader:
    imgs,target = data
    writer.add_images("input",imgs,step)
    output = myren(imgs)
    writer.add_images('output',output,step)
    step =step + 1

线性层

Linner

import torchvision
from torch import nn
import torch
from torch.nn import Conv2d
from torch.nn import MaxPool2d
from torch.nn import ReLU
from torch.nn import Sigmoid
from torch.nn import Linear
from torch.utils.data import DataLoader
from tensorboardX import SummaryWriter
dataset = torchvision.datasets.CIFAR10('../data',train = False,download = True,
                                       transform = torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset,batch_size = 64)

class Myren(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear1 = Linear(196608,10)
    def forward(self,input):
        output = self.linear1(input)
        return output

myren = Myren()
for data in dataloader:
    imgs,targets = data
    print(imgs.shape)
    output = torch.reshape(imgs,(1,1,1,-1))
    torch.flatten()
    print(output.shape)
    output = myren(output)
    print(output.shape)

Sequential

在Sequential中定义一系列模型

import torchvision
from torch import nn
import torch
from torch.nn import Conv2d
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from tensorboardX import SummaryWriter

class Myren(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3,32,(5,5),padding = 2)
        self.maxpool1 = nn.MaxPool2d(kernel_size = 2)
        self.conv2 = nn.Conv2d(32,32,(5,5),padding = 2)
        self.maxpool2 = nn.MaxPool2d(kernel_size = 2)
        self.conv3 = nn.Conv2d(32,64,(5,5),padding = 2)
        self.maxpool3 = nn.MaxPool2d(kernel_size = 2)
        self.flatten = nn.Flatten()
        self.linear1 = nn.Linear(1024,64)
        #最后分为10个类别
        self.linear2 = nn.Linear(64,10)
    def forward(self,input):
        input = self.conv1(input)
        input = self.maxpool1(input)
        input = self.conv2(input)
        input = self.maxpool2(input)
        input = self.conv3(input)
        input = self.maxpool3(input)
        input = self.flatten(input)
        input = self.linear1(input)
        output = self.linear2(input)
        return output

myren = Myren()

input = torch.ones((64,3,32,32))
output = myren(input)
print(output.shape)
######################################
torch.Size([64, 10])

使用Sequential

import torchvision
from torch import nn
import torch
from torch.nn import Conv2d
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from tensorboardX import SummaryWriter

class Myren(nn.Module):
    def __init__(self):
        super().__init__()
        self.model1 = nn.Sequential(
        nn.Conv2d(3,32,(5,5),padding = 2),
        nn.MaxPool2d(kernel_size = 2),
        nn.Conv2d(32,32,(5,5),padding = 2),
        nn.MaxPool2d(kernel_size = 2),
        nn.Conv2d(32,64,(5,5),padding = 2),
        nn.MaxPool2d(kernel_size = 2),
        nn.Flatten(),
        nn.Linear(1024,64),
        nn.Linear(1024,10))
        
    def forward(self,input):
        input = self.model1(input)
        return output

myren = Myren()

input = torch.ones((64,3,32,32))
output = myren(input)
print(output.shape)
####################################
torch.Size([64, 10])

#展示我们的模型
import torchvision
from torch import nn
import torch
from torch.nn import Conv2d
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from tensorboardX import SummaryWriter

class Myren(nn.Module):
    def __init__(self):
        super().__init__()
        self.model1 = nn.Sequential(
        nn.Conv2d(3,32,(5,5),padding = 2),
        nn.MaxPool2d(kernel_size = 2),
        nn.Conv2d(32,32,(5,5),padding = 2),
        nn.MaxPool2d(kernel_size = 2),
        nn.Conv2d(32,64,(5,5),padding = 2),
        nn.MaxPool2d(kernel_size = 2),
        nn.Flatten(),
        nn.Linear(1024,64),
        nn.Linear(64,10))
        
    def forward(self,input):
        input = self.model1(input)
        return output

myren = Myren()
input = torch.ones((64,3,32,32))
output = myren(input)
print(output.shape)

writer = SummaryWriter("../logs_seq")
writer.add_graph(myren.model1,input)
writer.close()

image-20211206212323903

image-20211130202541891

Loss Function

nn.CrossEntropyLoss()

在其中自动帮你做了softmax并求出了交叉熵

import torch
from torch.nn import L1Loss
import torch.nn as nn
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))

loss = L1Loss(reduction='sum')#默认是求和后取平均值
result = loss(inputs,targets)

print(result)

x = torch.tensor([0.1,0.2,0.3])
y = torch.tensor([1]) #代表选第二个0.2的
#batchsize : 1
x = torch.reshape(x,(1,3))
loss_cross = nn.CrossEntropyLoss()
result_cross = loss_cross(x,y)
print(result_cross)
#########################
tensor(2.)
tensor(1.1019)

优化器Optim

torch.optim.SGD随机梯度下降

import torchvision
from torch import nn
import torch
import torch.nn as nn
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from tensorboardX import SummaryWriter
dataset = torchvision.datasets.CIFAR10('../data',train = False,
                                       transform = torchvision.transforms.ToTensor(),download = True)
dataloader = DataLoader(dataset,batch_size = 64)
class Myren(nn.Module):
    def __init__(self):
        super().__init__()
        self.mode = nn.Sequential(
            nn.Conv2d(3,32,(5,5),padding = 2),
            nn.MaxPool2d(kernel_size = 2),
            nn.Conv2d(32,32,(5,5),padding = 2),
            nn.MaxPool2d(kernel_size = 2),
            nn.Conv2d(32,64,(5,5),padding = 2),
            nn.MaxPool2d(kernel_size = 2),
            nn.Flatten(),
            nn.Linear(1024,64),
            nn.Linear(64,10))
    def forward(self,input):
        output = self.mode(input)
        return output
        
loss = nn.CrossEntropyLoss()
myren = Myren()
#随机梯度下降
optim = torch.optim.SGD(myren.parameters(),lr=0.01)
for epoch in range(20):
    running_loss = 0.0
    for data in dataloader:
        imgs,targets = data
        outputs = myren(imgs)
        result_loss = loss(outputs,targets)
        optim.zero_grad()
        #反向传播
        result_loss.backward()
        optim.step()
        running_loss = running_loss + result_loss
    print(running_loss)

模型使用修改

模型添加：model.add_module(‘name’, nn.Linear())

image-20211206222310915

image-20211206222716270

模型修改：model.classifier[x] = nn.xxx()

模型保存加载

保存和加载

import torch
import torchvision

vgg16 = torchvision.models.vgg16(pretrained = False)
#保存方式1,保存了模型结构也保存了参数
torch.save(vgg16,"vgg16_metod1.pth")
#保存方式2，保存参数
torch.save(vgg16.state_dict(),"vgg16_metod2.pth")

import torch
import torchvision
#加载模型1
model = torch.load("vgg16_metod1.pth")
print(model)
#加载模型2
vgg16 = torchvision.models.vgg16(pretrained = False)
vgg16.load_state_dict(torch.load("vgg16_metod2.pth"))
print(vgg16)

完整模型训练

import torchvision
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from tensorboardX import SummaryWriter
#准备数据集
train_data = torchvision.datasets.CIFAR10(root = "../data",train = True,
                                          transform = torchvision.transforms.ToTensor(),
                                          download = True)
test_data = torchvision.datasets.CIFAR10(root = "../data",train = False,
                                          transform = torchvision.transforms.ToTensor(),
                                          download = True)
train_data_size = len(train_data)
test_data_size = len(test_data)
print(train_data_size)
print(test_data_size)
#加载数据集
train_dataloader = DataLoader(train_data,batch_size = 64)
test_dataloader = DataLoader(test_data,batch_size = 64)
#搭建神经网络
class Myren(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3,32,5,1,2),
            nn.MaxPool2d(2),
            nn.Conv2d(32,32,5,1,2),
            nn.MaxPool2d(2),
            nn.Conv2d(32,64,5,1,2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(1024,64),
            nn.Linear(64,10)
                )
    def forward(self,x):
        x = self.model(x)
        return x

myren = Myren()
#损失函数
loss_fn = nn.CrossEntropyLoss()
#优化器
optimizer = torch.optim.SGD(myren.parameters(),lr = 0.01)
#训练次数和步数
total_train_step = 0
total_test_step = 0
epoch = 10
#添加tensorboard
writer = SummaryWriter("../logs_train")
for i in range(epoch):
    print("--------训练轮数:{}--------".format(i+1))
    for data in train_dataloader:
        imgs,targets = data
        outputs = myren(imgs)
        loss = loss_fn(outputs,targets)
        #优化器优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        total_train_step += 1
        if(total_train_step%100 == 0):
            print("训练次数:{},loss:{}".format(total_train_step,loss.item()))
            writer.add_scalar("train_loss",loss.item(),total_train_step)
    #测试
    total_test_loss = 0
    total_test_step += 1
    total_accuracy = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs,targets = data
            outputs = myren(imgs)
            loss = loss_fn(outputs,targets)
            accuracy = (outputs.argmax(1) == targets).sum()
            total_accuracy += accuracy
            total_test_loss = total_test_loss + loss
    print("整体测试集上的Loss:{}".format(total_test_loss))
    print("整体测试集上的正确率:{}".format(total_accuracy/test_data_size))
    writer.add_scalar("test_accuracy",total_accuracy/total_test_step,total_test_step)
    writer.add_scalar("test_loss",total_test_loss,total_test_step)
    
writer.close()
HIT-Ministerry
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PyTorch-FilterResponseNormalizationLayer:PyTorch实现的“过滤器响应规范化层
04-15
PyTorch滤波器响应归一化层（FRN） 过滤器响应归一化层（FRN）的PyTorch实现 0.如何将FRN应用于您的模型 自己用FRN + TLU替换模型中的BatchNorm2d + ReLU 。 当前，很难用功能轻松地替换它们。 因为许多模型在不同的地方使用相同的ReLU。 1.实验（分类） 我们使用 数据集。 该数据集包含49位艺术家及其照片。 在此实验中，我们按图片对艺术家进行分类。 1.0假定库 火炬== 1.3.1 催化剂== 19.11.6 配基== 0.4.3 如果使用--fp16选项 1.1获取数据集 如果可以使用kaggle API命令，则可以轻松下载 $ cd input $ kaggle datasets download -d ikarus777/best-artworks-of-all-time $ unzip best-artworks-of-a
Pytorch学习笔记
长安过客君的博客
12-02 252
Pytorch学习笔记 深度学习中的batch、epoch、iteration的含义 深度学习的优化算法，说白了就是梯度下降。每次的参数更新有两种方式。 第一种，遍历全部数据集算一次损失函数，然后算函数对各个参数的梯度，更新梯度。这种方法每更新一次参数都要把数据集里的所有样本都看一遍，计算量开销大，计算速度慢，不支持在线学习，这称为Batch gradient descent，批梯度下降。 另一种...
pytorch中的filter类的作用
weixin_35754676的博客
02-08 161
是什么？Filter类在PyTorch中是什么呢？它是一个用于图像处理的工具，可以对图像进行卷积操作，以提取图像中的特征。通常，卷积操作可以用于图像识别、特征提取等任务。因此，Filter类是一个非常重要的工具，在许多计算机视觉应用中都有所应用。 ...
python--filter()函数
热门推荐
学渣的博客
11-08 2万+
描述 filter() 函数用于过滤列表形式的序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表，并以迭代器对象的形式返回。 语法 filter(function, iterable) function – 判断函数。 iterable – 可迭代对象。 示例 过滤出列表中的所有奇数 def is_odd(n): return n % 2 == 1 newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) # 因为返回的是迭代器，
pytorch快速入门文件
最新发布
10-25
1）pytorch的介绍 2）pytorch的基本操作
第2章 PyTorch快速入门.rar
08-09
在提供的"PyTorch快速入门"课程中，你将看到如何通过Jupyter Notebook实现上述概念，并通过实例理解它们的工作原理。 总之，PyTorch提供了一个强大且灵活的平台，用于深度学习模型的构建和训练。通过深入学习本课程...
Pytorch 快速入门实战之 Fashionmnist
04-24
《PyTorch快速入门实战——FashionMNIST》 在深度学习领域，PyTorch是一款备受推崇的开源框架，尤其适合初学者进行机器学习和深度学习的实践。本教程以FashionMNIST数据集为例，旨在帮助新手快速掌握PyTorch的基本...
pytorch快速入门–构建线性回归
01-20
准备数据  这里用一组比较简单的数据 x_data = torch.Tensor([[1.0],[2.0],[3.0]]) y_data = torch.Tensor([[3.0],[6.0],[9.0]]) 构建线性回归模型 #定义一个线性回归类 class Model(torch.nn.Module): ...
pytorch实现 dynamic filter convolution
Jee_King的博客
11-15 2392
代码逻辑和图片来自论文：Dynamic Multi-scale Filters for Semantic Segmentation class DCM(nn.Module): def __init__(self, in_channel=64, out_channel=64, filter_size=3): super(DCM, self).__init__() ...
pytorch载入预训练模型后，只想训练个别层怎么办？使用filter(lambda p: p.requires_grad, model.parameters())
Akita·Wang's Semantic Segmentation
05-23 2984
有了已经训练好的模型参数，对这个模型的某些层做了改变，如何利用这些训练好的模型参数继续训练 def init_weights(self, pretrained='',): logger.info('=> init weights from normal distribution') for m in self.modules(): if isinstance(m, nn.Conv2d): nn.init
PyTorch一些小知识点
fuyouzhiyi的博客
05-28 453
优化 filter lambda torch.optim.SGD(filter(lambda p: p.requires_grad, model_parameters), lr=lr, momentum=momentum,weight_decay=weight_decay) lambda 是匿名函数 ：lambda arg : expression arg是参数，expression 是参数的表...
一维卷积filter_从零开始学Pytorch（七）之卷积神经网络
weixin_36050894的博客
12-14 2160
卷积神经网络基础我们介绍卷积神经网络的卷积层和池化层，并解释填充、步幅、输入通道和输出通道的含义。import torch from torch.autograd import Variable a=Variable(torch.FloatTensor([[2.,4.]]),requires_grad=True) b=torch.zeros(1,2) b[0,0]=a[0,0]**2+a[0,1]...
Linux上安装pyTorch
cuijyer的博客
10-20 1148
官网安装pyTorch官网地址：http://pytorch.org/使用pip安装进入官网，依次选择OS、Package Manager、Python、CUDA版本，会有对应的安装command命令: 问题如果出现如下问题： RuntimeError: module compiled against API version 0xb but this version of numpy is 0x
DL知识拾贝（Pytorch）(一)：深度学习过程的通俗理解
贝壳er的博客
01-16 378
       这一系列的学习笔记是基于李沐等人的开源书《动手学深度学习（PyTorch 版本）》总结和扩展而来。感谢原作者：项目地址。        个人梳理了一下学习路线，并在知识体系中扩展了一些其他的东西，例如：讨论损失函数； 图卷积网络 ； 对抗生成网络； 注意力机制；模型压缩； 轻量化网络等等。 &nbsp...
pytorch学习的一些tips（11）
m0_46107891的博客
11-17 203
map, filter() ,torch.randperm(n)：
pytorch学习篇（一）：线性回归模型练习与解析
m0_37922496的博客
05-17 221
这边拿了两个大佬的课程作为学习 1. 莫烦老师课程线性回归 我对函数做了点修改生成了一个三次函数，代码如下： import torch import torch.nn from torch.autograd import Variable import matplotlib.pyplot as plt import torch.nn.functional as Fun def make_fake_data(): pass class Net(torch.nn.Module): def _
PyTorch ConvTranspose2d 的定义与计算过程
既然选择了远方 便只顾风雨兼程 - 永强
12-06 2875
PyTorch ConvTranspose2d 的定义与计算过程
pytorch快速入门
05-27
好的，关于PyTorch的快速入门，我先介绍一下PyTorch的基础知识。 PyTorch是一个开源的机器学习框架，它基于Python语言，由Facebook AI Research开发，旨在为深度学习研究提供高度灵活性和效率。它的特点是易于使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值