【深度学习】（四）逻辑斯蒂回归+与线性回归区别+pytorch代码实现

1、逻辑回归

1、sigmoid激活函数

 

2、逻辑回归：

1）对y值做进一步的函数映射，采用signmoid （）函数作为映射函数

2）函数被压缩在0-1之间，并且函数是连续变换的，函数表达的是概率，

3）是回归模型，解决分类问题，对分类边界做拟合，很容易产生欠拟合，是线性回归模型，所以效率很高，通常用于做base model

2、线性回归&逻辑回归区别

区别1：

 区别2：

Loss Function for Linear Regression

loss=(-y)²=(x*w-y)²

Loss Function for Binary Classification

loss=-(ylog+(1-y)log(1-))

（交叉熵 cross entropy：Pd(x=i)lnPt(x=i)   两个分布之间差异性的大小，值越大越好，表示越接近y）

BCE损失 loss=-(ylog+(1-y)log(1-))：值越小越好，取负号了

区别3

线性回归

# 继承nn.Module(神经网络模块的基类)不用人工设计backward
class LinearModel(torch.nn.Module):
    # 构造函数
    def __init__(self):
        super(LinearModel, self).__init__()
        # torch.nn.Linear是pytorch里面的一个类，类后面加（）表示构造一个对象
        # torch.nn.Linear构造的对象包含 w  b
        # 参数（in_features,out_features,bias=True默认）
        self.linear=torch.nn.Linear(1,1)
  # 必须这个名字，前馈执行计算函数  # 必须这个名字，前馈执行计算函数
    def forward(self, x):
        # 可调用的对象
        y_pred = F.sigmoid(self.linear(x))
        return y_pred

#
#
criterion=torch.nn.MSELoss(size_average=False)

逻辑回归

import torch.nn.functional as F
class LogisticRegressionModel(torch.nn.Module):
    def __int__(self):
        super(LogisticRegressionModel, self).__int__()
        self.linear = torch.nn.Linear(1, 1)
    def forward(self,x):
        # 可调用的对象
        y_pred=self.linear(x)
        return y_pred
#
#
criterion=torch.nn.BCELoss(size_average=False)

3、代码

练习：

x_data=torch.Tensor([[1.0],[2.0],[3.0]])

y_data=torch.Tensor([[0],[0],[1]])用逻辑斯蒂回归求loss 画出sigmoid效果图

import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt
import numpy as np
x_data=torch.Tensor([[1.0],[2.0],[3.0]])
y_data=torch.Tensor([[0],[0],[1]])
# 继承nn.Module(神经网络模块的基类)不用人工设计backward


class LogisticRegressionModel(torch.nn.Module):
    def __init__(self):
        super(LogisticRegressionModel, self).__init__()
        self.linear = torch.nn.Linear(1, 1)

    # 必须这个名字，前馈执行计算函数  # 必须这个名字，前馈执行计算函数
    def forward(self, x):
        # 可调用的对象
        y_pred = F.sigmoid(self.linear(x))
        return y_pred

model=LogisticRegressionModel()
# 构造损失函数求均值size_average=True
criterion=torch.nn.BCELoss(size_average=False)
# 构造优化器
optimizer=torch.optim.SGD(model.parameters(),lr=0.01)
for epoch in range(1000):
    y_pred=model(x_data)
    loss=criterion(y_pred,y_data)
    print(epoch,loss)
    # 清零梯度
    optimizer.zero_grad()
    loss.backward()
    # 更新优化器
    optimizer.step()
x=np.linspace(0,10,200)
X_test=torch.Tensor(x)
# print(X_test)
# print(X_test.shape)=torch.Size([200])
# print(type(X_test))=torch.Tensor
X_test=X_test.view((200,1))
# view((200,1)改变shape模型数据必须是二维的
# print(X_test)
# print(X_test.shape)=torch.Size([200, 1])
# print(type(X_test))=torch.Tensor
y_test_p=model(X_test)
# print(y_test.shape)
# print(type(y_test))
# torch.Size([200, 1])
# <class 'torch.Tensor'>
y_p=y_test_p.data.numpy()
# print(y.shape)
# print(type(y))
# (200, 1)
# <class 'numpy.ndarray'>
plt.plot(x,y_p)
plt.plot([0,10],[0.5,0.5],c='r')
# 一条y=0.5的直线
plt.xlabel('Hours')
plt.ylabel('Probability of Pass')
plt.grid()
plt.show()