1. 多维数组

用 NumPy 构建多维数组代码示例如下：

In [1]: import numpy as np

In [2]: A = np.array([1,2,3,4])

In [3]: A
Out[3]: array([1, 2, 3, 4])

In [4]: np.ndim(A)
Out[4]: 1

In [5]: A.shape
Out[5]: (4,)

In [6]: A.shape[0]
Out[6]: 4

In [7]: 

从以上可以看出：

• 数组的维数可以通过 np.ndim() 函数获得；
• 数组的形状可以通过实例变量 shape 获得；

注意，这里的 A.shape 的结果是个元组（ tuple ）。这是因为一维数组的情况下也要返回和多维数组的情况下一致的结果。

例如，二维数组时返回的是元组(4,3)，三维数组时返回的是元组(4,3,2)，因此一维数组时也同样以元组的形式返回结果。

生成一个二维数组：

In [7]: B = np.array([[1,2], [3, 4], [5, 6]])

In [8]: B
Out[8]: 
array([[1, 2],
       [3, 4],
       [5, 6]])

In [9]: B.shape
Out[9]: (3, 2)

In [11]: B.ndim
Out[11]: 2

In [12]: 

这里生成了一个 3 × 2 的数组 B 。3 × 2 的数组表示第一个维度有 3 个元素，第二个维度有 2 个元素。另外，第一个维度对应第 0 维，第二个维度对应第 1 维。二维数组也称为矩阵（ matrix ）。

2. 矩阵相乘

2 × 2 的矩阵，其乘积可以像图 3-11 这样进行计算：

矩阵的乘积是通过左边矩阵的行（横向）和右边矩阵的列（纵向）以对应元素的方式相乘后再求和而得到的。并且，运算的结果保存为新的多维数组的元素。

比如，A 的第 1 行和 B 的第 1 列的乘积结果是新数组的第 1 行第 1 列的元素，A 的第 2 行和 B 的第 1 列的结果是新数组的第 2 行第 1 列的元素。

用代码实现：

In [12]: A = np.array([[1,2], [3,4]])

In [13]: B = np.array([[5,6], [7,8]])

In [14]: A
Out[14]: 
array([[1, 2],
       [3, 4]])

In [15]: B
Out[15]: 
array([[5, 6],
       [7, 8]])

In [16]: A.dot(B)
Out[16]: 
array([[19, 22],
       [43, 50]])

In [17]: np.dot(A, B)
Out[17]: 
array([[19, 22],
       [43, 50]])

In [18]: np.dot(B, A)
Out[18]: 
array([[23, 34],
       [31, 46]])

In [19]: 

A 和 B 都是 2 × 2 的矩阵，它们的乘积可以通过 NumPy 的 np.dot() 函数计算（乘积也称为点积）。 np.dot() 接收两个 NumPy 数组作为参数，并返回数组的乘积。

这里要注意的是， np.dot(A, B) 和 np.dot(B, A) 的值可能不一样。和一般的运算（ + 或 * 等）不同，矩阵的乘积运算中，操作数（ A 、 B ）的顺序不同，结果也会不同。

注意：

• 矩阵 A 的形状是 2 × 3，矩阵 B 的形状是 3 × 2，矩阵 A 的第 1 维的元素个数（3）和矩阵 B 的第 0 维的元素个数（3）相等。如果这两个值不相等，则无法计算矩阵的乘积。
• 运算结果的矩阵 C 的形状是由矩阵 A 的行数和矩阵 B 的列数构成的。

In [19]: B = np.array([7,8])

In [20]: A = np.array([[1,2], [3, 4]])

In [22]: B
Out[22]: array([7, 8])

In [23]: A
Out[23]: 
array([[1, 2],
       [3, 4]])

In [24]: np.dot(B, A)
Out[24]: array([31, 46])

In [25]: B.shape
Out[25]: (2,)

In [26]: A.shape
Out[26]: (2, 2)

In [27]: 

In [27]: A = np.array([[1,2], [3, 4], [5,6]])

In [28]: A
Out[28]: 
array([[1, 2],
       [3, 4],
       [5, 6]])

In [29]: A.shape
Out[29]: (3, 2)

In [30]: B = np.array([7,8])

In [31]: B
Out[31]: array([7, 8])

In [32]: B.shape
Out[32]: (2,)

In [33]: np.dot(A, B)
Out[33]: array([23, 53, 83])

In [34]: 

3. 神经网络的內积

使用 NumPy 矩阵来实现神经网络。这里我们以图 3-14 中的简单神经网络为对象。这个神经网络省略了偏置和激活函数，只有权重。

实现该神经网络时，要注意 X 、 W 、 Y 形状，特别是 X 和 W 的对应维度的元素个数是否一致，这一点很重要。

In [1]: import numpy as np

In [2]: X = np.array([1,2])

In [3]: W = np.array([[1,3,5], [2,4,6]])

In [5]: X
Out[5]: array([1, 2])

In [6]: W
Out[6]: 
array([[1, 3, 5],
       [2, 4, 6]])

In [7]: Y = np.dot(X, W)

In [8]: Y
Out[8]: array([ 5, 11, 17])

In [9]: 

如上所示，使用 np.dot （多维数组的点积），可以一次性计算出 Y 的结果。这意味着，即便 Y 的元素个数为100 或 1000，也可以通过一次运算就计算出结果。

如果不使用 np.dot ，就必须单独计算 Y 的每一个元素（或者说必须使用 for 语句），非常麻烦。

参考：《深度学习入门：基于Python的理论与实现》