使用sklearn中的神经网络模块MLPClassifier处理分类问题

「爱情、让人受尽委屈。」 2022-06-04 07:35 356阅读 0赞

MLPClassifier（多层感知器分类器）  
一.首先简单使用sklearn中的neural\_network,实例1:

#coding=utf-8
    ''' Created on 2017-12-7 '''
    from sklearn.neural_network import MLPClassifier
    X = [[0., 0.], [1., 1.]]
    y = [0, 1]
    mlp = MLPClassifier(solver='lbfgs', alpha=1e-5,hidden_layer_sizes=(5, 5), random_state=1)
    mlp.fit(X, y)                         
    print mlp.n_layers_
    print mlp.n_iter_
    print mlp.loss_
    print mlp.out_activation_
    # 输出分别为
    # 4
    # 15
    # 0.000141233472537
    # logistic

二.MNIST数据集的下载  
MNIST是一些手写数字的图片，通过[http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz][http_www.iro.umontreal.ca_lisa_deep_data_mnist_mnist.pkl.gz]下载数据集。  
三.使用神经网络训练MNIST数据集并实现分类，实例2

#coding=utf-8
    ''' Created on 2017-12-6 '''
    
    from sklearn.neural_network import MLPClassifier
    from sklearn.datasets import fetch_mldata
    import numpy as np
    import pickle
    import gzip
    
    # 加载数据
    # mnist = fetch_mldata("MNIST original")
    with gzip.open("D:\\xxx\\mnist.pkl.gz") as fp:
        training_data,valid_data,test_data = pickle.load(fp)
    x_training_data,y_training_data = training_data
    x_valid_data,y_valid_data = valid_data
    x_test_data,y_test_data = test_data
    classes = np.unique(y_test_data)
    
    # 将验证集和训练集合并
    x_training_data_final = np.vstack((x_training_data,x_valid_data))
    y_training_data_final = np.append(y_training_data,y_valid_data)
    
    
    # 设置神经网络模型参数
    # mlp = MLPClassifier(solver='lbfgs', activation='relu',alpha=1e-4,hidden_layer_sizes=(50,50), random_state=1,max_iter=10,verbose=10,learning_rate_init=.1)
    # 使用solver='lbfgs',准确率为79%，比较适合小(少于几千)数据集来说，且使用的是全训练集训练，比较消耗内存
    # mlp = MLPClassifier(solver='adam', activation='relu',alpha=1e-4,hidden_layer_sizes=(50,50), random_state=1,max_iter=10,verbose=10,learning_rate_init=.1)
    # 使用solver='adam'，准确率只有67%
    mlp = MLPClassifier(solver='sgd', activation='relu',alpha=1e-4,hidden_layer_sizes=(50,50), random_state=1,max_iter=10,verbose=10,learning_rate_init=.1)
    # 使用solver='sgd'，准确率为98%，且每次训练都会分batch，消耗更小的内存
    
    # 训练模型
    mlp.fit(x_training_data_final, y_training_data_final) 
    
    # 查看模型结果
    print mlp.score(x_test_data,y_test_data)
    print mlp.n_layers_
    print mlp.n_iter_
    print mlp.loss_
    print mlp.out_activation_
    # Iteration 1, loss = 0.31452262
    # Iteration 2, loss = 0.13094946
    # Iteration 3, loss = 0.09715855
    # Iteration 4, loss = 0.08033498
    # Iteration 5, loss = 0.06761733
    # Iteration 6, loss = 0.06085069
    # Iteration 7, loss = 0.05485305
    # Iteration 8, loss = 0.04950742
    # Iteration 9, loss = 0.04468061
    # Iteration 10, loss = 0.04156696
    # D:\Python27\lib\site-packages\sklearn\neural_network\multilayer_perceptron.py:563: ConvergenceWarning: Stochastic Optimizer: Maximum iterations reached and the optimization hasn't converged yet.
    # % (), ConvergenceWarning)
    # 0.9726
    # 4
    # 10
    # 0.0415669639552
    # softmax

四.分析简单实例1和实例2  
对于神经网络的输出层（即mlp.out\_activation\_,且mlp.out\_activation\_不可设置），激活函数的选取还是有一定的原则的：  
1) 如果是两类判别，输出层只有一个神经元，那么选logistic，即实例1mlp.out\_activation\_输出；  
2) 如果是n类判别，输出层有n个神经元，那么选softmax即实例2，输出0-9多分类；  
3) 如果是回归，那么选线性。  
这些选择并不是为了提高性能，而只是让输出的范围合理。  
对于判别问题，输出是概率，所以必须在0到1之间，多类判别时还需要加起来等于1；  
对于回归问题，一般没有理由要求输出在0到1之间。  
五.fit和partial\_fit进行训练的区别  
可以看出即使训练的顺序和迭代的次数一样但准确率仍然有区别。

