到目前為止，我們可以將數據集加載到張量中，并使用基本的數學運算來操縱這些張量。要開始構建復雜的模型，我們還需要一些線性代數工具。本節簡要介紹了最基本的概念，從標量算術開始，一直到矩陣乘法。

import torch

from mxnet import np, npx

npx.set_np()

from jax import numpy as jnp

import tensorflow as tf

2.3.1. 標量

大多數日常數學都是一次處理一個數字。正式地，我們稱這些值為標量。例如，帕洛阿爾托的氣溫適中72華氏度。如果您想將溫度轉換為攝氏度，您可以計算表達式c=59(f?32)， 環境f到 72. 在這個等式中，值5,9， 和 32是標量。變量c和f代表未知標量。

我們用普通的小寫字母表示標量（例如，x, y， 和z) 和所有（連續）實值標量的空間 R. 為了方便起見，我們將跳過嚴格的空間定義。請記住這個表達式x∈R是一種正式的說法 x是一個實值標量。符號∈（發音為“in”）表示集合中的成員。例如， x,y∈{0,1}表示x和y是只能取值的變量0或者1.

標量被實現為僅包含一個元素的張量。下面，我們分配兩個標量并執行熟悉的加法、乘法、除法和求冪運算。

x = torch.tensor(3.0)
y = torch.tensor(2.0)

x + y, x * y, x / y, x**y

(tensor(5.), tensor(6.), tensor(1.5000), tensor(9.))

x = np.array(3.0)
y = np.array(2.0)

x + y, x * y, x / y, x ** y

(array(5.), array(6.), array(1.5), array(9.))

x = jnp.array(3.0)
y = jnp.array(2.0)

x + y, x * y, x / y, x**y

No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)

(Array(5., dtype=float32, weak_type=True),
 Array(6., dtype=float32, weak_type=True),
 Array(1.5, dtype=float32, weak_type=True),
 Array(9., dtype=float32, weak_type=True))

x = tf.constant(3.0)
y = tf.constant(2.0)

x + y, x * y, x / y, x**y

(,
 ,
 ,
 )

2.3.2. 載體

出于我們的目的，您可以將向量視為固定長度的標量數組。與它們的代碼對應物一樣，我們將這些值稱為 向量的元素（同義詞包括條目和組件). 當向量表示現實世界數據集中的示例時，它們的值具有一定的現實意義。例如，如果我們正在訓練一個模型來預測貸款違約的風險，我們可能會將每個申請人與一個向量相關聯，該向量的分量對應于他們的收入、工作年限或以前的違約次數等數量。如果我們正在研究心臟病發作風險，每個向量可能代表一個患者，其組成部分可能對應于他們最近的生命體征、膽固醇水平、每天的運動分鐘數等。我們用粗體小寫字母表示向量，（例如，x, y， 和z).

向量實現為1st-階張量。通常，此類張量可以具有任意長度，受內存限制。注意：在 Python 中，與大多數編程語言一樣，向量索引從0，也稱為從零開始的索引，而在線性代數中下標開始于1（基于一個的索引）。

x = torch.arange(3)
x

tensor([0, 1, 2])

x = np.arange(3)
x

array([0., 1., 2.])

x = jnp.arange(3)
x

Array([0, 1, 2], dtype=int32)

x = tf.range(3)
x

我們可以使用下標來引用向量的元素。例如，x2表示的第二個元素x. 自從x2是標量，我們不加粗。默認情況下，我們通過垂直堆疊元素來可視化向量。

(2.3.1)x=[x1?xn],

這里x1,…,xn是向量的元素。稍后，我們將區分這種列向量和元素水平堆疊的行向量。回想一下，我們通過索引訪問張量的元素。

x[2]

tensor(2)

x[2]

array(2.)

x[2]

Array(2, dtype=int32)

x[2]

表示一個向量包含n元素，我們寫 x∈Rn. 正式地，我們稱n向量的維 數。在代碼中，這對應于張量的長度，可通過 Python 的內置len函數訪問。

