Numpy简介
导入 NumPy
在导入 NumPy 库时，大多数情况下（包括这里）你会看到的一个约定，是将其命名为 np，像这样：
import numpy as np
现在，你可以给函数和类型名称加上前缀 “np” 来使用该库，你会在下面的示例中看到。
不过你仍然可以在 ndarray、NumPy 标量和普通的 Python 标量之间执行数学运算，你将在元素级数学运算课程中看到。你可以通过检查数组的 shape属性来查看数组的形状。你可以执行代码：
s.shape
它会打印出结果，即一对空括号 ()。 这表示它的维度为零，是标量。
即使标量位于数组中，你仍然可以像正常标量一样使用它们。你可以键入：
x = s + 3
x 现在会等于 8。如果你检查 x 的类型，可能会发现它是 numpy.int64，因为它在使用 NumPy 类型，而不是 Python。
顺便说一下，即使标量类型也支持大部分的数组函数。所以你可以调用 x.shape，它会返回 ()，因为它的维度为零，即使它不是数组。如果你使用普通的 Python 标量来尝试，就会收到一个错误。
Vectors
要创建一个向量，你可以将 Python 列表传递给 array
函数，像这样：
v = np.array([1,2,3])
Matrices
你使用 NumPy 的 array 函数创建矩阵，跟创建向量一样。但是，这次你不只是传入一个列表，而是提供列表的列表，其中每个列表代表一行。所以要创建一个包含数字 1 到 9 的 3x3 矩阵，你可以这样做：
m = np.array([[1,2,3], [4,5,6], [7,8,9]])
检查它的 shape属性将返回元组 (3, 3)，表示它有两个维度，每个的长度为 3。你可以像向量一样访问矩阵的元素，但要使用额外的索引值。所以要在上面的矩阵中找到数字 6，你可以访问 m[1][2]。
张量
张量与向量和矩阵一样，但它们可以有更多的维度。例如，要创建一个 3x3x2x1 的张量，你可以这样做：
t = np.array([[[[1],[2]],[[3],[4]],[[5],[6]]],[[[7],[8]],\ [[9],[10]],[[11],[12]]],[[[13],[14]],[[15],[16]],[[17],[17]]]])
而t.shape 会返回 (3, 3, 2, 1)。
你可以像在矩阵中一样访问项目，但需要使用更多的索引。所以 t[2][1][1][0]将返回 16。
这些行创建一个切片，查看 v的所有项目，但要求 NumPy 为相关轴添加大小为 1 的新维度。你现在看起来可能觉得很奇怪，但它是一种常见的技术，所以了解它没什么坏处。
Numpy元素级运算
Python 中的方式
假设你有一个数字列表，你想向列表中的每一项加上 5 。如果没有 NumPy，你可以像下面这样做：
values = [1,2,3,4,5]
for i in range(len(values)):
values[i] += 5
# 现在的值为 [6,7,8,9,10]
这是讲得通的，但是你要编写很多代码，而且因为它是纯 Python，所以运行的很慢。
NumPy 中的方式
在 NumPy 中，我们可以这么做：
values = [1,2,3,4,5]
values = np.array(values) + 5
# 现在值是包含 [6,7,8,9,10] 的一个 ndarray
创建该数组可能看起来很奇怪，但通常你总是要将数据存储在 ndarray 中的。所以如果你已经有一个名为 values的 ndarray，你可以这么做：
values += 5
我们应该指出，NumPy 实际上有用于添加、乘法等的函数。但它也支持使用标准的数学运算符。 所以以下两行是等价的：
x = np.multiply(some_array, 5)
x = some_array * 5
我们通常会使用运算符而不是函数，因为它们更方便键入，也更容易阅读，不过这只是个人偏好。
再看一个使用标量和 ndarrays 进行运算的例子。假设你有一个矩阵 m 并且你想重用它，但首先你需要将其所有值设为零。这很简单，只需给它乘以零，并将结果分配回矩阵就行了，如下所示：
m *= 0
# 现在 m 中的每个元素都是 0，无论它有多少维度
元素级矩阵运算
与标量和矩阵一起使用的相同函数和运算符也适用于其他维度。你只需要确保执行运算的项目具有兼容的形状。
假设你想得到矩阵的平方值。方法是 x = m * m（或者如果你要将值分配回 m，则是 m *= m）
这是可以运作的，因为它是两个形状相同的矩阵之间的元素乘法。（在这个例子中，它们的形状相同，是因为它们实际上是相同的对象。）
看一个示例：
a = np.array([[1,3],[5,7]])
a
# 显示以下结果：
# array([[1, 3],
# [5, 7]])
b = np.array([[2,4],[6,8]])
b
# 显示以下结果：
# array([[2, 4],
# [6, 8]])
a + b
# 显示以下结果：
# array([[ 3, 7],
# [11, 15]])
如果您尝试使用不兼容的形状，就像视频中的另一个示例一样，你会收到一个错误：
a = np.array([[1,3],[5,7]])
a
# 显示以下结果：
# array([[1, 3],
# [5, 7]])
c = np.array([[2,3,6],[4,5,9],[1,8,7]])
c
# 显示以下结果：
# array([[2, 3, 6],
# [4, 5, 9],
# [1, 8, 7]])
a.shape
# 显示以下结果：
# (2, 2)
c.shape
# 显示以下结果：
# (3, 3)
a + c
# 显示以下结果：
# ValueError: operands could not be broadcast together with shapes (2,2) (3,3)
你会在后面的介绍中详细了解“不能一起广播”的意义，现在只需注意这两种形状是不同的，因此我们无法执行元素级运算。
Numpy矩阵乘法
元素级乘法
你已看过了一些元素级乘法。你可以使用multiply函数或 *运算符来实现。回顾一下，它看起来是这样的，实现元素对应位置相乘：
m = np.array([[1,2,3],[4,5,6]])
m
# 显示以下结果：
# array([[1, 2, 3],
# [4, 5, 6]])
n = m * 0.25
n
# 显示以下结果：
# array([[ 0.25, 0.5 , 0.75],
# [ 1. , 1.25, 1.5 ]])
m * n
# 显示以下结果：
# array([[ 0.25, 1. , 2.25],
# [ 4. , 6.25, 9. ]])
np.multiply(m, n)
# 相当于 m * n
# 显示以下结果：
# array([[ 0.25, 1. , 2.25],
# [ 4. , 6.25, 9. ]])
矩阵乘积
要获得矩阵乘积，你可以使用 NumPy 的 matmul 函数。
如果你有兼容的形状，那就像这样简单：
a = np.array([[1,2,3,4],[5,6,7,8]])
a
# 显示以下结果：
# array([[1, 2, 3, 4],
# [5, 6, 7, 8]])
a.shape
# 显示以下结果：
# (2, 4)
b = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
b
# 显示以下结果：
# array([[ 1, 2, 3],
# [ 4, 5, 6],
# [ 7, 8, 9],
# [10, 11, 12]])
b.shape
# 显示以下结果：
# (4, 3)
c = np.matmul(a, b)
c
# 显示以下结果：
# array([[ 70, 80, 90],
# [158, 184, 210]])
c.shape
# 显示以下结果：
# (2, 3)
如果您的矩阵具有不兼容的形状，则会出现以下错误：
np.matmul(b, a)
# 显示以下错误：
# ValueError: shapes (4,3) and (2,4) not aligned: 3 (dim 1) != 2 (dim 0)
a = np.array([[1,2],[3,4]])
a
# 显示以下结果：
# array([[1, 2],
# [3, 4]])
np.dot(a,a)
# 显示以下结果：
# array([[ 7, 10],
# [15, 22]])
a.dot(a)
# 你可以直接对 `ndarray` 调用 `dot`
# 显示以下结果：
# array([[ 7, 10],
# [15, 22]])
np.matmul(a,a)
# array([[ 7, 10],
# [15, 22]])
矩阵转置
转置
在 NumPy 中获得矩阵的转置非常容易。只需访问其“T”属性即可。有一个 transpose() 函数也可以返回同样的结果，但是你很少看到它在任何地方使用，因为输入 T 的方法要简单得多。 :)
例如：
m = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
m
# 显示以下结果：
# array([[ 1, 2, 3, 4],
# [ 5, 6, 7, 8],
# [ 9, 10, 11, 12]])
m.T
# 显示以下结果：
# array([[ 1, 5, 9],
# [ 2, 6, 10],
# [ 3, 7, 11],
# [ 4, 8, 12]])
NumPy 在进行转置时不实际移动内存中的任何数据——只是改变对原始矩阵的索引方式，所以是非常高效的。
修改转置矩阵会改变原始矩阵的值
但是，这也意味着你也要特别注意修改对象的方式，因为它们共享相同的数据。例如，对于上面同一个矩阵 m，我们来创建一个新的变量 m_t来存储 m的转置。然后看看如果我们修改 m_t中的值，会发生什么：
m_t = m.T
m_t[3][1] = 200
m_t
# 显示以下结果：
# array([[ 1, 5, 9],
# [ 2, 6, 10],
# [ 3, 7, 11],
# [ 4, 200, 12]])
m
# 显示以下结果：
# array([[ 1, 2, 3, 4],
# [ 5, 6, 7, 200],
# [ 9, 10, 11, 12]])
注意它是如何修改转置和原始矩阵的！这是因为它们共享相同的数据副本。所以记住，将转置视为矩阵的不同视图，而不是完全不同的矩阵。
实际用例
假设你有以下两个矩阵，称为“inputs”和“weights”，
inputs = np.array([[-0.27, 0.45, 0.64, 0.31]])
inputs
# 显示以下结果：
# array([[-0.27, 0.45, 0.64, 0.31]])
inputs.shape
# 显示以下结果：
# (1, 4)
weights = np.array([[0.02, 0.001, -0.03, 0.036], \
[0.04, -0.003, 0.025, 0.009], [0.012, -0.045, 0.28, -0.067]])
weights
# 显示以下结果：
# array([[ 0.02 , 0.001, -0.03 , 0.036],
# [ 0.04 , -0.003, 0.025, 0.009],
# [ 0.012, -0.045, 0.28 , -0.067]])
weights.shape
# displays the following result:
# (3, 4)
我在这里不会讲解它们的用途，因为你稍后都会学到，但是最终你会想要获得这两个矩阵的矩阵乘积。
如果你像现在这样去尝试，会获得一个错误：
np.matmul(inputs, weights)
# 显示以下错误：
# ValueError: shapes (1,4) and (3,4) not aligned: 4 (dim 1) != 3 (dim 0)
如果你上了矩阵乘法课，那应该见过这个错误。它报告说形状不兼容，因为左边矩阵的列数 4 不等于右边矩阵的行数 3。
所以有问题，但是注意，如果你获取 weights 矩阵的转置，它会：
np.matmul(inputs, weights.T)
# 显示以下结果：
# array([[-0.01299, 0.00664, 0.13494]])
如果你获取 inputs 的转置，并调换它们的顺序也可以，就像我们在视频中展示的那样：
np.matmul(weights, inputs.T)
# 显示以下结果：
# array([[-0.01299],#
# [ 0.00664],
# [ 0.13494]])
这两个答案是彼此的转置，所以你使用的乘法只取决于你想要的输出的形状。