pytorch教程龙曲良46-55

最新推荐文章于 2023-05-21 18:37:16 发布
最新推荐文章于 2023-05-21 18:37:16 发布
阅读量341 收藏 6
点赞数
分类专栏： pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sueong/article/details/116885963
版权

46交叉验证2

只能用val set反馈去调整参数，看到test acc 不该做任何事情，如果反馈去调整参数泛化能力会变弱在这里插入图片描述
k-fold cross-validation
如果按照原来的划分是50k -train 10k-val 10k-test，因为test肯定不能反馈回去，所以我们要利用10k的val，可以先和50ktrain+10kval train一次，然后60k的数据再划分中间某10k为val（如图黄色部分），这样确保60k的数据都可以是train，每次切换train，既防止死记硬背又防止数据没有充分利用，但是其实用的也不是特别多，因为本质数据量没有增加
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

 # -*- 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)

print('train:',len(train_db),'test:',len(test_db))
train_db,val_db=torch.utils.data.random_split(train_db,[50000,10000])
print('db1:',len(train_db),'db2:',len(test_db))
train_loader=torch.utils.data.DataLoader(
    train_db,
    batch_size=batch_size,shuffle=True

)
val_loader=torch.utils.data.DataLoader(
    val_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给了两个初始值。
 
'''



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坐标。


        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再增加,在val_set里面进行参数调整
    test_loss=0
    correct=0

    for data,target in val_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()



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


#最终在test set测试，之后不能再反馈回去调整参数
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()



test_loss/=len(test_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: 60000 test: 10000
db1: 50000 db2: 10000
Train Epoch：0 [0/50000 (0%)]	 Loss:2.295601
Train Epoch：0 [20000/50000 (40%)]	 Loss:2.054641
Train Epoch：0 [40000/50000 (80%)]	 Loss:1.664214

 val set:average loss：0.0074,Accuracy:5805.0/10000 (58%)

Train Epoch：1 [0/50000 (0%)]	 Loss:1.464827
Train Epoch：1 [20000/50000 (40%)]	 Loss:1.394560
Train Epoch：1 [40000/50000 (80%)]	 Loss:1.171521

 val set:average loss：0.0058,Accuracy:6342.0/10000 (63%)

Train Epoch：2 [0/50000 (0%)]	 Loss:1.220029
Train Epoch：2 [20000/50000 (40%)]	 Loss:1.126450
Train Epoch：2 [40000/50000 (80%)]	 Loss:0.636756

 val set:average loss：0.0027,Accuracy:8721.0/10000 (87%)

Train Epoch：3 [0/50000 (0%)]	 Loss:0.635576
Train Epoch：3 [20000/50000 (40%)]	 Loss:0.389597
Train Epoch：3 [40000/50000 (80%)]	 Loss:0.323504

 val set:average loss：0.0018,Accuracy:8981.0/10000 (90%)

Train Epoch：4 [0/50000 (0%)]	 Loss:0.346836
Train Epoch：4 [20000/50000 (40%)]	 Loss:0.372384
Train Epoch：4 [40000/50000 (80%)]	 Loss:0.282964

 val set:average loss：0.0016,Accuracy:9077.0/10000 (91%)

Train Epoch：5 [0/50000 (0%)]	 Loss:0.308849
Train Epoch：5 [20000/50000 (40%)]	 Loss:0.365416
Train Epoch：5 [40000/50000 (80%)]	 Loss:0.271487

 val set:average loss：0.0015,Accuracy:9148.0/10000 (91%)

Train Epoch：6 [0/50000 (0%)]	 Loss:0.340268
Train Epoch：6 [20000/50000 (40%)]	 Loss:0.293617
Train Epoch：6 [40000/50000 (80%)]	 Loss:0.302988

 val set:average loss：0.0014,Accuracy:9175.0/10000 (92%)

Train Epoch：7 [0/50000 (0%)]	 Loss:0.214405
Train Epoch：7 [20000/50000 (40%)]	 Loss:0.256376
Train Epoch：7 [40000/50000 (80%)]	 Loss:0.324643

 val set:average loss：0.0013,Accuracy:9220.0/10000 (92%)

Train Epoch：8 [0/50000 (0%)]	 Loss:0.403245
Train Epoch：8 [20000/50000 (40%)]	 Loss:0.217200
Train Epoch：8 [40000/50000 (80%)]	 Loss:0.224958

 val set:average loss：0.0012,Accuracy:9251.0/10000 (93%)

Train Epoch：9 [0/50000 (0%)]	 Loss:0.300052
Train Epoch：9 [20000/50000 (40%)]	 Loss:0.236280
Train Epoch：9 [40000/50000 (80%)]	 Loss:0.220537

 val set:average loss：0.0012,Accuracy:9273.0/10000 (93%)


 test set:average loss：0.0012,Accuracy:9320.0/10000 (93%)


Process finished with exit code 0

    '''

47 regulization

如果不是必要的话尽量选择小的参数量
在这里插入图片描述
减小overfitting
更多数据
减少层数、正则化
dropout会增加鲁棒性
数据增强
使用val set提前终结
在这里插入图片描述
regularization使得θ范数的值接近0，减少模型复杂度，因为使得高纬网络bx^3 ，b x4前面的参数非常非常小，比如表达能力为七次方的一个网络结构x7经过regularization会退化成一个更小次方的一个网络结构，同时保持网络结构又能降低网络结构的复杂度，防止了overfitting
在这里插入图片描述
左图曲线不光滑说明网络表达能力强可以学到复杂的模式，但是因为数据集不复杂可能是噪声造成的因此泛化能力不强，右图是我们想要的
在这里插入图片描述
在这里插入图片描述
只有在overfitting的时候才能设置weight_decay,否则会降低原来模型的复杂程度，因为没有overfitting的时候模型的表达能力是匹配的，加了反而会使test acc下降,weight_decay就是λ=0.01使得w趋近于0，降低模型复杂度（迫使weight慢慢趋近于0）
在这里插入图片描述
对网络全局的范数有约束在这里插入图片描述

48动量与学习率衰减

momentum（惯性）：
learning rate decay：迫使学习率慢慢变为0

动量其实就是当前更新方向加历史惯性的结合，取决于b参数怎么选会产生不同的效应
在这里插入图片描述
如图没有动量，w的更新只考虑当前的更新方向不考虑历史的方向，所以更新的方向很尖锐（都是尖尖角），在局部最优就不动了

在这里插入图片描述
如图，考虑0.78的历史方向和0.22的当前方向，使得更新的幅度和程度缓和下来，陷入局部最优解的小坑，加了动量（考虑惯性）就会冲出小坑
在这里插入图片描述
adam内置了momentum不需要自己设置
SGD需要
在这里插入图片描述
learning rate decay

在这里插入图片描述
lr大了不收敛，小了更新慢
可能lr=0.1刚开始设置大一点（步数大一点）的随着训练过程慢慢减小到0.001这样还是能找到最优解，learning rate decay动态寻找lr的过程
在这里插入图片描述
lr的微调可以在原来已经效果好的基础上会提升性能
在这里插入图片描述torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=10, verbose=False, threshold=0.0001, threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-08)
在发现loss不再降低或者acc不再提高之后，降低学习率。各参数意义如下：在这里插入图片描述

