目录

1 对数几率回归原理分析

1.1 引入

1.2 损失函数

1.3  求最优解

2 对数几率回归实践

Logistic回归的一般过程

Logistic回归的优缺点

Logistic回归算法描述（改进的随机梯度下降）

《机器学习实战》第五章代码解析

         5-1 Logistic回归梯度上升优化方法

5-2 画出数据集和Logistic回归最佳拟合直线的函数

5-3 随机梯度上升算法

5-4 改进的随机梯度上升算法

5-5  示例：从疝气病症预测病马的死亡率

参考资料

1 对数几率回归原理分析

1.1 引入

Logistic Regression，对数几率回归，又称逻辑斯谛回归。该模型最初是用来解决0/1二分类问题，明明是分类问题，为何叫回归？科普一下，线性回归是找到一条直线或超平面尽可能地接近所有的训练数据点（就是用线性方程来拟合数据），而对数几率回归是找到一条直线或超平面尽可能地分开两种不同类别的数据点（就是在公式中的线性部分来做了回归）。
       首先，我们要解决的问题是：在线性模型上做二分类（这里不讨论多分类）。
       把问题转化为，让模型输出为0或者1，而且在分界处变化很陡。
       直接想法是套一个函数来实现一个单位阶跃函数，如下:

也就是把 线性模型 看作为一个两种类别的分界线。
           由于分段函数性质太差，不符合优化问题的目标函数要连续可微的特点。所以我们找一个形似的函数（由下图可见），Sigmoid 函数（S型函数）中的杰出代表——对数几率函数（一个任意阶可导的凸函数，有良好的数学性质，很适合优化问题）。

将线性模型代入就得到总的模型

其实，对数几率回归模型就是在拟合 线性模型，使得这条直线尽可能地将原始数据中的两个类别正确的划分开（引用张磊的知乎）。

1.2 损失函数

解决机器学习问题就要明确损失函数，回归问题一般用均方误差（平均损失）或者其平均数——平均误差平方损失来作为损失函数（这就是最小二乘法，用来找到一条直线使所有样本到直线的欧式距离之和最小）。
平均误差平方损失公式如下：

Logistic回归模型，要用到的是对数损失来作为损失函数

先来看它的效果，再来说怎么得来的

效果：真实值 是有 0/1 两种情况，而推测值 由于借助对数几率函数，其输出是介于0~1之间连续概率值。这个损失函数其实在每次计算时永远都只有一项在发挥作用，转换为分段函数如下：

 所以该损失函数可以达到这样的效果：当真实值 y为1时，输出值 y越接近1，则 L越小，当真实值 y为 0 时，输出值 y尖 越接近于0，则 L越小。

由来：
这与周志华《机器学习》的3.3节的对数几率回归模型最大化“对数似然”的似然项（详细过程看书P59）

有着异曲同工之妙，可能存在某种联系吧。

1.3  求最优解

 对数几率函数作为高阶可导连续凸函数，根据凸优化理论，典型的数值优化算法如梯度下降算法，牛顿法等
牛顿法的求法看周志华《机器学习》的P59~60。
下面我们用的是梯度下降算法（梯度上升同理，符号变为加号）来得到核心参数的更新方式：
w看做是一个向量的话，迭代同样要加减一个向量，α是每次迭代的步长（大小），α后面的偏导表示的是迭代的方向，这种通过多次迭代能够使得函数收敛到局部最小值。

具体怎么得来的看张磊知乎梯度下降算法，写得很棒。

通过链式求导法则，（具体推导见张磊知乎梯度下降算法）

最终迭代方式为（矩阵形式，也是接下来实践用到的公式，其实是通过一系列推导得来的）：

(归入了矩阵中)

2 对数几率回归实践

• Logistic回归的一般过程

