用pytorch 实现逻辑回归

最新推荐文章于 2025-07-01 12:18:01 发布

weixin_41710583

最新推荐文章于 2025-07-01 12:18:01 发布

阅读量9.1k

点赞数 5

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/weixin_41710583/article/details/90259957

本文详细介绍使用PyTorch构建逻辑回归模型的过程，包括数据集构造、模型搭建、损失函数定义、优化器设置及训练过程。通过10000次迭代训练，模型最终达到100%的分类准确率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

用pytorch 实现逻辑回归

构造数据集：

n_data = torch.ones(100, 2)
x0 = torch.normal(2 * n_data, 1)  # 生成均值为2.标准差为1的随机数组成的矩阵 shape=(100, 2)
y0 = torch.zeros(100)
x1 = torch.normal(-2 * n_data, 1)  # 生成均值为-2.标准差为1的随机数组成的矩阵 shape=(100, 2)
y1 = torch.ones(100)

#合并数据x,y
x=torch.cat((x0,x1),0).type(torch.FloatTensor)
y=torch.cat((y0,y1),0).type(torch.FloatTensor)

根据构造的数据集显示图像

从图中看到，数据集区分比较明显。
构建逻辑回归的网络

class LogisticRegression(nn.Module):
    def __init__(self):
        super(LogisticRegression,self).__init__()
        self.lr=nn.Linear(2,1)   #相当于通过线性变换y=x*T(A)+b可以得到对应的各个系数
        self.sm=nn.Sigmoid()   #相当于通过激活函数的变换

    def forward(self, x):
        x=self.lr(x)
        x=self.sm(x)
        return x

定义损失函数和优化器

criterion=nn.BCELoss()   #选用BCE损失函数,该损失函数是只用于2分类问题的损失函数
optimizer=torch.optim.SGD(logistic_model.parameters(),lr=1e-3,momentum=0.9)  #采用随机梯度下降的方法

开始训练

#开始训练
#训练10000次
for epoch in range(10000):
    if torch.cuda.is_available():
        x_data=Variable(x).cuda()
        y_data=Variable(y).cuda()
    else:
        x_data=Variable(x)
        y_data=Variable(y)

    out=logistic_model(x_data)  #根据逻辑回归模型拟合出的y值

    loss=criterion(out,y_data)  #计算损失函数
    print_loss=loss.data.item()  #得出损失函数值
    mask=out.ge(0.5).float()  #以0.5为阈值进行分类
    correct=(mask==y_data).sum()  #计算正确预测的样本个数
    acc=correct.item()/x_data.size(0)  #计算精度
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    #每隔20轮打印一下当前的误差和精度
    if (epoch+1)%20==0:
        print('*'*10)
        print('epoch {}'.format(epoch+1))  #误差
        print('loss is {:.4f}'.format(print_loss))
        print('acc is {:.4f}'.format(acc))  #精度

输出结果

**********
epoch 9980
loss is 0.0179
acc is 100.0000
**********
epoch 10000
loss is 0.0179
acc is 100.0000

输出结果的图像

从图中看到分类还是比较明显
完整代码

import torch
import matplotlib.pyplot as plt
import torch.nn as nn
from torch.autograd import Variable
import numpy as np


n_data = torch.ones(100, 2)
x0 = torch.normal(2 * n_data, 1)  # 生成均值为2.标准差为1的随机数组成的矩阵 shape=(100, 2)
y0 = torch.zeros(100)
x1 = torch.normal(-2 * n_data, 1)  # 生成均值为-2.标准差为1的随机数组成的矩阵 shape=(100, 2)
y1 = torch.ones(100)

#合并数据x,y
x=torch.cat((x0,x1),0).type(torch.FloatTensor)
y=torch.cat((y0,y1),0).type(torch.FloatTensor)

print(x.data.numpy()[:,0])
#画图
# plt.scatter(x.data.numpy()[:,0],x.data.numpy()[:,1],c=y.data.numpy(),s=100,lw=0,cmap='RdYlGn')
# plt.show()

class LogisticRegression(nn.Module):
    def __init__(self):
        super(LogisticRegression,self).__init__()
        self.lr=nn.Linear(2,1)   #相当于通过线性变换y=x*T(A)+b可以得到对应的各个系数
        self.sm=nn.Sigmoid()   #相当于通过激活函数的变换

    def forward(self, x):
        x=self.lr(x)
        x=self.sm(x)
        return x

logistic_model=LogisticRegression()
if torch.cuda.is_available():
    logistic_model.cuda()


#定义损失函数和优化器
criterion=nn.BCELoss()   #选用BCE损失函数,该损失函数是只用于2分类问题的损失函数
optimizer=torch.optim.SGD(logistic_model.parameters(),lr=1e-3,momentum=0.9)  #采用随机梯度下降的方法

#开始训练
#训练10000次
for epoch in range(10000):
    if torch.cuda.is_available():
        x_data=Variable(x).cuda()
        y_data=Variable(y).cuda()
    else:
        x_data=Variable(x)
        y_data=Variable(y)

    out=logistic_model(x_data)  #根据逻辑回归模型拟合出的y值

    loss=criterion(out,y_data)  #计算损失函数
    print_loss=loss.data.item()  #得出损失函数值
    mask=out.ge(0.5).float()  #以0.5为阈值进行分类
    correct=(mask==y_data).sum()  #计算正确预测的样本个数
    acc=correct.item()/x_data.size(0)  #计算精度
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    #每隔20轮打印一下当前的误差和精度
    if (epoch+1)%20==0:
        print('*'*10)
        print('epoch {}'.format(epoch+1))  #误差
        print('loss is {:.4f}'.format(print_loss))
        print('acc is {:.4f}'.format(acc))  #精度


# 结果可视化
w0,w1=logistic_model.lr.weight[0]
w0=float(w0.item())
w1=float(w1.item())
b=float(logistic_model.lr.bias.item())
plot_x=np.arange(-7,7,0.1)
plot_y=(-w0*plot_x-b)/w1
plt.scatter(x.data.numpy()[:,0],x.data.numpy()[:,1],c=y.data.numpy(),s=100,lw=0,cmap='RdYlGn')
plt.plot(plot_x,plot_y)
plt.show()