sklearn.neural_network常用API介绍

sklearn.nueral_network.MLPClassifier(hidden_layer_sizes=(100,),activation='relu',solver='adam',
alpha=0.0001,batch_size='auto',learning_rate='constant',learning_rate_init=0.001,power_t=0.5,
max_iter=200,shuffle=True,random_state=None,tol=0.0001,verbose=False,warm_start=False,momentum=0.9,
nesterovs_momentum=True,early_stopping=False,validation_fraction=0.1,beta_1=0.9,beta_2=0.999,epsilon=1e-8)
训练一个多层感知机模型，使用LBFGS或者随机梯度下降优化对数损失函数
hidder_layer_sizes:元组，length=n_layers-2,默认为(100,)
第i个数代表第i层隐藏层的神经元个数

activation:{'identity','logistic','tanh','relu'},默认为relu
隐藏层的**函数
identity:f(x)=x
logistic:f(x)=1/(1+exp(-x))
tanh:f(x)=tanh(x)
relu:f(x)=max(0,x)

slover:{'lbfgs','sgd','adam'},默认'adam'
权值优化的解决方案
大数据集时adam表现较好，小数据集时lbfgs收敛更快表现更好

alpha:float,默认0.0001
L2惩罚项（正则化项）的系数

batch_size:int,默认auto
每次优化迭代过程中使用的样本个数.auto时batch_size=min(200,n_samples)

learning_rate:{'constant','invscaling','adaptive'}默认constant,只在solver='sgd'有效
constant:训练过程中learning_rate不改变，为定值
invscaling:learning_rate逐渐减小，effective_learning_rate=learning_rate_init/pow(t,power_t)
adaptive:只要训练误差持续下降就保持不变

learning_rate_init:double,默认0.001
初始化的学习速率，solver='sgd','adam'有效

power_t:double,默认0.5
solver='sgd'且learning_rate='invscaling'时有效

max_iter:int,默认200
迭代最大次数。决定了训练次数而不是梯度下降次数

shuffle:boolean,默认True
每次迭代时是否打乱样本顺序.solver='sgd','adam'有效

tol:float,默认1e-4
当误差的改变量小于tol时认为模型收敛

momentum:float,默认0.9
梯度下降时的动量，加大冲出局部最优解的概率，solver='sgd'有效

nesterovs_momentum:boolean,默认True
是否使用nesterovs冲量，solver='sgd'且momentum>0有效

early_stopping:boolean,默认False
当交叉验证得分不再上升时是否早点停止迭代。设置为True时，自动取10%的训练集作为验证集，且验证得分提升小于tol时停止训练

validation_fraction:float,默认0.1
early_stopping有效时，验证集占训练集的比例

beta_1:float,默认0.9
adam算法中的第一个动量向量的指数衰减率,[0,1)

beta_2:float,默认0.9
adam算法中的第二个动量向量的指数衰减率,[0,1)

epsilon:float,默认1e-8
adam中的数值稳定性

属性：
classes_:array,或者list(array)。每次输出的类别标签

loss_:float:当前损失函数计算出的损失

coefs_:list,length=n_layers-1
第i个元素是第i层的权值矩阵

intercepts_:list,length=n_layers-1
第i个元素是第i+1层的偏差

n_iter_:int,迭代的次数

n_outputs_:int,输出的个数

out_activation:string,输出的**函数

方法:
fit(X,y)
get_params([deep])
predict(X)
predict_log_proba(X)
predict_proba(X)
score(X,y[,sample_weight])
set_params(**params)
与大多数API用法一致
example:
from sklearn.neural_network import MLPClassifier
mlp = MLPClassifier(solver='lbfgs',hidden_layer_sizes=(3,2))
X = [[-1,-1],[-2,-1],[-1,-2],[1,1],[1,2],[2,1]]
y = [-1,-1,-1,1,1,1]
mlp.fit(X,y)
print(mlp.predict([[-3,-3],[3,3]]))
#[-1  1]
print(mlp.predict_proba([[-3,-3],[3,3]]))
#[[1.00000000e+00 4.09123146e-19]
# [1.83471736e-04 9.99816528e-01]]

sklearn.neural_network.MLPRegressor(hidden_layer_sizes=(100, ), activation=’relu’, solver=’adam’,
alpha=0.0001, batch_size=’auto’, learning_rate=’constant’, learning_rate_init=0.001, power_t=0.5,
max_iter=200, shuffle=True, random_state=None, tol=0.0001, verbose=False, warm_start=False,
momentum=0.9, nesterovs_momentum=True, early_stopping=False, validation_fraction=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
参数及属性同MLPClassifier

方法:
fit(X,y)
get_params([deep])
predict(X)
score(X,y[,sample_weight])
set_params(**params)
同MLPclassifier
example:
from sklearn.neural_network import MLPRegressor
mlp = MLPRegressor(solver='lbfgs',hidden_layer_sizes=(3,2),activation='tanh')
X = np.arange(0.0,1,0.01).reshape(-1,1)
y = np.sin(2*np.pi*X).ravel()
mlp.fit(X,y)
test_x = np.arange(-0.1,1.1,0.01).reshape(-1,1)
test_y = mlp.predict(test_x)
fig = plt.figure()
ax1 = fig.add_subplot(111)
ax1.scatter(X,y,s=5,c='b',marker='o',label='real')
ax1.plot(test_x,test_y,c='r',label='prediction')
plt.legend()
plt.show()

当activation改成'relu'
mlp = MLPRegressor(solver='lbfgs',hidden_layer_sizes=(3,2),activation='relu')

可以看出relu其实几乎是线性的，不适合学习简单的非线性函数

而把solver改为adam时
mlp = MLPRegressor(solver='adam',hidden_layer_sizes=(3,2),activation='tanh',max_iter=10000)

看出收敛后与我们预期的数据几乎没有一致，说明数据点过小不适合使用adam