一、多元线性回归函数

上面解决了只有单一变量（面积）的房子价格预测问题，但是如果存在多个特征如：面积、卧室数量、楼层、修建年限等多个特征，如下：

我们用m表示样本数量，n表示特征数量，表示输入的第i个样本，表示输入的第i个样本的第j个特征。

只有一个变量时假设函数是：，现在我们有4个特征，所以假设函数变为：，我们引入=1，则方程可以变为：，写成矩阵形式为：

  则

这就是多特征的线性回归函数，我们称为多元线性回归函数。

二、使用梯度下降法处理多元线性回归函数

我们可以使用梯度下降处理一元线性回归函数的方法处理多元线性回归函数，如下图，左边是一元，右边是多元，注意其中的：

三、特征缩放

在进行梯度下降算法时，如果存在多个特征差距很大，比如房屋的卧室数量范围是1-5，面积值范围是500-2000，那么在进行梯度下降时，由于同样的步长，面积产生的数值更大，对结果的影响更大会导致函数的下降过程来回摇摆，收敛速度变慢。我们采用缩放的方法，将卧室数量/5，面积/2000，得到一个0和1之间的数值，那么下降过程就会顺滑很多，也会更快。如下：

但是，要注意，如果特征值的范围过小时也要适当放大。特征值不用都在同一区间，但彼此之间的差距不要太大。

均值归一化：（实际值-平均值）/最大值。经过均值归一化处理的数据能保证平均数为0的均匀分布。

四、学习率α

我们可以把梯度下降法的迭代次数作为横坐标，作为纵坐标，观察梯度下降算法是否收敛。

在迭代一定的次数之后，函数下降的幅度很小，几乎为一条直线。此时就可以看做函数已经收敛。

另外，也可以进行一种收敛的测试，设定一个阈值，如果代价函数一步迭代后的下降小于这个阈值，那么就可以认为函数收敛了。但是通常一个合适的阈值是难以确定的。曲线图会比较直观。 

学习率α过大，会出现下面这样的迭代次数-代价函数图：

总结：学习率α过小，会出现收敛速度慢的问题；过大，会出现代价函数不会每次迭代都下降甚至不收敛。

五、特征和多项式回归

（一）如何选取特征

假设我们想卖出的房子的图片长度为20米，宽度为10米。我们就有两个特征长和宽，但是我们使用线性回归算法的时候并不一定要直接使用这两个特征，我们可以自己创造新的特征，我们实际观察到房子的价格其实与房子的面积关系最大，我们可以使area=长度*宽度，这就是房子的面积，两个特征变成了一个新特征。

（二）选取不同的函数作为代价函数

比如有下面这样一个模型，直线不能很好的拟合。我们可以用二次模型去拟合，但是二次函数会降下来，不合理。我们不觉得随着土地面积的增加，房子价格会降下来。我们使用一个三次函数去预测，如图中绿色曲线。

那么假设函数就如下所示：

六、正规方程

（一）正规方程求解线性回归函数

设有一个数据集如下所示，x1,x2,x3是特征，y为标签：

x1	x2	x3	y
x11	x12	x13	y1
x21	x22	x23	y2

设假设函数为，其中，即在数据集上加上一列全为1的x1，如下：

则用矩阵的方式表示可得：等价于，其中：

，，，等价于，现在我们要求解向量。因为x矩阵不是方阵，只有方阵才能求逆矩阵，所以我们需要把x转换为方阵，两边同时左乘x矩阵的转置，得：，其中肯定是一个方阵，把它看做一个整体，两边同时右乘它的逆矩阵得：，此时就求出了向量。

使用特征方程的话就不需要特征缩放了。

（二）特征方程的优缺点

假设有m个样本，n个特征。

梯度下降	优点	不需要多次迭代
		不需要选择学习速率α
	缺点	当n特别大时需要计算，这是一个n*n的矩阵，运算速度慢，时间复杂度大约是O()
特征方程	优点	当n特别大时能很好的运行
		其中n的大小很难给出准确数字，但现在计算机的速度n在万级以下没有问题
	缺点	需要选择学习速率α
		需要多次迭代

对于一些复杂的方法，如一些分类算法，是无法使用特征方程求解的，我们只能使用梯度下降法。

（三）正规方程以及不可逆性

对于，如果不可逆，如何求解？我们把不可逆的矩阵称为退化矩阵或奇异矩阵，在实际情况中不可逆的情况很少见。矩阵求逆有两种，分别为：伪逆(pseudo-inverse)和逆(inverse)，数学上证明，即使矩阵是不可逆的，利用伪逆也可以求出结果。

（1）一般出现不可逆的情况

①冗余的特征

如 x1=平方英尺，x2=平方米，那么两个特征之间有换算关系即 x1=3.28.3.28*x2，两列成倍数则矩阵不可逆

②特征数n大于样本数m

删除一些特征或使用正则化方法可以解决这个问题

多元线性回归表达式

其中，
$$X=[1,x_1,\cdots ,x_n]$$

$$W=[w_0,w_1,\cdots ,w_n]$$

损失函数

其中$X,Y$是矩阵。

梯度下降

令$H=Y-X{W}^T$
$$L=H^{T}H$$

这里涉及到了矩阵求导的知识，具体请查看
矩阵求导

