PyTorch加载数据集、训练网络一个完整的网络(优化)及其注意事项

已于 2022-09-28 19:46:18 修改
阅读量1.2k 收藏 5
点赞数 1
分类专栏： PyTorch_learn
于 2022-09-28 17:30:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45703331/article/details/127083855
版权

【注意事项总结】
全部来源：https://blog.csdn.net/qq_43665602?type=blog感谢大佬提供灵感，大家快去关注！！！

  • （一）图像尺寸有问题的，（例如通道数有3有1），先检查数据集，数据集里可能有黑白图片。再检查网络结构看是不是卷积池化这些操作导致图像尺寸发生了意想不到的变化
  • （二）写测试代码，模块测试，每个完整的方法或者类写完就单独测试一下
  • （三）修修改改网络后面的那部分，分类加softmax（建议加，人家自己就没加，应该不加也可以）Softmax的参数https://blog.csdn.net/qq_43665602/article/details/126576622?spm=1001.2014.3001.5502
  • （四）优化函数现在常用Adam
  • （五）学习率太大了，可以使用学习率衰减策略，网络开始训练希望学习率大一点，训练后期小一点。人家的已经训练的很好了，所以你做的只是微调，所以学习率可能需要小一点
  • （六）网络太复杂但是数据集太简单容易过拟合

（一）、图像尺寸问题

训练神经网络时，一个epoch还没跑完，报错：

RuntimeError: stack expects each tensor to be equal size, but got [3, 224, 224] at entry 0 and [1, 224, 224] at entry 6

读入了通道数为1的图片。
解决方式：
① 检查数据集，有一个无关的黑白图片，删掉。
② 黑白图片有用的话，将黑白图片的通道数改成3通道。
在制作数据集的getitem方法里，将获取的img转成3通道。

img=img.convert("RGB")

（二）、学会写测试模块

①制作数据集

  1. 制作数据集的时候，要将图片和标签一一对应制作好，因为在训练的时候数据集可能会打乱。
  2. getitem方法是关键：获取图像和图像的label，并且torch的神经网络接收的都是tensor数据类型，需要在制作数据集的时候进行tensor数据类型的转换。返回img，label，len。将img和label都改成tensor数据类型！！！
class MyData(Dataset):
    def __init__(self,root_dir,label_dir,transform=None):
        '''初始化类：根据一个类创建实例。为整个class/后面的函数提供全局变量'''
        '''获取图片的步骤
        1、创建图片的列表：获取文件夹；获取文件夹下所有的图片root_dir
        2、label：这里的label是图片上一级的名称(文件夹的名字)
        '''
        # self:指定了类里面的一个全局变量
        #获取图片的列表和label
        #a_base/dataset/train
        self.root_dir=root_dir
        #ants或bees，注意：文件名就是label
        self.label_dir=label_dir
        #将路径连接起来,就是ants或bees的路径
        self.path=os.path.join(self.root_dir,self.label_dir)
        #获取所有图片的地址,放在一个list里面(只是获取了所有图片的名字)
        self.img_path=os.listdir(self.path)
        self.transform=transform


    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：从路径打开图片
        img=Image.open(img_item_path)
        #img=img.convert("RGB")
        #获取label
        label=self.label_dir
        if self.transform:
            img=self.transform(img)
        if label=="ants":
            label=torch.tensor(1)
        else:label=torch.tensor(0)
        return img,label
    def __len__(self):
        '''返回数据集的长度：图片的数量'''
        return len(self.img_path)

② 创建数据集

  1. 创建数据集时，调用dataset函数，在参数里写transfrom的一系列操作
'''创建数据集'''
#获取蚂蚁的训练数据集
root_dir_train= "dataset/train"
ants_label_dir_train="ants"
ants_dataset=MyData(root_dir_train,ants_label_dir_train,
                    transform=torchvision.transforms.Compose(
                        [torchvision.transforms.Resize((224,224)),
                         torchvision.transforms.ToTensor(),]
                    ))

