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

import torch

from mxnet import np, npx

npx.set_np()

from jax import numpy as jnp

import tensorflow as tf

2.3.1. 標(biāo)量

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

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

標(biāo)量被實現(xiàn)為僅包含一個元素的張量。下面，我們分配兩個標(biāo)量并執(zhí)行熟悉的加法、乘法、除法和求冪運算。

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. 載體

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

向量實現(xiàn)為1st-階張量。通常，此類張量可以具有任意長度，受內(nèi)存限制。注意：在 Python 中，與大多數(shù)編程語言一樣，向量索引從0，也稱為從零開始的索引，而在線性代數(shù)中下標(biāo)開始于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

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

(2.3.1)x=[x1?xn],

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

x[2]

tensor(2)

x[2]

array(2.)

x[2]

Array(2, dtype=int32)

x[2]

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

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])

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

2.3.3. 矩陣

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

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

在代碼中，我們表示一個矩陣 A∈Rm×n通過一個 2nd-具有形狀的階張量 (m,n). 我們可以轉(zhuǎn)換任何適當(dāng)大小的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

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

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

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

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)

對稱矩陣是方陣的子集，它們等于它們自己的轉(zhuǎn)置：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)

矩陣對于表示數(shù)據(jù)集很有用。通常，行對應(yīng)于單個記錄，列對應(yīng)于不同的屬性。

2.3.4. 張量

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

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

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. 張量運算的基本性質(zhì)

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

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

將標(biāo)量和張量相加或相乘會產(chǎn)生與原始張量形狀相同的結(jié)果。在這里，張量的每個元素都被添加到（或乘以）標(biāo)量。

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. 減少

通常，我們希望計算張量元素的總和。表達(dá)向量中元素的總和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)

(,
 )

為了表達(dá)任意形狀張量元素的總和，我們簡單地對其所有軸求和。例如，一個元素的總和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]), )

默認(rèn)情況下，調(diào)用 sum 函數(shù)會減少沿其所有軸的張量，最終生成標(biāo)量。我們的庫還允許我們指定應(yīng)減少張量的軸。為了對沿行（軸 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)

(,
 )

一個相關(guān)的量是均值，也叫平均值。我們通過將總和除以元素總數(shù)來計算平均值。因為計算平均值非常普遍，所以它有一個專用的庫函數(shù)，其工作方式類似于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()

(,
 )

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

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. 非減額

有時在調(diào)用用于計算和或平均值的函數(shù)時保持軸數(shù)不變可能很有用。當(dāng)我們想要使用廣播機(jī)制時，這很重要。

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創(chuàng)建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（逐行），我們可以調(diào)用該cumsum 函數(shù)。按照設(shè)計，此函數(shù)不會減少沿任何軸的輸入張量。

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. 點積

到目前為止，我們只執(zhí)行了元素運算、求和和平均。如果這就是我們所能做的全部，那么線性代數(shù)就不值得單獨一節(jié)了。幸運的是，這是事情變得更有趣的地方。最基本的操作之一是點積。給定兩個向量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)

(,
 ,
 )

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

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和一組權(quán)重表示為 w∈Rn, 中值的加權(quán)和 x根據(jù)權(quán)重w可以表示為點積x?w. 當(dāng)權(quán)重為非負(fù)且總和為一時，即 (∑i=1nwi=1)，點積表示加權(quán)平均值。將兩個向量歸一化為單位長度后，點積表示它們之間夾角的余弦值。在本節(jié)的后面，我們將正式介紹長度的概念。

2.3.9. 矩陣向量積

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

(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. 這些轉(zhuǎn)換非常有用。例如，我們可以將旋轉(zhuǎn)表示為某些方矩陣的乘法。矩陣向量乘積還描述了在給定前一層輸出的情況下計算神經(jīng)網(wǎng)絡(luò)中每一層輸出所涉及的關(guān)鍵計算。

為了在代碼中表達(dá)矩陣向量乘積，我們使用函數(shù)mv。請注意，（其沿軸 1 的長度）的列維度必須與（其長度）A的維度相同。xPyTorch 有一個方便的運算符@，可以執(zhí)行矩陣向量和矩陣矩陣乘積（取決于它的參數(shù)）。因此我們可以寫 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。矩陣-矩陣乘法

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

假設(shè)我們有兩個矩陣 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點積并將結(jié)果拼接在一起形成一個 n×m矩陣。在以下代碼片段中，我們對A和執(zhí)行矩陣乘法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)

術(shù)語矩陣-矩陣乘法通常簡化為矩陣乘法，不應(yīng)與 Hadamard 乘積混淆。

2.3.11。規(guī)范

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

范數(shù)是函數(shù)‖?‖將向量映射到標(biāo)量并滿足以下三個屬性：

給定任何向量x，如果我們用標(biāo)量縮放向量（的所有元素）α∈R, 它的范數(shù)相應(yīng)地縮放：

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

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

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

向量的范數(shù)是非負(fù)的，只有當(dāng)向量為零時它才會消失：

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

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

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

該方法norm計算?2規(guī)范。

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范數(shù)也很流行，相關(guān)的度量標(biāo)準(zhǔn)稱為曼哈頓距離。根據(jù)定義，?1norm 對向量元素的絕對值求和：

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

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

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規(guī)范是更一般的特殊情況?p 規(guī)范：

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

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

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

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

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)))

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

2.3.12。討論

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

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

回顧一下：

標(biāo)量、向量、矩陣和張量是線性代數(shù)中使用的基本數(shù)學(xué)對象，分別具有零、一、二和任意數(shù)量的軸。

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

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

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

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

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

2.3.13. 練習(xí)

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

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

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

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

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

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

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

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

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

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

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

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