神经网络实战

1. MLPClassifier参数设置
（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_init:double,可选，默认0.001，初始学习率，控制更新权重的补偿，只有当solver=’sgd’ 或’adam’时使用。
（13）verbose : bool, 可选, 默认False,是否将过程打印到stdout
（14）warm_start : bool, 可选, 默认False,当设置成True，使用之前的解决方法作为初始拟合，否则释放之前的解决方法。
（15）momentum : float, 默认 0.9,动量梯度下降更新，设置的范围应该0.0-1.0. 只有solver=’sgd’时使用.
（16）nesterovs_momentum : boolean, 默认True, Whether to use Nesterov’s momentum. 只有solver=’sgd’并且momentum > 0使用.
（17）early_stopping : bool, 默认False,只有solver=’sgd’或者’adam’时有效,判断当验证效果不再改善的时候是否终止训练，当为True时，自动选出10%的训练数据用于验证并在两步连续迭代改善，低于tol时终止训练。
（18）validation_fraction : float, 可选, 默认 0.1,用作早期停止验证的预留训练数据集的比例，早0-1之间，只当early_stopping=True有用
（19）beta_1 : float, 可选, 默认0.9，只有solver=’adam’时使用，估计一阶矩向量的指数衰减速率，[0,1)之间
（20）beta_2 : float, 可选, 默认0.999,只有solver=’adam’时使用估计二阶矩向量的指数衰减速率[0,1)之间
（21） epsilon : float, 可选, 默认1e-8,只有solver=’adam’时使用数值稳定值。
属性说明：

classes_:每个输出的类标签
loss_:损失函数计算出来的当前损失值
coefs_:列表中的第i个元素表示i层的权重矩阵
intercepts_:列表中第i个元素代表i+1层的偏差向量
n_iter_ ：迭代次数
n_layers_:层数
n_outputs_:输出的个数
out_activation_:输出**函数的名称。

2.代码实战
2.1手动写神经网络

import numpy as np
import matplotlib.pyplot as plt

数据初始化

np.random.seed(0)
# 每个类点的个数
N = 100
# 维度
D = 2
# 类的个数
K = 3
X = np.zeros(((N*K),D))
y = np.zeros(N*K,dtype='uint8')

构造数据集

for j in range(K):
    ix = range(N*j,N*(j+1))
    # 半径
    r = np.linspace(0,1,N)
    # theta
    t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N) * 0.2
    X[ix] = np.c_[r*np.sin(t),r*np.cos(t)]
    y[ix] = j
plt.scatter(X[:,0],X[:,1],c=y)

神经网络实战
隐藏层的大小

h = 100
W = 0.01 * np.random.randn(D,h)
b = np.zeros((1,h))
W2 = 0.01 * np.random.randn(h,K)
b2 = np.zeros((1,K))

超参数设置

# 步长
step_size = 0.001
# 正则化强度
reg = 1e-3

梯度下降

num_examples = X.shape[0]
for i in range(2001):
    # relu**函数，shape：300*100
    hidden_layer = np.maximum(0,np.dot(X,W)+b)
    # 得到第二层隐藏层的阈值，shape：300*3
    scores = np.dot(hidden_layer,W2) + b2
    exp_scores = np.exp(scores)
    probs = exp_scores / np.sum(exp_scores,axis=1,keepdims=True)

    # 计算损失值：平均交叉熵损失和正则化
    corect_logprobs = -np.log(probs[range(num_examples),y])
    data_loss = np.sum(corect_logprobs) / num_examples
    reg_loss = 0.5 * reg * np.sum(W * W) + 0.5 * reg * np.sum(W2 * W2)
    loss = data_loss + reg_loss
    if i % 100 == 0:
        print("iteration %d: loss %f" % (i, loss))

    # 计算梯度的分数
    dscores = probs
    # soft_max导数值
    dscores[range(num_examples),y] -= 1
    dscores /= num_examples

    # 反向传播
    # 首先反向更新W2和b2,relu在大于0时导数为1，所以gj=dscores，bh=hidden_layer
    dW2 = np.dot(hidden_layer.T,dscores)
    db2 = np.sum(dscores,axis=0,keepdims=True)
    # 更新W和b
    dhidden = np.dot(dscores,W2.T)
    # 经过relu求导得
    dhidden[dhidden <= 0] = 0
    dW = np.dot(X.T,dhidden)
    db = np.sum(dhidden,axis=0,keepdims=True)

    # 加正则化梯度贡献值
    dW2 += reg * W2
    dW += reg * W

    # 更新参数
    W += - step_size * dW
    b += -step_size * db
    W2 = -step_size * dW2
    b2 = -step_size * db2

查看预测精度

hidden_layer = np.maximum(0,np.dot(X,W) + b)
scores = np.dot(hidden_layer,W2) + b2
predicted_class = np.argmax(scores,axis=1)
print('training accuracy: %.2f' % (np.mean(predicted_class == y)))

输出结果：training accuracy: 0.49
查看预测效果

h = 0.02
x_min,x_max = X[:,0].min() - 1,X[:,0].max() + 1
y_min,y_max = X[:,1].min() -1,X[:,1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))
Z = np.dot(np.maximum(0, np.dot(np.c_[xx.ravel(), yy.ravel()], W) + b), W2) + b2
Z = np.argmax(Z, axis=1)
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)
plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())

神经网络实战
2.2使用MLPClassifier

from sklearn.neural_network import MLPClassifier
mlpc = MLPClassifier(hidden_layer_sizes=(100,100),
                     solver='sgd',
                     activation='relu',
                     alpha=0.001,
                     learning_rate='constant',
                     learning_rate_init=0.001,
                     max_iter=2000,
                     batch_size=300)
mlpc.fit(X,y)
print('training accuracy: %.2f' % (np.mean(mlpc.predict(X)-y)))

输出结果：training accuracy: 46.08
查看效果

Z = mlpc.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)
plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())

神经网络实战

参考文章：
https://blog.csdn.net/u011311291/article/details/78743393