len(x)

3

len(x)

3

len(x)

3

len(x)

3

我們還可以通過屬性訪問長度shape。形狀是一個元組，指示張量沿每個軸的長度。只有一個軸的張量具有只有一個元素的形狀。

x.shape

torch.Size([3])

x.shape

(3,)

x.shape

(3,)

x.shape

TensorShape([3])

通常，“維度”這個詞會被過度表示為軸的數量和沿特定軸的長度。為了避免這種混淆，我們使用順序來指代軸的數量，使用維度 專門指代組件的數量。

2.3.3. 矩陣

就像標量一樣0th-階張量和向量是1st-階張量，矩陣是 2nd-階張量。我們用粗體大寫字母表示矩陣（例如，X,Y， 和 Z), 并用兩個軸的張量在代碼中表示它們。表達方式A∈Rm×n 表示一個矩陣A包含m×n 實值標量，排列為m行和n列。什么時候m=n，我們說矩陣是方陣。在視覺上，我們可以將任何矩陣表示為表格。為了引用單個元素，我們對行和列索引都下標，例如，aij是屬于的值A的ith行和jth柱子：

(2.3.2)A=[a11a12?a1na21a22?a2n????am1am2?amn].

在代碼中，我們表示一個矩陣 A∈Rm×n通過一個 2nd-具有形狀的階張量 (m,n). 我們可以轉換任何適當大小的m×n張量變成 m×n通過將所需的形狀傳遞給矩陣reshape：

A = torch.arange(6).reshape(3, 2)
A

tensor([[0, 1],
    [2, 3],
    [4, 5]])

A = np.arange(6).reshape(3, 2)
A

array([[0., 1.],
    [2., 3.],
    [4., 5.]])

A = jnp.arange(6).reshape(3, 2)
A

Array([[0, 1],
    [2, 3],
    [4, 5]], dtype=int32)

A = tf.reshape(tf.range(6), (3, 2))
A

有時，我們想翻轉坐標軸。當我們交換矩陣的行和列時，結果稱為轉置。形式上，我們表示一個矩陣A的轉置A?而如果B=A?， 然后bij=aji 對全部i和j. 因此，轉置一個 m×n矩陣是一個n×m矩陣：

(2.3.3)A?=[a11a21…am1a12a22…am2????a1na2n…amn].

在代碼中，我們可以訪問任何矩陣的轉置，如下所示：

A.T

tensor([[0, 2, 4],
    [1, 3, 5]])

A.T

array([[0., 2., 4.],
    [1., 3., 5.]])

A.T

Array([[0, 2, 4],
    [1, 3, 5]], dtype=int32)

tf.transpose(A)

對稱矩陣是方陣的子集，它們等于它們自己的轉置：A=A?. 以下矩陣是對稱的：

