Logistic回归

标签：linear nn sigmoid 回归 torch Logistic output 模型

一、线性回归简介

线性回归模型是指采用线性组合形式的回归模型，在线性回归问题中，因变量和自变量之间是线性关系的。对于第i个因变量xi，我们乘以权重系数wi，取y为因变量的线性组合：

y=f(x)=wⁱxⁱ+…+w ⁿxⁿ+b
其中b为常数项。若w=(w¹…wⁿ)，则上式可以写成向量形式：
y=f(x)=wᵀx+b

二、Logistic回归简介

在上节中，我们假设随机变量x..x与y之间的关系是线性的。但在实际中，我们通常会遇到非线性关系。这个时候，我们可以使用一个非线性变换g(.)，使得线性回归模型f(.)实际上对g(y)而非y进行拟合，即：y=g¯1(f(x))
其中(.)仍为：f(x)=wᵀx+b
因此这样的回归模型称为广义线性回归模型。

三、用PyTorch实现Logistic回归

• 逻辑回归实现同样是四个步骤： • 准备数据集 • 设计模型 • 定义损失函数和优化器 • 模型训练

代码依赖模块：

import matplotlib.pyplot as plt
import  numpy as np
import torch
%matplolib inline

3.1数据准备

为了便于描述，我们分别从两个多元高斯分布N₁( $\mu 1$ ， $\sum 1$ )、N₂( $\mu 2$ ， $\sum 2$ )中生成数据x1和x₂，这两个多元高斯分布分别表示两个类别，分别设置其标签为和y₁和y₂。
PyTorch 的 torch.distributions提供了MultivariateNormal 构建多元高斯分布。下面第5~8行代码设置两组不同的均值向量和协方差矩阵， $\mu 1$ (mul)和 $\mu 2$ (mu2)是二维均值向量， $\sum 1$ (sigmal)和 $\sum 2$ (sigma2)是2×2的协方差矩阵。在第11~12行，前面定义的均值向量和协方差矩阵作为参数传入MultivariateNormal，就实例化了两个多元高斯分布m和m。第13~14行调用m₁和m₂的sample方法分别生成100个样本。
第17~18行设置样本对应的标签y，分别用0和1表示不同高斯分布的数据，也就是正样归模
本和负样本。第21行使用cat 函数将x₁(ml)和x₂(m2)组合在一起。第22~24行打乱样本和标签的顺序，将数据重新随机排列，这是十分重要的步骤，否则算法的每次迭代只会学习到同一个类别的信息，容易造成模型过拟合。

import matplotlib.pyplot as plt
import  numpy as np
import torch
from torch import nn, sigmoid_
from torch.distributions import  MultivariateNormal
from torch.nn.modules.module import T

#设置两组不同的均值向量和协方差矩阵
mu1 = -3 * torch.ones(2)
mu2 = 3 * torch.ones(2)
sigma1 = torch.eye(2) * 0.5
sigma2 = torch.eye(2) * 2

#各从两个多元高斯分布中生成100个样本
m1 = MultivariateNormal(mu1,sigma1)
m2 = MultivariateNormal(mu2,sigma2)
x1 = m1.sample((100,))
x2 = m2.sample((100,))

#设置正反样本的标签
y = torch.zeros((200,1))
y[100:] = 1

#组合、打乱样本
x = torch.cat([x1,x2], dim=0)
idx = np.random.permutation(len(x))
x = x[idx]
y = y[idx]

#绘制样本
plt.scatter(x1.numpy()[:,0],x1.numpy()[:,1])
plt.scatter(x2.numpy()[:,0],x2.numpy()[:,1])

运行结果：

3.2线性方程

Logistic 回归用输入变量x的线性函数表示样本为正类的对数概率。nn.Linear实现了
y=xA+b，我们可以直接调用它来实现Logistic回归的线性部分。

D_in,D_out = 2,1
linear = nn.Linear(D_in,D_out,bias=True)
output = linear(x)

print(x.shape,linear.weight.shape,linear.bias.shape,output.shape)

def my_linear(x,w,b):
    return torch.mm(x,w.t()) + b
torch.sum((output - my_linear(x,linear.weight,linear.bias)))

上面代码的第1行定义了线性模型的输入维度D_in和输出维度D_out，因为前面定义的多元高斯分布 m₁(m1)和m₂(m2)产生的变量是二维的，所以线性模型的输入维度应该定义为D_in=2；而 Logistic 回归是二分类模型，预测的是变量为正类的概率，所以输出的维度应该为D_in=1。第2~3行实例化了nn.Linear，将线性模型应用到数据x上，得到计算结果output。
Linear 的初始参数是随机设置的，可以调用 Linearweight 和 Linear.bias 获取线性模型的参数。第5行输出了输人变量x、模型参数weight和bias，以及计算结果outout的维度。第7~8行定义了线性模型my_linear。第10行将my_linear的计算结果和PyTorch的计算结果output进行比较，可以发现它们是一致的。

3.3激活函数