（1）收集数据：采用任意方法收集数据。
（2）准备数据：由于需要进行距离计算，因此要求数据类型为数值型。（有限）另外，结构化数据格式则最佳。
（3）分析数据： 采用任意方法对数据进行分析。
（4）训练算法：大部分时间将用于训练，训练的目的是为了找到最佳的分类回归系数
（5）测试算法：一旦训练完成，分类将会很快。
（6）使用算法：首先，我们需要输入一些数据，并将起转化成对应的结构化数值。接着，基于训练好的回归系数既可以 对这些数值进行简单的回归计算，在这之后，我们就可以在输出的类别上做一些其他分析工作。

• Logistic回归的优缺点

 优点：计算代价不高，易于理解和实现。
 缺点：容易欠拟合，分类精度可能不高。

• Logistic回归算法描述（改进的随机梯度下降）

输入：训练集 ，是维样本向量，即 ,是对应的分类标签
           学习率
过程：

1. 由对数似然得到代价函数
2. ##下面采用梯度下降对代价函数进行迭代，迭代次（选择一个较大值，如500），得到最终的参数向量
3. 初始化为全1矩阵
4. repeat:
5.    for all  do(这里采用随机选取样本来更新回归系数)
6.       动态调整
7.       
8.      从数据集中删除该样本（避免重复）
9. util: 迭代了次（要到达达到局部最小的效果）

输出：的最优解

• 《机器学习实战》第五章代码解析

    5-1 Logistic回归梯度上升优化方法

•     算法伪代码：

每个回归系数初始化为1
重复R次：
    计算整个数据集的梯度
    使用 alpha*gradient 更新回归系数的向量
返回回归系数

•   数据集特点:

   testSet.txt每行如下： 

  -0.017612     14.053064     0
  每个样本点包括两个特征值x,y坐标，和对应的分类标签（0或1）

from numpy import *
def loadDataSet():   # 加载数据集
    dataMat = []  # 创建数据列表
    labelMat = []  # 创建标签列表
    fr = open('testSet.txt')  # 打开测试数据文件
    for line in fr.readlines():  # 读取文件每一行
        lineArr = line.strip().split()  # 除去每一行的空格后拆分成列表， 例如 ['0.317029', '14.739025', '0']
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])  # 增加子列表，[1.0,lineArr第一个元素（float）,lineArr第二个元素（float）]
        labelMat.append(int(lineArr[2]))  # 添加元素，元素来源于 lineArr列表的第三个元素（transform str to int first）         
    return dataMat, labelMat  # 返回数据列表，标签列表

# 注：[1.0, float(lineArr[0]), float(lineArr[1])] 中的1.0 表示的是特征X0 的值，一般默认X0 = 1.0（or 1）
def sigmoid(inX):   # 定义sigmoid函数， 同书P74
    return 1.0/(1+exp(-inX))

def gradAscent(dataMatIn, classLabels):  # 定义梯度上升函数
    dataMatrix = mat(dataMatIn)   # 把数据列表转化成矩阵形式（列表和矩阵的简单差别：列表一般是一行，以逗号分隔，而矩阵是多行，没逗号）
    labelMat = mat(classLabels).transpose()  # 把标签列表转化成矩阵形式，然后转置 （行向量 -> 列向量）
    m,n = shape(dataMatrix)   # 取 数据矩阵的行和列   第一个是 行数m=100， 第二个是 列数n=3 
    alpha = 0.001   # 学习率初始化 = 0.001，步长为0.001
    maxCycles = 500   # 最大循环次数 = 500
    weights = ones((n,1))  # 权重初始化为全1矩阵  列向量（形式为n行1列）
    for k in range(maxCycles):  
        h = sigmoid(dataMatrix * weights)  # 1.0/(1+exp(-Z)    f[x,y] = Z = dataMatrix * weights
        error = (labelMat - h)#损失函数，真实值与预测值之间的差值
        weights = weights + alpha * dataMatrix.transpose() * error  # 更新权重  ：要注意矩阵运算，几行几列要对应，注意转置，error(m行1列)，
    return weights  # 返回 权重

#运行代码
dataArr, labelMat = loadDataSet()
dataMatrix = mat(dataArr)
#print(dataMatrix)
res = gradAscent(dataArr,labelMat)
print(res)

• 结果如下：

[[ 4.12414349]
 [ 0.48007329]
 [-0.6168482 ]]

