基于逻辑回归的PyTorch手写数字识别-yiteyi-C++库

逻辑回归是一种非常常用的统计方法，它允许我们从一组自变量中预测二进制输出。逻辑回归的各种属性及其Python实现已在本文中介绍本文先前深度学习lib库是脸谱网开发的一个非常流行的深度学习库。现在，我们将看到如何使用PyTorch中的逻辑回归从MNIST数据集中对手写数字进行分类。首先，需要将Pytork安装到Python环境中。最简单的方法是使用pip或conda工具。参观皮托克。组织并安装您想要使用的Python解释器和包管理器的版本。安装了PyTorch之后，让我们看看代码。编写下面给出的三行代码，以导入所需的库函数和对象。

null

Python3

                           import                                        torch                         
                           import                                        torch.nn as nn                         
                           import                                        torchvision.datasets as dsets                         
                           import                                        torchvision.transforms as transforms                         
                           from                                        torch.autograd                                        import                                        Variable                         

给 手电筒nn 模块包含模型所需的代码， 火炬视觉。数据集 包含MNIST数据集。它包含我们将在这里使用的手写数字数据集。这个 火炬视觉。转变 模块包含将对象转换为其他对象的各种方法。在这里，我们将使用它将图像转换为PyTorch张量。还有 手电筒签名 模块中包含变量类，我们将在定义张量时使用它。接下来，我们将下载数据集并将其加载到内存中。

Python3

                           # MNIST Dataset (Images and Labels)                         
                           train_dataset                                        =                                        dsets.MNIST(root                                        =                                        './data'                                        ,                         
                                                     train                                        =                                        True                                        ,                         
                                                     transform                                        =                                        transforms.ToTensor(),                         
                                                     download                                        =                                        True                                        )                         
                                      
                           test_dataset                                        =                                        dsets.MNIST(root                                        =                                        './data'                                        ,                         
                                                     train                                        =                                        False                                        ,                         
                                                     transform                                        =                                        transforms.ToTensor())                         
                                      
                           # Dataset 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                                        )                         

现在，我们将定义超参数。

Python3

                           # Hyper Parameters                         
                           input_size                                        =                                        784                         
                           num_classes                                        =                                        10                         
                           num_epochs                                        =                                        5                         
                           batch_size                                        =                                        100                         
                           learning_rate                                        =                                        0.001                         

在我们的数据集中，图像大小是28*28。因此，我们的输入大小是784。此外，这里面有10个数字，因此，我们可以有10个不同的输出。因此，我们将num_类设置为10。此外，我们将在整个数据集上进行五次训练。最后，我们将以小批量的方式进行训练，每组100张图像，以防止程序因内存溢出而崩溃。在此之后，我们将定义我们的模型如下。在这里，我们将把我们的模型初始化为 手电筒nn。单元 然后定义向前传球。在我们正在编写的代码中，softmax是在每次向前传递期间内部计算的，因此我们不需要在forward（）函数中指定它。

Python3

                           class                                        LogisticRegression(nn.Module):                         
                                                     def                                        __init__(                                        self                                        , input_size, num_classes):                         
                                                     super                                        (LogisticRegression,                                        self                                        ).__init__()                         
                                                     self                                        .linear                                        =                                        nn.Linear(input_size, num_classes)                         
                                      
                                                     def                                        forward(                                        self                                        , x):                         
                                                     out                                        =                                        self                                        .linear(x)                         
                                                     return                                        out                         

定义了类之后，现在我们为同一个类实例化一个对象。

Python3

model = LogisticRegression(input_size, num_classes)

接下来，我们设置损失函数和优化器。这里，我们将使用交叉熵损失，对于优化器，我们将使用学习率为0.001的随机梯度下降算法，如上面的超参数所定义。

Python3

criterion = nn.CrossEntropyLoss()

optimizer = torch.optim.SGD(model.parameters(), lr = learning_rate)

现在，我们开始训练。在这里，我们将执行以下任务：

将所有渐变重置为0。
向前传球。
计算损失。
执行反向传播。
更新所有权重。

Python3

                           # Training the Model                         
                           for                                        epoch                                        in                                        range                                        (num_epochs):                         
                                                     for                                        i, (images, labels)                                        in                                        enumerate                                        (train_loader):                         
                                                     images                                        =                                        Variable(images.view(                                        -                                        1                                        ,                                        28                                        *                                        28                                        ))                         
                                                     labels                                        =                                        Variable(labels)                         
                                      
                                                     # Forward + Backward + Optimize                         
                                                     optimizer.zero_grad()                         
                                                     outputs                                        =                                        model(images)                         
                                                     loss                                        =                                        criterion(outputs, labels)                         
                                                     loss.backward()                         
                                                     optimizer.step()                         
                                      
                                                     if                                        (i                                        +                                        1                                        )                                        %                                        100                                        =                                        =                                        0                                        :                         
                                                     print                                        (                                        'Epoch: [% d/% d], Step: [% d/% d], Loss: %.4f'                         
                                                     %                                        (epoch                                        +                                        1                                        , num_epochs, i                                        +                                        1                                        ,                         
                                                     len                                        (train_dataset)                                        /                                        /                                        batch_size, loss.data[                                        0                                        ]))                         

最后，我们将使用以下代码测试该模型。