前文介绍了nn.Linear 可用于实现线性模型，除此之外，torch.nn还提供了机器学习中常用的激活函数。当Logistic 回归用于二分类问题时，使用sigmoid 函数将线性模型的计算结果映射到0和1之间，得到的计算结果作为样本为正类的置信概率。nn.Sigmoid提供了sigmoid函数的计算，在使用时，将Sigmoid类实例化，再将需要计算的变量作为参数传递给实例化的对象。

sigmoid = nn.Sigmoid()
scores = sigmoid(output)

def my_sigmoid(x):
    x = 1 / (1 + torch.exp(-x))
    return x
torch.sum(sigmoid(output) - sigmoid_(output))

作为练习，第4~6行手动实现sigmoid函数，第8行通过PyTorch验证我们的实现结果，
其结果一致。

3.4损失函数

Logistic回归使用交叉熵作为损失函数。PyTorch的torch.nn提供了许多标准的损失函数，我们可以直接使用nn.BCELoss计算二值交叉熵损失。第1~2行调用了BCELoss来计算我们实
Logistic 回归模型的输出结果sigmoid(output)和数据的标签y。同样地，在第4~6行我们78+值交叉熵函数，在第8行将my loss和PyTorch的BCELoss进行比较，发现其结果一致。

loss = nn.BCELoss()
loss(sigmoid(output),y)

def my_loss(x,y):
    loss = - torch.mean(torch.log(x) * y + torch.log(1 - x) * (1 - y))
    return loss

loss(sigmoid(output),y) - my_loss(sigmoid_(output),y)

在前面的代码中，我们使用了torchnn包中的线性模型nn.Linear、激活函数 nn.Softmax损失函数nn.BCELoss，它们都继承自nn，Module类。而在PyTorch中，我们通过继承nn.Module来构建我们自己的模型。接下来我们用nn.Module来实现Logistic回归。

import torch.nn as nn

class LogisticRegression(nn.Module):
    def __init__(self,D_in):
        super(LogisticRegression,self).__init__()
        self.linear = nn.Linear(D_in,1)
        self.sigmoid = nn.Sigmoid()
    def forward(self,x):
        x = self.linear(x)
        output = self.sigmoid(x)
        return  output

lr_model = LogisticRegression(2)
loss = nn.BCELoss()
loss(lr_model(x),y)

当通过继承 nn.Module实现自己的模型时，forward方法是必须被子类覆写的，在forward内部应当定义每次调用模型时执行的计算。从代码中我们可以看出，nn.Module 类的主要作用
就是接收Tensor然后计算并返回结果。 Module的属性就可以被自动获
在一个Module中，还可以嵌套其他的Module，被嵌套的
取，比如可以调用nn.Module.parameters方法获取Module所有保留的参数，调用 nn.Module.to方法将模型的参数放置到GPU上等。

class MyModel(nn.Module):
    def __init__(self):
       super(MyModel,self).__init__()
       self.linear = nn.Linear(1,1,bias=True)
       self.linear = nn.Linear(1,1,bias=False)
    def forward(self):
        pass

for param in MyModel().parameters():
    print(param)

3.5优化算法

Logistic回归通常采用稀度下降法优化目标函数。PyTorch的torch.optim包实现了大多数意用的优化算法，使用起来非常简单。首先构建一个优化器，在构建时，需要将待学习的参数传入，然后传人优化器需要的参数，比如学习率。

from torch import  optim

optimizer = optim.SGD(lr_model.parameters(),lr=0.03)

构建完优化器，就可以迭代地对模型进行训练，有两个步骤：首先调用损失函数的backward方法计算模型的梯度，然后调用优化器的step方法更新模型的参数。需要注意的是，应当提前调用优化器的zero_grad方法清空参数的梯度。

batch_size =10
iters = 10
#for input,target in dataset:
for _ in range(iters):
    for i in range(int(len(x)/batch_size)):
        input = x[i*batch_size:(i+1)*batch_size]
        target = y[i*batch_size:(i+1)*batch_size]
        optimizer.zero_grad()
        output = lr_model(input)
        l = loss(output,target)
        l.backward()
        optimizer.step()

3.6模型可视化

Logistic 回归模型的判决边界在高维空间是一个超平面，而我们的数据集是二维的，所以判决边界只是平面内的一条直线，在线的一侧被预测为正类，另一侧则被预测为负类。下面我们实现draw decision boundary函数。它接收线性模型的参数w和b，以及数据集x。绘制判决边界的方法十分简单，如第10行，只需要计算一些数据在线性模型的映射值，然后调用plt.plot绘制线条即可。

output = lr_model(x)
pred_neg = (output <= 0.5).view(-1)
pred_pos = (output > 0.5).view(-1)
plt.scatter(x[pred_neg,0],x[pred_neg,1])
plt.scatter(x[pred_pos,0],x[pred_pos,1])

w = lr_model.linear.weight[0]
b = lr_model.linear.bias[0]

def draw_decision_boundary(w,b,x0):
    x1 = (-b - w[0] * x0) / w[1]
    plt.plot(x0.detach().numpy(),x1.detach().numpy(),'b')

draw_decision_boundary(w,b,torch.linspace(x.min(),x.max(),50))
plt.show()