5-2 画出数据集和Logistic回归最佳拟合直线的函数

def plotBestFit(weights):
    import matplotlib.pyplot as plt
    dataMat, labelMat = loadDataSet()  
    dataArr = array(dataMat)  # 列表要转为数组
    n = shape(dataArr)[0]  # n=100  数组的行n=100，（数组的列m=3）
    xcord1 = []  #类型1的x,y值
    ycord1 = []
    xcord2 = []  #类型0的x,y值
    ycord2 = []
    for i in range(n):  # 遍历 （0->100-1）
        if int(labelMat[i]) == 1:   # 如果第i个元素的标签值是 1
            xcord1.append(dataArr[i,1])   # 把对应数据数组（形似矩阵）的第i行的第2个元素 增加到 xcord1
            ycord1.append(dataArr[i,2])   # 把对应数据数组（形似矩阵）的第i行的第3个元素 增加到 ycord1
        else:   # 如果标签列表（labelMat）中第i个元素的标签是 0
            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')
    ax.scatter(xcord2, ycord2, s=30, c='green')
    # 绘制拟合直线
    x = arange(-3.0,3.0)  # x取值范围 起点-3.0， 终点3.0 步长0.1 
    y = (-weights[0]-weights[1]*x)/weights[2]  # weight[1]是1*1的矩阵，z=w[0]+w[1]*x+w[2]*y,
    #print(x)
    #print(y)
    ax.plot(x,y)#绘制拟合直线
    plt.xlabel('X1')
    plt.ylabel('X2')
    plt.show()

#运行代码
%matplotlib inline#在界面上显示
dataArr, LabelMat = loadDataSet()
weights = gradAscent(dataArr,LabelMat)
plotBestFit(weights.getA()) #getA()将numpy矩阵转换为数组

• 结果如图

• “梯度上升法”的不足在于每次更新回归系数时都要遍历整个数据集，计算复杂度高
   因此，产生了“随机梯度上升法”，即每次仅使用1个样本点数据来更新回归系数

5-3 随机梯度上升算法

随机梯度上升算法：一次仅用一个样本点来更新回归系数
随机梯度上升伪代码：
每个回归系数初始化为1
    对数据集中每个样本：
    计算该样本的梯度
    使用 alpha*gradient 更新回归系数的向量
返回回归系数

• 和梯度上升法的区别：第一，后者的变量h和error都是向量，而前者则全是数值；第二，前者没有矩阵的转化过程，所有变量的数据类型都是Numpy数组

def stocGradAscent0(dataMatrix, classLabels):
    m,n = shape(dataMatrix)  # 取数组的行m， 列n
    alpha = 0.01  # 学习率初始化
    weights = ones(n)   # 创建 含有 n 个元素的 数组
    for i in range(m): # 循环每一行的元素
        h = sigmoid(sum(dataMatrix[i]*weights))# sum(dataMatrix[i]*weights)=w0*x0+w1*x1+w2*x2
        error = classLabels[i] - h 
        weights = weights + alpha * error * dataMatrix[i]    # 更新权重
    return weights   # 返回权重

#运行代码：
dataArr,labelMat = loadDataSet()
weights = stocGradAscent0(array(dataArr), labelMat)
plotBestFit(weights)

• 结果如图
   

• “随机梯度上升法”分错了三分之一，因为原始梯度上升算法（5-1）是在整个数据集上迭代500次得来的，这是不公平，我们对本算法同样进行多次迭代，发现问题如下：
  不足在于回归系数存在周期震荡波动。
  因此，产生了“改进的随机梯度上升法”，改进之处有两点：    
   1、动态调整步进因子；     
    2、随机选取样本来更新回归系数。

5-4 改进的随机梯度上升算法

