pytorch教程龙曲良41-45

最新推荐文章于 2023-04-30 14:19:10 发布
最新推荐文章于 2023-04-30 14:19:10 发布
阅读量261 收藏 3
点赞数
分类专栏： pytorch 文章标签： 深度学习 python 人工智能 pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sueong/article/details/116857407
版权

41激活函数与GPU加速

sigmoid /Tanh 会出现梯度离散问题，就是梯度为0（导数为0）
relu 在x=0处不连续，x小于0时梯度为0，x大于0梯度为1不变，利于串行的传播，这样就不会出现梯度爆炸或梯度离散的情况

在这里插入图片描述
relu x小于0时梯度为0，为解决这个在x小于0部分 设置了y=a*x，使得有一定的梯度a而不是0，斜角一般默认0.02的样子
在这里插入图片描述
在这里插入图片描述
selu=relu+指数函数，使得在x=0出也有平滑的曲线变得连续。
在这里插入图片描述
softplus， 是relu在x=0做个平滑的曲线使得其在附近连续

gpu加速
使用.to(device)方法
注意data和data.to(device)的类型是不一样的 因为一个是cpu版本一个是gpu版本，除此之外的.to(deviece)是一样的
在这里插入图片描述

 激活函数改成leakyrelu且搬到gpu上加速， 比原来的relu acc从83%变94%

# 超参数
from torchvision import datasets, transforms

batch_size = 200
learning_rate = 0.01
epochs = 10

# 获取训练数据
train_db = datasets.MNIST('../data', train=True, download=True,  # train=True则得到的是训练集
                          transform=transforms.Compose([  # transform进行数据预处理
                              transforms.ToTensor(),  # 转成Tensor类型的数据
                              transforms.Normalize((0.1307,), (0.3081,))  # 进行数据标准化(减去均值除以方差)
                          ]))

# DataLoader把训练数据分成多个小组，此函数每次抛出一组数据。直至把所有的数据都抛出。就是做一个数据的初始化
train_loader = torch.utils.data.DataLoader(train_db, batch_size=batch_size, shuffle=True)

# 获取测试数据
test_db = datasets.MNIST('../data', train=False,
                         transform=transforms.Compose([
                             transforms.ToTensor(),
                             transforms.Normalize((0.1307,), (0.3081,))
                         ]))

test_loader = torch.utils.data.DataLoader(test_db, batch_size=batch_size, shuffle=True)


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

        self.model=nn.Sequential(#sequential串联起来
            nn.Linear(784,200),
            nn.LeakyReLU(inplace=True),
            nn.Linear(200, 200),
            nn.LeakyReLU(inplace=True),
            nn.Linear(200,10),
            nn.LeakyReLU(inplace=True),
        )
    def forward(self,x):
        x = self.model(x)
        return x



#Train
device=torch.device('cuda:0')
net=MLP().to(device)#网络结构 就是foward函数
optimizer=optim.SGD(net.parameters(),lr=learning_rate)#使用nn.Module可以直接代替之前[w1,b1,w2,b2.。。]
criteon=nn.CrossEntropyLoss().to(device)

for epoch in range(epochs):
    for batch_ind,(data,target) in enumerate(train_loader):
        data=data.view(-1,28*28)
        data,target=data.to(device),target.to(device) #target.cuda()

        logits=net(data)#这不要再加softmax logits就是pred
        loss=criteon(logits,target)#求loss

        optimizer.zero_grad()
        loss.backward()

        optimizer.step()

        if batch_ind%100==0:
            print('Train Epoch：{} [{}/{} ({:.0f}%)]\t Loss:{:.6f}'.format(
                epoch,batch_ind*len(data),len(train_loader.dataset),
                100.* batch_ind/len(train_loader),loss.item()
            ))

test_loss=0
correct=0

for data,target in test_loader:
    data=data.view(-1,28*28)#第一个维度保持不变写-1
    data, target = data.to(device), target.to(device)
    logits=net(data)
    test_loss+=criteon(logits,target).item()

    pred=logits.data.max(1)[1]#因为
    correct+=pred.eq(target.data).sum()