代码实现

import numpy as np
import matplotlib.animation as animation
import matplotlib.pyplot as plt
# 以下两行代码解决jupyter notebook显示图片模糊问题
%matplotlib inline
%config InlineBackend.figure_format = 'svg'
# 支持中文
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
##  测试数据
x1 = np.arange(0,10,0.2)
x2 = np.arange(-10,0,0.2)
y = 10*x1+3*x2+5 + np.random.random((len(x1)))*20

def f(X,W):
    return X.dot(W.T)
## 初始化参数
W =np.mat(np.random.random([3])*2-1)
X=np.mat(np.column_stack((np.ones(len(x1)),x1,x2))) #按列组合
Y = np.mat(y).T

## 梯度下降
lr = 0.00005
for i in range(60):
    # 更新梯度
    w = -2*(Y-X.dot(W.T)).T.dot(X)
    W = W-lr*w
# 绘图
Y_Test = f(X,W)
x = np.arange(len(Y))+1
plt.scatter(x,list(Y),s=10)
plt.plot(x,Y,'b')
plt.plot(x,Y_Test,'r')

多元线性回归法也是深度学习的内容之一，用java实现一下多元线性回归。

一元线性回归的公式为 y =  a*x + b, 多元线性回归的公式与一元线性回归的公式类似，不过是矩阵的形式，可以表示为Y =　AX + b，其中，Y是样本输出的合集，X是样本输入的合集。

多元线性回归最终求解的内容也就是 A 和 B， 这里省去求证步骤，直接列出求解 A 和 B 矩阵的公式，公式如下：

（

这里的X是样本输入的合集，是二维矩阵，Y是样本输出的合集，是一维矩阵。

可以看到，这里要求解两次，先将 A 求出来，再将 b 求出来，这样会增加计算量，也增加了编程时的困难，实际上，如果我们将多元线性回归的方程展开来看：

可以看到，如果我们将 b <=> a0 , 那么线性回归方程可以表示为：

这样的话，矩阵的求解公式可以表示为：

这里的 X 是一个新的矩阵，增加了“第零列”元素，该列元素全部设置为1。

现在可以进行编程，编程过程可以分为两步，第一步，给 X 矩阵增加“第零列”， 第二步， 求解 A 矩阵。

第一步的代码如下，这里我设置了一个多元线性回归类，将传进来的 X 和 Y，赋值给类中的 X 和 Y：

	/**如果采用无参构造，则需要通过set输入相应的矩阵
	 * @param X x的矩阵
	 * @param Y y的矩阵
	 */
	public void set(double X[][], double Y[]){
		this.X = new double[X.length][X[0].length + 1];
		for(int i = 0; i < X.length; i++){
			this.X[i][0] = 1;
			for(int j = 0; j < X[0].length; j++){
				this.X[i][j + 1] = X[i][j];
			}
		}
		this.Y = Y;
	}

完成后，求解 A 矩阵， 因为公式是矩阵形式，所以直接采用设计好的矩阵计算类进行求解，这里用到的主要是矩阵的转置，求逆以及矩阵的乘法，矩阵求逆和乘法在之前的两篇博客中列出，矩阵求逆： 点击打开链接，矩阵的乘法： 点击打开链接，因为这次计算只需要用到二维矩阵的转置，所以这里只列出二维矩阵的转置：

	/**求转置矩阵
	 * @param A 要求解的矩阵
	 * @return 转置矩阵
	 */
	public double[][] matrix_transpoistion(double A[][]){
		int row = A.length; 
		int col = A[0].length;
		double A_T[][] = new double[col][row];
		for(int i = 0; i < row; i++){
			for(int j = 0; j < col; j++){
				A_T[j][i] = A[i][j];
			}
		}
		return A_T;
	}

A 矩阵的求解公式列在这里：

也就是说，整个求解过程分为五步，(1)求转置，(2)转置与原矩阵的乘积，(3)乘积的逆，（4）结果乘矩阵的转置，(5)结果乘输出矩阵，考虑到 X 的转置要用两次，可以预设一个 X_T 矩阵，保存 X 的转置，整个求解过程的实现代码如下：

	/**计算相应的系数
	 * @return 包含b的系数组
	 */
	public double[] cal_coefficient(){
		int row = X.length;
		int col = X[0].length;
		//使用矩阵计算相应结果
		Matrix_cal mc = new Matrix_cal();
		//求X的转置
		double X_T[][] = mc.matrix_transpoistion(X);
		//求XT*X;
		mc.set(X_T);
		double temp[][] = mc.matrix_multriple(X);
		//求逆矩阵
		if(temp.length > 1){
			//如果X_T*X的矩阵行列数不为1
			mc.set(temp);
			temp = mc.inverse_Matrix();
		}
		else{
			//如果矩阵行列式为1，则temp不变
			temp[0][0] = 1/temp[0][0];
		}
		//求temp*X_T;
		mc.set(temp);
		temp = mc.matrix_multriple(X_T);
		//mc.show(temp);
		//求temp*Y
		mc.set(temp);
		B = mc.matrix_multriple(Y);
		return B;
	}
}

这里的 Matrix_cal，是我之前所写的一个基本的矩阵运算类，最后返回的结果是一个一维矩阵，也就是需要计算的 A。