scheduler=ReduceLROnPlateau(optimizer, mode='min'）
scheduler.step(loss_val)
#在发现loss不再降低或者acc不再提高之后，降低学习率，假设patience=10就是连续调用scheduler.step（loss_val这个函数连续10次）
#去监听loss发现loss连续10次没有减少（达到平原状态），代表需要把lr减少一定程度，如果loss不饱和就什么都不做，只是记录作用


在这里插入图片描述

49early stop dropuot

在这里插入图片描述
可以依照经验，在某个不在上升的点进行early stop
在这里插入图片描述
dropout
防止overfitting，使训练过程中有效的w的数量越小越好，和learning rate decay中使得w越来越小不一样，就是网络连接过程中每部分连接的地方有一定的概率会丢失不参与连接，这样用到有效的参数量会减少
在这里插入图片描述

可以看到蓝色曲线比较平滑不容易overfitting
在这里插入图片描述
在连接的层之间加dropout，在两层之间断掉一部分输入，否则就是直连
在这里插入图片描述
在这里插入图片描述
pytorch中p=dropout_prob：p=1有可能全部断掉，p=0.1线断开的比较少，
在tf中keep_prob :p=1所有连接都保持住，p=0.1保持住的概率是0.1 所以断开的概率是0.99

dropout在train和test的行为是不一样的
train中 连接可能断开
test所有连接都会使用不会参考断开的行为，防止在test中断开，所以人为的切换到eval中，net_dropped.eval()
在这里插入图片描述
stochastic 并不是真的随机，符合某一分布
deterministic在这里插入图片描述
在这里插入图片描述
数据很大的时候不可能整个数据集load到显存中，为了节省显存
stochastic gradient descent
不再是求整个样本的loss对w的梯度，而是求一个batch梯度在这里插入图片描述

50什么是卷积1

黑白图片每张图的每个点表示了灰度值从0-255可以变换到0-1
在这里插入图片描述
在这里插入图片描述
彩色图片三个通道
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
一层一般值的是权值w和输出是一层，三个隐藏层，一共是4层（一般input layer不算）
多少参数就是有多少条线
在这里插入图片描述
局部相关性 感受野，感受不是全局的是一次一次小块
在这里插入图片描述
卷积神经网络，卷积指的是局部相关性
在这里插入图片描述
卷积：滑动小窗口从2828变成33参数大大降低
本来有784条全连接的权值现在变成9个与之位置相关的位置权值，位置太远不考虑
在这里插入图片描述
在这里插入图片描述
卷积层的权值数量会成倍减少，但是可以考虑到全局信息只是移动的时候是用的同样的参数，同时考虑了全局的属性但是又考虑了位置相近的信息，
小窗口和大窗口做的是相乘再累加再的一个操作变成点，这叫卷积操作在这里插入图片描述
在这里插入图片描述

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

52卷积层1

kernel的类型决定了你以什么方式观察这个map，卷积运算后得到新的map，新map和之前map大小类似或者一致，但是数据不同

在这里插入图片描述

多个kernel代表观察角度的信息不同，如图可能有观察blur face dog edge的多个信息在这里插入图片描述

七个kernel 维度（7,1,3,3）,新的map是7features map

在这里插入图片描述
卷积运算的过程
在这里插入图片描述
上下左右都打了一个padding 所以得到的feature map也是5*5

input channel:黑白照片1 彩色照片3，中间可能是16或者64等等等
kernel channel：指的是你有多少个核
kernel size：3*3
stride：步长 每次kernel移动的大小 一次移动几格
padding：打的空白的行和列 如果行列打两行的话padding是1

输出图片公式的大小如图在这里插入图片描述

53卷积层2

input的通道数是多少，kernel的通道数也要是多少
x[1,3,28,28]#一张图片 三个通道rgb 2828的大小
one k：[3,3,3]:第一个3是对应x的三个通道，后面是kernel的size33，如果input的channel是16 则kernel的channel也必须是16，必须和inut的channel是一一对应的
multi-k：[16,3,3,3]16表示一共有16个kernel，可能是不同类型的kernel比如edge、blur等等，第一个3表示是输入图片的通道RGB
bias[16]:每个kernel会带一个偏置，所以16个kernel生成维度16的bias
out：[1,16,26,26]#1表示几张图片就是batch，16和kernel的个数是对应的，2626输出图片的大小，这取决于padding的大小也有可能是2828
kernel也成为filter weight
在这里插入图片描述
LeNet-5
如图所示分析两个convolutions的信息
x[1,32,32]
c1:[6,28,28]
所以中间的kernel是[6,1,55]因为与output是6代表有六种kernel，32变28，所以kernelsize是55 (32-28+1=5)

s2:[6,14,14]6是因为c1作为input是6，
C3[16,10,10]16是因为上一步
所以kernel是[16,6,5,5]16是因为16是16种kernel，6是6因为input channel是6，所以bias是[16]
总结kernel[num of category，input_channel，kernel_height，kernel_weight]

在这里插入图片描述
不停叠加（stack）
conv1是低级特征线条等等
conv2是小型概念弧形圆形等等
conv3高纬的概念有没有轮子窗户等等
由具像到抽象
为什么叫特征学习：因为就是特征不断提取的过程
在这里插入图片描述

54卷积层3

实现二维的卷积神经网络

layer=nn.Conv2d(1,3,kernel_size=3,stride=1,padding=0)
#batch是1,3是ker个数因为input_channel是3
#如果sride=2，就是隔一个看一个outputsize可能会折半，是一种降维的功能

。不推荐直接使用layer.forward函数，建议直接实例化layer使用layer(x)因为里面有.call函数不仅会实现forward函数还有pytorch自带封装好的一些hooks
在这里插入图片描述
w和b是需要梯度信息的在kernel卷积的过程中会自动更新
在这里插入图片描述

w=[16,3,5,5]16表示16种类kernel ,3是input_channel，5*5kernel_size，当输入的x的channel和3不匹配的时候会报错
x[B,C,W,H]
w[N,C,W,H]#kernel[num of category，input_channel，kernel_height，kernel_weight]`
在这里插入图片描述

55池化与采样

down/up sample
pooling：下采样 把feature map变小，与图片缩小不太类似
upsample：上采样 把图片放大类似
relu:在feature map进行relu操作
在这里插入图片描述
观察这个窗口是取这个窗口的最大值还是平均值
在这里插入图片描述
在这里插入图片描述
subsampling隔行采样
pooling是取当前窗口的一个最小值或者平均值
以上都是降维操作
在这里插入图片描述

在这里插入图片描述
upsample：针对tensor放大两倍，简单复制最近一个数值的过程在这里插入图片描述
实现上采样F.interpolate
out=F.interpolate(x,scale_factor=2,mode=‘nearest’)，放大2倍，nearest就是采用临近复制的模式，channel通道不会改变
在这里插入图片描述
relu激活函数
一个简单的unit神经元单元一般是conv2d-batch_normalization-pooling-relu
relu函数加在feature_map上的效应：把feature_map中负的单元给去掉，把相应低的点去掉，如图圈起来的相应太低，把该部分像素点变成0
在这里插入图片描述
layer=nn.ReLu(inplace=True)#表示x->x’的过程，x’使用的是x的内存空间节省内存
之后会发现out最小值都变成0，因为负数都被过滤了
在这里插入图片描述

sueong
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
bilibili_回归问题实战（第六课） 深度学习与PyTorch入门实战_龙良曲 .rar
06-20
深度学习与PyTorch入门实战_龙良曲 bilibili_回归问题实战（第六课） 1 data.csv 用于回归的数据数据 2 gd.py 回归实战运行代码 3 lesseon4.pdf 课件
pytorch-grad-cam-master.zip
05-29
在提供的"pytorch-grad-cam-master.zip"文件中，包含了实现Grad-CAM的PyTorch代码。这个项目可能包含了一个简单的图像分类网络，以及使用Grad-CAM可视化功能的脚本。通过运行这些代码，你可以观察到模型在处理不同...
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教程龙曲良36-40
sueong的博客
05-14 366
36函数极小值优化实战 四个解都是0所以都是全局最小值 PLOT #最小值0取的值（x,y）是（3,2）x初始化是0 #最小值0取的值（x,y）是（3.584428，-1.8484=126）x初始化是4 import os os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE' import torch import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d impo
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龙良曲配套课程课件和代码
02-03
深度学习pytorch龙良曲配套课程课件和代码 视频见https://www.bilibili.com/video/BV1TU4y1H7Mz
PyTorch 学习资源（代码类）
07-24
pytorch教程，代码类，分章节，共10章。
2019最新pytorch教程
02-09
 这本书面向数据科学家、自然语言处理工程师、人工智能解决方案开发人员、从事图形计算框架的现有从业人员以及图论研究人员。这本书主要讲解张量（Tensor）的基础知识、计算、执行基于算术的运算、矩阵代数和使用PyTorch框架的基于统计分布式运算。
pytorch教程龙曲良31-35
sueong的博客
05-13 191
31激活函数与Loss的梯度3 softmax 概率0-1，且所有所属结点的概率和为1，用softmax适合多分类，且把之间的差距拉大，本来2.0与1.0差两倍，现在0.7与0.2差3.5倍 求的是pi对aj的偏导，当i=j i!=j 32感知机的梯度推导1 x上标0下标n，上标0表示第0层，下标n表示第n个x w上标1下标ij，上标1表示第一层i表示连接上一层的xi，下标j表示连接本层的j号结点 x上标1下标0，上标1表示第1层的，下标0表示第0号结点，激活后变O O上标1下标0，上标1表示第
pytorch 龙良曲 自用笔记
一只活活泼泼快快乐乐的萨摩耶的博客
09-14 1116
pytorch龙良曲 笔记
pytorch教程龙曲良41-45
sueong的博客
05-16 261
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加
pytorch教程龙曲良11-15
sueong的博客
05-11 338
11创建tensor02 randn一般是均值为0，方差为1的正态分布N(0,1)，也可以自定义N(u,std)用torch.normal torch.normal(mean=torch.full([10],0),std=torch.arange(1,0,-0.1)) #比如先把一个2*5的矩阵打平变成1*10，然后normal后再reshape为2*5 #torch.full先构建一个一维长度为10全是0的tensor，这样他们的mean就都是0 #torch.arange使得标准差std分布为[1,0.
pytorch教程龙曲良26-30
sueong的博客
05-13 211
26什么是梯度1 导数（在给定方向的变化量）和偏微分（在给定的自变量上的变化量）都是标量,只有大小没有方向 梯度就是所有偏微分的向量，有方向有大小 函数梯度是一个向量，向量方向表示这个函数在当前点的一个增长方向，向量的模/长度表示增长速率 这里的a是lr，这里初始化（0,0）刚好取到极小值 当lr太大的话会更新太快跳到箭头所指的地方，显然不是我们想要的情况 27什么是梯度2 总是有z1>z2，就是凸函数（碗一样），可以找到全局最优解，但是这种情况在现实中不常见 存在多个局部最小值 res
Pytorch龙良曲实战代码与所遇问题解决
BAB__的博客
05-21 1011
本文为个人学习Pytorch龙良曲版本时跟写的代码，碍于版本、环境等诸多原因，原视频中代码不能直接照搬。针对自己所遇到的问题进行了改动，与大家分享共勉。
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、付费专栏及课程。

余额充值