python逻辑回归逐步回归_逻辑回归Python?

#线性回归问题
import csv
import matplotlib
import torch
from torch import nn
from torch import optim
from matplotlib import pyplot as plt
##%matplotlib inline省略掉这行代码  添加plt show（）
import numpy as np
from torch.distributions import MultivariateNormal

#设置两组不同的均值向量和协方差矩阵
mu1=-3*torch.ones(2)
mu2=3*torch.ones(2)
sigmal1=torch.eye(2)*0.5#对角线全为1的二维数组
sigmal2=torch.eye(2)*2

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

#设置正负样本的标签
y=torch.zeros((200,1))#生成200个0
y[100:]=1#将后一百个标记为1

#组合、打乱样本
x=torch.cat([x1,x2],dim=0)
idx=np.random.permutation(len(x))  #premutation 用来随机排列一个数组
x=x[idx]
y=y[idx]

#绘制样本
plt.scatter(x1.numpy()[:,0],x1.numpy()[:,1]) #scatter绘制散点图
plt.scatter(x2.numpy()[:,0],x2.numpy()[:,1])
#plt.show()  #显示图片

D_in,D_out=2,1
linear=nn.Linear(D_in,D_out,bias=True)#bias为偏置
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)))

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

def my_sigmoid(x):
    x=1/(1+torch.exp(-x))
    return x

a1=torch.sum(sigmoid(output)-my_sigmoid(output))

#损失函数
loss=nn.BCELoss()
a1=loss(sigmoid(output),y)

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

a2=my_loss(sigmoid(output),y)
a3=a1-a2

import torch.nn as nn

class LogisticRegression(nn.Module):
    def __init__(self,D_in):
        super(LogisticRegression,self).__init__()#super用来调用父类的方法
        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)

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel,self).__init__()
        self.linear1=nn.Linear(1,1,bias=False)
        self.linear2=nn.Linear(1,1,bias=False)

    def forward(self):
        pass
#for param in MyModel().parameters():
#    print(param)

#优化算法
optimizer=optim.SGD(lr_model.parameters(),lr=0.03)#lr是学习率

batch_size=10
iters=10
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()

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(),'r')

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