摘要：根據錯誤率決定是否回退到訓練階段，通過改變迭代的次數和步長等參數來得到更好的回歸系數。使用回歸方法進行分類所需做的是把測試集上每個特征向量乘以最優化方法得來的回歸系數，再將該乘積結果求和，最后輸入到函數即可。

本篇內容為《機器學習實戰》第 5 章 Logistic 回歸程序清單。

書中所用代碼為 python2，下面給出的程序清單是在 python3 中實踐改過的代碼，希望對你有幫助。

梯度上升法的偽代碼如下：

每個回歸系數初始化為 1
重復 R 次：
————計算整個數據集的梯度
————使用 alpha $ imes$ gradient 更新回歸系數的向量
返回回歸系數

# 打開文本文件 testSet.txt 并逐行讀取
def loadDataSet():
    dataMat = []; lableMat = []
    fr = open("testSet.txt")
    for line in fr.readlines():
        lineArr = line.strip().split()
        # 為計算方便，將 X0 的值設為 1.0
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
        lableMat.append(int(lineArr[2]))
    return dataMat, lableMat

def sigmoid(intX):
    return 1.0/(1+exp(-intX))

# 參數 dataMatIn 是一個 2 維 numpy 數組，存放的是一個 100*3 的矩陣
# 每列分別代表每個不同的特征，每行代表每個訓練樣本
def gradAscent(dataMatIn, classLabels):
    # 轉換為 numpy 矩陣的數據類型
    dataMatrix = mat(dataMatIn)
    # classLabels 類別標簽
    labelMat = mat(classLabels).transpose()
    # 得到矩陣大小
    m,n = shape(dataMatrix)

    # 設置梯度上升法所需參數
    # alpha 步長，maxCycles 迭代次數
    alpha = 0.001
    maxCycles = 500
    weights = ones((n,1))

    for k in range(maxCycles):
        h = sigmoid(dataMatrix * weights)
        # 計算真實類別與預測類的差值，然后按照該差值的方向調整回歸系數
        error = (labelMat - h)
        weights = weights + alpha * dataMatrix.transpose() * error
    # 返回訓練好的回歸系數
    return weights

在 python 提示符下，執行代碼并得到結果：

>>> import logRegres
>>> dataArr, labelMat=logRegres.loadDataSet()
>>> logRegres.gradAscent(dataArr, labelMat)
matrix([[ 4.12414349],
        [ 0.48007329],
        [-0.6168482 ]])

# 畫出數據集和logistic回歸最佳擬合直線的函數
def plotBestFit(weights):
    import matplotlib.pyplot as plt
    dataMat, labelMat = loadDataSet()
    dataArr = array(dataMat)
    n = shape(dataArr)[0]
    xcord1 = []
    ycord1 = []

    xcord2 = []
    ycord2 = []

    for i in range(n):
        if int(labelMat[i]) == 1:
            xcord1.append(dataArr[i,1])
            ycord1.append(dataArr[i,2])
        else:
            xcord2.append(dataArr[i,1])
            ycord2.append(dataArr[i,2])

    fig = plt.figure()
    ax = fig.add_subplot(111)
    # 形狀參數 marker "s"：正方形，參數 s：點的大小
    ax.scatter(xcord1, ycord1, s=30, c="red", marker="s")
    ax.scatter(xcord2, ycord2, s=30, c="green")

    # arange(start, end, step)，返回一個array對象
    x = arange(-3.0, 3.0, 0.1)
    # 設置 sigmoid 函數為0
    y = (-weights[0]-weights[1]*x)/weights[2]
    ax.plot(x, y)
    plt.xlabel("X1")
    plt.ylabel("X2")
    plt.show()

在 python 提示符下，執行代碼并得到結果：

>>> import importlib
>>> importlib.reload(logRegres)

>>> weights = logRegres.gradAscent(dataArr, labelMat)
>>> logRegres.plotBestFit(weights.getA())

隨機梯度上升算法的偽代碼如下：
所有回歸系數初始化為 1
對數據集中每個樣本
————計算該樣本的梯度
————使用 alpha $ imes$ gradient 更新回歸系數值
返回回歸系數值

# 隨機梯度上升算法
def stocGradAscent0(dataMatrix, classLabels):
    m,n = shape(dataMatrix)
    alpha = 0.01
    weights = ones(n)
    for i in range(m):
        # 變量 h 和誤差 error 都是向量
        h = sigmoid(sum(dataMatrix[i]*weights))
        error = classLabels[i] - h
        weights = weights + alpha * error * dataMatrix[i]
    return weights