test_loss/=len(train_loader.dataset)
print('\n test set:average loss：{:.4f},Accuracy:{}/{} ({:.0f}%)\n'.format(
    test_loss,correct,len(test_loader.dataset),
    100.*correct/len(test_loader.dataset)
))

'''
F:\anaconda\envs\pytorch\python.exe F:/pythonProject1/pythonProject3/ll.py
Train Epoch：0 [0/60000 (0%)]	 Loss:2.315502
Train Epoch：0 [20000/60000 (33%)]	 Loss:2.117644
Train Epoch：0 [40000/60000 (67%)]	 Loss:1.659186
Train Epoch：1 [0/60000 (0%)]	 Loss:1.290930
Train Epoch：1 [20000/60000 (33%)]	 Loss:1.049087
Train Epoch：1 [40000/60000 (67%)]	 Loss:0.872082
Train Epoch：2 [0/60000 (0%)]	 Loss:0.528612
Train Epoch：2 [20000/60000 (33%)]	 Loss:0.402818
Train Epoch：2 [40000/60000 (67%)]	 Loss:0.400452
Train Epoch：3 [0/60000 (0%)]	 Loss:0.318432
Train Epoch：3 [20000/60000 (33%)]	 Loss:0.344411
Train Epoch：3 [40000/60000 (67%)]	 Loss:0.443066
Train Epoch：4 [0/60000 (0%)]	 Loss:0.310835
Train Epoch：4 [20000/60000 (33%)]	 Loss:0.263893
Train Epoch：4 [40000/60000 (67%)]	 Loss:0.292117
Train Epoch：5 [0/60000 (0%)]	 Loss:0.331171
Train Epoch：5 [20000/60000 (33%)]	 Loss:0.192741
Train Epoch：5 [40000/60000 (67%)]	 Loss:0.396357
Train Epoch：6 [0/60000 (0%)]	 Loss:0.363707
Train Epoch：6 [20000/60000 (33%)]	 Loss:0.225204
Train Epoch：6 [40000/60000 (67%)]	 Loss:0.218652
Train Epoch：7 [0/60000 (0%)]	 Loss:0.209941
Train Epoch：7 [20000/60000 (33%)]	 Loss:0.210056
Train Epoch：7 [40000/60000 (67%)]	 Loss:0.296629
Train Epoch：8 [0/60000 (0%)]	 Loss:0.361880
Train Epoch：8 [20000/60000 (33%)]	 Loss:0.213277
Train Epoch：8 [40000/60000 (67%)]	 Loss:0.170169
Train Epoch：9 [0/60000 (0%)]	 Loss:0.301176
Train Epoch：9 [20000/60000 (33%)]	 Loss:0.175931
Train Epoch：9 [40000/60000 (67%)]	 Loss:0.214820

 test set:average loss：0.0002,Accuracy:9370/10000 (94%)


Process finished with exit code 0

'''

42测试方法

当在train上面不停的train，可能会使得loss很低 accuracy很高，但其实模型只是记住很浅层的东西，不能学习本质上的东西，造成over fitting过拟合，在validation上做test就可以发现在后面阶段acc不稳定甚至下降，loss不稳定甚至上升，所以不是说越训练越好，数据量和架构是核心
在这里插入图片描述

logits=torch.rand(4,10)
#四张图片每张图片10维的vector（代表特征：类别0-9）
pred=F.softmax(logits,dim=1)
#在dim=1上做softmax 因为希望对每张图片的输出值做softmax， 再dim=0做softmax结果也是[4，10]的tensor但是结果不同

pred_label=pred.argmax(dim=1)
logits.argmax(dim=1)
#先对pred的值做argmax，再对logits的值做argmax，返回的都是[b]大小的tensor，发现是二者的argmax是一样的，因为4张图片每张图片都有一个最大可能性的label，所以对pred还是对logits对argmax都可以


correct=torch.eq(pred_label,label)#比较是否预测正确
correct.sum().float().item()/4#就是acc 因为correct是tensor，.item()取标量

在这里插入图片描述
控制精度test频率变高，花大量时间train就是test频率变小
在这里插入图片描述