def stocGradAscent1(dataMatrix, classLabels, numIter = 150):#因为由图可知迭代到150次左右就收敛（达到稳定值）
    m,n = shape(dataMatrix)   # 取数组（narray）的行，列 m=100， n=3  （narray 和 matrix 长的一样）
    weights = ones(n)  # [1. 1. 1.]
    for j in range(numIter):  # 循环到 最大循环次数numIter = 150：
        # dataIndex = range(m) ### 书中需要更改的地方  tip: TypeError: 'range' object doesn't support item deletion
        dataIndex = list(range(m))  # 创建一个0到99， 步长为1 的列表
        for i in range(m):   # 循环listIndex
            alpha = 4/(1.0+j+i)+0.01#动态调整步进因子
            randIndex = int(random.uniform(0, len(dataIndex)))   # 随机选取样本来更新回归系数
            h = sigmoid(sum(dataMatrix[randIndex]*weights))   #  1.0/(1+exp(-Z))    Z = dataMatrix * weights
            error = classLabels[randIndex] - h
            weights = weights + alpha * error * dataMatrix[randIndex]   # 更新权重
            del(dataIndex[randIndex])   # 删除用过的 随机数 （避免重复）
    return weights   # 返回权重

#运行代码
from numpy import *
dataArr,labelMat = loadDataSet()
weights = stocGradAscent1(array(dataArr), labelMat)
plotBestFit(weights)

• 结果如图

5-5  示例：从疝气病症预测病马的死亡率
 

def classifyVector(inX, weights):
    prob = sigmoid(sum(inX*weights))  # 输入Z=inX*weights（特征向量*回归系数） 计算Sigmoid值
    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('\t')   # 除去空格，然后用split方法 转化 成list
        lineArr = []   # 定义行数组（处理每行数据）
        for i in range(21):  #数据有22列，前21个为特征，最后一个是分类标签
            lineArr.append(float(currLine[i]))  # 添加currLine的第i个元素到lineArr
        trainingSet.append(lineArr)   # 把 lineArr 作为 子列表 添加到 训练集列表trainingSet[ [],[],[],...]的形式
        trainingLabels.append(float(currLine[21]))  #  把 currLine 最后一个元素（是标签） 添加到训练标签trainingLabels
    trainWeights = stocGradAscent1(array(trainingSet),trainingLabels,500)   # 迭达500次 求 训练权重
    errorCount = 0   #错误计数器
    numTestVec = 0.0 #总数计数器
    #把测试集文本
    for line in frTest.readlines():   # 读取测试文本的每一行
        numTestVec += 1.0  # numTestVec == 1.0
        currLine = line.strip().split('\t')  # 除去空格，然后用split方法 转化 成list
        lineArr = []    # 定义行数组（处理每行数据）
        for i in range(21):  # 数据有22列，前21个为特征，最后一个是分类标签
            lineArr.append(float(currLine[i]))   # 添加currLine的第i个元素到lineArr
        if int(classifyVector(array(lineArr), trainWeights)) != int(currLine[21]):  # 如果分类有错误
            errorCount += 1
    errorRate = (float(errorCount)/numTestVec)   # 计算错误率
    print("the error rate of this test is: %f" % errorRate)
    return errorRate
    # errorCount,numTestVec 各变量结果  25, 67.0

def multiTest():    # 调用colicTest（）函数10次并求平均值
    numTests = 10
    errorSum = 0.0
    for k in range(numTests):
        errorSum += colicTest()
    print("after %d iterations the average error rate is: %f" % (numTests, errorSum/float(numTests)))

print(colicTest())
multiTest()

结果 如下：
 

the error rate of this test is: 0.388060
0.3880597014925373
the error rate of this test is: 0.417910
the error rate of this test is: 0.432836
the error rate of this test is: 0.402985
the error rate of this test is: 0.328358
the error rate of this test is: 0.388060
the error rate of this test is: 0.402985
the error rate of this test is: 0.238806
the error rate of this test is: 0.358209
the error rate of this test is: 0.462687
the error rate of this test is: 0.328358
after 10 iterations the average error rate is: 0.376119


​​​​​

参考资料

【1】https://zhuanlan.zhihu.com/p/36670444
【2】https://zhuanlan.zhihu.com/p/36564434
【3】《机器学习》周志华
【4】《机器学习实战》

（仅供个人学习记录）

