原创：logistic regression实战（一）：SGD Without lasso

　　logistic regression是分类算法中非常重要的算法，也是非常基础的算法。logistic regression从整体上考虑样本预测的精度，用判别学习模型的条件似然进行参数估计，假设样本遵循iid,参数估计时保证每个样本的预测值接近真实值的概率最大化。这样的结果，只能是牺牲一部分的精度来换取另一部分的精度。而svm从局部出发，假设有一个分类平面，找出所有距离分类平面的最近的点(support vector,数量很少)，让这些点到平面的距离最大化，那么这个分类平面就是最佳分类平面。从这个角度来看待两个算法，可以得出logistic regression的精度肯定要低于后者。今天主要写logistic regression的Python代码。logistic regression的推导过程比较简单：

　　第一个公式是条件似然函数估计，意思是指定未知常量theta（;表示频率学派），对于每个输入feature vector x(i),产生y(i)的概率都最大，取对数是为了求导方便。第二个公式是sigmoid函数的导数，在这里推导出具体的导函数(推导过程非常简单，复合函数求导法则)，第三个公式是求出的梯度(实际为偏导数组成的向量，梯度与方向导数同方向时取得最大值，相反时取得最小值)。公式3的线性意义为：对于容量为m的样本(矩阵mxn),权重为nx1的列向量，每一行的样本数据与权重向量相乘求得预测值，m行样本的预测值组成mx1的列向量(其数值为exp（-inX）)，其实就是mxn的样本矩阵左乘权重向量nx1，因为的矩阵的本质是线性变换，相当于每一行样本数据投影到权重向量。得到预测值的列向量后，与真实值向量(需要转置）做差值得到新的列向量。最后样本矩阵倒置，然后左乘这个向量得到nx1的权重向量(梯度)。这个过程是计算批量梯度。当似然函数取得最大时，就是损失函数最小，所以二者是相反的关系，最后结果也就是梯度上升法。

　　对于逻辑回归的损失函数，也可以从另外一个角度来理解。上面的公式我们看到损失函数和最大似然函数是相反的关系，一般情况下，logistic regression的loss function 可以采用交叉熵的形式，然后取mean。

　　SGD(stochastic gradient descent)在计算的过程中，每次迭代不用计算所用样本，而是随机选取一个样本进行梯度上升(下降)，在工程实践中可以满足精度要求，而且时间复杂度比批量要低。对于SGD而言，学习速率alpha的选取，随着循环次数增加，刚开始的时候，梯度下降应该比较快，到后期的时候，可能会出现在某一个值徘徊的情况，而且下降速率会越来越慢。所以选取一个比较合理的study rate,应该是先选取到的样本study rate相对较高，后面的相对较小，这样比较合理。

　　在训练出模型后，预测时应该使用"五折交叉验证理论"寻找出最优模型出来(调节参数的过程)，这个过程一般用RMSE（均方根误差）来衡量，并且可以定义一个基准均方根误差。在用最优模型预测时取得的RMSE与基准RMSE对比，分析数据结果。

　　本文主要探讨logistic regression的SGD算法，并且不考虑正则化。事实上，在高维度的情况下，泛化能力或者正则化技术非常关键。在90年代有学者提出lasso后，至今有很多方法实践了lasso,比如LARS，CD……。下一篇博客将探讨lasso技术，并且动手实践CD算法。接下来，上传最近写的SGD Python代码,首先是引入模块：logisticRegression.py，这里面定义了两个class:LogisticRegressionWithSGD,LRModel,还有全局函数RMSE，loadDataSet和sigmoid函数。后面是测试代码，主要是参数调优。

logisticRegression.py：

'''
Created on 2017/03/15
Logistic Regression without lasso
@author: XueQiang Tong
'''
'''
this algorithm include SGD，batch gradient descent except lasso regularization，So the generalization
ability is relatively weak, follow-up and then write a CD algorithm for lasso.
'''
from numpy import *
import matplotlib.pyplot as plt
import numpy as np;

# load dataset into ndarray(numpy)
def loadDataSet(filepath, seperator="\t"):
    with open(filepath) as fr:
        lines = fr.readlines();
        num_samples = len(lines);
        dimension = len(lines[0].strip().split(seperator));
        dataMat = np.zeros((num_samples, dimension));
        labelMat = [];

    index = 0;
    for line in lines:
        sample = line.strip().split();
        feature = list(map(np.float32, sample[:-1]));
        dataMat[index, 1:] = feature;
        dataMat[index, 0] = 1.0;
        labelMat.append(float(sample[-1]));
        index += 1;

    return dataMat, array(labelMat);

#sigmoid function
def sigmoid(inX):
    return 1.0/(1+exp(-inX))

# compute rmse
def RMSE(true,predict):
    true_predict = zip(true,predict);
    sub = [];
    for r,p in true_predict:
        sub.append(math.pow((r-p),2));
    return math.sqrt(mean(sub));

def maxstep(dataMat):
    return 2 / abs(np.linalg.det(np.dot(dataMat.transpose(),dataMat)));

class LRModel:
    def __init__(self,weights = np.empty(10),alpha = 0.01,iter = 150):
        self.weights = weights;
        self.alpha = alpha;
        self.iter = iter;

    #predict
    def predict(self,inX):
        prob = sigmoid(dot(inX,self.weights))
        if prob > 0.5: return 1.0
        else: return 0.0

    def getWeights(self):
        return self.weights;

    def __getattr__(self, item):
        if item == 'weights':
            return self.weights;

class LogisticRegressionWithSGD:
    # batch gradient descent
    @classmethod
    def batchGradDescent(cls,data,maxCycles = 500,alpha = 0.001):
        dataMatrix = mat(data[0])             # convert to NumPy matrix
        labelMat = mat(data[1]).transpose() # convert to NumPy matrix
        m,n = shape(dataMatrix)
        weights = ones((n,1))
        for k in range(maxCycles):
            h = sigmoid(dataMatrix*weights)    # compute predict_value
            error = (labelMat - h)              # compute deviation
            weights = weights + alpha * dataMatrix.transpose()* error # update weight

        model = LRModel(weights = weights,alpha = alpha,iter = maxCycles);
        return model;

    '''
    # draw samples of the scatter plot to view the distribution of sample points
    @classmethod
    def viewScatterPlot(cls,weights,dataMat,labelMat):
        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)
        ax.scatter(xcord1, ycord1, s=30, c='red', marker='s',label='1')
        ax.scatter(xcord2, ycord2, s=30, c='green',label='0')
        plt.legend();
        x = arange(-3.0, 3.0, 0.1)
        y = (-weights[0]-weights[1]*x)/weights[2]
        ax.plot(mat(x), mat(y))
        plt.xlabel('X1'); plt.ylabel('X2');
        plt.show()
    '''
    @classmethod
    def train_nonrandom(cls,data,alpha = 0.01):
        dataMatrix = data[0];
        classLabels = data[1];
        m,n = shape(dataMatrix);
        weights = ones(n)   #initialize to all ones
        for i in range(m):
            h = sigmoid(sum(dataMatrix[i]*weights));
            error = classLabels[i] - h;
            weights = weights + alpha * error * dataMatrix[i];

        model = LRModel(weights = weights,alpha = alpha);
        return model;

    @classmethod
    def train_random(cls,data, numIter=150):
        dataMatrix = data[0];
        classLabels = data[1];
        m,n = shape(dataMatrix);
        weights = ones(n);   #initialize to all ones
        indices = np.arange(len(dataMatrix))
        for iter in range(numIter):
            np.random.shuffle(indices)
            for index in indices:
                alpha = 4 / (1.0 + iter + index) + 0.0001    #apha decreases with iteration, does not
                h = sigmoid(sum(dataMatrix[index]*weights));
                error = classLabels[index] - h;
                weights = weights + alpha * error * array(dataMatrix[index]);

        model = LRModel(weights = weights,iter = numIter);
        return model;

    def colicTest(self):
        data = loadDataSet('G:\\testSet.txt');
        trainWeights = self.stoGradDescent_random(data);
        dataMat = data[0];
        labels = data[1];
        errnums = 0;
        for index in range(dataMat.shape[0]):
            preVal = self.predict(dataMat[index,:],trainWeights);
            if(preVal != labels[index]):
                errnums += 1;
        print('error rate:%.2f' % (errnums/dataMat.shape[0]));
        return errnums;

    def multiTest(self):
        numTests = 10; errorSum=0.0
        for k in range(numTests):
            errorSum += self.colicTest()
        print("after %d iterations the average error rate is: %.2f" % (numTests, errorSum/numTests))

 

 测试代码，把最优模型保存在npy文件里，以后使用的时候，直接取出来，不用再训练了。

from logisticRegression import *;
from numpy import *;
import math;

def main():
    dataMat, labels = loadDataSet('G:\\testSet.txt');
    num_samples = dataMat.shape[0];

    num_trains = int(num_samples * 0.6);
    num_validations = int(num_samples * 0.2);
    num_tests = int(num_samples * 0.2);

    data_trains = dataMat[:num_trains, :];
    data_validations = dataMat[num_trains:(num_trains + num_validations), :];
    data_tests = dataMat[(num_trains + num_validations):, :];

    label_trains = labels[:num_trains];
    label_validations = labels[num_trains:(num_trains + num_validations)];
    label_tests = labels[(num_trains + num_validations):];
    '''
    minrmse = (1 << 31) - 1;
    bestModel = LRModel();
    iterList = [10, 20, 30, 80];

    for iter in iterList:
        model = LogisticRegressionWithSGD.train_random((data_trains, label_trains), numIter=iter);
        preVals = zeros(num_validations);
        for i in range(num_validations):
            preVals[i] = model.predict(data_validations[i, :]);

        rmse = RMSE(label_validations, preVals);
        if rmse < minrmse:
            minrmse = rmse;
            bestModel = model;

    print(bestModel.iter, bestModel.weights, minrmse);
    save('D:\\Python\\models\\weights.npy',bestModel.weights);'''

    #用最佳模型预测测试集的评分，并计算和实际评分之间的均方根误差
    weights = load('D:\\Python\\models\\weights.npy');

    LogisticRegressionWithSGD.viewScatterPlot(weights,dataMat,labels);#显示散点图
    model = LRModel();
    model.weights = weights;

    preVals = zeros(num_tests);
    for i in range(num_tests):
        preVals[i] = model.predict(data_tests[i,:]);


    testRMSE = RMSE(label_tests,preVals); #预测产生的均方根误差
    #用基准偏差衡量最佳模型在测试数据上的预测精度
    tavMean = mean(hstack((label_trains,label_validations)));
    baseRMSE = math.sqrt(mean((label_tests - tavMean) ** 2)) #基准均方根误差

    improvement = abs(testRMSE - baseRMSE) / baseRMSE * 100;

    print("The best model improves the base line by %% %1.2f" % (improvement));

if __name__ == '__main__':
    main();

 

 

运行结果：
样本点的散点图：

最佳迭代次数，权重以及RMSE：     10 [ 12.08509707   1.4723024   -1.86595103] 0.0
The best model improves the base line by % 55.07

另外，由于训练过程中是随机选取样本点，所以迭代次数相同的情况下，权重以及RMSE有可能不同，我们要的是RMSE最小的模型！
算法比较简单，但是用Python的nump库实施的时候，有很多注意的细节，只有经过自己仔细的理论推导然后再代码实施后，才能算基本掌握了一个算法。写代码及优化的过程是很费时的，后续还要改进算法，深化理论研究，并且坚持理论与编程结合，切不可眼高手低！