# -*- codeing = utf-8 -*-
# @Time :2021/5/14 21:06
# @Author:sueong
# @File:ll.py
# @Software:PyCharm
import torch
import torch.nn as nn
from torch import optim

# 超参数
from torchvision import datasets, transforms

batch_size = 200
learning_rate = 0.01
epochs = 10

# 获取训练数据
train_db = datasets.MNIST('../data', train=True, download=True,  # train=True则得到的是训练集
                          transform=transforms.Compose([  # transform进行数据预处理
                              transforms.ToTensor(),  # 转成Tensor类型的数据
                              transforms.Normalize((0.1307,), (0.3081,))  # 进行数据标准化(减去均值除以方差)
                          ]))

# DataLoader把训练数据分成多个小组，此函数每次抛出一组数据。直至把所有的数据都抛出。就是做一个数据的初始化
train_loader = torch.utils.data.DataLoader(train_db, batch_size=batch_size, shuffle=True)

# 获取测试数据
test_db = datasets.MNIST('../data', train=False,
                         transform=transforms.Compose([
                             transforms.ToTensor(),
                             transforms.Normalize((0.1307,), (0.3081,))
                         ]))

test_loader = torch.utils.data.DataLoader(test_db, batch_size=batch_size, shuffle=True)


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

        self.model=nn.Sequential(#sequential串联起来
            nn.Linear(784,200),
            nn.LeakyReLU(inplace=True),
            nn.Linear(200, 200),
            nn.LeakyReLU(inplace=True),
            nn.Linear(200,10),
            nn.LeakyReLU(inplace=True),
        )
    def forward(self,x):
        x = self.model(x)
        return x



#Train
device=torch.device('cuda:0')
net=MLP().to(device)#网络结构 就是foward函数
optimizer=optim.SGD(net.parameters(),lr=learning_rate)#使用nn.Module可以直接代替之前[w1,b1,w2,b2.。。]
criteon=nn.CrossEntropyLoss().to(device)

for epoch in range(epochs):
    for batch_ind,(data,target) in enumerate(train_loader):
        data=data.view(-1,28*28)
        data,target=data.to(device),target.to(device) #target.cuda()

        logits=net(data)#这不要再加softmax logits就是pred
        loss=criteon(logits,target)#求loss

        optimizer.zero_grad()
        loss.backward()

        optimizer.step()

        if batch_ind%100==0:
            print('Train Epoch：{} [{}/{} ({:.0f}%)]\t Loss:{:.6f}'.format(
                epoch,batch_ind*len(data),len(train_loader.dataset),
                100.* batch_ind/len(train_loader),loss.item()
            ))
    #每一个epcho test一次可以发现acc再增加
    test_loss=0
    correct=0

    for data,target in test_loader:
        data=data.view(-1,28*28)#第一个维度保持不变写-1
        data, target = data.to(device), target.to(device)
        logits=net(data)
        test_loss+=criteon(logits,target).item()

        pred=logits.data.max(1)[1]#因为
        correct+=pred.eq(target.data).sum()

    test_loss/=len(train_loader.dataset)
    print('\n test set:average loss：{:.4f},Accuracy:{}/{} ({:.0f}%)\n'.format(
        test_loss,correct,len(test_loader.dataset),
        100.*correct/len(test_loader.dataset)
    ))
