用pytorch实现逻辑回归

用pytorch实现逻辑回归

import torch
from torch.autograd import Variable

torch.manual_seed(2)
x_data = Variable(torch.Tensor([[1.0], [2.0], [3.0], [4.0]]))
y_data = Variable(torch.Tensor([[0.0], [0.0], [1.0], [1.0]]))

#初始化
w = Variable(torch.Tensor([-1]), requires_grad=True)
b = Variable(torch.Tensor([0]), requires_grad=True)
epochs = 100
costs = []
lr = 0.1
print("before training, predict of x = 1.5 is:")
print("y_pred = ", float(w.data*1.5 + b.data > 0))

#模型训练
for epoch in range(epochs):
	#计算梯度
	A = 1/(1+torch.exp(-(w*x_data+b))) #逻辑回归函数
	J = -torch.mean(y_data*torch.log(A) + (1-y_data)*torch.log(1-A))  #逻辑回归损失函数
	#J = -torch.mean(y_data*torch.log(A) + (1-y_data)*torch.log(1-A)) +alpha*w**2
	#基础类进行正则化,加上L2范数
	costs.append(J.data)
	J.backward()  #自动反向传播

	#参数更新
	w.data = w.data - lr*w.grad.data
	w.grad.data.zero_()
	b.data = b.data - lr*b.grad.data
	b.grad.data.zero_()

print("after training, predict of x = 1.5 is:")
print("y_pred =", float(w.data*1.5+b.data > 0))
print(w.data, b.data)
before training, predict of x = 1.5 is:
y_pred =  0.0
after training, predict of x = 1.5 is:
y_pred = 0.0
tensor([ 0.6075]) tensor([-0.9949])
[Finished in 0.4s]

用pytorch实现torch.nn.module

import torch
from torch.autograd import Variable

torch.manual_seed(2)
x_data = Variable(torch.Tensor([[1.0], [2.0], [3.0], [4.0]]))
y_data = Variable(torch.Tensor([[0.0], [0.0], [1.0], [1.0]]))

#定义网络模型
#先建立一个基类Module,都是从父类torch.nn.Module继承过来,Pytorch写网络的固定写法
class Model(torch.nn.Module):
	def __init__(self):
		super(Model, self).__init__()  #初始父类
		self.linear = torch.nn.Linear(1, 1)  #输入维度和输出维度都为1

	def forward(self, x):
		y_pred = self.linear(x)
		return y_pred

model = Model()  #实例化

#定义loss和优化方法
criterion = torch.nn.BCEWithLogitsLoss()  #损失函数,封装好的逻辑损失函数
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)   #进行优化梯度下降
#optimizer = torch.optim.SGD(model.parameters(), lr=0.01, weight_decay=0.001)
#Pytorch类方法正则化方法,添加一个weight_decay参数进行正则化

#befor training 
hour_var = Variable(torch.Tensor([[2.5]]))
y_pred = model(hour_var)
print("predict (before training)given", 4, 'is', float(model(hour_var).data[0][0]>0.5))

epochs = 40
for epoch in range(epochs):
	#计算grads和cost
	y_pred = model(x_data)   #x_data输入数据进入模型中
	loss = criterion(y_pred, y_data)
	print('epoch = ', epoch+1, loss.data[0])
	optimizer.zero_grad() #梯度清零
	loss.backward() #反向传播
	optimizer.step()  #优化迭代

#After training 
hour_var = Variable(torch.Tensor([[4.0]]))
y_pred = model(hour_var)
print("predict (after training)given", 4, 'is', float(model(hour_var).data[0][0]>0.5))
predict (before training)given 4 is 0.0
[Decode error - output not utf-8]
epoch =  1 tensor(0.6004)
epoch =  2 tensor(0.5998)
epoch =  3 tensor(0.5993)
epoch =  4 tensor(0.5987)
epoch =  5 tensor(0.5982)
epoch =  6 tensor(0.5977)
epoch =  7 tensor(0.5972)
epoch =  8 tensor(0.5967)
epoch =  9 tensor(0.5962)
epoch =  10 tensor(0.5957)
epoch =  11 tensor(0.5952)
epoch =  12 tensor(0.5947)
epoch =  13 tensor(0.5943)
epoch =  14 tensor(0.5938)
epoch =  15 tensor(0.5934)
epoch =  16 tensor(0.5930)
epoch =  17 tensor(0.5926)
epoch =  18 tensor(0.5921)
epoch =  19 tensor(0.5917)
epoch =  20 tensor(0.5913)
epoch =  21 tensor(0.5909)
epoch =  22 tensor(0.5906)
epoch =  23 tensor(0.5902)
epoch =  24 tensor(0.5898)
epoch =  25 tensor(0.5894)
epoch =  26 tensor(0.5891)
epoch =  27 tensor(0.5887)
epoch =  28 tensor(0.5884)
epoch =  29 tensor(0.5880)
epoch =  30 tensor(0.5877)
epoch =  31 tensor(0.5873)
epoch =  32 tensor(0.5870)
epoch =  33 tensor(0.5867)
epoch =  34 tensor(0.5863)
epoch =  35 tensor(0.5860)
epoch =  36 tensor(0.5857)
epoch =  37 tensor(0.5854)
epoch =  38 tensor(0.5851)
epoch =  39 tensor(0.5848)
epoch =  40 tensor(0.5845)
predict (after training)given 4 is 1.0
[Finished in 0.5s]
  • 0
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
好的,下面是使用 PyTorch 实现逻辑回归的代码示例: ```python import torch import torch.nn as nn import torch.optim as optim import numpy as np # 定义数据 X = torch.tensor([[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0]]) y = torch.tensor([[0.0], [0.0], [1.0], [1.0]]) # 定义模型 class LogisticRegression(nn.Module): def __init__(self, input_dim, output_dim): super(LogisticRegression, self).__init__() self.linear = nn.Linear(input_dim, output_dim) self.sigmoid = nn.Sigmoid() def forward(self, x): out = self.linear(x) out = self.sigmoid(out) return out model = LogisticRegression(input_dim=2, output_dim=1) # 定义损失函数和优化器 criterion = nn.BCELoss() optimizer = optim.SGD(model.parameters(), lr=0.1) # 训练模型 num_epochs = 1000 for epoch in range(num_epochs): # 前向传播 outputs = model(X) loss = criterion(outputs, y) # 反向传播和优化 optimizer.zero_grad() loss.backward() optimizer.step() # 打印损失值 if (epoch+1) % 100 == 0: print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item())) # 预测 with torch.no_grad(): predicted = model(X).round() print('Predicted Values:', predicted) ``` 上述代码中: - `X` 和 `y` 分别表示输入和输出数据; - `LogisticRegression` 类定义了模型,其中包含一个线性层和一个 sigmoid 函数,用于计算输出; - `BCELoss` 是二元交叉熵损失函数,用于计算损失值; - `SGD` 是随机梯度下降优化器,用于优化模型; - `num_epochs` 表示训练的次数; - 在训练过程中,首先进行前向传播计算,然后计算损失值,接着进行反向传播和优化; - 在训练结束后,使用训练好的模型进行预测,输出预测结果。 注意:在实际应用中,需要对数据进行预处理和归一化等操作。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值