#coding=utf-8
    ''' Created on 2017-12-6 '''
    
    from sklearn.neural_network import MLPClassifier
    from sklearn.datasets import fetch_mldata
    import numpy as np
    import pickle
    import gzip
    
    # 加载数据
    # mnist = fetch_mldata("MNIST original")
    with gzip.open("D:\\xxx\\mnist.pkl.gz") as fp:
        training_data,valid_data,test_data = pickle.load(fp)
    x_training_data,y_training_data = training_data
    x_valid_data,y_valid_data = valid_data
    x_test_data,y_test_data = test_data
    classes = np.unique(y_test_data)
    
    # 将验证集和训练集合并
    x_training_data_final = np.vstack((x_training_data,x_valid_data))
    y_training_data_final = np.append(y_training_data,y_valid_data)
    
    # 将数据切割成batch
    x_training_data_final1 = x_training_data_final[:30000]
    y_training_data_final1 = y_training_data_final[:30000]
    x_training_data_final2 = x_training_data_final[30000:]
    y_training_data_final2 = y_training_data_final[30000:]
    
    
    # 设置神经网络模型参数
    mlp = MLPClassifier(solver='sgd', activation='relu',alpha=1e-4,hidden_layer_sizes=(50,50), random_state=1,max_iter=10,verbose=10,learning_rate_init=.1)
    
    # 训练模型
    # mlp.fit(x_training_data_final, y_training_data_final) 
    # # Iteration 1, loss = 0.31452262
    # # Iteration 2, loss = 0.13094946
    # # Iteration 3, loss = 0.09715855
    # # Iteration 4, loss = 0.08033498
    # # Iteration 5, loss = 0.06761733
    # # Iteration 6, loss = 0.06085069
    # # Iteration 7, loss = 0.05485305
    # # Iteration 8, loss = 0.04950742
    # # Iteration 9, loss = 0.04468061
    # # Iteration 10, loss = 0.04156696
    # # 0.9726
    # # 4
    # # 10
    # # 0.0415669639552
    # # softmax
    
    
    # #partial_fit只会进行一次迭代，需要循环进行迭代max_iter=10
    # for i in range(10):
    # #第一次调用需要加classes
    # mlp.partial_fit(x_training_data_final1,y_training_data_final1,classes)
    # mlp.partial_fit(x_training_data_final2,y_training_data_final2)
    # # Iteration 1, loss = 0.45255654
    # # Iteration 2, loss = 0.18496152
    # # Iteration 3, loss = 0.13822314
    # # Iteration 4, loss = 0.12282689
    # # Iteration 5, loss = 0.10101545
    # # Iteration 6, loss = 0.09582430
    # # Iteration 7, loss = 0.07989131
    # # Iteration 8, loss = 0.07949180
    # # Iteration 9, loss = 0.06864537
    # # Iteration 10, loss = 0.06737931
    # # Iteration 11, loss = 0.05911539
    # # Iteration 12, loss = 0.06098091
    # # Iteration 13, loss = 0.05412258
    # # Iteration 14, loss = 0.05293271
    # # Iteration 15, loss = 0.04915052
    # # Iteration 16, loss = 0.04907510
    # # Iteration 17, loss = 0.04609325
    # # Iteration 18, loss = 0.04990013
    # # Iteration 19, loss = 0.04260426
    # # Iteration 20, loss = 0.04509487
    # # 0.9664
    # # 4
    # # 20
    # # 0.0450948664394
    # # softmax
    
    # 查看模型结果
    print mlp.score(x_test_data,y_test_data)
    print mlp.n_layers_
    print mlp.n_iter_
    print mlp.loss_
    print mlp.out_activation_

六.neural\_network中MLPClassifier各个参数  
例如:mlp = MLPClassifier(solver=’sgd’, activation=’relu’,alpha=1e-4,hidden\_layer\_sizes=(50,50), random\_state=1,max\_iter=10,verbose=10,learning\_rate\_init=.1)