#查看第一张图片的信息
print(ants_dataset[0])
img,label=ants_dataset[0]
print("图片的信息：{}，图片的label：{}".format(img,label))
print('图片的数据类型：{}'.format(type(img)))
print('label的数据类型：{}'.format(type(label)))
#查看第一张图片
#img.show()
#获取蜜蜂的训练数据集
bees_label_dir_train="bees"
bees_dataset=MyData(root_dir_train,bees_label_dir_train,
                    transform=torchvision.transforms.Compose(
                        [torchvision.transforms.Resize((224,224)),
                         torchvision.transforms.ToTensor(), ]
                    ))

#获取测试集
#蚂蚁
root_dir_test="dataset/val"
ants_label_dir_test="ants"
ants_dataset_test=MyData(root_dir_test,ants_label_dir_test,
                         transform=torchvision.transforms.Compose(
                             [torchvision.transforms.Resize((224,224)),
                              torchvision.transforms.ToTensor(), ]
                         ))
#蜜蜂
bees_label_dir_test="bees"
bees_dataset_test=MyData(root_dir_test,bees_label_dir_test,
                         transform=torchvision.transforms.Compose(
                             [torchvision.transforms.Resize((224,224)),
                              torchvision.transforms.ToTensor(), ]
                         ))

#整个训练数据集:对象可以相加
train_dataset=ants_dataset+bees_dataset  #训练集的图片

#整个测试数据集：
test_dataset=ants_dataset_test+bees_dataset_test  #测试集的图片

#定义训练的设备
device=torch.device("cuda:0")

'''查看数据集的长度'''
train_data_size=len(train_dataset)
test_data_size=len(test_dataset)
print("训练数据集的长度:{}".format(train_data_size))
print("测试数据集的长度:{}".format(test_data_size))

'''利用dataloader加载数据集'''
train_dataloader=DataLoader(train_dataset,batch_size=10)
test_dataloader=DataLoader(test_dataset,batch_size=10)

输出一下结果对不对：
可以看到img和label的数据类型均为tensor数据类型。
在这里插入图片描述

③ 测试数据集是否正确

  1. 主要看是否符合网络的输入
'''测试一下数据的形状'''
for (data,label) in train_dataloader:
    print('数据:{}'.format(data))
    print('数据的形状:{}'.format(data.shape))
    print('数据类型:{}'.format(type(data)))
    print('label:{}'.format(label))
    print('label的形状:{}'.format(label.shape))
    print('label类型:{}'.format(type(label)))
    break

结果：为什么label的Size是10，因为此时batch_size是10。
在这里插入图片描述

④ 数据集没问题后准备网络

使用ResNet34预训练网络。测试的时候发现修改的网络和之前修改的网络（Resnet34）分类数都有问题！！！如何修改正确的网络看（三）修改网络。这部分只写如何测试网络。

'''3创建网络模型 resnet34 预训练的模型'''
resnet34=torchvision.models.resnet34(pretrained=True,progress=True)
resnet34.fc=nn.Sequential(
    nn.Linear(resnet34.fc.in_features,resnet34.fc.out_features),
    nn.ReLU(),
    nn.Dropout(0.2),
    nn.Linear(resnet34.fc.out_features,2)
)
resnet34.add_module("Softmax",nn.Softmax(dim=None))
resnet34=resnet34.cuda()
print(resnet34)

⑤ 对网络进行测试

  • 随机生成一个数据，让该数据经过网络，看结果是否符合预期，避免了直接使用数据集进行训练浪费资源。
inp_tensor=torch.randint(10,size=(1,3,244,244),dtype=torch.float32)
inp_tensor=inp_tensor.cuda()
print('输入图片的形状:{}'.format(inp_tensor))
out=resnet34(inp_tensor)
print('测试网络的输出结果:{}'.format(out))
print('测试网络输出结果的形状:{}'.format(out.shape))

⑥ 后面的步骤参见完整代码

（三）、修改网络

此处以ResNet34为例，将网络修改成分为两类的分类器。

① 查看ResNet34的网络结构

