本讲主要说下逻辑回归的相关问题和详细的实现方法

1. 什么是逻辑回归

逻辑回归是线性回归的一种，那么什么是回归，什么是线性回归

回归指的是公式已知，对公式中的未知參数进行预计，注意公式必须是已知的，否则是没有办法进行回归的

线性回归指的是回归中的公式是一次的，比如z=ax+by

逻辑回归事实上就是在线性回归的基础上套了一个sigmoid函数，详细的样子例如以下

2. 正则化项

引入正则化项的目的是防止模型过拟合，函数对样本的拟合有三种结果

欠拟合：直观的理解就是在训练集上的误差比較大，拟合出来的函数应该是曲线，结果拟合成了一条直线

过拟合：在训练集上的误差非常小甚至为0，追求经验风险最小化，模型拟合的非常复杂，往往在未知的样本集上表现的不够好

合适的拟合：在训练集合測试集上都表现的比較好，追求经验风险和结构风险的均衡

解决过拟合的问题一般有两种方法，一是降低特征的维度，二是进行正则化。对降低特征的维度我的理解是造成过拟合的原因是特征太多样本太少，所以进行特征选择以降低特征会得到比較好的拟合效果，以下具体说一下正则化。

先看一下正则化的样子

事实上就是在损失函数里增加一个正则化项，正则化项就是权重的L1或者L2范数乘以一个lamda，用来控制损失函数和正则化项的比重，直观的理解，首先防止过拟合的目的就是防止最后训练出来的模型过分的依赖某一个特征，当最小化损失函数的时候，某一维度非常大，拟合出来的函数值与真实的值之间的差距非常小，通过正则化能够使总体的cost变大，从而避免了过分依赖某一维度的结果。当然加正则化的前提是特征值要进行归一化，比如有的特征的范围是200-500，有个特征的范围是0-1，这个时候就要进行归一化，比如都化为0-1之间。

3. 最小二乘法和最大似然法

最小二乘法，感觉名字起的不好，不能一目了然，有点拗口，事实上就是最小平方和的意思么，那么为什么用最小二乘法呢，我们知道，我们的目的就是较少预測值和真实值之间的差值，那么直接把差值直接加起来作为误差不就好了，当然不行，由于误差有正有负，有些误差会抵消，那么绝对值的和呢，听起来也比較合理，理论上应该也能够，只是最小二乘法有个比較合理解释，有样本点D，然后非常多候选的曲线h来分开这些点，那么选择哪条直线呢，我们选的应该是后验概率最大的那条线，也就是P(h|D)最大的那条线。由贝叶斯知道p(h|D)正比于p(h)*p(D|h)，先验概率p(h)觉得是均等的，所以仅仅要最大化p(D|h)就可以，由于样本点D是独立的，所以p(D|h)=p(d1|h)*p(d2|h)*......*p(dn|h)。我们觉得这些点是含有噪音的，是由于噪音让他偏离了一条完美的曲线，一种非常合理的如果就是偏离远大的概率越小，那么这个偏离的概率能够用正态分布来描写叙述，形式化的表达为p(dn|h)=exp(-delta^2)，所以p(D|h)=exp(-(delta1^2+delta2^2......+deltan^2))，我们的目的是最大化这个概率，等价于最小化里面的平方和，min（delta1^2+delta2^2......+deltan^2），是不是非常熟悉啊

这个时候，我们看一下，最小二乘法适合做逻辑回归的误差函数么，答案是不适合，由于最小二乘法的误差我们如果的事符合正态分布，而逻辑回归的误差符合的是二项分布，所以不能用最小二乘法来作为损失函数，那么能够用最大似然预计来做

4. java实现梯度下降法

实验：

样本：