在 python 提示符下，執行代碼并得到結果：

>>> from numpy import *
>>> importlib.reload(logRegres)

>>> dataArr, labelMat=logRegres.loadDataSet()
>>> weights = logRegres.stocGradAscent0(array(dataArr), labelMat)
>>> logRegres.plotBestFit(weights)

# 改進的隨機梯度上升算法
def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    m,n = shape(dataMatrix)
    weights = ones(n)
    for j in range(numIter):
        dataIndex = list(range(m))
        for i in range(m):
            alpha = 4/(1.0+j+i)+0.01
            # uniform() 方法將隨機生成下一個實數
            randIndex = int(random.uniform(0, len(dataIndex)))
            h = sigmoid(sum(dataMatrix[randIndex]*weights))
            error = classLabels[randIndex] - h
            weights = weights + alpha * error * dataMatrix[randIndex]
            del(dataIndex[randIndex])
    return weights

在 python 提示符下，執行代碼并得到結果：

>>> importlib.reload(logRegres)

>>> dataArr, labelMat=logRegres.loadDataSet()
>>> weights = logRegres.stocGradAscent1(array(dataArr), labelMat)
>>> logRegres.plotBestFit(weights)

使用 Logistic 回歸估計馬疝病的死亡率

收集數據：給定數據文件。

準備數據：用 Python 解析文本文件并填充缺失值。

分析數據：可視化并觀察數據。

訓練算法：使用優化算法，找到最佳的系數。

測試算法：為了量化回歸的效果，需要觀察錯誤率。根據錯誤率決定是否回退到訓練階段，通過改變迭代的次數和步長等參數來得到更好的回歸系數。

使用算法：實現一個簡單的命令行程序來收集馬的癥狀并輸出預測結果。

使用 Logistic 回歸方法進行分類所需做的是把測試集上每個特征向量乘以最優化方法得來的回歸系數，再將該乘積結果求和，最后輸入到 sigmoid 函數即可。如果對應的 sigmoid 值大于 0.5 就預測類別標簽為 1，否則為 0。

# 以回歸系數和特征向量作為輸入來計算對應的 sigmoid 值
def classifyVector(inX, weights):
    prob = sigmoid(sum(inX*weights))
    if prob > 0.5: return 1.0
    else: return 0.0

# 打開測試集和訓練集，并對數據進行格式化處理
def colicTest():
    frTrain = open("horseColicTraining.txt")
    frTest = open("horseColicTest.txt")
    trainingSet = []
    trainingLabels = []

    for line in frTrain.readlines():
        currLine = line.strip().split("	")
        lineArr = []

        for i in range(21):
            lineArr.append(float(currLine[i]))
        trainingSet.append(lineArr)
        trainingLabels.append(float(currLine[21]))
    
    # 計算回歸系數向量
    trainWeights = stocGradAscent1(array(trainingSet), trainingLabels, 500)
    errorCount = 0
    numTestVec = 0.0
    
    # 導入測試集并計算分類錯誤率
    for line in frTest.readlines():
        numTestVec += 1.0
        currLine = line.strip().split("	")
        lineArr = []

        for i in range(21):
            lineArr.append(float(currLine[i]))
        if int(classifyVector(array(lineArr), trainWeights)) !=int(currLine[21]):
            errorCount += 1

    errorRate = (float(errorCount) / numTestVec)
    
    print("這個測試集的錯誤率是：%f" % errorRate)
    return errorRate

def multiTest():
    numTests = 10
    errorSum = 0.0
    
    for k in range(numTests):
        errorSum += colicTest()
        
    print("經過 %d 次迭代后平均錯誤率是：%f" % (numTests, errorSum/float(numTests)))

在 python 提示符下，執行代碼并得到結果：

>>> importlib.reload(logRegres)

>>> logRegres.multiTest()
這個測試集的錯誤率是：0.358209
這個測試集的錯誤率是：0.373134
這個測試集的錯誤率是：0.253731
這個測試集的錯誤率是：0.402985
這個測試集的錯誤率是：0.358209
這個測試集的錯誤率是：0.298507
這個測試集的錯誤率是：0.343284
這個測試集的錯誤率是：0.298507
這個測試集的錯誤率是：0.402985
這個測試集的錯誤率是：0.417910
經過 10 次迭代后平均錯誤率是：0.350746

Logistic 回歸的目的是尋找一個非線性函數 sigmoid 的最佳擬合參數，求解過程可以由最優化算法來完成。

不足之處，歡迎指正。

$$$$