resnet34=torchvision.models.resnet34(pretrained=True,progress=True)
resnet34=resnet34.cuda()
print(resnet34)

结果：
在这里插入图片描述

② 对网络进行修改

  • 错误案例：修改最后一个fc层再加一个fc层
'''3创建网络模型 resnet34 预训练的模型'''
resnet34=torchvision.models.resnet34(pretrained=True,progress=True)
resnet34.fc=nn.Linear(in_features=512,out_features=128)
resnet34.add_module("fc2",nn.Linear(in_features=128,out_features=2))
resnet34.add_module("softmax",nn.Softmax())
resnet34=resnet34.cuda()
print(resnet34)

结果：分类的结果还是128！！！并没有分成2。原因是必须在fc这个模块里进行修改。
在这里插入图片描述

  • 错误案例：直接在后面加层fc层

网络模型：

resnet34=torchvision.models.resnet34(pretrained=True,progress=True)
#resnet34.fc=nn.Linear(in_features=512,out_features=2)
resnet34.add_module("fc_add",nn.Linear(in_features=1000,out_features=2))
resnet34.add_module("softmax",nn.Softmax())
resnet34=resnet34.cuda()

测试案例：

inp_tensor=torch.randint(10,size=(1,3,244,244),dtype=torch.float32)
inp_tensor=inp_tensor.cuda()
print('输入图片的形状:{}'.format(inp_tensor))
out=resnet34(inp_tensor)
print('测试网络的输出结果:{}'.format(out))
print('测试网络输出结果的形状:{}'.format(out.shape))

结果：输出的结果还是1000！！！加的out_feature=1根本没用！！！
在这里插入图片描述

  • 正确案例：整体修改fc层
resnet34=torchvision.models.resnet34(pretrained=True,progress=True)
resnet34.fc=nn.Sequential(
    nn.Linear(resnet34.fc.in_features,resnet34.fc.out_features),
    nn.ReLU(),
    nn.Dropout(0.4),
    nn.Linear(resnet34.fc.out_features,2)
)
resnet34.add_module("Softmax",nn.Softmax(dim=None))
resnet34=resnet34.cuda()
print(resnet34)

修改后的网络结构：
在这里插入图片描述
测试案例：

inp_tensor=torch.randint(10,size=(1,3,244,244),dtype=torch.float32)
inp_tensor=inp_tensor.cuda()
print('输入图片的形状:{}'.format(inp_tensor))
out=resnet34(inp_tensor)
print('测试网络的输出结果:{}'.format(out))
print('测试网络输出结果的形状:{}'.format(out.shape))

结果：可以看到成功的分成了两类
在这里插入图片描述

  • 正确案例：直接将fc层的output_feature改成想要的分类数
'''3创建网络模型 resnet34 预训练的模型'''
resnet34=torchvision.models.resnet34(pretrained=True,progress=True)
#直接修改全连接层
resnet34.fc=nn.Linear(in_features=512,out_features=2)
#加入softmax层输出的就是一个概率值
#resnet34.add_module("softmax",nn.Softmax())
resnet34=resnet34.cuda()
print(resnet34)

效果一般般。。。

（三一）、之前修改网络模型遇到的一些错误

  • Resnet34只给fc层后有加了一层fc，以为是10分类模型其实是1000分类模型，乌鱼子。。。注意Resnet修改要修改整个fc模块。
  • VGG16添加一个线性层也是要添加到模块里面去。

要点就是要将线性层加到模块里面去！！！

vgg16_t=torchvision.models.vgg16(pretrained=True,progress=True)
vgg16_t.classifier.add_module("7",nn.Linear(1000,10))
vgg16_t=vgg16_t.to(device)
print(vgg16_t)

将模型打印出来：
在这里插入图片描述
测试：分成了10类。
在这里插入图片描述

  • 在同样的条件下，VGG16的网络效果要比ResNet34好。

VGG16的效果：
在这里插入图片描述
Resnet34的效果：
在这里插入图片描述

原因可能是过拟合(在训练集上的效果好，在测试集上的效果差，泛化能力差)了，或者参数选择，模型太大等等。。。