'''
F:\anaconda\envs\pytorch\python.exe F:/pythonProject1/pythonProject3/ll.py
Train Epoch：0 [0/60000 (0%)]	 Loss:2.308717
Train Epoch：0 [20000/60000 (33%)]	 Loss:2.017611
Train Epoch：0 [40000/60000 (67%)]	 Loss:1.563952

 test set:average loss：0.0011,Accuracy:6175/10000 (62%)

Train Epoch：1 [0/60000 (0%)]	 Loss:1.301144
Train Epoch：1 [20000/60000 (33%)]	 Loss:1.313298
Train Epoch：1 [40000/60000 (67%)]	 Loss:1.184744

 test set:average loss：0.0008,Accuracy:7102/10000 (71%)

Train Epoch：2 [0/60000 (0%)]	 Loss:0.946402
Train Epoch：2 [20000/60000 (33%)]	 Loss:0.762401
Train Epoch：2 [40000/60000 (67%)]	 Loss:0.697880

 test set:average loss：0.0004,Accuracy:8841/10000 (88%)

Train Epoch：3 [0/60000 (0%)]	 Loss:0.579781
Train Epoch：3 [20000/60000 (33%)]	 Loss:0.480412
Train Epoch：3 [40000/60000 (67%)]	 Loss:0.347749

 test set:average loss：0.0003,Accuracy:9047/10000 (90%)

Train Epoch：4 [0/60000 (0%)]	 Loss:0.363675
Train Epoch：4 [20000/60000 (33%)]	 Loss:0.304079
Train Epoch：4 [40000/60000 (67%)]	 Loss:0.401550

 test set:average loss：0.0003,Accuracy:9118/10000 (91%)

Train Epoch：5 [0/60000 (0%)]	 Loss:0.324268
Train Epoch：5 [20000/60000 (33%)]	 Loss:0.269142
Train Epoch：5 [40000/60000 (67%)]	 Loss:0.284855

 test set:average loss：0.0002,Accuracy:9195/10000 (92%)

Train Epoch：6 [0/60000 (0%)]	 Loss:0.181122
Train Epoch：6 [20000/60000 (33%)]	 Loss:0.214253
Train Epoch：6 [40000/60000 (67%)]	 Loss:0.310929

 test set:average loss：0.0002,Accuracy:9229/10000 (92%)

Train Epoch：7 [0/60000 (0%)]	 Loss:0.233558
Train Epoch：7 [20000/60000 (33%)]	 Loss:0.345559
Train Epoch：7 [40000/60000 (67%)]	 Loss:0.240973

 test set:average loss：0.0002,Accuracy:9286/10000 (93%)

Train Epoch：8 [0/60000 (0%)]	 Loss:0.197916
Train Epoch：8 [20000/60000 (33%)]	 Loss:0.368038
Train Epoch：8 [40000/60000 (67%)]	 Loss:0.367101

 test set:average loss：0.0002,Accuracy:9310/10000 (93%)

Train Epoch：9 [0/60000 (0%)]	 Loss:0.221928
Train Epoch：9 [20000/60000 (33%)]	 Loss:0.190280
Train Epoch：9 [40000/60000 (67%)]	 Loss:0.183632

 test set:average loss：0.0002,Accuracy:9351/10000 (94%)


Process finished with exit code 0

'''

43可视化

TensorBoard
在这里插入图片描述

visdom

1安装
在这里插入图片描述
2 run server damon
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

legend里面放的是y1y2的一个图标
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

# -*- codeing = utf-8 -*-
# @Time :2021/5/14 21:06
# @Author:sueong
# @File:ll.py
# @Software:PyCharm
import torch
import torch.nn as nn
from torch import optim
from visdom import Visdom

# 超参数
from torchvision import datasets, transforms
from visdom import Visdom

batch_size = 200
learning_rate = 0.01
epochs = 10

# 获取训练数据
train_db = datasets.MNIST('../data', train=True, download=True,  # train=True则得到的是训练集
                          transform=transforms.Compose([  # transform进行数据预处理
                              transforms.ToTensor(),  # 转成Tensor类型的数据
                              transforms.Normalize((0.1307,), (0.3081,))  # 进行数据标准化(减去均值除以方差)
                          ]))

# DataLoader把训练数据分成多个小组，此函数每次抛出一组数据。直至把所有的数据都抛出。就是做一个数据的初始化
train_loader = torch.utils.data.DataLoader(train_db, batch_size=batch_size, shuffle=True)

# 获取测试数据
test_db = datasets.MNIST('../data', train=False,
                         transform=transforms.Compose([
                             transforms.ToTensor(),
                             transforms.Normalize((0.1307,), (0.3081,))
                         ]))