-0.017612	14.053064	0
-1.395634	4.662541	1
-0.752157	6.538620	0
-1.322371	7.152853	0
0.423363	11.054677	0
0.406704	7.067335	1
0.667394	12.741452	0
-2.460150	6.866805	1
0.569411	9.548755	0
-0.026632	10.427743	0
0.850433	6.920334	1
1.347183	13.175500	0
1.176813	3.167020	1
-1.781871	9.097953	0
-0.566606	5.749003	1
0.931635	1.589505	1
-0.024205	6.151823	1
-0.036453	2.690988	1
-0.196949	0.444165	1
1.014459	5.754399	1
1.985298	3.230619	1
-1.693453	-0.557540	1
-0.576525	11.778922	0
-0.346811	-1.678730	1
-2.124484	2.672471	1
1.217916	9.597015	0
-0.733928	9.098687	0
-3.642001	-1.618087	1
0.315985	3.523953	1
1.416614	9.619232	0
-0.386323	3.989286	1
0.556921	8.294984	1
1.224863	11.587360	0
-1.347803	-2.406051	1
1.196604	4.951851	1
0.275221	9.543647	0
0.470575	9.332488	0
-1.889567	9.542662	0
-1.527893	12.150579	0
-1.185247	11.309318	0
-0.445678	3.297303	1
1.042222	6.105155	1
-0.618787	10.320986	0
1.152083	0.548467	1
0.828534	2.676045	1
-1.237728	10.549033	0
-0.683565	-2.166125	1
0.229456	5.921938	1
-0.959885	11.555336	0
0.492911	10.993324	0
0.184992	8.721488	0
-0.355715	10.325976	0
-0.397822	8.058397	0
0.824839	13.730343	0
1.507278	5.027866	1
0.099671	6.835839	1
-0.344008	10.717485	0
1.785928	7.718645	1
-0.918801	11.560217	0
-0.364009	4.747300	1
-0.841722	4.119083	1
0.490426	1.960539	1
-0.007194	9.075792	0
0.356107	12.447863	0
0.342578	12.281162	0
-0.810823	-1.466018	1
2.530777	6.476801	1
1.296683	11.607559	0
0.475487	12.040035	0
-0.783277	11.009725	0
0.074798	11.023650	0
-1.337472	0.468339	1
-0.102781	13.763651	0
-0.147324	2.874846	1
0.518389	9.887035	0
1.015399	7.571882	0
-1.658086	-0.027255	1
1.319944	2.171228	1
2.056216	5.019981	1
-0.851633	4.375691	1
-1.510047	6.061992	0
-1.076637	-3.181888	1
1.821096	10.283990	0
3.010150	8.401766	1
-1.099458	1.688274	1
-0.834872	-1.733869	1
-0.846637	3.849075	1
1.400102	12.628781	0
1.752842	5.468166	1
0.078557	0.059736	1
0.089392	-0.715300	1
1.825662	12.693808	0
0.197445	9.744638	0
0.126117	0.922311	1
-0.679797	1.220530	1
0.677983	2.556666	1
0.761349	10.693862	0
-2.168791	0.143632	1
1.388610	9.341997	0
0.317029	14.739025	0

public class LogRegression {

	public static void main(String[] args) {
		
		LogRegression lr = new LogRegression();
		Instances instances = new Instances();
		lr.train(instances, 0.01f, 200, (short)1);
	}
	
	public void train(Instances instances, float step, int maxIt, short algorithm) {
		
		float[][] datas = instances.datas;
		float[] labels = instances.labels;
		int size = datas.length;
		int dim = datas[0].length;
		float[] w = new float[dim];
		
		for(int i = 0; i < dim; i++) {
			w[i] = 1;
		}
		
		switch(algorithm){
		//批量梯度下降
		case 1: 
			for(int i = 0; i < maxIt; i++) {
				//求输出
				float[] out = new float[size];
				for(int s = 0; s < size; s++) {
					float lire = innerProduct(w, datas[s]);
					out[s] = sigmoid(lire);
				}
				for(int d = 0; d < dim; d++) {
					float sum = 0;
					for(int s = 0; s < size; s++) {
						sum  += (labels[s] - out[s]) * datas[s][d];
					}
					w[d] = w[d] + step * sum;
				}
				System.out.println(Arrays.toString(w));
			}
			break;
		//随机梯度下降
		case 2: 
			for(int i = 0; i < maxIt; i++) {
				for(int s = 0; s < size; s++) {
					float lire = innerProduct(w, datas[s]);
					float out = sigmoid(lire);
					float error = labels[s] - out;
					for(int d = 0; d < dim; d++) {
						w[d] += step * error * datas[s][d];
					}
				}
				System.out.println(Arrays.toString(w));
			}
			break;
		}
	}
	
	private float innerProduct(float[] w, float[] x) {
		
		float sum = 0;
		for(int i = 0; i < w.length; i++) {
			sum += w[i] * x[i];
		}
		
		return sum;
	}
	
	private float sigmoid(float src) {
		return (float) (1.0 / (1 + Math.exp(-src)));
	}
}