（四）、优化函数的选择问题

参见：https://blog.csdn.net/shanglianlm/article/details/85019633

（五）、学习率衰减策略

网络训练初期希望学习率大一点，后期希望学习率小一点，可以使用学习率衰减策略。
参见：https://blog.csdn.net/qq_43665602/article/details/126981783?spm=1001.2014.3001.5502

（六）、网络太复杂数据集太简单容易过拟合

  1. 使用dropot丢失一些神经元防止过拟合
  2. 使用大型模型的一小部分

完整代码：

# function:将数据加载进来后进行分类
from torch.utils.data import Dataset
from PIL import Image
import os
import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader

#继承Dataset类
#在Dataset里就要进行图片数据类型的转换
class MyData(Dataset):
    def __init__(self,root_dir,label_dir,transform=None):
        '''初始化类：根据一个类创建实例。为整个class/后面的函数提供全局变量'''
        '''获取图片的步骤
        1、创建图片的列表：获取文件夹；获取文件夹下所有的图片root_dir
        2、label：这里的label是图片上一级的名称(文件夹的名字)
        '''
        # self:指定了类里面的一个全局变量
        #获取图片的列表和label
        #a_base/dataset/train
        self.root_dir=root_dir
        #ants或bees，注意：文件名就是label
        self.label_dir=label_dir
        #将路径连接起来,就是ants或bees的路径
        self.path=os.path.join(self.root_dir,self.label_dir)
        #获取所有图片的地址,放在一个list里面(只是获取了所有图片的名字)
        self.img_path=os.listdir(self.path)
        self.transform=transform


    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：从路径打开图片
        img=Image.open(img_item_path)
        #img=img.convert("RGB")
        #获取label
        label=self.label_dir
        if self.transform:
            img=self.transform(img)
        if label=="ants":
            label=torch.tensor(1)
        else:label=torch.tensor(0)
        return img,label
    def __len__(self):
        '''返回数据集的长度：图片的数量'''
        return len(self.img_path)

'''创建数据集'''
#获取蚂蚁的训练数据集
root_dir_train= "dataset/train"
ants_label_dir_train="ants"
ants_dataset=MyData(root_dir_train,ants_label_dir_train,
                    transform=torchvision.transforms.Compose(
                        [torchvision.transforms.Resize((224,224)),
                         torchvision.transforms.ToTensor(),]
                    ))

#查看第一张图片的信息
print(ants_dataset[0])
img,label=ants_dataset[0]
print("图片的信息：{}，图片的label：{}".format(img,label))
print('图片的数据类型：{}'.format(type(img)))
print('label的数据类型：{}'.format(type(label)))
#查看第一张图片
#img.show()
#获取蜜蜂的训练数据集
bees_label_dir_train="bees"
bees_dataset=MyData(root_dir_train,bees_label_dir_train,
                    transform=torchvision.transforms.Compose(
                        [torchvision.transforms.Resize((224,224)),
                         torchvision.transforms.ToTensor(), ]
                    ))

#获取测试集
#蚂蚁
root_dir_test="dataset/val"
ants_label_dir_test="ants"
ants_dataset_test=MyData(root_dir_test,ants_label_dir_test,
                         transform=torchvision.transforms.Compose(
                             [torchvision.transforms.Resize((224,224)),
                              torchvision.transforms.ToTensor(), ]
                         ))
#蜜蜂
bees_label_dir_test="bees"
bees_dataset_test=MyData(root_dir_test,bees_label_dir_test,
                         transform=torchvision.transforms.Compose(
                             [torchvision.transforms.Resize((224,224)),
                              torchvision.transforms.ToTensor(), ]
                         ))

#整个训练数据集:对象可以相加
train_dataset=ants_dataset+bees_dataset  #训练集的图片

#整个测试数据集：
test_dataset=ants_dataset_test+bees_dataset_test  #测试集的图片

#定义训练的设备
device=torch.device("cuda:0")