test_loader = torch.utils.data.DataLoader(test_db, batch_size=batch_size, shuffle=True)


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

        self.model=nn.Sequential(#sequential串联起来
            nn.Linear(784,200),
            nn.LeakyReLU(inplace=True),
            nn.Linear(200, 200),
            nn.LeakyReLU(inplace=True),
            nn.Linear(200,10),
            nn.LeakyReLU(inplace=True),
        )
    def forward(self,x):
        x = self.model(x)
        return x



#Train
device=torch.device('cuda:0')
net=MLP().to(device)#网络结构 就是foward函数
optimizer=optim.SGD(net.parameters(),lr=learning_rate)#使用nn.Module可以直接代替之前[w1,b1,w2,b2.。。]
criteon=nn.CrossEntropyLoss().to(device)


#在训练-测试的迭代过程之前，定义两条曲线，这里相当于是占位，
#在训练-测试的过程中再不断填充点以实现曲线随着训练动态增长：
'''
这里第一步可以提供参数env='xxx'来设置环境窗口的名称，这里什么都没传，所以是在默认的main窗口下。

第二第三步的viz.line的前两个参数是曲线的Y和X的坐标（前面是纵轴后面才是横轴），
这里为了占位所以都设置了0（实际上为Loss初始Y值设置为0的话，
在图中刚开始的地方会有个大跳跃有点难看，因为Loss肯定是从大往小了走的）。
为它们设置了不同的win参数，它们就会在不同的窗口中展示，
因为第三步定义的是测试集的loss和acc两条曲线，所以在X等于0时Y给了两个初始值。
 
'''

viz = Visdom()
viz.line([0.], [0.], win='train_loss', opts=dict(title='train loss'))
viz.line([[0.0, 0.0]], [0.], win='test', opts=dict(title='test loss&acc.',legend=['loss', 'acc.']))

global_step = 0
#为了知道训练了多少个batch了，紧接着设置一个全局的计数器：

for epoch in range(epochs):
    for batch_ind,(data,target) in enumerate(train_loader):
        data=data.view(-1,28*28)
        data,target=data.to(device),target.to(device) #target.cuda()

        logits=net(data)#这不要再加softmax logits就是pred
        loss=criteon(logits,target)#求loss

        optimizer.zero_grad()
        loss.backward()
        # print(w1.grad.norm(), w2.grad.norm())

        optimizer.step()
        #在每个batch训练完后，为训练曲线添加点，来让曲线实时增长：
        #注意这里用win参数来选择是哪条曲线，
        # 用update='append'的方式添加曲线的增长点，前面是Y坐标，后面是X坐标。
        global_step+=1
        viz.line([loss.item()], [global_step], win='train_loss', update='append')

        if batch_ind%100==0:
            print('Train Epoch：{} [{}/{} ({:.0f}%)]\t Loss:{:.6f}'.format(
                epoch,batch_ind*len(data),len(train_loader.dataset),
                100.* batch_ind/len(train_loader),loss.item()
            ))
    #每一个epcho test一次可以发现acc再增加
    test_loss=0
    correct=0

    for data,target in test_loader:
        data=data.view(-1,28*28)#第一个维度保持不变写-1
        data, target = data.to(device), target.to(device)
        logits=net(data)
        test_loss+=criteon(logits,target).item()

        pred=logits.data.max(1)[1]# 在dim=1上找最大值
        correct += pred.eq(target).float().sum().item()

    #在每次测试结束后， 并在另外两个窗口（用win参数设置）中展示图像（.images）和真实值（文本用.text）：
    viz.line([[test_loss, correct / len(test_loader.dataset)]],[global_step], win='test', update='append')
    viz.images(data.view(-1, 1, 28, 28), win='x')
    viz.text(str(pred.detach().cpu().numpy()), win='pred',
             opts=dict(title='pred'))#老师的代码里用到了.detach()，并把数据搬到了CPU上，这样才能展示出来。

    test_loss/=len(train_loader.dataset)
    print('\n test set:average loss：{:.4f},Accuracy:{}/{} ({:.0f}%)\n'.format(
        test_loss,correct,len(test_loader.dataset),
        100.*correct/len(test_loader.dataset)
    ))

44欠拟合和过拟合

在这里插入图片描述
在这里插入图片描述

