【Pytorch深度学习实战】（3）逻辑回归（Logistic Regression）

🔎大家好，我是Sonhhxg_柒，希望你看完之后，能对你有所帮助，不足请指正！共同学习交流🔎

📝个人主页－Sonhhxg_柒的博客_CSDN博客 📃

🎁欢迎各位→点赞👍 + 收藏⭐️ + 留言📝​

📣系列专栏 - 机器学习【ML】 自然语言处理【NLP】  深度学习【DL】

​

 🖍foreword

✔说明⇢本人讲解主要包括Python、机器学习（ML）、深度学习（DL）、自然语言处理（NLP）等内容。

如果你对这个系列感兴趣的话，可以关注订阅哟👋

逻辑回归Pytorch实现 

 
 

   
   

    
    

   
   
   
   

    
    

     
     import torch
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     import torch.nn 
     
     as nn
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     import torchvision
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     import torchvision.transforms 
     
     as transforms
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     # 超参数
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     input_
     
     size 
     
     = 
     
     28 
     
     * 
     
     28    # 
     
     784
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     num_classes 
     
     = 
     
     10
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     num_epochs 
     
     = 
     
     5
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     batch_
     
     size 
     
     = 
     
     100
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     learning_rate 
     
     = 
     
     0.001
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     # MNIST 数据集（图像和标签）
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     train_dataset 
     
     = torchvision.datasets.MNIST(root
     
     =
     
     '../../data', 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                                                train
     
     =
     
     True, 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                                                transform
     
     =transforms.ToTensor(),
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                                                download
     
     =
     
     True)
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     test_dataset 
     
     = torchvision.datasets.MNIST(root
     
     =
     
     '../../data', 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                                               train
     
     =
     
     False, 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                                               transform
     
     =transforms.ToTensor())
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     # 数据加载器（输入管道）
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     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)
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     # 逻辑回归模型
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     model 
     
     = nn.Linear(
     
     input_
     
     size, num_classes)
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     # 损失和优化器
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     # nn.CrossEntropyLoss() computes softmax internally
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     criterion 
     
     = nn.CrossEntropyLoss()  
    
    
   
   

   
   

    
    

   
   
   
   

    
    

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

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     # 训练模型
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     total_step 
     
     = len(train_loader)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     for epoch 
     
     in range(num_epochs):
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     for i, (images, labels) 
     
     in enumerate(train_loader):
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             # 将images重塑为 (batch_
     
     size, 
     
     input_
     
     size)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             images 
     
     = images.reshape(-
     
     1, 
     
     input_
     
     size)
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             # 前向传播
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             outputs 
     
     = model(images)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             loss 
     
     = criterion(outputs, labels)
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             # 向后优化
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             optimizer.
     
     zero_grad()
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             loss.backward()
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             optimizer.step()
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
    
    
   
   

   
   

    
    

   
   
   
   

    
    
        
     
     if (i
     
     +
     
     1) % 
     
     100 
     
     =
     
     = 
     
     0:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                 print (
     
     'Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}' 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
                        .
     
     format(epoch
     
     +
     
     1, num_epochs, i
     
     +
     
     1, total_step, loss.item()))
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     # 测试模型
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     # 在测试阶段，我们不需要计算梯度（为了内存效率）
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     with torch.
     
     no_grad():
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         correct 
     
     = 
     
     0
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
         total 
     
     = 
     
     0
    
    
   
   

   
   

    
    

   
   
   
   

    
    
    
     
     for images, labels 
     
     in 
     
     test_loader:
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             images 
     
     = images.reshape(-
     
     1, 
     
     input_
     
     size)
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
             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: {} %'.
     
     format(
     
     100 
     
     * correct 
     
     / total))
    
    
   
   

   
   

    
    

   
   
   
   

    
    
 
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     # 保存模型
    
    
   
   

   
   

    
    

   
   
   
   

    
    

     
     torch.save(model.state_dict(), 
     
     'model.ckpt')