'''查看数据集的长度'''
train_data_size=len(train_dataset)
test_data_size=len(test_dataset)
print("训练数据集的长度:{}".format(train_data_size))
print("测试数据集的长度:{}".format(test_data_size))

'''利用dataloader加载数据集'''
train_dataloader=DataLoader(train_dataset,batch_size=10,shuffle=True)
test_dataloader=DataLoader(test_dataset,batch_size=10,shuffle=True)

# for batch,(img,label) in enumerate(train_dataloader):
#     channels=img.shape[1]
#     if channels==1:
#         print(batch)
#         img=torch.permute(img[0],dims=(1,2,0))
#         plt.imshow(img,cmap='gray')
#     plt.show()

'''3创建网络模型 resnet34 预训练的模型'''
resnet34=torchvision.models.resnet34(pretrained=True,progress=True)
resnet34.fc=nn.Sequential(
    nn.Linear(resnet34.fc.in_features,resnet34.fc.out_features),
    nn.ReLU(),
    nn.Dropout(0.3),
    nn.Linear(resnet34.fc.out_features,2)
)
resnet34.add_module("Softmax",nn.Softmax(dim=None))
resnet34=resnet34.cuda()
print(resnet34)

'''4创建损失函数'''
loss_fn = nn.CrossEntropyLoss()
loss_fn=loss_fn.cuda()

'''5优化器'''
learning_rate = 1e-4  # 学习率
optimizer = torch.optim.Adam(resnet34.parameters(), learning_rate, )

'''6设置训练啊网络的一些参数'''
total_train_step = 0  # 记录训练的次数
total_test_step = 0  # 记录测试的次数
epoch = 10  # 记录训练的轮数  第七轮开始往后精度不在上升


for i in range(epoch):
    print("-----------------第{}轮训练开始：------------------".format(i))

    '''训练步骤开始'''
    resnet34.train()
    total_train_accuracy=0  #训练集的正确个数
    for data in train_dataloader:
        imgs, targets = data  # 取数据
        imgs=imgs.cuda()
        targets=targets.cuda()
        outputs = resnet34(imgs)  # 送入神经网络模型
        loss = loss_fn(outputs, targets)  # 计算误差

        '''训练一次：优化器优化模型'''
        optimizer.zero_grad()  # 梯度清零
        loss.backward()  # 反向传播
        optimizer.step()  # 对参数进行优化

        total_train_step = total_train_step + 1
        print("在训练集上的训练次数：{}，loss：{}".format(total_train_step, loss.item()))  # 例如.item()可以把一个tensor数据类型转换成真实的数字

        train_accuracy = (outputs.argmax(1) == targets).sum()  # outputs.argmax(1)==targets  预测结果和标签值相同的求和
        total_train_accuracy = total_train_accuracy + train_accuracy

    #整体训练集的准确率
    print("整体训练集上的准确率:{}".format(total_train_accuracy/train_data_size))


    '''训练完一轮后，在测试数据集上进行测试，看是否需要终止训练'''
    '''测试步骤'''

    resnet34.eval()
    total_test_loss = 0
    total_accuracy = 0  # 整体正确的个数
    with torch.no_grad():  # 没有梯度
        for data in test_dataloader:
            imgs, targets = data
            imgs=imgs.cuda()
            targets=targets.cuda()
            outputs = resnet34(imgs)
            loss = loss_fn(outputs, targets)  # loss是一部分loss
            total_test_loss = loss.item() + total_test_loss  # 整体loss
            # 指标
            accuracy = (outputs.argmax(1) == targets).sum()  # outputs.argmax(1)==targets  预测结果和标签值相同的求和
            total_accuracy = total_accuracy + accuracy

    print("整体测试集上的loss:{}".format(total_test_loss))
    print("整体测试集上的正确率:{}".format(total_accuracy / test_data_size))



    total_test_step = total_test_step + 1

    '''保存模型'''
    #torch.save(resnet34, "resnet34_t_{}.pth".format(i))  # 将每一轮训练的结果都保存一下
    #print("模型已经保存")