1.下面说法正确的是（）。（选择两项）
A. java程序的main()方法必须写在类里面。
B. java程序必须有多个main()方法。
C. java程序中，如果类名由public修饰，则类名必须与文件名一致。
D. 如果java程序的main()方法只有一条语句，则可以不用{}括起来。
2.在myelipse中，（）视图显示输出结果。
A. 包资源管理器。 B. 导航器。
C. 控制台。 D. 问题。
3.为一个boolean类型变量赋值时，可以使用（）方式。
A. boolean a=1 B. boolean a=(9>10);
C. boolean a=”真” D. boolean a=false；
4.下列语句中，（）正确完成了整型变量的生命和赋值。（选择两项）
A. int count ,count=0 B. int count=0;
C. count=0; D. int count1=0,count2=0
5. java中关于if选择结构描述错误的是（）。
A. if选择结构是根据条件判断之后再做处理的一种语法结构。
B. 关键字if后小括号里必须是一个条件表达式，值必须为boolean类型。
C. if小括号里的表达式的值为false时，程序需要执行大括号里的语句。
D. if语句可以和else一起使用。
6. 在流程图中，下面说法正确的是（）
A. “菱形”表示计算步骤/处理符号。 B.“长方形”表示程序开始/结束
C. “平行四边形”表示输入/输出指令 D. “圆角长方形”表示判断分支
7. 下列关于if选择结构和switch选择结构的说法正确的是（）（选择两项）
A. if-else选择结构中的else语句是必须有的。
B. 多重if选择结构中的else语句可选。
C. 嵌套if选择结构中不能包含else语句。
D. switch选择结构中的default可选。
8. 在JDK1.6中，下列关于switch选择结构的说法，正确的是（）（选择两项）
A. switch选择结构可以完全替代多重if选择结构。
B. 当条件判断为等值判断，并且判断的条件为字符串时，可以使用 switch 结构。
C. 当条件判断为等值判断,并且判断的条件为字符时，可以使用switch 选择结构。
D. 当条件判断为等值判断,并且判断的条件为整型变量时，可以使用switch选择结构。
9.以下说法正确的是（）。（两项）
A. 如果while 循环结构的循环条件始终为true，则一定会出现死循环。
B.程序调试时假如断点会改变程序的执行流程。
C. do-while循环结构的循环体至少无条件执行一次。
D. while循环结构的循环体有可能一次都不执行。
10. 对以下代码，下列说法正确的是（）

int k=10;
    while(k==0){
  k=k-1;
} 

A.循环将执行10次 B. 循环一次也不执行
C. 循环将执行一次 D. 死循环，一直执行下去
11. 以下关于break 和continue 语句的说法正确的是（）
A. continue语句的作用是结束整个循环的执行。
B. 在循环体内和switch结构体内可以使用break 语句。
C. 循环体内使用break语句或continue语句的作用相同。
D. 在switch结构体内也可以使用continue。// 不能用continue
12. 下面循环的执行次数是（）
for(int i=2; i==0;){
System.out.println(i)
i++;
}
A.0 B.1 C.2 D.无限次
13. 下列数组的初始化正确的是（）（选择两项）
A. int score={90,12,34,77,56}; B. int[]score=new int[5];
C. int [] score=new int[3]{90,12,34} ; D. int[]score=new int[]{90,12,34};
14. 以下代码输出的结果为（）

 public calss Test{
public static void main(String[]args){
    double[]price=new double[5];
    price[0]=98.10;
    price[1]=32.18;
    price[2]=77.74;
    for(int i=0;i<5;i++){
        System.out.println((int)price[i]+” ”);
    }
    }

}
A. 98 32 77 0 0 B. 98 32 78 0 0
C. 98 32 78 D.编译出错
15. 以下关于二重循环的说的法正确的是（）
A. 二重循环就是一段程序中只能有两个循环。
B. while循环不能嵌套在for循环里。
C. 两个不重叠的循环不能嵌套在第三个循环里。
D. 如果一个for循环被嵌套在另一个for循环中，则两个循环中的循环变量名称必须不同。
16.下面说法正确的是（）（选择两项）
A. 程序执行到break语句时一定会结束所有循环。
B. 程序执行到continue语句时会结束当前循环即continue语句所在的循环。
C. continue和break语句可以出现在同一个循环体中。
D. continue和break语句的作用相同。
17. （）是拥有属性和方法的实体。（选择两项）
A. 对象 B. 类 C.方法 D. 类的实例
18.对象的静态特征在类中表示为变量，称为类的（）
A．对象 B. 属性 C. 方法 D. 数据类型
19. 有一个汽车类Car，包含的属性有：颜色（color）、型号（type）、品牌（brand）。现在要在main（）方法中创建Car类的对象，下面代码中，正确的是（）
A. Car myCar=new Car; B. Car myCar=new Car();
myCar color=”黑色”; myCar.brand=”宝马”;
C. Car myCar; D. Car myCar=new Car();
myCar.brand = ”宝马”; color=”蓝色”;
20. 编译Java Applet 源程序文件产生的字节码文件的扩展名为()。
A、java B、class C、html D、exe
21.下列哪些是合法变量名（）(多选)
A._myCar B. My Variable C. $myCar D.9my
22. 在流程图里的意思为（）
A. 计算步骤/处理符号
B. 输入/输出指令
C. 判断和分支
D.程序开始或结束
23. &&、||、! 的意义依次为（）
A. 或者，并且，非
B. 或者，非，并且
C. 并且，非，或者
D. 并且，或者，非
24．以下代码的输出结果是（）

