深度学习—从入门到抛弃（三)多层感知器MLP

1.MLP简介

正式进入MLP之前，咱们先来看看单个神经元组成的线性神经网络，由上图可知单个神经元的神经网络无法解决像XOR这样的非线性问题。这个时候MLP就进场了！

多层感知机（MLP，Multilayer Perceptron）也叫人工神经网络（ANN，Artificial Neural Network），除了输入输出层，它中心能够有多个躲藏层，最简略的MLP只含一个躲藏层，即三层的结构。

MLP最特殊的地方就在于这个躲藏层：躲藏层的激活函数例如ReLU、Tanh、sigmoid都能够给神经元引入非线性要素，使得神经网络能够任意迫临任何非线性函数，这样神经网络就能够利用到更多的非线性模型中。

上图为利用一个躲藏层的MLP解决XOR问题的比如。

2.ReLU

ReLU，正如之前所说到的，是MLP躲藏层激活函数的一种。

ReLU能够了解为一组分段函线性函数的调集，$y(x)=max(0,x+b)$，其中b为x轴的输入的负数，按照这样的规则咱们能够将上图拆分红 : $ReLU(x+1),ReLU(x),ReLU(x-1)$ 除此之外咱们需求结合原函数点和点之间的斜率来进行线性修正，即combination_weights：

 prev_slope = 0
 for i in range(n_relus):
    delta_x = x_train[i+1] - x_train[i]
    slope = (y_train[i+1] - y_train[i]) / delta_x
    combination_weights[i] = slope - prev_slope
    prev_slope = slope

最后只需将combination_weights与relu点乘，便可得出终究成果。 有关其他激活函数

3.Pytorch完成简略MLP

class Net(nn.Module):
  def __init__(self, actv, input_feature_num, hidden_unit_nums, output_feature_num):
    super(Net, self).__init__()
    self.input_feature_num = input_feature_num # save the input size for reshapinng later
    self.mlp = nn.Sequential() # 初始化MLP的一切层
    in_num = input_feature_num # initialize the temporary input feature to each layer
    for i in range(len(hidden_unit_nums)): # 创立hidden_unit_nums个躲藏层
      out_num = hidden_unit_nums[i] # 定位目前处在循环的躲藏层
      layer = nn.Linear(in_num, out_num) # 用nn.Linear界说层
      in_num = out_num # 定位下一个躲藏层，此刻input_num变为上一层output_num
      self.mlp.add_module('Linear_%d'%i, layer) # 增加到模型并命名
      actv_layer = eval('nn.%s'%actv) # 激活函数 (eval 能够将object转换为str)
      self.mlp.add_module('Activation_%d'%i, actv_layer) # 增加到模型并命名
    out_layer = nn.Linear(in_num, output_feature_num) # 创立输出层
    self.mlp.add_module('Output_Linear', out_layer) #增加到模型并命名
  def forward(self, x):
    # reshape inputs to (batch_size, input_feature_num)
    # just in case the input vector is not 2D, like an image!
    x = x.view(-1, self.input_feature_num)
    logits = self.mlp(x) # 指定了当数据经过网络时网络需求进行的核算
    return logits
input = torch.zeros((100, 2))
net = Net(actv='LeakyReLU(0.1)', input_feature_num=2, hidden_unit_nums=[100, 10, 5], output_feature_num=1).to(DEVICE)
y = net(input.to(DEVICE))

咱们这儿完成了一个有三个躲藏层，激活函数为leakyReLU的MLP。

4.MLP应用于分类使命

4.1穿插熵丢失

穿插熵是用来衡量两个概率散布的距离(也能够叫不同)。只要把p作为正确成果(如[0，0，0，1，0，0])，把q作为预测成果(如[0.1，0.1，0.4，0.1，0.2，0.1])，就能够得到两个概率散布的穿插熵了，穿插熵值越低，表明两个概率散布越靠近。 穿插熵丢失一般作为深度学习分类使命的方针函数。

4.2 数据预备

def create_spiral_dataset(K, sigma, N):
  # Initialize t, X, y
  t = torch.linspace(0, 1, N)
  X = torch.zeros(K*N, 2)
  y = torch.zeros(K*N)
  # Create data
  for k in range(K):
    X[k*N:(k+1)*N, 0] = t*(torch.sin(2*np.pi/K*(2*t+k)) + sigma*torch.randn(N))
    X[k*N:(k+1)*N, 1] = t*(torch.cos(2*np.pi/K*(2*t+k)) + sigma*torch.randn(N))
    y[k*N:(k+1)*N] = k
  return X, y
# Set parameters
K = 4
sigma = 0.16
N = 1000
set_seed(seed=SEED)
X, y = create_spiral_dataset(K, sigma, N)
plt.scatter(X[:, 0], X[:, 1], c = y)
plt.show()

4.2.1 Pytorch练习集测验集随机划分

1.shuffle torch.randperm(N) ：回来一个0到n-1的数组

def shuffle_and_split_data(X, y, seed):
  # set seed for reproducibility
  torch.manual_seed(seed)
  # Number of samples
  N = X.shape[0]
  # Shuffle data
  shuffled_indices = torch.randperm(N)   #回来一个0到n-1的数组
  X = X[shuffled_indices]
  y = y[shuffled_indices]
  # Split data into train/test
  test_size = int(0.2 * N)    # 20%作为测验集
  X_test = X[:test_size]
  y_test = y[:test_size]
  X_train = X[test_size:]
  y_train = y[test_size:]
  return X_test, y_test, X_train, y_train

4.3 练习模型

def train_test_classification(net, criterion, optimizer, train_loader,
                              test_loader, num_epochs=1, verbose=True,
                              training_plot=False, device='cpu'):
  net.train()
  training_losses = []
  for epoch in tqdm(range(num_epochs)):  # loop over the dataset multiple times
    running_loss = 0.0
    for i, data in enumerate(train_loader, 0):
      # get the inputs; data is a list of [inputs, labels]
      inputs, labels = data
      inputs = inputs.to(device).float()
      labels = labels.to(device).long()
      ###梯度下降
      # zero the parameter gradients
      optimizer.zero_grad()
      # forward + backward + optimize
      outputs = net(inputs)
      loss = criterion(outputs, labels)
      loss.backward()
      optimizer.step()
      ###梯度下降
      # print statistics
      if verbose:
        training_losses += [loss.item()]
  net.eval()
  def test(data_loader):
    correct = 0
    total = 0
    for data in data_loader:
      inputs, labels = data
      inputs = inputs.to(device).float()
      labels = labels.to(device).long()
      outputs = net(inputs)
      _, predicted = torch.max(outputs, 1)
      total += labels.size(0)
      correct += (predicted == labels).sum().item()
    acc = 100 * correct / total
    return total, acc
  train_total, train_acc = test(train_loader)
  test_total, test_acc = test(test_loader)
  if verbose:
    print(f"Accuracy on the {train_total} training samples: {train_acc:0.2f}")
    print(f"Accuracy on the {test_total} testing samples: {test_acc:0.2f}")
  if training_plot:
    plt.plot(training_losses)
    plt.xlabel('Batch')
    plt.ylabel('Training loss')
    plt.show()
  return train_acc, test_acc

以上为构建train_test_classification功用，包含了关于练习数据权重的梯度下降，以及每一epoch的丢失改变的核算。

set_seed(SEED)
net = Net('ReLU()', X_train.shape[1], [128], K).to(DEVICE)#用的咱们之前界说的简略MLP
criterion = nn.CrossEntropyLoss()#方针函数为穿插熵丢失
optimizer = optim.Adam(net.parameters(), lr=1e-3)#优化器为Adam优化器
num_epochs = 100#练习epoch为100
_, _ = train_test_classification(net, criterion, optimizer, train_loader,
                                 test_loader, num_epochs=num_epochs,
                                 training_plot=True, device=DEVICE)

5. MLP宽度 vs 深度

1.MLP的深度： 神经网络的深度，之前也说过，指的就是网络中的层数，放在MLP里就是指躲藏层的数量。那么躲藏层的数量是不是越多越有利于咱们解决问题呢？

从上图中咱们不难看出跟着咱们网络中权重的方差增大，网络中数据的混乱程度也越大，而这种混乱状态跟着网络深度的增加而变得明显。换言之，增大的权重方差也就意味着x(w,b)>1x(\delta_w,\delta_b)>1x(w​,b​)>1也就是说在梯度下降的反向传播过程中可能会形成梯度爆炸。同样x(w,b)<1x(\delta_w,\delta_b)<1x(w​,b​)<1会形成梯度消失

2.MLP的宽度 神经网络的宽度是指每层中神经元的数量，浅层神经网络能够经过指数级增加自己每层神经元的个数来达到和深层神经网络相同的作用，但是模型的可学习性通常会大打折扣，因而一般不会用单纯的浅层神经网络。

5.1 MLP深度与模型作用的关系

结合上文说到的关于深度的了解咱们能够发现关于深层MLP而言，躲藏层的数量不是越多越好，存在一个最优躲藏层数。

5.2 MLP宽度与模型作用的关系

在这儿咱们先树立一个单层神经网络，为了增加网络的宽度，咱们挑选在网络中增加多项式特征，随后练习该网络，与4.3顶用MLP练习后的成果作比照。

能够看出浅层神经网络的分类作用较差，关于相对简略的分类使命都如此，能够幻想到如果是实在事例的准确率会有多低。

==欢迎我们重视公众号奇趣多多一同交流！==

深度学习—从入门到抛弃(一)pytorch根底 深度学习—从入门到抛弃（二）简略线性神经网络