# Number of records and input units
# 数据点数量以及每个数据点有多少输入节点
n_records, n_inputs = features.shape
# Number of hidden units
# 隐藏层节点个数
n_hidden = 2
weights_input_to_hidden = np.random.normal(0, n_inputs**-0.5, size=(n_inputs, n_hidden))

这样创建了一个名为 weights_input_to_hidden 的二维数组，维度是 n_inputs 乘 n_hidden。记住，输入到隐藏节点是所有输入乘以隐藏节点权重的和。所以对每一个隐藏层节点 h_jhj​，我们需要计算：

为了实现这点，我们需要运用矩阵乘法，如果你对线性代数的知识有些模糊，我们建议你看下之前先修部分的资料。这里你只需要了解矩阵与向量如何相乘。

在这里，我们把输入（一个行向量）与权重相乘。要实现这个，要把输入点乘（内积）以权重矩阵的每一列。例如要计算到第一个隐藏节点 j = 1的输入，你需要把这个输入与权重矩阵的第一列做点乘：

hidden_inputs = np.dot(inputs, weights_input_to_hidden)

你可以定义你的权重矩阵的维度是 n_hidden 乘 n_inputs 然后与列向量形式的输入相乘：

注意：

这里权重的索引在上图中做了改变，与之前图片并不匹配。这是因为，在矩阵标注时行索引永远在列索引之前，所以用之前的方法做标识会引起误导。你只需要了解这跟之前的权重矩阵是一样的，只是做了转换，之前的第一列现在是第一行，之前的第二列现在是第二行。如果用之前的标记，权重矩阵是下面这个样子的：

切记，上面标注方式是不正确的，这里只是为了让你更清楚这个矩阵如何跟之前神经网络的权重匹配。

矩阵相乘最重要的是他们的维度相匹配。因为它们在点乘时需要有相同数量的元素。在第一个例子中，输入向量有三列，权重矩阵有三行；第二个例子中，权重矩阵有三列，输入向量有三行。如果维度不匹配，你会得到：

# Same weights and features as above, but swapped the order
hidden_inputs = np.dot(weights_input_to_hidden, features)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-11-1bfa0f615c45> in <module>()
----> 1 hidden_in = np.dot(weights_input_to_hidden, X)ValueError: shapes (3,2) and (3,) not aligned: 2 (dim 1) != 3 (dim 0)

3x2 的矩阵跟 3 个元素的数组是没法相乘的。因为矩阵中的两列与数组中的元素个数并不匹配。能够相乘的矩阵如下：

这里的规则是，如果是数组在左边，数组的元素个数必须与右边矩阵的行数一样。如果矩阵在左边，那么矩阵的列数，需要与右边向量的行数匹配。

构建一个列向量

看上面的介绍，你有时会需要一个列向量，尽管 NumPy 默认是行向量。你可以用 arr.T 来对数组进行转置，但对一维数组来说，转置还是行向量。所以你可以用 arr[:,None] 来创建一个列向量：

print(features)
> array([ 0.49671415, -0.1382643 ,  0.64768854])print(features.T)
> array([ 0.49671415, -0.1382643 ,  0.64768854])print(features[:, None])
> array([[ 0.49671415],[-0.1382643 ],[ 0.64768854]])

当然，你可以创建一个二维数组，然后用 arr.T 得到列向量。

np.array(features, ndmin=2)
> array([[ 0.49671415, -0.1382643 ,  0.64768854]])np.array(features, ndmin=2).T
> array([[ 0.49671415],[-0.1382643 ],[ 0.64768854]])

import numpy as npdef sigmoid(x):"""Calculate sigmoid"""return 1/(1+np.exp(-x))# Network size
N_input = 4
N_hidden = 3
N_output = 2np.random.seed(42)
# Make some fake data
X = np.random.randn(4)weights_input_to_hidden = np.random.normal(0, scale=0.1, size=(N_input, N_hidden))
weights_hidden_to_output = np.random.normal(0, scale=0.1, size=(N_hidden, N_output))# TODO: Make a forward pass through the networkhidden_layer_in = np.dot(X, weights_input_to_hidden)
hidden_layer_out = sigmoid(hidden_layer_in)print('Hidden-layer Output:')
print(hidden_layer_out)output_layer_in = np.dot(hidden_layer_out, weights_hidden_to_output)
output_layer_out = sigmoid(output_layer_in)print('Output-layer Output:')
print(output_layer_out)