逻辑回归模型

生成数据

import numpy as np
import matplotlib.pyplot as plt
c0=np.random.normal(6,1,100)
c1=np.random.normal(3,1,100)
c2=np.random.normal(3,1,100)
c3=np.random.normal(6,1,100)

c0y=np.zeros(100)
c1y=np.ones(100)
print(c1y)
print(c0y)


#划分训练集和测试集
data1=np.concatenate((c0.reshape(100,1),c1.reshape(100,1),c0y.reshape(100,1)),axis=1)
data2=np.concatenate((c2.reshape(100,1),c3.reshape(100,1),c1y.reshape(100,1)),axis=1)
data=np.concatenate((data1,data2))
np.random.shuffle(data)
train_data_x=data[:150,0:2]
test_data_x=data[150:,0:2]
train_y=data[:150,-1]
test_y=data[150:,-1]


#随机产生初始参数W
W=np.random.rand(2) #array([0.98038737, 0.28897428])

有了数据，还有所求参数W[w0,w1]

y=w0*x0+w1*x1  可以变形为x1=(-W[0]*X)/W[1]

横纵坐标为 x1,x2，你知道的

x=np.arange(10)
y=-1.*(W[0]*x)/W[1]
plt.scatter(c0,c1)
plt.scatter(c2,c3)
plt.plot(x,y)
plt.show()
#画图看一下

使用sigmod函数

 

求解交叉熵损失函数和sigmod

加负号变形为

def sigmod(z):
    gz=1./(1.+np.exp(-z))
    return gz

#损失函数
def loss(y,gz):
    loss=np.sum(-1.0*y*np.log(gz)-(1-y)*np.log(1-gz))
    return loss

对损失函数求导

 

梯度计算

lr=0.01
lss=[]
#train_data_x是一个150行X2列的矩阵
#h(x)-y是一个150行X1列的矩阵
#要求梯度g
#假设h(x)-y=[d0,d1,d2....].T   是（150*1）
#我们要的是[d0*X00,d0*X01]  每一列对应着[w0,w1]    x00是第0个样本的第0个值
#         [d1*X10,d1*X11]
#         [d2*X20,d2*X21]
#所以需要train_data_x (150x2) 的转置 (2*150)
#去乘以D (150 x 1) 会自动加起来得到(2*1）的矩阵

for i in range(1000):
    hx=np.sum(W*train_data_x,axis=1).reshape(150,1)
    gz=sigmod(hx)
    train_y=train_y.reshape(150,1)
    ls=loss(train_y,gz)
    lss.append(ls)
    gz_t=gz-train_y
    g=np.dot(train_data_x.T,gz_t)/150
    g=g.T     #求得的g 是（2*1）的，我这里要用的是一维的,需要转置，具体怎么用具体分析
    W=W-lr*g


print(W[0])  #应为是[[156,456]]这样，需要拿出来
plt.scatter(c0,c1)
plt.scatter(c2,c3)
y1=(-W[0][0]*x)/W[0][1]
plt.plot(x,y1)
plt.show()
plt.plot(np.array(lss))
plt.show()