从逻辑回归模型可以得到，支持向量机（SVM）模型，下面是一些普遍使用的准则：
n为特征数，m为训练样本数。
1、如果相较于m而言，n要大许多，即训练集数据量不够支持我们训练一个复杂的非线性模型，我们选用逻辑回归模型或者不带核函数的支持向量机
2、如果n比较小，而且m大小中等，例如n在1-1000之间，而m在10-100000之间，使用高斯核函数的支持向量机。
3、如果n比较小，而m较大，例如n在1-1000之间，而m大于50000，则使用支持向量会非常慢，解决方案是增加更多的特征，然后使用逻辑回归或不带核函数的支持向量机。

我们前面提到过，降低方差的方法有模型正则化，此方法也是最重要提供模型泛化能力方法。我们今天了解L1和L2两种正则化方法。用到正则化的算法有Lasso回归、岭回归、支持向量机等。
一、模型正则化概念
模型正则化（Regularization），对学习算法的修改，限制参数的大小，减少泛化误差而不是训练误差。
在使用比较复杂的模型，去拟合数据时，很容易出现过拟合现象(训练集表现很好，测试集表现较差)，这会导致模型的泛化能力下降，这时候，我们就需要使用正则化，降低模型的复杂度。
正则化的策略包括：约束和惩罚被设计为编码特定类型的先验知识 偏好简单模型其他形式的正则化，如：集成的方法，即结合多个假说解释训练数据。
二、L1正则化
L1正则化，就是在目标函数中加了L1范数这一项。使用L1正则化的回归模型叫做LASSO回归（Least Absolute Shrinkage and Selection Operator Regression）。
数学原理就是：若模型过拟合，参数θ就会非常大。为了限制参数θ，我们改变损失函数，加入模型正则化。使$J(θ)=MSE(y,\hat{y};θ)+\alpha\sum_{i=1}^{n}|θ_i|$尽可能小。
注意：

①、  $\sum_{i=1}^{n}|θ_i|$取值范围是1～n，即不包含$θ_0$。这是因为，$θ_0$不是任何一个参数的系数，是截距。反映到图形上就是$θ_0$反映了曲线的高低，而不决定曲线每一部分的陡峭与缓和。所以模型正则化时不需要。

②、对于超参数$\alpha$系数，在模型正则化的新的损失函数中，要让每个$θ_i$都尽可能小的程度占整个优化损失函数程度的多少。即$\alpha$的大小表示优化的侧重。
L1正则化可以使得参数稀疏化，即得到的参数是一个稀疏矩阵。因此可以常使用LASSO回归做特征选择，筛选最重要的特征。
# 使用Pipeline封装一个Lasso回归方法
def LassoRegression(degree,alpha):
    return Pipeline([
        ('poly',PolynomialFeatures(degree=degree)),
        ('std_scaler',StandardScaler()),
        ('lasso_reg',Lasso(alpha=alpha))
    ])
    # 我们调整alpha=0.0001，0.1，10 看不同结果
alphas=[0.0001,0.1,10]
for alpha in alphas:
    lasso_reg = LassoRegression(30,alpha)
    lasso_reg.fit(X_train,y_train)
    y1_predict=lasso_reg.predict(X_test)
    print(mean_squared_error(y_test,y1_predict)) 
    X_plot = np.linspace(-3,3,100).reshape(100,1)
    y_plot = lasso_reg.predict(X_plot)
    plt.scatter(X,y)
    plt.plot(X_plot[:,0],y_plot,color='r')
    plt.axis([-3,3,0,10])
    plt.show()

看效果图发现，α值适中，模型效果才更佳。

α=0.0001



α=0.01



α=10


三、L2正则化
L2正则化，就是在目标函数中加了L2范数这一项(用平方和来做正则项)。使用L2正则化的回归模型叫做岭回归（Ridge Regression）。
数学原理就是：若模型过拟合，参数θ就会非常大。为了限制参数θ，我们改变损失函数，加入模型正则化。使$J(θ)=MSE(y,\hat{y};θ)+\alpha\sum_{i=1}^{n}θ_i^{2}$尽可能小。
将系数压缩无限接近0，不会等于0；因此，和LASSO回归对比，不会生成稀疏矩阵。
# 使用Pipeline封装一个Lasso回归方法
def ridgeregression(degree,alpha):
    return Pipeline([
        ('poly',PolynomialFeatures(degree=degree)),
        ('std_scaler',StandardScaler()),
        ('ridge_reg',Ridge(alpha=alpha))
    ])
    # 我们调整alpha=0.0001，1，1000 看不同结果