真实分布符合认知，但是不知道真实的分布和function的参数
在这里插入图片描述
而且这些函数不是线性的可能存在噪声在这里插入图片描述
次方越大，波形越大，抖动越大波形越复杂
在这里插入图片描述
衡量模型的学习能力，次方增加了，表达能力增强，能表达的分布更复杂，对复杂的映射也能学习到，即model capacity增大了

在这里插入图片描述
在这里插入图片描述
estimated用的模型的表达能力
ground-truth真实模型的复杂度
case1:Estimated<Ground-truth :under-fitting,用的模型表达能力不够导致欠拟合
在这里插入图片描述

在这里插入图片描述
underfitting的表现，增加模型复杂度/层数是否得到改善在这里插入图片描述
case2:Ground-truth<Estimated :under-fitting,模型过于复杂，在有限数据集上包含了噪声，过拟合导致泛化能力不好
在train上很好 但是test不好在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
现实中通常是overfitting
在这里插入图片描述

45交叉验证 1Train-Val-Test划分

在这里插入图片描述
我们做test的目的是看有没有overfitting 选取在overfitting之前最好的参数，这里的test_loader其实的validation

在这里插入图片描述
我们一般选取test acc最高的点，然后终止训练，然后选取最高点作为模型的最终状态
在这里插入图片描述

保存在overfitting前效果最好的参数w和b
在这里插入图片描述
val set：挑选模型参数，在overfitting前停止train
test set：测试，是交给客户在验收的时候看性能怎么样（test是模型不知道的数据，防止val和train一起训练，如果客户用val测试，那么val已经train过了效果就很好就是作弊）

因为test是看不见的，如果根据test set反馈的acc去调整参数，那么test和val的功能就一样就会造成数据污染
在这里插入图片描述

sueong
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pytorch教程龙曲良06-10
sueong的博客
05-09 463
06手写数字识别1 每张图片2828 针对y=wx+b 对于手写数字图片来说可以用灰度0-1表示，所以就是2828值在0-1的矩阵，然后打平变成784的向量 y的维度怎么表示 法1先讨论H1，H2，H3的维度，以下都表示维度，Hi不断作为Hi+1的一个输入，如[1,784]表示一行784列，但这样h1，h2…h9存在大小关系，没有相关性 ， 07手写数字识别02 法2用one-hot去表示概率， 1=[0,1,0,0,0,0,0,0,0,0] 3=[0,0,0,1,0,0,0,0,0,0] 求loss
龙曲良版本的pytorch学习
aliuxuwhy的博客
08-18 965
1 权重参数的更新（Optimer.step()） ：根据上述计算的梯度值，不断进行权重参数得更新 参数优化目的：不断更新权重参数，使得损失值达到最小。 参数优化的方法：权重参数=权重参数-权重参数梯度学习率 损失值计算的方法：给定参数计算损失值； loss = inputw.t() +b – target 的平方 例子： 求 y=wx+b的参数，给100个点( x , y )； 解法：我们已知(x,y)的N个点，此时我们定义的损失函数如上所示，不断更新权重参数W和B，使得总损失值最小（根据已知的x,
pytorch教程龙曲良01-05
sueong的博客
05-08 699
01深度学习框架与介绍 pytorch优势 1使用gpu加速 # -*- codeing = utf-8 -*- # @Time :2021/5/6 20:51 # @Author:sueong # @File:grad.py # @Software:PyCharm import torch import time print(torch.__version__) print(torch.cuda.is_available()) a=torch.randn(10000,1000)#a矩阵 b=torch
pytorch教程龙曲良16-20
sueong的博客
05-12 324
17维度变换4 .t 转置，但是只适合2d的矩阵，其他会报错 a.shape#[3,4] a.t() a.shape#[4,3] transpose 加粗样式
TensorFlow深度学习-龙曲良-学习笔记1
HELLOWORLD2424的博客
02-14 1301
TensorFlow深度学习-龙曲良-学习笔记 1. 经典的深度学习网络规模 AlexNet(8 层) VGG16(16 层) GoogLeNet(22 层) ResNet50(50 层) DenseNet121(121 层) 2. TensorFlow基础介绍 TensorFlow 2 和 PyTorch 都是采用动态图(优先)模式开发，调试方便，所见即所得。一般来说，动态图模式开发效率高，但是运行效率可能不如静态图模式。TensorFlow 2 也支持通过 tf.function 将动态图优先模式的
pytorch-grad-cam-master.zip
05-29
在提供的"pytorch-grad-cam-master.zip"文件中，包含了实现Grad-CAM的PyTorch代码。这个项目可能包含了一个简单的图像分类网络，以及使用Grad-CAM可视化功能的脚本。通过运行这些代码，你可以观察到模型在处理不同...
a-PyTorch-Tutorial-to-Image-Captioning-master_pytorch_
09-30
本教程将引导你入门PyTorch，通过实例学习其基本原理和操作。 **基础原理知识** 1. **张量(Tensors)**：PyTorch的基础数据结构是张量，类似于多维数组。张量可以在CPU或GPU上运行，支持各种数学运算，如加法、乘法...
a-PyTorch-Tutorial-to-Image-Captioning:显示，参加和讲述| PyTorch教程以进行图像字幕
05-07
这是图像字幕的教程。 这是我正在编写的第一篇，是关于如何使用令人惊叹的PyTorch库自己实现酷模型的。 假定具备PyTorch，卷积和递归神经网络的基本知识。 如果您是PyTorch的新手，请先阅读PyTorch的和 。 问题...
PyTorch-Image-Models-Multi-Label-Classification-main.zip
03-26
PyTorch-Image-Models-Multi-Label-Classification-main.zip
Python库 | pytorch_lightning-1.1.2-py3-none-any.whl
05-09
资源分类：Python库 所属语言：Python 资源全名：pytorch_lightning-1.1.2-py3-none-any.whl 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
PyTorch 学习资源（代码类）
07-24
pytorch教程，代码类，分章节，共10章。
2019最新pytorch教程
02-09
 这本书面向数据科学家、自然语言处理工程师、人工智能解决方案开发人员、从事图形计算框架的现有从业人员以及图论研究人员。这本书主要讲解张量（Tensor）的基础知识、计算、执行基于算术的运算、矩阵代数和使用PyTorch框架的基于统计分布式运算。
