# 机器学习逻辑回归：算法兑现为python代码

0 回顾

1 生成模拟的数据集

import numpy as np

import matplotlib.pyplot as plt

#按照一定规律均匀分布含有两个特征的数据点

def createData(samplecnt,coef=1.0,intercept=0.05):

x1 = np.random.uniform(0,1,samplecnt)

x2 = np.random.uniform(0,1,samplecnt)

index = (x2-intercept)/x1 <coef

x1_pos = x1[index]

x2_pos = x2[index]

index = (x2-intercept)/x1 >=coef

x1_neg = x1[index]

x2_neg = x2[index]

plt.xlabel("w1")

plt.ylabel("w2")

plt.scatter(x1_pos,x2_pos)

plt.scatter(x1_neg,x2_neg)

regx = np.linspace(0,1,samplecnt)

regy = coef*regx+intercept

#plt.plot(regx,regy,color='g')

plt.show()

return x1_pos,x1_neg,x2_pos,x2_neg

#组合成原始数据

def combine_data(x1_pos,x1_neg,x2_pos,x2_neg):

x1_pos_1 = x1_pos.reshape(-1,1)

x2_pos_1 = x2_pos.reshape(-1,1)

x_pos = np.concatenate((x1_pos_1,x2_pos_1),axis=1)

x_pos_shape = np.shape(x_pos)

y_pos = np.ones(x_pos_shape[0])

y_pos = y_pos.reshape(-1,1)

data_pos = np.concatenate((x_pos,y_pos),axis=1)

x1_neg_1 = x1_neg.reshape(-1,1)

x2_neg_1 = x2_neg.reshape(-1,1)

x_neg = np.concatenate((x1_neg_1,x2_neg_1),axis=1)

x_neg_shape = np.shape(x_neg)

y_neg = np.zeros(x_neg_shape[0])

y_neg = y_neg.reshape(-1,1)

data_neg = np.concatenate((x_neg,y_neg),axis=1)

data = np.vstack((data_pos,data_neg))

data = np.random.permutation(data)

return data

w1 w2 y

array([[ 0.78863156, 0.45879449, 1. ],

[ 0.70291388, 0.03437041, 1. ],

[ 0.89775764, 0.24842968, 1. ],

[ 0.92674416, 0.13579184, 1. ],

[ 0.80332783, 0.71211063, 1. ],

[ 0.7208047 , 0.48432214, 1. ],

[ 0.8523947 , 0.06768344, 1. ],

[ 0.49226351, 0.24969169, 1. ],

[ 0.85094261, 0.79031018, 1. ],

[ 0.76426901, 0.07703571, 1. ]])

2 梯度下降求权重参数

'model' 建立的逻辑回归模型：包括Sigmoid映射

'cost' 代价函数

'theta update' 参数更新公式

'stop stratege' 迭代停止策略：代价函数小于阈值法

'偏移量 b shape=(200,1)'

b = np.ones(200)

'将偏移量与2个特征值组合 shape = (200,3)'

X = np.hstack((b,X))

'model'

def sigmoid(x):

return 1/(1+ np.exp(-x))

def model(theta,X):

theta = np.array(theta)

return sigmoid( X.dot(theta) )

'cost'

def cost(m,theta,X,y):

ele = y*np.log(model(theta,X)) + (1-y)*np.log(1-model(theta,X))

item_sum = np.sum(ele)

return -item_sum/m

for j in range(cols):

'theta update'

return theta - sigma * grad_theta

'stop stratege'

def stop_stratege(cost,cost_update,threshold):

return cost-cost_update < threshold

'逻辑回归算法'

def LogicRegression(X,y,threshold,m,xcols):

start = time.clock()

'设置权重参数的初始值'

theta = np.zeros(xcols)

'迭代步数'

iters = 0;

'记录代价函数的值'

cost_record=[]

'学习率'

sigma = 0.01

cost_val = cost(m,theta,X,y)

cost_record.append(cost_val)

while True:

'参数更新'

cost_update = cost(m,theta,X,y)

if stop_stratege(cost_val,cost_update,threshold):

break

iters=iters+1

cost_val = cost_update

print("cost_val:%f" %cost_val)

cost_record.append(cost_val)

end = time.clock()

print("LogicRegressionconvergence duration: %f s" % (end - start))

return cost_record, iters,theta

3 分析结果

array([ 0.48528656, 9.48593954, -9.42256868])

plt.scatter(x1_pos,x2_pos)

plt.scatter(x1_neg,x2_neg)

wp = np.linspace(0.0,1.0,200)

plt.plot(wp,-(theta[0]+theta[1]*wp)/theta[2],color='g')

plt.show()

4 总结

1. 如果代价函数的最后稳定的值，确认比较大，比如0.5，说明模型中一定存在某些bug，比如在我调试过程中，将标签值错误地被赋值了第三列，实际应该为第四列，所以导致最后迭代终止时的成本值为0.50。

2. 学习率直接关系到迭代速度，如果学习率太小，迭代下降的会很慢，相反会比较快。

3. 迭代终止的策略选取，一般会根据迭代次数，成本函数前后两次的差小于某个阈值等，如果选取的终止策略不当，会导致看似收敛，实际成本值还很大的情况。

383 篇文章98 人订阅

0 条评论

## 相关文章

14050

### 【学术】一文教你如何正确利用kNN进行机器学习

AiTechYun 编辑：xiaoshan k最近邻算法（kNN）是机器学习中最简单的分类方法之一，并且是入门机器学习和分类的好方法。它基本上是通过在训练数据中...

28350

19730

68450

10720

46390

57390

95660

516110

89460