A = torch.tensor([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
A == A.T

tensor([[True, True, True],
    [True, True, True],
    [True, True, True]])

A = np.array([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
A == A.T

array([[ True, True, True],
    [ True, True, True],
    [ True, True, True]])

A = jnp.array([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
A == A.T

Array([[ True, True, True],
    [ True, True, True],
    [ True, True, True]], dtype=bool)

A = tf.constant([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
A == tf.transpose(A)

矩陣對于表示數據集很有用。通常，行對應于單個記錄，列對應于不同的屬性。

2.3.4. 張量

雖然您可以僅使用標量、向量和矩陣在機器學習之旅中走得更遠，但最終您可能需要使用高階張量。張量為我們提供了一種通用的方式來描述對 nth-順序數組。我們將張量類的軟件對象稱為 “張量”，正是因為它們也可以有任意數量的軸。雖然將張量這個詞用于數學對象及其在代碼中的實現可能會造成混淆，但我們的意思通常應該從上下文中清楚。我們用特殊字體的大寫字母表示一般張量（例如，X, Y， 和Z) 及其索引機制（例如，xijk和[X]1,2i?1,3) 從矩陣中自然得出。

當我們開始處理圖像時，張量將變得更加重要。每個圖像作為3rd-階張量，其軸對應于高度、寬度和通道。在每個空間位置，每種顏色（紅色、綠色和藍色）的強度都沿著通道堆疊。此外，一組圖像在代碼中表示為4th-階張量，其中不同的圖像沿第一軸索引。通過增加形狀分量的數量，高階張量的構造類似于向量和矩陣。

torch.arange(24).reshape(2, 3, 4)

tensor([[[ 0, 1, 2, 3],
     [ 4, 5, 6, 7],
     [ 8, 9, 10, 11]],

    [[12, 13, 14, 15],
     [16, 17, 18, 19],
     [20, 21, 22, 23]]])

np.arange(24).reshape(2, 3, 4)

array([[[ 0., 1., 2., 3.],
    [ 4., 5., 6., 7.],
    [ 8., 9., 10., 11.]],

    [[12., 13., 14., 15.],
    [16., 17., 18., 19.],
    [20., 21., 22., 23.]]])

jnp.arange(24).reshape(2, 3, 4)

Array([[[ 0, 1, 2, 3],
    [ 4, 5, 6, 7],
    [ 8, 9, 10, 11]],

    [[12, 13, 14, 15],
    [16, 17, 18, 19],
    [20, 21, 22, 23]]], dtype=int32)

tf.reshape(tf.range(24), (2, 3, 4))

2.3.5. 張量運算的基本性質

標量、向量、矩陣和高階張量都有一些方便的屬性。例如，逐元素運算產生與其操作數具有相同形狀的輸出。

A = torch.arange(6, dtype=torch.float32).reshape(2, 3)
B = A.clone() # Assign a copy of A to B by allocating new memory
A, A + B

(tensor([[0., 1., 2.],
     [3., 4., 5.]]),
 tensor([[ 0., 2., 4.],
     [ 6., 8., 10.]]))

A = np.arange(6).reshape(2, 3)
B = A.copy() # Assign a copy of A to B by allocating new memory
A, A + B

(array([[0., 1., 2.],
    [3., 4., 5.]]),
 array([[ 0., 2., 4.],
    [ 6., 8., 10.]]))

A = jnp.arange(6, dtype=jnp.float32).reshape(2, 3)
B = A
A, A + B

(Array([[0., 1., 2.],
    [3., 4., 5.]], dtype=float32),
 Array([[ 0., 2., 4.],
    [ 6., 8., 10.]], dtype=float32))

A = tf.reshape(tf.range(6, dtype=tf.float32), (2, 3))
B = A # No cloning of A to B by allocating new memory
A, A + B

(,
 )

兩個矩陣的元素積稱為它們的Hadamard 積（表示為⊙). 下面，我們拼出兩個矩陣的 Hadamard 乘積的條目 A,B∈Rm×n:

(2.3.4)A⊙B=[a11b11a12b12…a1nb1na21b21a22b22…a2nb2n????am1bm1am2bm2…amnbmn].

A * B

tensor([[ 0., 1., 4.],
    [ 9., 16., 25.]])

A * B

array([[ 0., 1., 4.],
    [ 9., 16., 25.]])

A * B

Array([[ 0., 1., 4.],
    [ 9., 16., 25.]], dtype=float32)

A * B

將標量和張量相加或相乘會產生與原始張量形狀相同的結果。在這里，張量的每個元素都被添加到（或乘以）標量。

a = 2
X = torch.arange(24).reshape(2, 3, 4)
a + X, (a * X).shape

(tensor([[[ 2, 3, 4, 5],
     [ 6, 7, 8, 9],
     [10, 11, 12, 13]],

     [[14, 15, 16, 17],
     [18, 19, 20, 21],
     [22, 23, 24, 25]]]),
 torch.Size([2, 3, 4]))

a = 2
X = np.arange(24).reshape(2, 3, 4)
a + X, (a * X).shape

(array([[[ 2., 3., 4., 5.],
     [ 6., 7., 8., 9.],
     [10., 11., 12., 13.]],

    [[14., 15., 16., 17.],
     [18., 19., 20., 21.],
     [22., 23., 24., 25.]]]),
 (2, 3, 4))

a = 2
X = jnp.arange(24).reshape(2, 3, 4)
a + X, (a * X).shape

(Array([[[ 2, 3, 4, 5],
     [ 6, 7, 8, 9],
     [10, 11, 12, 13]],

    [[14, 15, 16, 17],
     [18, 19, 20, 21],
     [22, 23, 24, 25]]], dtype=int32),
 (2, 3, 4))

a = 2
X = tf.reshape(tf.range(24), (2, 3, 4))
a + X, (a * X).shape

(,
 TensorShape([2, 3, 4]))

2.3.6. 減少

通常，我們希望計算張量元素的總和。表達向量中元素的總和x長度 n， 我們寫∑i=1nxi. 它有一個簡單的功能：

x = torch.arange(3, dtype=torch.float32)
x, x.sum()

(tensor([0., 1., 2.]), tensor(3.))

x = np.arange(3)
x, x.sum()

(array([0., 1., 2.]), array(3.))

x = jnp.arange(3, dtype=jnp.float32)
x, x.sum()

(Array([0., 1., 2.], dtype=float32), Array(3., dtype=float32))

x = tf.range(3, dtype=tf.float32)
x, tf.reduce_sum(x)

(,
 )

為了表達任意形狀張量元素的總和，我們簡單地對其所有軸求和。例如，一個元素的總和m×n矩陣A可以寫成 ∑i=1m∑j=1naij.

A.shape, A.sum()

(torch.Size([2, 3]), tensor(15.))

A.shape, A.sum()

((2, 3), array(15.))

A.shape, A.sum()

((2, 3), Array(15., dtype=float32))

A.shape, tf.reduce_sum(A)

(TensorShape([2, 3]), )

默認情況下，調用 sum 函數會減少沿其所有軸的張量，最終生成標量。我們的庫還允許我們指定應減少張量的軸。為了對沿行（軸 0）的所有元素求和，我們指定axis=0in sum。由于輸入矩陣沿軸 0 減少以生成輸出向量，因此輸出的形狀中缺少該軸。

A.shape, A.sum(axis=0).shape

(torch.Size([2, 3]), torch.Size([3]))

A.shape, A.sum(axis=0).shape

((2, 3), (3,))

A.shape, A.sum(axis=0).shape

((2, 3), (3,))

A.shape, tf.reduce_sum(A, axis=0).shape

(TensorShape([2, 3]), TensorShape([3]))

指定axis=1將通過匯總所有列的元素來減少列維度（軸 1）。

A.shape, A.sum(axis=1).shape

(torch.Size([2, 3]), torch.Size([2]))

A.shape, A.sum(axis=1).shape

((2, 3), (2,))

A.shape, A.sum(axis=1).shape

((2, 3), (2,))

A.shape, tf.reduce_sum(A, axis=1).shape

(TensorShape([2, 3]), TensorShape([2]))

通過求和沿行和列減少矩陣等同于對矩陣的所有元素求和。

A.sum(axis=[0, 1]) == A.sum() # Same as A.sum()

tensor(True)

A.sum(axis=[0, 1]) == A.sum() # Same as A.sum()

array(True)

A.sum(axis=[0, 1]) == A.sum() # Same as A.sum()

Array(True, dtype=bool)

tf.reduce_sum(A, axis=[0, 1]), tf.reduce_sum(A) # Same as tf.reduce_sum(A)

(,
 )

一個相關的量是均值，也叫平均值。我們通過將總和除以元素總數來計算平均值。因為計算平均值非常普遍，所以它有一個專用的庫函數，其工作方式類似于sum.

A.mean(), A.sum() / A.numel()

(tensor(2.5000), tensor(2.5000))

A.mean(), A.sum() / A.size

(array(2.5), array(2.5))

A.mean(), A.sum() / A.size

(Array(2.5, dtype=float32), Array(2.5, dtype=float32))

tf.reduce_mean(A), tf.reduce_sum(A) / tf.size(A).numpy()

(,
 )

同樣，計算均值的函數也可以減少沿特定軸的張量。

A.mean(axis=0), A.sum(axis=0) / A.shape[0]

(tensor([1.5000, 2.5000, 3.5000]), tensor([1.5000, 2.5000, 3.5000]))

A.mean(axis=0), A.sum(axis=0) / A.shape[0]

(array([1.5, 2.5, 3.5]), array([1.5, 2.5, 3.5]))

A.mean(axis=0), A.sum(axis=0) / A.shape[0]

(Array([1.5, 2.5, 3.5], dtype=float32), Array([1.5, 2.5, 3.5], dtype=float32))

tf.reduce_mean(A, axis=0), tf.reduce_sum(A, axis=0) / A.shape[0]

(,
 )

2.3.7. 非減額

有時在調用用于計算和或平均值的函數時保持軸數不變可能很有用。當我們想要使用廣播機制時，這很重要。

sum_A = A.sum(axis=1, keepdims=True)
sum_A, sum_A.shape

(tensor([[ 3.],
     [12.]]),
 torch.Size([2, 1]))

sum_A = A.sum(axis=1, keepdims=True)
sum_A, sum_A.shape

(array([[ 3.],
    [12.]]),
 (2, 1))

sum_A = A.sum(axis=1, keepdims=True)
sum_A, sum_A.shape

(Array([[ 3.],
    [12.]], dtype=float32),
 (2, 1))

sum_A = tf.reduce_sum(A, axis=1, keepdims=True)
sum_A, sum_A.shape

(,
 TensorShape([2, 1]))

例如，由于在sum_A對每一行求和后保留其兩個軸，我們可以通過廣播除以A創建sum_A一個矩陣，其中每一行總和為1.

A / sum_A

tensor([[0.0000, 0.3333, 0.6667],
    [0.2500, 0.3333, 0.4167]])

A / sum_A

array([[0.    , 0.33333334, 0.6666667 ],
    [0.25   , 0.33333334, 0.41666666]])

A / sum_A

Array([[0.    , 0.33333334, 0.6666667 ],
    [0.25   , 0.33333334, 0.41666666]], dtype=float32)

A / sum_A

如果我們想計算沿某個軸的元素的累積和A，比如axis=0（逐行），我們可以調用該cumsum 函數。按照設計，此函數不會減少沿任何軸的輸入張量。

A.cumsum(axis=0)

tensor([[0., 1., 2.],
    [3., 5., 7.]])

A.cumsum(axis=0)

array([[0., 1., 2.],
    [3., 5., 7.]])

A.cumsum(axis=0)

Array([[0., 1., 2.],
    [3., 5., 7.]], dtype=float32)

tf.cumsum(A, axis=0)

2.3.8. 點積

到目前為止，我們只執行了元素運算、求和和平均。如果這就是我們所能做的全部，那么線性代數就不值得單獨一節了。幸運的是，這是事情變得更有趣的地方。最基本的操作之一是點積。給定兩個向量x,y∈Rd, 他們的 點積 x?y（或者 ?x,y?) 是同一位置元素乘積的總和： x?y=∑i=1dxiyi.

y = torch.ones(3, dtype = torch.float32)
x, y, torch.dot(x, y)

(tensor([0., 1., 2.]), tensor([1., 1., 1.]), tensor(3.))

y = np.ones(3)
x, y, np.dot(x, y)

(array([0., 1., 2.]), array([1., 1., 1.]), array(3.))

y = jnp.ones(3, dtype = jnp.float32)
x, y, jnp.dot(x, y)

(Array([0., 1., 2.], dtype=float32),
 Array([1., 1., 1.], dtype=float32),
 Array(3., dtype=float32))

y = tf.ones(3, dtype=tf.float32)
x, y, tf.tensordot(x, y, axes=1)

(,
 ,
 )

等價地，我們可以通過執行逐元素乘法然后求和來計算兩個向量的點積：

torch.sum(x * y)

tensor(3.)

np.sum(x * y)

array(3.)

jnp.sum(x * y)

Array(3., dtype=float32)

tf.reduce_sum(x * y)

點積在廣泛的上下文中很有用。例如，給定一組值，用向量表示 x∈Rn和一組權重表示為 w∈Rn, 中值的加權和 x根據權重w可以表示為點積x?w. 當權重為非負且總和為一時，即 (∑i=1nwi=1)，點積表示加權平均值。將兩個向量歸一化為單位長度后，點積表示它們之間夾角的余弦值。在本節的后面，我們將正式介紹長度的概念。

2.3.9. 矩陣向量積

既然我們知道如何計算點積，我們就可以開始了解點積m×n矩陣 A和n維向量 x. 首先，我們根據行向量可視化我們的矩陣

(2.3.5)A=[a1?a2??am?],

每個ai?∈Rn是一個行向量，表示ith矩陣的行 A.

矩陣向量積Ax只是長度的列向量m，誰的ith元素是點積ai?x:

(2.3.6)Ax=[a1?a2??am?]x=[a1?xa2?x?am?x].

我們可以考慮與矩陣相乘 A∈Rm×n作為投影矢量的變換Rn到Rm. 這些轉換非常有用。例如，我們可以將旋轉表示為某些方矩陣的乘法。矩陣向量乘積還描述了在給定前一層輸出的情況下計算神經網絡中每一層輸出所涉及的關鍵計算。

為了在代碼中表達矩陣向量乘積，我們使用函數mv。請注意，（其沿軸 1 的長度）的列維度必須與（其長度）A的維度相同。xPyTorch 有一個方便的運算符@，可以執行矩陣向量和矩陣矩陣乘積（取決于它的參數）。因此我們可以寫 A@x.

A.shape, x.shape, torch.mv(A, x), A@x

(torch.Size([2, 3]), torch.Size([3]), tensor([ 5., 14.]), tensor([ 5., 14.]))

To express a matrix-vector product in code, we use the same dot function. The operation is inferred based on the type of the arguments. Note that the column dimension of A (its length along axis 1) must be the same as the dimension of x (its length).

A.shape, x.shape, np.dot(A, x)

((2, 3), (3,), array([ 5., 14.]))

A.shape, x.shape, jnp.matmul(A, x)

((2, 3), (3,), Array([ 5., 14.], dtype=float32))

To express a matrix-vector product in code, we use the matvec function. Note that the column dimension of A (its length along axis 1) must be the same as the dimension of x (its length).

A.shape, x.shape, tf.linalg.matvec(A, x)

(TensorShape([2, 3]),
 TensorShape([3]),
 )

2.3.10。矩陣-矩陣乘法

如果您掌握了點積和矩陣-向量積的竅門，那么矩陣-矩陣乘法應該很簡單。

假設我們有兩個矩陣 A∈Rn×k和 B∈Rk×m:

(2.3.7)A=[a11a12?a1ka21a22?a2k????an1an2?ank],B=[b11b12?b1mb21b22?b2m????bk1bk2?bkm].

讓ai?∈Rk表示行向量表示ith矩陣的行 A然后讓bj∈Rk 表示來自的列向量jth矩陣的列B:

(2.3.8)A=[a1?a2??an?],B=[b1b2?bm].

形成矩陣乘積 C∈Rn×m，我們簡單地計算每個元素cij作為點積之間 ith一排A和 jth列的B， IE， ai?bj:

(2.3.9)C=AB=[a1?a2??an?][b1b2?bm]=[a1?b1a1?b2?a1?bma2?b1a2?b2?a2?bm????an?b1an?b2?an?bm].

我們可以想到矩陣-矩陣乘法AB作為表演m矩陣向量乘積或m×n點積并將結果拼接在一起形成一個 n×m矩陣。在以下代碼片段中，我們對A和執行矩陣乘法B。這里，A是一個2行3列的矩陣，B是一個3行4列的矩陣。相乘后得到一個2行4列的矩陣。

B = torch.ones(3, 4)
torch.mm(A, B), A@B

(tensor([[ 3., 3., 3., 3.],
     [12., 12., 12., 12.]]),
 tensor([[ 3., 3., 3., 3.],
     [12., 12., 12., 12.]]))

B = np.ones(shape=(3, 4))
np.dot(A, B)

array([[ 3., 3., 3., 3.],
    [12., 12., 12., 12.]])

B = jnp.ones((3, 4))
jnp.matmul(A, B)

Array([[ 3., 3., 3., 3.],
    [12., 12., 12., 12.]], dtype=float32)

B = tf.ones((3, 4), tf.float32)
tf.matmul(A, B)

術語矩陣-矩陣乘法通常簡化為矩陣乘法，不應與 Hadamard 乘積混淆。

2.3.11。規范

線性代數中一些最有用的運算符是范數。通俗地說，向量的范數告訴我們它有多大。例如，?2范數測量向量的（歐幾里德）長度。在這里，我們使用了一個大小概念，它涉及向量分量的大小（而不是其維度）。

范數是函數‖?‖將向量映射到標量并滿足以下三個屬性：

給定任何向量x，如果我們用標量縮放向量（的所有元素）α∈R, 它的范數相應地縮放：

(2.3.10)‖αx‖=|α|‖x‖.

對于任何向量x和y：范數滿足三角不等式：

(2.3.11)‖x+y‖≤‖x‖+‖y‖.

向量的范數是非負的，只有當向量為零時它才會消失：

(2.3.12)‖x‖>0for allx≠0.

許多函數都是有效的范數，不同的范數編碼不同的大小概念。我們小學幾何學計算直角三角形的斜邊時都學過的歐幾里德范數，就是對向量元素的平方和開平方根。正式地，這被稱為?2 規范并表示為

(2.3.13)‖x‖2=∑i=1nxi2.

該方法norm計算?2規范。

u = torch.tensor([3.0, -4.0])
torch.norm(u)

tensor(5.)

u = np.array([3, -4])
np.linalg.norm(u)

array(5.)

u = jnp.array([3.0, -4.0])
jnp.linalg.norm(u)

Array(5., dtype=float32)

u = tf.constant([3.0, -4.0])
tf.norm(u)

這?1范數也很流行，相關的度量標準稱為曼哈頓距離。根據定義，?1norm 對向量元素的絕對值求和：

(2.3.14)‖x‖1=∑i=1n|xi|.

相比于?2norm，它對異常值不太敏感。計算?1范數，我們用求和運算合成絕對值。

torch.abs(u).sum()

tensor(7.)

np.abs(u).sum()

array(7.)

jnp.linalg.norm(u, ord=1) # same as jnp.abs(u).sum()

Array(7., dtype=float32)

tf.reduce_sum(tf.abs(u))

這倆?2和?1規范是更一般的特殊情況?p 規范：

(2.3.15)‖x‖p=(∑i=1n|xi|p)1/p.

在矩陣的情況下，事情要復雜得多。畢竟，矩陣既可以看作是單個條目的集合，也 可以看作是對向量進行運算并將它們轉換為其他向量的對象。例如，我們可以問矩陣向量乘積多長時間Xv可能是相對于 v. 這種思路導致了一種稱為 譜范數的范數。現在，我們介??紹Frobenius 范數，它更容易計算并定義為矩陣元素平方和的平方根：

(2.3.16)‖X‖F=∑i=1m∑j=1nxij2.

Frobenius 范數的行為就好像它是一個?2矩陣形向量的范數。調用以下函數將計算矩陣的 Frobenius 范數。

torch.norm(torch.ones((4, 9)))

tensor(6.)

np.linalg.norm(np.ones((4, 9)))

array(6.)

jnp.linalg.norm(jnp.ones((4, 9)))

Array(6., dtype=float32)

tf.norm(tf.ones((4, 9)))

雖然我們不想過于超前，但我們已經對這些概念為何有用有了一些直覺。在深度學習中，我們經常試圖解決優化問題：最大化分配 給觀察數據的概率；最大化與推薦模型相關的收入；最小化預測和地面實況觀察之間的距離；最小化同一個人的照片表示之間的距離，同時最大化 不同人的照片表示之間的距離。這些構成深度學習算法目標的距離通常表示為規范。

2.3.12。討論

在本節中，我們回顧了理解大量現代深度學習所需的所有線性代數。線性代數還有很多內容，其中大部分對機器學習很有用。例如，矩陣可以分解為因子，這些分解可以揭示現實世界數據集中的低維結構。機器學習的整個子領域都專注于使用矩陣分解及其對高階張量的推廣來發現數據集中的結構并解決預測問題。但這本書側重于深度學習。我們相信，一旦您親手將機器學習應用于真實數據集，您將更愿意學習更多數學。因此，雖然我們保留稍后介紹更多數學的權利，但我們在此結束本節。

如果你渴望學習更多的線性代數，有很多優秀的書籍和在線資源。如需更高級的速成課程，請考慮查看 Kolter ( 2008 )、Petersen等人。（2008 年），斯特朗（1993 年）。

回顧一下：

標量、向量、矩陣和張量是線性代數中使用的基本數學對象，分別具有零、一、二和任意數量的軸。

可以分別通過索引或sum和 等操作沿指定軸對張量進行切片或縮減。mean

Elementwise 產品稱為 Hadamard 產品。相比之下，點積、矩陣-向量積和矩陣-矩陣積不是按元素運算，并且通常返回與操作數具有不同形狀的對象。

與 Hadamard 積相比，矩陣-矩陣積的計算時間要長得多（三次而不是二次時間）。

范數捕捉了向量大小的各種概念，并且通常應用于兩個向量的差異以測量它們的距離。

常見的向量范數包括?1和?2 范數，常見的矩陣范數包括譜范數和Frobenius 范數。

2.3.13. 練習

證明矩陣轉置的轉置就是矩陣本身：(A?)?=A.

給定兩個矩陣A和B, 表明總和和轉置交換： A?+B?=(A+B)?.

給定任何方陣A， 是 A+A?總是對稱的？你能僅用前兩個練習的結果來證明這個結果嗎？

我們在本節中定義了形狀為 (2, 3, 4) 的張量X。的輸出是什么len(X)？在不執行任何代碼的情況下寫下您的答案，然后使用代碼檢查您的答案。

對于任意形狀的張量X，總是len(X)對應于某個軸的長度X？那個軸是什么？

跑看看會發生什么。能分析一下原因嗎？A / A.sum(axis=1)

在曼哈頓市中心的兩點之間旅行時，根據坐標，即大道和街道，您需要經過的距離是多少？可以對角線旅行嗎？

考慮一個形狀為 (2, 3, 4) 的張量。沿軸 0、1 和 2 的求和輸出的形狀是什么？

將具有 3 個或更多軸的張量輸入函數linalg.norm并觀察其輸出。對于任意形狀的張量，此函數計算什么？

定義三個大矩陣，比如說 A∈R210×216, B∈R216×25和 C∈R25×214，例如用高斯隨機變量初始化。你想計算產品ABC. 內存占用和速度是否有任何差異，具體取決于您是否計算(AB)C或者 A(BC). 為什么？

定義三個大矩陣，比如說 A∈R210×216, B∈R216×25和 C∈R25×216. 根據您是否計算，速度是否有任何差異 AB或者AC?？為什么？如果初始化會發生什么變化 C=B?沒有克隆內存？為什么？

定義三個矩陣，比如說 A,B,C∈R100×200. 通過堆疊構成具有3個軸的張量 [A,B,C]. 什么是維度？切出第三軸第二坐標恢復B. 檢查你的答案是否正確。