cv学习路线个人向
weixin_44611320的博客
04-11 1947
仅作为初学者的cv路线参考
【龙良曲博士】深度学习与PyTorch-lesson5-手写数字问题
qq_45000512的博客
04-30 157
【代码】【龙良曲博士】深度学习与PyTorch-lesson5-手写数字问题。
龙良曲pytorch基础课程学习笔记
kexiaoleqq的博客
01-13 3771
什么是Pytorch? PyTorch 是一个基于 Python 的科学计算包，主要定位两类人群： NumPy 的替代品，可以利用 GPU 的性能进行计算 深度学习研究平台拥有足够的灵活性和速度 开始学习 tensor对象 在 TensorFlow 中，数据不是以整数，浮点数或者字符串形式存在的，而是被封装在一个叫做 tensor 的对象中。Tensor是张量的意思，张量包含了0到任意维度的量...
CurveNet点云分类和分割
topsogn的博客
01-10 1064
介绍CurveNet点云分类和分割模型的具体流程
torch.utils.data中Dataset TensorDataset以及Dataloader
lbj23hao1的博客
04-26 7637
在打包自己处理的数据时有两种方法： 1.写个数据集的类（myDataset ），并继承Dataset 在myDataset 类中实现__len__()和__getitem__两个函数， __len__返回数据集的总长，__getitem__返回每次按照 索引所取的项，即x, y 比如：在处理序列问题时： __len__返回的是：all_len/seq_len __getitem__返回的是：一...
深度学习与PyTorch入门实战教程
01-30
亚洲排名第1的新加坡国立大学AI团队倾情打造，资深研究员龙龙老师主讲，帮助人工智能、深度学习初学者快速、深刻理解深度学习算法原理与实践。【莫烦老师】权威推荐：在教学中，龙龙老师以简短高效的方式，从深度学习的多个角度向我们展开了论述，非常适合想对深度学习有全方位了解的朋友。【PyTorch中文网】：讲解简单易懂、由浅入深，是一门值得推荐的课程。课程特色：1. 通俗易懂，快速入门对深度学习算法追本溯源、循序渐进式讲解，学员不需要任何机器学习基础，只需要写过代码即可轻松上手。2. 实用主导，简单高效使用新手最容易掌握的深度学习框架PyTorch实战，比起使用TensorFlow的课程难度降低了约50%，而且PyTorch是业界最灵活，最受好评的框架。3. 案例为师，实战护航基于计算机视觉和NLP领域的经典数据集，从零开始结合PyTorch与深度学习算法完成多个案例实战。4. 持续更新，永久有效一次购买，永久有效。深度学习课程会持续更新下去，内容和学术界最前沿算法保持同步。
龙曲良 Tensorflow —— 神经网络与全连接层（自用）-3
清园暖歌的博客
02-14 1279
导入的格式是个 numpy 的api，所以可以直接 x.min()，不然 tensor 中是 tf.reduce_min。因为 cifar 大小非常小，所以图片会模糊，真实大小是 [32, 32, 3]x_test，y_test 为测试集：[10k, 32, 32]，[10k, 1]x_test，y_test 为测试集：[10k, 28, 28]，[10k, ]x，y 为训练集：[50k, 32, 32]，[50k, 1]x，y 为训练集：[60k, 28, 28]，[60k, ]
pytorch-multi-label-classifier-master
最新发布
07-09
### 回答1： pytorch-multi-label-classifier-master是一个基于PyTorch的多标签分类器项目。该项目旨在使用PyTorch框架构建一个能够对具有多个标签的数据样本进行分类的模型。 PyTorch是一个流行的深度学习框架，能够实现多种深度学习模型的构建与训练。它提供了丰富的工具和函数，简化了模型的复杂性，并提供了高效的计算能力。 在这个项目中，multi-label指的是数据样本可以被分为多个标签。与传统的单标签分类不同，每个样本可以被分为多个类别，这增加了分类问题的复杂性。模型需要学习如何给每个样本分配正确的标签。 pytorch-multi-label-classifier-master项目提供了一个设置多标签分类模型的基础架构。它包含了数据预处理、模型构建、训练和评估等步骤。用户可以根据自己的数据集和需求，对该项目进行定制。 通过使用pytorch-multi-label-classifier-master项目，用户可以快速搭建一个多标签分类器，用于解决具有多个标签的数据分类问题。同时，该项目还提供了一些示例数据和模型，帮助用户更好地理解和使用多标签分类技术。 总而言之，pytorch-multi-label-classifier-master是一个基于PyTorch框架用于多标签分类的项目，为用户提供了一个简单且灵活的搭建多标签分类器的框架，方便用户解决多标签分类问题。 ### 回答2： pytorch-multi-label-classifier-master是一个基于PyTorch的多标签分类器项目。它提供了一种使用神经网络模型来处理多标签分类任务的解决方案。 该项目的主要目标是通过深度学习技术来提高多标签分类问题的准确度。它使用PyTorch作为深度学习框架，该框架提供了丰富的工具和功能来构建和训练神经网络模型。 在pytorch-multi-label-classifier-master中，你可以找到许多工具和函数来进行数据预处理、模型构建、训练和评估。它支持常见的多标签分类算法，如卷积神经网络（CNN）和递归神经网络（RNN）。你可以根据自己的需求选择合适的模型，并通过简单的配置来进行训练。 该项目还提供了一些示例数据集和预训练模型，以帮助你更快地开始。你可以使用这些数据集来测试和调试你的模型，或者使用预训练模型来进行迁移学习。 pytorch-multi-label-classifier-master还支持一些常见的性能评估指标，如准确率、精确率、召回率和F1值。你可以使用这些指标来评估你的模型在多标签分类任务上的性能。 总的来说，pytorch-multi-label-classifier-master是一个方便易用的项目，旨在帮助你构建和训练用于多标签分类的深度学习模型。它提供了丰富的功能和工具，使你能够快速搭建一个准确度较高的多标签分类器。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值