精华内容
下载资源
问答
  • pytorch多分类
    千次阅读
    2020-03-05 00:01:00

    PolyLoss用1行代码+1个超参完成超车

    ICLR 2022 超越Focal Loss PolyLoss用1行代码+1个超参完成超车_AI视觉网奇的博客-CSDN博客

    将“softmax+交叉熵”推广到多标签分类问题

    将“softmax+交叉熵”推广到多标签分类问题 - 科学空间|Scientific Spaces

    多标签分类问题:

    torch版:

    import torch
    import numpy as np
    from scipy.special import logsumexp
    import torch.nn.functional as F
    def multilabel_categorical_crossentropy(y_true, y_pred):
        y_pred = (1 - 2 * y_true) * y_pred
        y_pred_neg = y_pred - y_true * 1e12
        y_pred_pos = y_pred - (1 - y_true) * 1e12
        zeros = torch.zeros_like(y_pre
    更多相关内容
  • 计算百分比有numpy和pytorch两种实现方案实现,都是根据索引计算百分比,以下为具体二分类实现过程。 pytorch out = torch.Tensor([[0,3], [2,3], [1,0], [3,4]]) cond = torch.Tensor([[1,0], [0,1], [1,0], ...
  • PyTorch多分类问题

    2022-03-07 19:19:40
    本文对经典手写数字数据集进行多分类,损失函数采用交叉熵,激活函数采用ReLU,优化器采用带有动量的mini-batchSGD算法。所有代码如下: # 0、导包 import torch from torchvision import transforms,datasets from ...

    一、实现过程

    本文对经典手写数字数据集进行多分类,损失函数采用交叉熵,激活函数采用ReLU,优化器采用带有动量的mini-batchSGD算法。所有代码如下:

    # 0、导包
    import torch
    from torchvision import transforms,datasets
    from torch.utils.data import DataLoader
    import torch.nn.functional as F
    import torch.optim as optim
    
    # 1、准备数据
    batch_size = 64
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,),(0.3081,))
    ])
    
    # 训练集
    train_dataset = datasets.MNIST(root='G:/datasets/mnist',train=True,download=False,transform=transform)
    train_loader = DataLoader(train_dataset,shuffle=True,batch_size=batch_size)
    # 测试集
    test_dataset = datasets.MNIST(root='G:/datasets/mnist',train=False,download=False,transform=transform)
    test_loader = DataLoader(test_dataset,shuffle=False,batch_size=batch_size)
    
    # 2、设计模型
    class Net(torch.nn.Module):
        def __init__(self):
            super(Net, self).__init__()
            self.l1 = torch.nn.Linear(784, 512)
            self.l2 = torch.nn.Linear(512, 256)
            self.l3 = torch.nn.Linear(256, 128)
            self.l4 = torch.nn.Linear(128, 64)
            self.l5 = torch.nn.Linear(64, 10)
    
        def forward(self, x):
            x = x.view(-1, 784)
            x = F.relu(self.l1(x))
            x = F.relu(self.l2(x))
            x = F.relu(self.l3(x))
            x = F.relu(self.l4(x))
            return self.l5(x)
    model = Net()
    # 模型加载到GPU上
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    model.to(device)
    
    # 3、构造损失函数和优化器
    criterion = torch.nn.CrossEntropyLoss()
    optimizer = optim.SGD(model.parameters(),lr=0.01,momentum=0.5)
    
    # 4、训练和测试
    def train(epoch):
        running_loss = 0.0
        for batch_idx, data in enumerate(train_loader, 0):
            inputs, target = data
            optimizer.zero_grad()
    
            # forward+backward+update
            outputs = model(inputs.to(device))
            loss = criterion(outputs, target.to(device))
            loss.backward()
            optimizer.step()
    
            running_loss += loss.item()
            if batch_idx % 300 == 299:
                print('[%d,%d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
                running_loss = 0.0
    def test():
        correct = 0
        total = 0
        with torch.no_grad():
            for data in test_loader:
                images, labels = data
                outputs = model(images.to(device))
                _, predicted = torch.max(outputs.data, dim=1)
                total += labels.size(0)
                correct += (predicted.cpu() == labels).sum().item()
        print('Accuracy on test set: %d %%' % (100 * correct / total))
    
    for epoch in range(10):
        train(epoch)
        test()
    

    运行结果如下:

    [1,300] loss: 2.166
    [1,600] loss: 0.797
    [1,900] loss: 0.405
    Accuracy on test set: 90 %
    [2,300] loss: 0.303
    [2,600] loss: 0.252
    [2,900] loss: 0.218
    Accuracy on test set: 94 %
    [3,300] loss: 0.178
    [3,600] loss: 0.168
    [3,900] loss: 0.142
    Accuracy on test set: 95 %
    [4,300] loss: 0.129
    [4,600] loss: 0.119
    [4,900] loss: 0.110
    Accuracy on test set: 96 %
    [5,300] loss: 0.094
    [5,600] loss: 0.092
    [5,900] loss: 0.091
    Accuracy on test set: 96 %
    [6,300] loss: 0.077
    [6,600] loss: 0.070
    [6,900] loss: 0.075
    Accuracy on test set: 97 %
    [7,300] loss: 0.061
    [7,600] loss: 0.058
    [7,900] loss: 0.058
    Accuracy on test set: 97 %
    [8,300] loss: 0.043
    [8,600] loss: 0.051
    [8,900] loss: 0.050
    Accuracy on test set: 97 %
    [9,300] loss: 0.041
    [9,600] loss: 0.038
    [9,900] loss: 0.043
    Accuracy on test set: 97 %
    [10,300] loss: 0.030
    [10,600] loss: 0.032
    [10,900] loss: 0.033
    Accuracy on test set: 97 %
    

    二、参考文献

    [1] https://www.bilibili.com/video/BV1Y7411d7Ys?p=9

    展开全文
  • pytorch 中的损失函数:在多分类的时候,我们希望输出是符合概率分布的,所以利用Softmax做了归一化的处理。

    前言

    pytorch  中的损失函数:

    1. CrossEntropyLoss
    2. LogSoftmax
    3. NLLLoss

    Softmax

    在多分类的时候,我们希望输出是符合概率分布的,所以利用Softmax做了归一化的处理。

    这个过程非常好理解,将所有的项相加得到分母,各项在作为分子,只不过这里加了一个e为底的指数函数,确保值都大于0。

    多分类的神经网络的最后一层,一般就会用到Softmax,所以最后一层一般不用激活(详见最后的数字分类的代码),因为Softmax就相当于做了激活(将数据映射到0~1)。最终Softmax输出每个类别的概率值。

    CrossEntropyLoss <==> LogSoftmax + NLLLoss

    有了概率值之后,就开始构造损失函数了,这里还是用到交叉熵。

    最大似然估计,散度,交叉熵_code bean的博客-CSDN博客

     回忆一下二分类的交叉熵:当时我们的函数时BCE

    criterion = torch.nn.BCELoss(size_average=True)  # 二分类交叉熵损失函数

     这是式子是上面的展开,p=y   q=(1-y)  而Y只有两种选择0和1,所以当Y等于1的时候,后面那一项就没了。所以当到了多分类其实也一样,Y只有两种选择0和1。当某一类为1时那么其他的类都是0.(这里分类是互斥的,就会有这个特性,你是猫就不会是狗的这种分类)

    交叉熵公式,最终保存下的也只有一项。

     右侧的独热码,就是人判断的标签,也是人给的概率。互斥的这种多分类交叉熵最终就只有只有一项:

    LogSoftmax 

     那LogSoftmax的含义就是对softmax的结果取了一个log

    m = nn.LogSoftmax()
    input = torch.randn(2, 3)
    output = m(input)

     那为啥输出的好好的概率,又加个log干什么呢?

    有种说法是,因为输出的概率是0~1,从log函数看出,如果概率越接近1,那么对应Y的绝对值越小。这种表示确定性越大,信息量越小,反之信息量越大。

    那我觉得还有另外一个原因,就是LogSoftmax一般是和NLLLoss结合使用的。

    NLLLoss

    NLLLoss完成的就是交叉熵的部分:

     

    而且 NLLLoss要求的输入值就是概率取对数的结果,那LogSoftmax和NLLLoss就可以无缝的链接了:

    m = nn.LogSoftmax(dim=1)
    loss = nn.NLLLoss()
    # input is of size N x C = 3 x 5
    input = torch.randn(3, 5, requires_grad=True)
    # each element in target has to have 0 <= value < C
    target = torch.tensor([1, 0, 4])
    output = loss(m(input), target)
    output.backward()

    CrossEntropyLoss

    那说了这么多,CrossEntropyLoss把几个人的活全部干了:

    import torch
    y = torch.LongTensor([0])
    z = torch.Tensor([[0.2, 0.1, -0.1]])
    criterion = torch.nn.CrossEntropyLoss()
    loss = criterion(z, y)
    print(loss)
    

     一个数字识别的多分类的例子

     最后在一个详细的例子里看一下,具体的用法

    import torch
    from torchvision import transforms
    from torchvision import datasets
    from torch.utils.data import DataLoader
    import torch.optim as optim
    import torch.nn.functional as F
    
    # 准备数据集
    batch_size = 64
    transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
    
    train_dataset = datasets.MNIST(root='./dataset/mnist/', train=True, download=True, transform=transform)
    train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)
    test_dataset = datasets.MNIST(root='./dataset/mnist/', train=False, download=True, transform=transform)
    test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)
    
    
    # 构造网络模型
    class Net(torch.nn.Module):
        def __init__(self):
            super(Net, self).__init__()
            self.l1 = torch.nn.Linear(784, 512)
            self.l2 = torch.nn.Linear(512, 256)
            self.l3 = torch.nn.Linear(256, 128)
            self.l4 = torch.nn.Linear(128, 64)
            self.l5 = torch.nn.Linear(64, 10)
    
        def forward(self, x):
            # 将C*W*H三维张量变为二维张量,用于深度深度学习处理
            x = x.view(-1, 784)
            x = F.relu(self.l1(x))
            x = F.relu(self.l2(x))
            x = F.relu(self.l3(x))
            x = F.relu(self.l4(x))
            # 最后一层不进行激活,不做非线性变换
            return self.l5(x)
    
    
    model = Net()
    
    # 构造损失函数和优化器
    criterion = torch.nn.CrossEntropyLoss()  # 此函数,需要一个未激活的输入,它将 交叉熵 和 softmax 的计算进行融合。(这样计算更快更稳定!)
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)  # momentum:冲量
    
    
    def train(epoch):
        running_loss = 0
        for batch_idx, data in enumerate(train_loader, 0):
            # 获得一个批次的输入与标签
            inputs, target = data
            # 开始训练
            optimizer.zero_grad()
            # 正向传播
            y_pred = model(inputs)
            # 计算损失
            loss = criterion(y_pred, target)
            # 反向传播
            loss.backward()
            # 更新梯度
            optimizer.step()
    
            running_loss = running_loss + loss
            if batch_idx % 300 == 299:
                print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
                running_loss = 0.0
    
    
    def test():
        correct = 0
        total = 0
        # 不计算梯度
        with torch.no_grad():
            for data in test_loader:
                inputs, labels = data
                prec = model(inputs)
                '''
                torch.max(input, dim) 函数
                输入:
                input是softmax函数输出的一个tensor
                dim是max函数索引的维度0/1,0是每列的最大值,1是每行的最大值
                输出:
                函数会返回两个tensor,第一个tensor是每行的最大值,softmax的输出中最大的是1,
                所以第一个tensor是全1的tensor;第二个tensor是每行最大值的索引,这个索引的值正好和预测的数字相等。
                '''
                _, predicted = torch.max(prec.data, dim=1)  # predicated为维度(784,1)的张量
                total += labels.size(0)
                # 张量之间的比较运算
                correct += (predicted == labels).sum().item()
        print('accuracy on test set: %d %% ' % (100 * correct / total))
    
    
    if __name__ == "__main__":
        for epoch in range(10):  # 每轮训练之后,都预测一次
            train(epoch)
            test()
    

     输出结果:

    [1,   300] loss: 2.166
    [1,   600] loss: 0.820
    [1,   900] loss: 0.422
    accuracy on test set: 89 % 
    [2,   300] loss: 0.306
    [2,   600] loss: 0.269
    [2,   900] loss: 0.231
    accuracy on test set: 94 % 
    [3,   300] loss: 0.185
    [3,   600] loss: 0.172
    [3,   900] loss: 0.152
    accuracy on test set: 95 % 
    [4,   300] loss: 0.129
    [4,   600] loss: 0.124
    [4,   900] loss: 0.118
    accuracy on test set: 96 % 
    [5,   300] loss: 0.103
    [5,   600] loss: 0.094
    [5,   900] loss: 0.095
    accuracy on test set: 96 % 
    [6,   300] loss: 0.080
    [6,   600] loss: 0.076
    [6,   900] loss: 0.077
    accuracy on test set: 97 % 
    [7,   300] loss: 0.062
    [7,   600] loss: 0.067
    [7,   900] loss: 0.059
    accuracy on test set: 97 % 
    [8,   300] loss: 0.052
    [8,   600] loss: 0.050
    [8,   900] loss: 0.051
    accuracy on test set: 97 % 
    [9,   300] loss: 0.036
    [9,   600] loss: 0.045
    [9,   900] loss: 0.042
    accuracy on test set: 97 % 
    [10,   300] loss: 0.031
    [10,   600] loss: 0.034
    [10,   900] loss: 0.032
    accuracy on test set: 97 % 

    参考资料:

    《PyTorch深度学习实践》完结合集_哔哩哔哩_bilibili

    softmax交叉熵为什么要取-log_LEILEI18A的博客-CSDN博客_交叉熵的log

    展开全文
  • 11.21.Pytorch多分类问题 1.21.1.PyTorch:Softmax多分类实战 1.21.1.1.MNIST数据集 1.21.1.2.Softmax分类 1.21.1.3.PyTorch实战 1.21.2.利用神经网络进行分类 1.21.Pytorch多分类问题 1.21.1.PyTorch:Softmax多分类...

    此文为学习博文整理出

    11.21.Pytorch多分类问题
    1.21.1.PyTorch:Softmax多分类实战
    1.21.1.1.MNIST数据集
    1.21.1.2.Softmax分类
    1.21.1.3.PyTorch实战
    1.21.2.利用神经网络进行分类

    1.21.Pytorch多分类问题

    1.21.1.PyTorch:Softmax多分类实战

    多分类一种比较常用的做法是在最后一层加softmax归一化,值最大的维度所对应的位置则作为该样本对应的类。本文采用PyTorch框架,选用经典图像数据集mnist学习一波多分类。

    1.21.1.1.MNIST数据集

    MNIST 数据集(手写数字数据集)来自美国国家标准与技术研究所, National Institute of Standards and Technology (NIST). 训练集 (training set) 由来自 250 个不同人手写的数字构成, 其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员. 测试集(test set) 也是同样比例的手写数字数据。MNIST数据集下载地址:http://yann.lecun.com/exdb/mnist/。手写数字的MNIST数据库包括60,000个的训练集样本,以及10,000个测试集样本。
    在这里插入图片描述
    其中:
    train-images-idx3-ubyte.gz (训练数据集图片)
    train-labels-idx1-ubyte.gz (训练数据集标记类别)
    t10k-images-idx3-ubyte.gz: (测试数据集)
    t10k-labels-idx1-ubyte.gz(测试数据集标记类别)

    在这里插入图片描述
    MNIST数据集是经典图像数据集,包括10个类别(0到9)。每一张图片拉成向量表示,如下图784维向量作为第一层输入特征。
    在这里插入图片描述

    1.21.1.2.Softmax分类

    softmax函数的本质就是将一个K 维的任意实数向量压缩(映射)成另一个K维的实数向量,其中向量中的每个元素取值都介于(0,1)之间,并且压缩后的K个值相加等于1(变成了概率分布)。在选用Softmax做多分类时,可以根据值的大小来进行多分类的任务,如取权重最大的一维。softmax介绍和公式网上很多,这里不介绍了。下面使用Pytorch定义一个多层网络(4个隐藏层,最后一层softmax概率归一化),输出层为10正好对应10类。
    在这里插入图片描述

    1.21.1.3.PyTorch实战

    # -*- coding: UTF-8 -*-
    
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    import torch.optim as optim
    from torchvision import datasets, transforms
    from torch.autograd import Variable
    
    # Training settings
    batch_size = 64
    
    # MNIST Dataset
    train_dataset = datasets.MNIST(root='./mnist_data/',
                                   train=True,
                                   transform=transforms.ToTensor(),
                                   download=True)
    
    test_dataset = datasets.MNIST(root='./mnist_data/',
                                  train=False,
                                  transform=transforms.ToTensor())
    
    # Data Loader (Input Pipeline)
    train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                               batch_size=batch_size,
                                               shuffle=True)
    
    test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                              batch_size=batch_size,
                                              shuffle=False)
    
    
    class Net(nn.Module):
        def __init__(self):
            super(Net, self).__init__()
            self.l1 = nn.Linear(784, 520)
            self.l2 = nn.Linear(520, 320)
            self.l3 = nn.Linear(320, 240)
            self.l4 = nn.Linear(240, 120)
            self.l5 = nn.Linear(120, 10)
    
        def forward(self, x):
            # Flatten the data (n, 1, 28, 28) --> (n, 784)
            x = x.view(-1, 784)
            x = F.relu(self.l1(x))
            x = F.relu(self.l2(x))
            x = F.relu(self.l3(x))
            x = F.relu(self.l4(x))
            return F.log_softmax(self.l5(x), dim=1)
            #return self.l5(x)
    
    
    model = Net()
    
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
    
    
    def train(epoch):
        # 每次输入barch_idx个数据
        for batch_idx, (data, target) in enumerate(train_loader):
            data, target = Variable(data), Variable(target)
    
            optimizer.zero_grad()
            output = model(data)
            # loss
            loss = F.nll_loss(output, target)
            loss.backward()
            # update
            optimizer.step()
            if batch_idx % 200 == 0:
                print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                    epoch, batch_idx * len(data), len(train_loader.dataset),
                    100. * batch_idx / len(train_loader), loss.item()))
    
    
    def test():
        test_loss = 0
        correct = 0
        # 测试集
        for data, target in test_loader:
            data, target = Variable(data, volatile=True), Variable(target)
            output = model(data)
            # sum up batch loss
            test_loss += F.nll_loss(output, target).item()
            # get the index of the max
            pred = output.data.max(1, keepdim=True)[1]
            correct += pred.eq(target.data.view_as(pred)).cpu().sum()
    
        test_loss /= len(test_loader.dataset)
        print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
            test_loss, correct, len(test_loader.dataset),
            100. * correct / len(test_loader.dataset)
        ))
    
    
    for epoch in range(1, 6):
        train(epoch)
        test()
    

    输出结果:

    Python 3.7.4 (default, Aug  9 2019, 18:34:13) [MSC v.1915 64 bit (AMD64)] on win32
    Django 3.0.6
    runfile('E:/workspace/pytorch-learn/26_多分类问题/01_多分类问题.py', wdir='E:/workspace/pytorch-learn/26_多分类问题')
    Train Epoch: 1 [0/60000 (0%)]	Loss: 2.299828
    Train Epoch: 1 [12800/60000 (21%)]	Loss: 2.296097
    Train Epoch: 1 [25600/60000 (43%)]	Loss: 2.286291
    Train Epoch: 1 [38400/60000 (64%)]	Loss: 2.258982
    Train Epoch: 1 [51200/60000 (85%)]	Loss: 2.001041
    E:/workspace/pytorch-learn/26_多分类问题/01_多分类问题.py:81: UserWarning: volatile was removed and now has no effect. Use `with torch.no_grad():` instead.
      data, target = Variable(data, volatile=True), Variable(target)
    Test set: Average loss: 0.0223, Accuracy: 5924/10000 (59%)
    Train Epoch: 2 [0/60000 (0%)]	Loss: 1.392825
    Train Epoch: 2 [12800/60000 (21%)]	Loss: 0.917865
    Train Epoch: 2 [25600/60000 (43%)]	Loss: 0.554404
    Train Epoch: 2 [38400/60000 (64%)]	Loss: 0.556347
    Train Epoch: 2 [51200/60000 (85%)]	Loss: 0.422638
    Test set: Average loss: 0.0065, Accuracy: 8784/10000 (88%)
    Train Epoch: 3 [0/60000 (0%)]	Loss: 0.348750
    Train Epoch: 3 [12800/60000 (21%)]	Loss: 0.396100
    Train Epoch: 3 [25600/60000 (43%)]	Loss: 0.404045
    Train Epoch: 3 [38400/60000 (64%)]	Loss: 0.275161
    Train Epoch: 3 [51200/60000 (85%)]	Loss: 0.526218
    Test set: Average loss: 0.0052, Accuracy: 8978/10000 (90%)
    Train Epoch: 4 [0/60000 (0%)]	Loss: 0.422416
    Train Epoch: 4 [12800/60000 (21%)]	Loss: 0.269215
    Train Epoch: 4 [25600/60000 (43%)]	Loss: 0.182410
    Train Epoch: 4 [38400/60000 (64%)]	Loss: 0.150055
    Train Epoch: 4 [51200/60000 (85%)]	Loss: 0.224126
    Test set: Average loss: 0.0036, Accuracy: 9333/10000 (93%)
    Train Epoch: 5 [0/60000 (0%)]	Loss: 0.149385
    Train Epoch: 5 [12800/60000 (21%)]	Loss: 0.271054
    Train Epoch: 5 [25600/60000 (43%)]	Loss: 0.340432
    Train Epoch: 5 [38400/60000 (64%)]	Loss: 0.311231
    Train Epoch: 5 [51200/60000 (85%)]	Loss: 0.127134
    Test set: Average loss: 0.0026, Accuracy: 9511/10000 (95%)
    

    1.21.2.利用神经网络进行分类

    本文就是用最简单的途径来看看神经网络是怎么进行事物的分类。具体的实现如下:

    # -*- coding: UTF-8 -*-
    
    import torch
    import torch.nn.functional as F
    import matplotlib as plt
    from torch.autograd import Variable
    
    #创建一些假数据
    n_data = torch.ones(100, 2)         # 数据的基本形态
    x0 = torch.normal(2*n_data, 1)      # 类型0 x data (tensor), shape=(100, 2)
    y0 = torch.zeros(100)               # 类型0 y data (tensor), shape=(100, 1)
    x1 = torch.normal(-2*n_data, 1)     # 类型1 x data (tensor), shape=(100, 1)
    y1 = torch.ones(100)                # 类型1 y data (tensor), shape=(100, 1)
    
    # 注意 x, y 数据的数据形式是一定要像下面一样 (torch.cat 是在合并数据)
    x = torch.cat((x0, x1), 0).type(torch.FloatTensor)    # FloatTensor = 32-bit floating
    y = torch.cat((y0, y1), ).type(torch.LongTensor)      # LongTensor = 64-bit integer
    
    # torch只能在Variable上训练,所以把它们变成Variable
    x, y = Variable(x), Variable(y)
    
    
    # 建立一个神经网络我们可以直接运用torch中的体系,先定义所有的层属性(init()),然后再一层层搭建(forward(x))
    # 层与层的关系链接。这个和我们在前面的regression的时候的神经网络基本没差。建立关系的时候,我们会用到激活函数。
    
    
    # 建立神经网络
    class Net(torch.nn.Module):    # 继承torch的Module
        def __init__(self, n_feature, n_hidden, n_output):
            super(Net, self).__init__()                              #继承__init__功能
            self.hidden = torch.nn.Linear(n_feature, n_hidden)     # 隐藏层线性输出
            self.out = torch.nn.Linear(n_hidden, n_output)         # 输出层线性输出
    
        def forward(self, x):
            # 正向传播输入值,神经网络分析输出值
            x = F.relu(self.hidden(x))                               # 激活函数(隐藏层的线性值)
            x = self.out(x)                                           # 输出值, 但是这个不是预测值, 预测值还需要再另外计算
            return x
    
    
    net = Net(n_feature=2, n_hidden=10, n_output=2)                # 几个类别就几个 output
    print(net)
    # 训练网络
    # optimizer是训练的工具
    optimizer = torch.optim.SGD(net.parameters(), lr=0.02)         #传入net的所有参数,学习率
    # 算误差的时候, 注意真实值!不是! one-hot 形式的, 而是1D Tensor, (batch,)
    # 但是预测值是2D tensor (batch, n_classes)
    loss_func = torch.nn.CrossEntropyLoss()
    
    for t in range(200):
        out = net(x)         # 喂给 net 训练数据 x, 输出分析值
    
        loss = loss_func(out, y)     # 计算两者的误差
        print(loss)
    
        optimizer.zero_grad()        # 清空上一步的残余更新参数值
        loss.backward()              # 误差反向传播, 计算参数更新值
        optimizer.step()             # 将参数更新值施加到 net 的 parameters上
    

    输出结果:

    runfile('E:/workspace/pytorch-learn/26_多分类问题/03_pytorch之区分类型.py', wdir='E:/workspace/pytorch-learn/26_多分类问题')
    Net(
      (hidden): Linear(in_features=2, out_features=10, bias=True)
      (out): Linear(in_features=10, out_features=2, bias=True)
    )
    tensor(1.2678, grad_fn=<NllLossBackward>)
    tensor(1.1538, grad_fn=<NllLossBackward>)
    tensor(1.0548, grad_fn=<NllLossBackward>)
    tensor(0.9684, grad_fn=<NllLossBackward>)
    tensor(0.8926, grad_fn=<NllLossBackward>)
    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    tensor(0.2143, grad_fn=<NllLossBackward>)
    tensor(0.2082, grad_fn=<NllLossBackward>)
    tensor(0.2023, grad_fn=<NllLossBackward>)
    tensor(0.1968, grad_fn=<NllLossBackward>)
    

    再如案例

    import  torch
    import  torch.nn as nn
    import  torch.nn.functional as F
    import  torch.optim as optim
    from    torchvision import datasets, transforms
    
    
    batch_size=200
    learning_rate=0.01
    epochs=10
    
    train_loader = torch.utils.data.DataLoader(
        datasets.MNIST('../data', train=True, download=True,
                       transform=transforms.Compose([
                           transforms.ToTensor(),
                           transforms.Normalize((0.1307,), (0.3081,))
                       ])),
        batch_size=batch_size, shuffle=True)
    test_loader = torch.utils.data.DataLoader(
        datasets.MNIST('../data', train=False, transform=transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize((0.1307,), (0.3081,))
        ])),
        batch_size=batch_size, shuffle=True)
    
    
    
    w1, b1 = torch.randn(200, 784, requires_grad=True),\
             torch.zeros(200, requires_grad=True)
    w2, b2 = torch.randn(200, 200, requires_grad=True),\
             torch.zeros(200, requires_grad=True)
    w3, b3 = torch.randn(10, 200, requires_grad=True),\
             torch.zeros(10, requires_grad=True)
    
    torch.nn.init.kaiming_normal_(w1)
    torch.nn.init.kaiming_normal_(w2)
    torch.nn.init.kaiming_normal_(w3)
    
    
    def forward(x):
        x = x@w1.t() + b1
        x = F.relu(x)
        x = x@w2.t() + b2
        x = F.relu(x)
        x = x@w3.t() + b3
        x = F.relu(x)
        return x
    
    
    
    optimizer = optim.SGD([w1, b1, w2, b2, w3, b3], lr=learning_rate)
    criteon = nn.CrossEntropyLoss()
    
    for epoch in range(epochs):
    
        for batch_idx, (data, target) in enumerate(train_loader):
            data = data.view(-1, 28*28)
    
            logits = forward(data)
            loss = criteon(logits, target)
    
            optimizer.zero_grad()
            loss.backward()
            # print(w1.grad.norm(), w2.grad.norm())
            optimizer.step()
    
            if batch_idx % 100 == 0:
                print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                    epoch, batch_idx * len(data), len(train_loader.dataset),
                           100. * batch_idx / len(train_loader), loss.item()))
    
    
        test_loss = 0
        correct = 0
        for data, target in test_loader:
            data = data.view(-1, 28 * 28)
            logits = forward(data)
            test_loss += criteon(logits, target).item()
    
            pred = logits.data.max(1)[1]
            correct += pred.eq(target.data).sum()
    
        test_loss /= len(test_loader.dataset)
        print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
            test_loss, correct, len(test_loader.dataset),
            100. * correct / len(test_loader.dataset)))
    
    展开全文
  • pytorch实现天气分类

    2022-05-17 16:13:01
    pytorch实现天气分类
  • pytorch多分类的语义分割

    千次阅读 热门讨论 2020-08-30 09:00:26
    基于segmentation_models.pytorch实现的多分类的语义分割。 github中的示例没有包含多分类的内容,网上资料比较少,就动手调了一下。 segmentation_models.pytorch\examples\cars segmentation (camvid).ipynb 里...
  • 一、代码中的数据集可以通过运行以下代码进行获取 train_ds = torchvision.datasets.MNIST(root=r'dataset', train=True, transform=ToTensor(), download=True) test_ds = torchvision.datasets....Pytorch-gpu==1
  • Pytorch——分类问题

    2020-12-22 05:36:02
    这次我们也是用最简单的途径来看看神经网络是怎么进行事物的分类. 2.数据准备 import torch import matplotlib.pyplot as plt n_data = torch.ones(200,2) x0 = torch.normal(2*n_data, 1) y0 = torch.zeros(200) x1...
  • unet 细胞分割 pytorch 模板(多分类也能用)
  • 使用Pytorch完成多分类问题

    万次阅读 2021-11-06 16:33:46
    多分类问题在最后的输出层采用的Softmax Layer,其具有两个特点:1.每个输出的值都是在(0,1);2.所有值加起来和为1. 假设是最后线性层的输出,则对应的Softmax function为: 输出经过sigmoid运算即可是西安输出...
  • Unet通常应用到单类别的语义分割,经过调整后该代码适合于类别的语义分割。对应博客:https://blog.csdn.net/brf_UCAS/article/details/112383722
  • 【总结】PyTorch多分类log_softmax、softmax的区别与联系 log_softmax、softmax在F和nn中存在,在此主要介绍nn 1.softmax torch.nn.functional.softmax (Python function, in torch.nn.functional) torch.nn....
  • pytorch实现多分类模型

    千次阅读 2021-06-17 09:17:17
    数据集使用的是mnist import torch import numpy as np import torch.nn as nn import torch.nn.functional as F import matplotlib.pyplot as plt from torch.utils.data import Dataset from torch.utils.data ...
  • pytorch-multi-label-classifier引言实现的用于标签分类分类器。 您可以轻松地train , test标签分类模型并visualize训练过程。 以下是可视化单标签分类器训练的示例。 如果您有个属性,则毫无疑问,每个...
  • Pytorch 标签分类Loss

    2021-08-03 09:47:04
    import torch import numpy as np pred = np.array([[-0.4089, -1.2471, 0.5907], [-0.4897, -0.8267, -0.7349], [0.5241, -0.1246, -0.4751]]) label = np.array([[0, 1, 1], [0, 0, 1], [1, 0, 1]]..
  • 一、batch_size 在合理范围内,增大batch_size的好处 1)内存利用率提高了,大矩阵乘法的并行化...随着 Batch_Size 增大,达到相同精度所需要的 epoch 数量越来越。" 由于最终收敛精度会陷入不同的局部极值,因此
  • PyTorch 04—多分类问题

    千次阅读 2022-03-08 20:08:58
    PyTorch多分类,训练使用的通用函数
  • 零基础学Pytorch#3 | 用Pytorch实现Softmax多分类 Ⅰ.笔记目标 此博文就学习Pytorch具体实践做学习笔记,适用于对机器学习、深度学习有一定理论基础但实践能力薄弱的朋友。本文也着重讲解代码实践过程,不重概念的...
  • Pytorch 多分类模型绘制 ROC, PR 曲线

    万次阅读 多人点赞 2020-12-06 17:14:34
    记录利用sklearn和matplotlib两个库为pytorch分类模型绘制roc,pr曲线的方法,不介绍相关理论。 ROC曲线: import torch import torch.nn as nn import os import numpy as np from torchvision.datasets import ...
  • pytorch: 做多分类

    2021-02-04 18:39:56
    pytorch中的交叉熵函数在是 torch.nn中是 CrossEntropyLoss()。对于二分类问题(一般 标签为 【0,1】),交叉函数公式表示为:在二分类中,我们通过神经网络的到一个映射值,随后会通过sigmoid函数,输出一个概率值,...
  • 目录pytorch搭建神经网络解决多分类问题softmax损失函数多分类的实现数据的准备构建模型、损失函数及优化器训练及测试部分训练结果 pytorch搭建神经网络解决多分类问题 softmax 核心:最后一层使用softmax层 1.求...
  • 这个省去了很多多标签分类麻烦问题
  • 先运行main.py进行文本序列化,再train.py模型训练 dataset.py from torch.utils.data import DataLoader,Dataset import torch import os from utils import tokenlize import config class ImdbDataset(Dataset): ...
  • 使用PyTorch在CIFAR-10 / 100和ImageNet上进行分类。 特征 适用于不同网络架构的统一接口 GPU支持 具有丰富信息的培训进度栏 训练日志和训练曲线可视化代码(请参阅./utils/logger.py ) 安装 安装 递归克隆git ...
  • 基于python利用pytorch实现图像分类项目源码,其中包含的densenet,resnext,mobilenet,efficientnet等图像分类网络,可以根据需要再行利用torchvision扩展其他的分类算法
  • 今天小编就为大家分享一篇Pytorch 实现计算分类器准确率(总分类及子分类),具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 利用pytorch实现多分类

    千次阅读 2019-09-10 17:56:29
    训练分类器 就是这个。您已经了解了如何定义神经网络,计算损耗并更新网络权重。 现在你可能在想 数据怎么样? 通常,当您必须处理图像,文本,音频或视频数据时,您可以使用标准的python包将数据加载到numpy数组中...
  • 本文主要记录一下pytorch里面的二分类多分类交叉熵损失函数的使用。 import torch import torch.nn as nn import torch.nn.functional as F torch.manual_seed(2020) <torch._C.Generator at 0x7f4e8b3298b0&...
  • Pytorch 实现分类.zip

    2021-01-22 15:41:40
    Pytorch 实现分类

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,493
精华内容 21,797
关键字:

pytorch多分类