最近在看吳恩達的機器學習課程，自己用python實現了其中的logistic演算法，並用梯度下降獲取最優值。
logistic分類是一個二分類問題，而我們的線性迴歸函式

的取值在負無窮到正無窮之間，對於分類問題而言，我們希望假設函式的取值在0~1之間，因此logistic函式的假設函式需要改造一下

由上面的公式可以看出，0 < h(x) < 1，這樣，我們可以以1/2為分界線

cost function可以這樣定義

其中，m是樣本的數量，初始時θ可以隨機給定一個初始值，算出一個初始的J(θ)值，再執行梯度下降演算法迭代，直到達到最優值，我們知道，迭代的公式主要是每次減少一個偏導量

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)

執行結果如下