public class Test {
  public static void main(String[] args) {
System.out.println(9+6+“Hello”+2+5);
}
}

A．96Hello25 B．96Hello7
C．15Hello25 D．15Hello7

25． 以下()不是合法的标识符
A、 STRING B、 x3x; C、 void D、 de$f
26． 表达式(11+3*8)/4%3的值是()
A、 31 B、 0 C、 1 D、 2
27． （）表达式不可以作为循环条件
A、 i++; B、 i>5; C、 bEqual = str.equals(“q”); D、 count = = i;
28．以下程序的运行结果是（）

public class Increment{
     public static void main(String args[]) { 
        int a;
        a = 6;   
System.out.print(a);    
System.out.print(a++);    
System.out.print(a);  
}  
} 

A．666 B.667 C.668 D.669
29．下列输出结果是（ ）

int  a = 0 ； 
while ( a < 5 ) {    
switch(a){ 
        case 0: 
            case 3 : a = a + 2;    
case 1 : 
        case 2 : a = a + 3;     
default : a = a + 5;     } } 
System.out.print (  )  

A、 0 B、 5 C、 10 D、 其他
30．下列（ ）属于引用数据类型（选择两项）
A、 String B、 char C、 用户自定义的Student类类型 D、 int
31．以下（ ）代码，能够对数组正确初始化。
A、 int a; B、 a = {1, 2, 3, 4, 5};
C、 int[] a = new int[5]{1, 2, 3, 4, 5}; D、 int[] a = new int[5];
32．执行下面代码结果（ ）
for(int i=0;;){
System.out.println(“这是 “+i);
break；
}
A、 语法错误，缺少表达式2和表达式3 B、 死循环
C、 程序什么都不输出 D、 输出：这是0
33．关于面向对象的说法正确的是（ ）
A、 类可以让我们用程序模拟现实世界中的实体
B、 有多少个实体就要创建多少个类
C、 对象的行为和属性被封装在类中，外界通过调用类的方法来获得，但是要知道类的内部是如何实现
D、 现实世界中的某些实体不能用类来描述
34． 用于将java源代码文件编译成字节码的编译器是 ()。
A . javac B. java C. jdb D . javah

1.AC
2.C
3.BD
4.BD
5.C
6.C
7.BD
8.BD
9.CD
10.B
11.B
12.A
13.BD
14.A
15.D
16.BC
17.AD
18.B
19.B
20.A
21.AC
22.A
23.D
24.C
25.C
26.D
27.C
28.B
29.C
30.AC
31.D
32.D
33.A
34.A