参数说明:  
1. hidden\_layer\_sizes :例如hidden\_layer\_sizes=(50, 50)，表示有两层隐藏层，第一层隐藏层有50个神经元，第二层也有50个神经元。  
2. activation :激活函数,\{‘identity’, ‘logistic’, ‘tanh’, ‘relu’\}, 默认relu  
\- identity：f(x) = x  
\- logistic：其实就是sigmod,f(x) = 1 / (1 + exp(-x)).  
\- tanh：f(x) = tanh(x).  
\- relu：f(x) = max(0, x)  
3. solver： \{‘lbfgs’, ‘sgd’, ‘adam’\}, 默认adam，用来优化权重  
\- lbfgs：quasi-Newton方法的优化器  
\- sgd：随机梯度下降  
\- adam： Kingma, Diederik, and Jimmy Ba提出的机遇随机梯度的优化器  
注意：默认solver ‘adam’在相对较大的数据集上效果比较好（几千个样本或者更多），对小数据集来说，lbfgs收敛更快效果也更好。  
4. alpha :float,可选的，默认0.0001,正则化项参数  
5. batch\_size : int , 可选的，默认’auto’,随机优化的minibatches的大小batch\_size=min(200,n\_samples)，如果solver是’lbfgs’，分类器将不使用minibatch  
6. learning\_rate :学习率,用于权重更新,只有当solver为’sgd’时使用，\{‘constant’，’invscaling’, ‘adaptive’\},默认constant  
\- ‘constant’: 有’learning\_rate\_init’给定的恒定学习率  
\- ‘incscaling’：随着时间t使用’power\_t’的逆标度指数不断降低学习率learning\_rate\_ ，effective\_learning\_rate = learning\_rate\_init / pow(t, power\_t)  
\- ‘adaptive’：只要训练损耗在下降，就保持学习率为’learning\_rate\_init’不变，当连续两次不能降低训练损耗或验证分数停止升高至少tol时，将当前学习率除以5.  
7. power\_t: double, 可选, default 0.5，只有solver=’sgd’时使用，是逆扩展学习率的指数.当learning\_rate=’invscaling’，用来更新有效学习率。  
8. max\_iter: int，可选，默认200，最大迭代次数。  
9. random\_state:int 或RandomState，可选，默认None，随机数生成器的状态或种子。  
10. shuffle: bool，可选，默认True,只有当solver=’sgd’或者‘adam’时使用，判断是否在每次迭代时对样本进行清洗。  
11. tol：float, 可选，默认1e-4，优化的容忍度  
12. learning\_rate\_int:double,可选，默认0.001，初始学习率，控制更新权重的补偿，只有当solver=’sgd’ 或’adam’时使用。  
14. verbose : bool, 可选, 默认False,是否将过程打印到stdout  
15. warm\_start : bool, 可选, 默认False,当设置成True，使用之前的解决方法作为初始拟合，否则释放之前的解决方法。  
16. momentum : float, 默认 0.9,动量梯度下降更新，设置的范围应该0.0-1.0. 只有solver=’sgd’时使用.  
17. nesterovs\_momentum : boolean, 默认True, Whether to use Nesterov’s momentum. 只有solver=’sgd’并且momentum > 0使用.  
18. early\_stopping : bool, 默认False,只有solver=’sgd’或者’adam’时有效,判断当验证效果不再改善的时候是否终止训练，当为True时，自动选出10%的训练数据用于验证并在两步连续迭代改善，低于tol时终止训练。  
19. validation\_fraction : float, 可选, 默认 0.1,用作早期停止验证的预留训练数据集的比例，早0-1之间，只当early\_stopping=True有用  
20. beta\_1 : float, 可选, 默认0.9，只有solver=’adam’时使用，估计一阶矩向量的指数衰减速率，\[0,1)之间  
21. beta\_2 : float, 可选, 默认0.999,只有solver=’adam’时使用估计二阶矩向量的指数衰减速率\[0,1)之间  
22. epsilon : float, 可选, 默认1e-8,只有solver=’adam’时使用数值稳定值。  
属性说明：  
\- classes\_:每个输出的类标签  
\- loss\_:损失函数计算出来的当前损失值  
\- coefs\_:列表中的第i个元素表示i层的权重矩阵  
\- intercepts\_:列表中第i个元素代表i+1层的偏差向量  
\- n\_iter\_ ：迭代次数  
\- n\_layers\_:层数  
\- n\_outputs\_:输出的个数  
\- out\_activation\_:输出激活函数的名称。

[http_www.iro.umontreal.ca_lisa_deep_data_mnist_mnist.pkl.gz]: http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz