全文共2875字，预计学习时长20分钟或更长

Photo by Alina Grubnyak on Unsplash

如果你是个对神经网络有所了解的初级数据科学家，或是个对深度学习略有耳闻的机器学习爱好者，一定要读一读这篇文章。本文介绍了使用NumPy从头搭建神经网络的9个步骤，即从数据预处理到反向传播这一“必经之路”。

对机器学习、人工神经网络、Python语法和编程逻辑有些基本理解最好，（但这也不是必需条件，你可以边读边学）。

1. 初始化

导入NumPy。

import numpy as npnp.random.seed(42) # for reproducibility

2. 生成数据

深度学习需要大量的数据。网上有很多干净的数据集，但为了使用简单，会选择生成自己的数据集，即输入a和b，输出a + b，a-b和| a-b |。这样可以生成10,000个基准点。

X_num_row, X_num_col = [2, 10000] # Row is no. of feature, col is no.of datum pointsX_raw = np.random.rand(X_num_row,X_num_col) * 100y_raw = np.concatenate(([(X_raw[0,:] + X_raw[1,:])], [(X_raw[0,:] -X_raw[1,:])], np.abs([(X_raw[0,:] - X_raw[1,:])])))# for input a and b, output is a+b; a-b and |a-b|y_num_row, y_num_col = y_raw.shape

Photo by Kristopher Roller on Unsplash

3. 分割测试集与训练集

将数据集划分为训练集（占70％）和测试集（30％）两个子集。训练集只用于神经网络的调整，测试集则是在训练完成后用来测试性能。

train_ratio = 0.7num_train_datum = int(train_ratio*X_num_col)X_raw_train = X_raw[:,0:num_train_datum]X_raw_test = X_raw[:,num_train_datum:] y_raw_train = y_raw[:,0:num_train_datum]y_raw_test = y_raw[:,num_train_datum:]

4. 数据标准化

训练集中的数据已进行了标准化处理，所以各标准化特征都呈零均值、单位方差的分布。然后可以将上述过程产生的定标器应用于测试集。

class scaler: def __init__(self, mean,std): self.mean = mean self.std = std def get_scaler(row): mean = np.mean(row) std = np.std(row) return scaler(mean, std) def standardize(data, scaler): return (data -scaler.mean) / scaler.std def unstandardize(data, scaler): return (data * scaler.std) +scaler.mean  # Construct scalers from training set X_scalers = [get_scaler(X_raw_train[row,:]) for row inrange(X_num_row)]X_train = np.array([standardize(X_raw_train[row,:], X_scalers[row]) forrow in range(X_num_row)]) y_scalers = [get_scaler(y_raw_train[row,:]) for row inrange(y_num_row)]y_train = np.array([standardize(y_raw_train[row,:], y_scalers[row]) forrow in range(y_num_row)])  # Apply those scalers to testing set X_test = np.array([standardize(X_raw_test[row,:], X_scalers[row]) forrow in range(X_num_row)])y_test = np.array([standardize(y_raw_test[row,:], y_scalers[row]) forrow in range(y_num_row)])  # Check if data has been standardized print([X_train[row,:].mean() for row in range(X_num_row)]) # should beclose to zeroprint([X_train[row,:].std() for row in range(X_num_row)]) # should be close to one print([y_train[row,:].mean() for row in range(y_num_row)]) # should beclose to zeroprint([y_train[row,:].std() for row in range(y_num_row)]) # should be close to one

因此，定标器不含有测试集的任何信息。这也是在对神经网络进行调整前我们所希望的结果。

至此，历经上述4个步骤后，数据预处理就完成了。

5. 搭建神经网络

Photo by freestocks.org on Unsplash

使用Python中的类对‘层’进行对象化。每个层（输入层除外）具有权重矩阵W、偏置矢量b和激活函数。各个层都将被附加到名为neural_net的列表中，从而得到全连接的神经网络。

class layer: def __init__(self,layer_index, is_output, input_dim, output_dim, activation): self.layer_index = layer_index# zero indicates input layer self.is_output =is_output # true indicates output layer, false otherwise self.input_dim =input_dim self.output_dim =output_dim self.activation =activation  # the multiplicationconstant is sorta arbitrary if layer_index != 0: self.W = np.random.randn(output_dim,input_dim) * np.sqrt(2/input_dim) self.b =np.random.randn(output_dim, 1) * np.sqrt(2/input_dim)  # Change layers_dim to configure your own neural net! layers_dim = [X_num_row, 4, 4, y_num_row] # input layer --- hiddenlayers --- output layersneural_net = [] # Construct the net layer by layerfor layer_index in range(len(layers_dim)): if layer_index == 0: # ifinput layer neural_net.append(layer(layer_index, False, 0, layers_dim[layer_index],'irrelevant')) elif layer_index+1 ==len(layers_dim): # if output layer neural_net.append(layer(layer_index, True, layers_dim[layer_index-1],layers_dim[layer_index], activation='linear')) else: neural_net.append(layer(layer_index,False, layers_dim[layer_index-1], layers_dim[layer_index], activation='relu'))  # Simple check on overfitting pred_n_param =sum([(layers_dim[layer_index]+1)*layers_dim[layer_index+1] for layer_index inrange(len(layers_dim)-1)])act_n_param = sum([neural_net[layer_index].W.size +neural_net[layer_index].b.size for layer_index in range(1,len(layers_dim))])print(f'Predicted number of hyperparameters: {pred_n_param}')print(f'Actual number of hyperparameters: {act_n_param}')print(f'Number of data: {X_num_col}') if act_n_param >= X_num_col:raise Exception('It willoverfit.')

最后，使用下列公式，通过计数对超参数的数量进行完整性检查。可用的基准数量应该多于超参数数量，否则就会过度拟合。

N ^ l是第l层的超参数个数，L是层数（不包括输入层）。

6. 前向传播

在给定一组权重和偏差的情况下，定义一个前向传播的函数。各层之间的连接以矩阵形式定义为：

σ 是element-wise 激活函数，上标T表示矩阵的转置。

def activation(input_, act_func): if act_func == 'relu': return np.maximum(input_,np.zeros(input_.shape)) elif act_func == 'linear': return input_ else: raiseException('Activation function is not defined.')  def forward_prop(input_vec, layers_dim=layers_dim,neural_net=neural_net): neural_net[0].A = input_vec #Define A in input layer for for-loop convenience for layer_index inrange(1,len(layers_dim)): # W,b,Z,A are undefined in input layer neural_net[layer_index].Z= np.add(np.dot(neural_net[layer_index].W, neural_net[layer_index-1].A),neural_net[layer_index].b) neural_net[layer_index].A =activation(neural_net[layer_index].Z, neural_net[layer_index].activation)return neural_net[layer_index].A 

激活函数是逐个定义的。 ReLU实现为a→max（a，0），而sigmoid函数应返回a → 1/(1+e^(-a))，其实现就留给读者作为练习吧。

Photo by Holger Link on Unsplash

7. 反向传播

这是最棘手的一步，很多人都不明白。在定义了用于评估性能的损失度量函数后，就想看一看如果扰乱每个权重或偏差，损失度量会如何变化。即每个权重和偏差对损失度量的敏感程度如何。

def get_loss(y, y_hat, metric='mse'): if metric == 'mse': individual_loss = 0.5 *(y_hat - y) ** 2 returnnp.mean([np.linalg.norm(individual_loss[:,col], 2) for col inrange(individual_loss.shape[1])]) else: raise Exception('Loss metric is notdefined.') def get_dZ_from_loss(y, y_hat, metric): if metric == 'mse': return y_hat - y else: raise Exception('Lossmetric is not defined.') def get_dactivation(A, act_func): if act_func == 'relu': returnnp.maximum(np.sign(A), np.zeros(A.shape)) # 1 if backward input >0, 0 otherwise;then diaganolize elif act_func == 'linear': return np.ones(A.shape) else: raiseException('Activation function is not defined.')  def backward_prop(y, y_hat, metric='mse', layers_dim=layers_dim,neural_net=neural_net, num_train_datum=num_train_datum): for layer_index inrange(len(layers_dim)-1,0,-1): if layer_index+1 ==len(layers_dim): # if output layer dZ =get_dZ_from_loss(y, y_hat, metric) else: dZ = np.multiply(np.dot(neural_net[layer_index+1].W.T,dZ), get_dactivation(neural_net[layer_index].A,neural_net[layer_index].activation)) dW = np.dot(dZ,neural_net[layer_index-1].A.T) / num_train_datum db = np.sum(dZ, axis=1,keepdims=True) / num_train_datum  neural_net[layer_index].dW = dW neural_net[layer_index].db = db

这通过偏导数∂e/∂W（在代码中表示为dW）和∂e/∂b（在代码中表示为db）来表示，还可以通过分析计算。

这些反向传播方程都假设只有y这一个比较数据。每次迭代的性能仅受一个基准点的影响，所以梯度更新过程会非常嘈杂。为减少噪声，可以使用多个基准。其中∂W（y_1，y_2，...）是∂W（y_1），∂W（y_2），...的平均值，∂b也一样。这些在方程中都没有显示出来，但在下面的代码中可以实现。

8. 迭代优化

现在我们有了训练神经网络的全部要素。

知道权重和偏差的敏感性后，可使用以下更新规则通过梯度下降来迭代最小化（因此用减号表示）损失度量：

W = W - learning_rate * ∂W

b = b - learning_rate * ∂b

Photo by Rostyslav Savchyn on Unsplash

learning_rate = 0.01max_epoch = 100000for epoch in range(1,max_epoch+1): y_hat_train =forward_prop(X_train) # update y_hat backward_prop(y_train,y_hat_train) # update (dW,db) for layer_index inrange(1,len(layers_dim)): # update(W,b) neural_net[layer_index].W= neural_net[layer_index].W - learning_rate * neural_net[layer_index].dW neural_net[layer_index].b= neural_net[layer_index].b - learning_rate * neural_net[layer_index].db if epoch % 100000 == 0: print(f'{get_loss(y_train, y_hat_train):.4f}')

9. 测试

如果测试损失没有超出训练损失太多，该模型就可以进行推广。为了解模型的执行情况，我们还制作了一些测试用例。

print(get_loss(y_test, forward_prop(X_test))) def predict(X_raw_any): X_any =np.array([standardize(X_raw_any[row,:], X_scalers[row]) for row inrange(X_num_row)]) y_hat = forward_prop(X_any) y_hat_any =np.array([unstandardize(y_hat[row,:], y_scalers[row]) for row in range(y_num_row)]) return y_hat_any predict(np.array([[30,70],[70,30],[3,5],[888,122]]).T)

这就是使用NumPy从头搭建神经网络的9个步骤。本文所讲述的并非构建和训练神经网络最有效的方法，在未来还有很大的改进空间。有人可能用过一些高级框架（如TensorFlow、PyTorch或Keras）搭建神经网络。不过，仅用低级库进行搭建可以让我们真正弄明白这一神秘科学背后的原理。

留言 点赞 关注

我们一起分享AI学习与发展的干货

欢迎关注全平台AI垂类自媒体 “读芯术”