alphas=[0.0001,1,1000]
for alpha in alphas:
    ridge_reg = ridgeregression(30,alpha)
    ridge_reg.fit(X_train,y_train)
    y1_predict=ridge_reg.predict(X_test)
    print(mean_squared_error(y_test,y1_predict)) 
    X_plot = np.linspace(-3,3,100).reshape(100,1)
    y_plot = ridge_reg.predict(X_plot)
    plt.scatter(X,y)
    plt.plot(X_plot[:,0],y_plot,color='r')
    plt.axis([-3,3,0,10])
    plt.show()

看效果图发现，跟LASSO回归一样，α值适中，模型效果才更佳。
α=0.0001



α=1



α=1000


完整代码

参考文章：https://mp.weixin.qq.com/s/fbwx0mlG88YjFTNwYErnxQ

看到网上的地保清扫机器人，就在想他是用什么策略能更快更好的清扫家里的卫生。
实际中情况比较复杂（房间，家具的形状，地保的大小等），我把模型简化下来，类似于下面这个矩阵：

1
0
0
0
2
2
0
0
0
0
0
0
0
0
0
0

从最左上角的格子开始，0代表为经过的路径，1代表走过的路，2代表是障碍，问：是否可以不重复的覆盖值为0的方框，如果可以有几种方法？
类似于小时候游戏机上面的简单智力问题（宠物小精灵。。。）其实就是个探索问题，先上代码：

package com.code;

import java.util.ArrayList;
import java.util.List;

public class PathCover {
//不回头覆盖矩阵中的所有格子,智力游戏中的题目
	public static void main(String[] args){
		int n=3;
		int m=3;
		int[][] matrix=new int[n][m];
		//0 未经过的
		//1 走过的
		//2墙壁，不能通过
		for(int i=0;i<n;i++)
			for(int j=0;j<m;j++)
				matrix[i][j]=0;
		
		matrix[0][1]=2;
	    matrix[0][2]=2;
	    matrix[2][0]=2;
	    matrix[0][0]=1;//start
	    List<String> list=new ArrayList<String>();
	    int k=n*m-3-1;
	    dfs(matrix,k,0,0,list);
	    
	}
	
	public static void dfs(int[][] matrix,int k,int x,int y,List<String> path){
		//按上下左右顺序探索
		if(k==0){	
			for(String point:path)
			System.out.println(point);
			
			System.out.println("*******");
			return;
		
		}
		//up
		if(x>0&&matrix[x-1][y]==0){
			matrix[x-1][y]=1;
			path.add((x-1)+","+y);
			dfs(matrix,k-1,x-1,y,path);
			path.remove(path.size()-1);
			matrix[x-1][y]=0;
		}
		
		//down
		if(x<matrix.length-1&&matrix[x+1][y]==0){
			matrix[x+1][y]=1;
			path.add((x+1)+","+y);
			dfs(matrix,k-1,x+1,y,path);
			path.remove(path.size()-1);
			matrix[x+1][y]=0;
		}
		
		//left
		if(y>0&&matrix[x][y-1]==0){
			matrix[x][y-1]=1;
			path.add(x+","+(y-1));
			dfs(matrix,k-1,x,y-1,path);
			path.remove(path.size()-1);
			matrix[x][y-1]=0;
		}
		
		//right
		if(y<matrix[0].length-1&&matrix[x][y+1]==0){
			matrix[x][y+1]=1;
			path.add(x+","+(y+1));
			dfs(matrix,k-1,x,y+1,path);
			path.remove(path.size()-1);
			matrix[x][y+1]=0;
		}
	}
}


就是按上下左右的顺序深度优先遍历，结束条件为遍历的格子数等于总共的值为0的格子数