Python3

                           # Test the Model                         
                           correct                                        =                                        0                         
                           total                                        =                                        0                         
                           for                                        images, labels                                        in                                        test_loader:                         
                                                     images                                        =                                        Variable(images.view(                                        -                                        1                                        ,                                        28                                        *                                        28                                        ))                         
                                                     outputs                                        =                                        model(images)                         
                                                     _, predicted                                        =                                        torch.                                        max                                        (outputs.data,                                        1                                        )                         
                                                     total                                        +                                        =                                        labels.size(                                        0                                        )                         
                                                     correct                                        +                                        =                                        (predicted                                        =                                        =                                        labels).                                        sum                                        ()                         
                                      
                           print                                        (                                        'Accuracy of the model on the 10000 test images: % d %'                                        %                                        (                         
                                                     100                                        *                                        correct                                        /                                        total))                         

假设您正确执行了所有步骤，您将获得82%的准确率，这与当今使用特殊类型神经网络架构的最先进模型相去甚远。作为参考，您可以在下面找到本文的完整代码：

Python3

                           import                                        torch                         
                           import                                        torch.nn as nn                         
                           import                                        torchvision.datasets as dsets                         
                           import                                        torchvision.transforms as transforms                         
                           from                                        torch.autograd                                        import                                        Variable                         
                                      
                                      
                           # MNIST Dataset (Images and Labels)                         
                           train_dataset                                        =                                        dsets.MNIST(root                                        =                                        './data'                                        ,                         
                                                     train                                        =                                        True                                        ,                         
                                                     transform                                        =                                        transforms.ToTensor(),                         
                                                     download                                        =                                        True                                        )                         
                                      
                           test_dataset                                        =                                        dsets.MNIST(root                                        =                                        './data'                                        ,                         
                                                     train                                        =                                        False                                        ,                         
                                                     transform                                        =                                        transforms.ToTensor())                         
                                      
                           # Dataset 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                                        )                         
                                      
                           # Hyper Parameters                         
                           input_size                                        =                                        784                         
                           num_classes                                        =                                        10                         
                           num_epochs                                        =                                        5                         
                           batch_size                                        =                                        100                         
                           learning_rate                                        =                                        0.001                         
                                      
                           # Model                         
                           class                                        LogisticRegression(nn.Module):                         
                                                     def                                        __init__(                                        self                                        , input_size, num_classes):                         
                                                     super                                        (LogisticRegression,                                        self                                        ).__init__()                         
                                                     self                                        .linear                                        =                                        nn.Linear(input_size, num_classes)                         
                                      
                                                     def                                        forward(                                        self                                        , x):                         
                                                     out                                        =                                        self                                        .linear(x)                         
                                                     return                                        out                         
                                      
                                      
                           model                                        =                                        LogisticRegression(input_size, num_classes)                         
                                      
                           # Loss and Optimizer                         
                           # Softmax is internally computed.                         
                           # Set parameters to be updated.                         
                           criterion                                        =                                        nn.CrossEntropyLoss()                         
                           optimizer                                        =                                        torch.optim.SGD(model.parameters(), lr                                        =                                        learning_rate)                         
                                      
                           # Training the Model                         
                           for                                        epoch                                        in                                        range                                        (num_epochs):                         
                                                     for                                        i, (images, labels)                                        in                                        enumerate                                        (train_loader):                         
                                                     images                                        =                                        Variable(images.view(                                        -                                        1                                        ,                                        28                                        *                                        28                                        ))                         
                                                     labels                                        =                                        Variable(labels)                         
                                      
                                                     # Forward + Backward + Optimize                         
                                                     optimizer.zero_grad()                         
                                                     outputs                                        =                                        model(images)                         
                                                     loss                                        =                                        criterion(outputs, labels)                         
                                                     loss.backward()                         
                                                     optimizer.step()                         
                                      
                                                     if                                        (i                                        +                                        1                                        )                                        %                                        100                                        =                                        =                                        0                                        :                         
                                                     print                                        (                                        'Epoch: [% d/% d], Step: [% d/% d], Loss: %.4f'                         
                                                     %                                        (epoch                                        +                                        1                                        , num_epochs, i                                        +                                        1                                        ,                         
                                                     len                                        (train_dataset)                                        /                                        /                                        batch_size, loss.data[                                        0                                        ]))                         
                                      
                           # Test the Model                         
                           correct                                        =                                        0                         
                           total                                        =                                        0                         
                           for                                        images, labels                                        in                                        test_loader:                         
                                                     images                                        =                                        Variable(images.view(                                        -                                        1                                        ,                                        28                                        *                                        28                                        ))                         
                                                     outputs                                        =                                        model(images)                         
                                                     _, predicted                                        =                                        torch.                                        max                                        (outputs.data,                                        1                                        )                         
                                                     total                                        +                                        =                                        labels.size(                                        0                                        )                         
                                                     correct                                        +                                        =                                        (predicted                                        =                                        =                                        labels).                                        sum                                        ()                         
                                      
                           print                                        (                                        'Accuracy of the model on the 10000 test images: % d %'                                        %                                        (                         
                                                     100                                        *                                        correct                                        /                                        total))                         

工具书类 :

文章版权归作者所有，未经允许请勿转载。

THE END

Python