在小蜜蜂分类上的效果哈行~
在这里插入图片描述

待定的问题

CIFAR10模型上效果较差，使用学习率衰减策略试一下
前期的图像处理问题
冻结一部分参数，修改网络的一部分参数

莫听穿林打叶声@
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
【Pytorch学习笔记】pytorch加载网络模型示例
热情、奔放、快乐编程！
12-04 233
本文主要介绍记录如何使用pytorch加载一个网络模型到神经网络的例子，仅供参考学习使用。代码如下（示例）： 2.定义网络 代码如下（示例）： 3.保存，并加载模型参数(仅保存模型参数) 4.将net的参数全部置0，方便对比 5.通过load_state_dict 加载参数 二、完整代码 总结 以上就是今天要讲的内容，pytorch加载网络模型示例。
【pytorch】（deeplizard22-26）加载数据 | 训练模型 | 计算梯度 | 优化
Hensere的博客
08-24 607
p22 将一个图像传递到网络中并输出预测 理解前向传播：将输入张量转换为输出张量的过程 将前面的一系列整合： 在开始之前，要关闭pytorch的梯度计算特性，这将阻止pytorch通过网络将张量构建成一个计算图。这个计算图通过跟踪张量在网络中传播的每一个计算来跟踪网络的映射，然后在训练过程中使用这个图形来计算导数（损失函数的导数），在训练模型的时候才打开。 预测的张量形状是[1,10]，第一个轴长度是1，第二个轴长度是10：即在批处理中有一个图像和10个预测类。第一个图像的标签是
Pytorch深度学习——优化算法、数据集类、数据加载器 05
#仙女不扎马尾#的博客
09-25 888
总结：在自定义的数据集类中，继承Dataset类，同时需要实现两个方法__len__： 能够实现通过全局的len() 方法获取其中的元素个数；： 能够通过传入索引的方式获取数据，例如通过dataset[i]获取其中的第i条数据。6万个训练，1万个测试，都是黑白图像，像素是28*28可以看出，返回值是（图片，目标值）
Pytorch学习笔记5——优化和加载保存模型
qq_50003999的博客
11-18 445
Pytorch学习笔记5——Optimization&&SAVE AND LOAD THE MODEL**Pytorch Learning Notes**1.Optimization1.1 先前的代码1.2 超参数1.3 Epoch1.4 损失函数1.5 Optimizer1.6 Full Implementation2.SAVE AND LOAD THE MODEL Pytorch Learning Notes 1.Optimization 搭建完模型load完数据后，便需要对模型的参数进
使用内存映射加快PyTorch数据集的读取
数据派THU
08-14 311
来源：DeepHub IMBA 本文约1800字，建议阅读9分钟本文将介绍如何使用内存映射文件加快PyTorch数据集的加载速度。在使用Pytorch训练神经网络时，最常见的与速度相关的瓶颈是数据加载的模块。如果我们将数据通过网络传输，除了预取和缓存之外，没有任何其他的简单优化方式。但是如果数据本地存储，我们可以通过将整个数据集组合成一个文件，然后映射到内存中来优化读取操...
一个神经网络的的例子，基于Resnet的医学数据集分类实战，包含说明
最新发布
06-20
3. **数据集加载**：描述如何组织和加载数据集，可能是使用`ImageDataGenerator`类或其他自定义函数。 4. **ResNet模型构建**：展示如何利用深度学习库构建ResNet模型，可能包括ResNet50、ResNet101等不同变种。 5. ...
【BP回归预测】基于BP神经网络实现数据预测附Python代码+数据集.zip
09-08
总的来说，这个压缩包提供了一个完整的 BP 回归预测的示例，包括 Python 代码和所需的数据集，对于初学者和进阶者都是很好的学习材料。通过理解和实践这些内容，你将能够掌握 BP 神经网络在回归预测中的应用。
pytorch制作自己的LMDB数据操作示例
09-18
PyTorch作为一个流行的深度学习框架，可以和LMDB无缝集成，用于制作训练数据集和推理数据的快速读取。 ### PyTorch制作LMDB数据操作实例 #### 导入必要的库 ```python import lmdb import cv2 import numpy as np...
Pytorch 完整的模型训练套路
别下完这场雪
02-16 2105
Pytorch 完整的模型训练套路 model.py import torch from torch import nn # 搭建神经网络 class Model(nn.Module): def __init__(self) -> None: super().__init__() self.model = nn.Sequential( nn.Conv2d(3, 32, 5, 1, 2), nn.MaxPool2
PyTorch - 26 - CNN训练循环说明 - 神经网络代码项目
weixin_48367136的博客
01-12 908
欢迎来到这个神经网络编程系列。 在本集中，我们将学习如何使用Python为卷积神经网络构建训练循环。
pytorch加载自定义网络权重的实现
09-18
今天小编就为大家分享一篇pytorch加载自定义网络权重的实现，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
pytorch框架--网络方面--模型保存与加载
雪剑封心
11-23 392
模型保存与加载示例 保存 import torch import torchvision vgg16 = torchvision.models.vgg16(pretrained=False) # 保存方式一 torch.save(vgg16, "vgg16_.pth") # 保存方式二 torch.save(vgg16.state_dict(), "vgg16_1.pth") 加载 import torch import torchvision # 加载方式1 # moudel = torch.l
Pytorch自己的网络模型的保存和加载
RuanJianNB的博客
11-21 763
自己在加载模型时总会遇到各种各样的问题，然后稀里糊涂的解决，写一下引以为戒
在pytorch中 保存 和加载神经网络
热门推荐
东方佑
06-14 15万+
import torch import matplotlib.pyplot as plt torch.manual_seed(1) # reproducible fake data x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1) # x data (tensor), shape=(100, 1) y = x.pow(2) + 0...
【PyTorch】模型的保存与读取
安静
07-17 508
import torch import torch.nn as nn from torch.autograd import Variable import torch.nn.functional as F import torch.optim as optim import matplotlib.pyplot as plt import numpy as np #torch.manual_se...
pytorch 加载已训练网络的部分层到新网络
qq_36450004的博客
06-05 1245
最近正在学习迁移学习，现在有两个结构一样的网络，一个是已经训练好的网络B，一个是新构建的网络T。现在的目标是将T网络的前 m 层直接使用B网络前 m 层以训练好的参数，同时可以选择在训练T网络时，是否冻结（frozen）B网络的前 m 层。 废话不多说，直接上代码： NumTransfer_layers = 1 # 只迁移前1层 count = 0 for t, b in zip(Tmodel.children(), Bmodel.children()): count += 1 if cou
Pytorch运行自己的数据集（基于小土堆）
混吃等死，研究生在读，毕业无望，偶尔搞点好玩的
10-14 1012
用自己的数据集训练模型（Pytorch）
pytorch深度学习——现有网络模型的使用、修改、保存、加载
m0_51474171的博客
06-15 630
以vgg16为例 代码示例： 输出：通过输出可以看到vgg16基本的网络架构在这个network下，最后一个线性函数输出为1000，说明可能在这个训练中，最后分类为1000种，如果想把最后的输出修改为10，有下面三个方式两种方式，一个是保存现有模型的结构，一个是字典形式保存 代码示例 model_save.py model_load.py 方式一的输出： 方式二的输出：...
PyTorch 性能调优指南 | （一）一般优化方法
Galaxy_Husky的博客
06-22 1541
性能调优指南是一套优化方法和最佳实践方式，可以加速PyTorch 深度学习模型的训练和推理。所介绍的技术通常可以通过仅更改几行代码来实现，并且可以应用于跨所有领域的广泛的深度学习模型。
PyTorch神经网络训练实战教程：模型构建与数据集设计
本教程旨在提供一个通俗易懂的PyTorch神经网络训练指南，适合初学者和大创项目组员。通过作者个人经验，讲解如何使用PyTorch构建和训练神经网络模型。教程主要涉及以下几个关键步骤： 1. **网络模型设计**： - ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

莫听穿林打叶声@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值