python实现logistic分类算法代码

最近在看吴恩达的机器学习课程，自己用python实现了其中的logistic算法，并用梯度下降获取最优值。

logistic分类是一个二分类问题，而我们的线性回归函数

的取值在负无穷到正无穷之间，对于分类问题而言，我们希望假设函数的取值在0~1之间，因此logistic函数的假设函数需要改造一下

由上面的公式可以看出，0 < h(x) < 1，这样，我们可以以1/2为分界线

cost function可以这样定义

其中，m是样本的数量，初始时θ可以随机给定一个初始值，算出一个初始的J(θ)值，再执行梯度下降算法迭代，直到达到最优值，我们知道，迭代的公式主要是每次减少一个偏导量

如果将J(θ)代入化简之后，我们发现可以得到和线性回归相同的迭代函数

按照这个迭代函数不断调整θ的值，直到两次J(θ)的值差值不超过某个极小的值之后，即认为已经达到最优解，这其实只是一个相对较优的解，并不是真正的最优解。 其中，α是学习速率，学习速率越大，就能越快达到最优解，但是学习速率过大可能会让惩罚函数最终无法收敛，整个过程python的实现如下

import math

ALPHA = 0.3
DIFF = 0.00001

def predict(theta, data):
 results = []
 for i in range(0, data.__len__()):
   temp = 0
   for j in range(1, theta.__len__()):
     temp += theta[j] * data[i][j - 1]
   temp = 1 / (1 + math.e ** (-1 * (temp + theta[0])))
   results.append(temp)
 return results

def training(training_data):
 size = training_data.__len__()
 dimension = training_data[0].__len__()
 hxs = []
 theta = []
 for i in range(0, dimension):
   theta.append(1)
 initial = 0
 for i in range(0, size):
   hx = theta[0]
   for j in range(1, dimension):
     hx += theta[j] * training_data[i][j]
   hx = 1 / (1 + math.e ** (-1 * hx))
   hxs.append(hx)
   initial += (-1 * (training_data[i][0] * math.log(hx) + (1 - training_data[i][0]) * math.log(1 - hx)))
 initial /= size
 iteration = initial
 initial = 0
 counts = 1
 while abs(iteration - initial) > DIFF:
   print("第", counts, "次迭代, diff=", abs(iteration - initial))
   initial = iteration
   gap = 0
   for j in range(0, size):
     gap += (hxs[j] - training_data[j][0])
   theta[0] = theta[0] - ALPHA * gap / size
   for i in range(1, dimension):
     gap = 0
     for j in range(0, size):
       gap += (hxs[j] - training_data[j][0]) * training_data[j][i]
     theta[i] = theta[i] - ALPHA * gap / size
     for m in range(0, size):
       hx = theta[0]
       for j in range(1, dimension):
         hx += theta[j] * training_data[i][j]
       hx = 1 / (1 + math.e ** (-1 * hx))
       hxs[i] = hx
       iteration += -1 * (training_data[i][0] * math.log(hx) + (1 - training_data[i][0]) * math.log(1 - hx))
     iteration /= size
   counts += 1
 print('training done,theta=', theta)
 return theta

if __name__ == '__main__':
 training_data = [[1, 1, 1, 1, 0, 0], [1, 1, 0, 1, 0, 0], [1, 0, 1, 0, 0, 0], [0, 0, 0, 0, 1, 1], [0, 1, 0, 0, 0, 1],
       [0, 0, 0, 0, 1, 1]]
 test_data = [[0, 1, 0, 0, 0], [0, 0, 0, 0, 1]]
 theta = training(training_data)
 res = predict(theta, test_data)
 print(res)

运行结果如下

来源：https://blog.csdn.net/u012722531/article/details/79274528