為了完成任何事情，我們需要一些方法來存儲和操作數據。通常，我們需要對數據做兩件重要的事情：（i）獲取它們；(ii) 一旦它們進入計算機就對其進行處理。如果沒有某種存儲方式，獲取數據是沒有意義的，所以首先，讓我們動手操作n維數組，我們也稱之為張量。如果您已經了解 NumPy 科學計算包，那么這將是一件輕而易舉的事。對于所有現代深度學習框架，張量類（ndarray在 MXNet、 TensorPyTorch 和 TensorFlow 中）類似于 NumPy ndarray，但增加了一些殺手級功能。首先，張量類支持自動微分。其次，它利用 GPU 來加速數值計算，而 NumPy 只能在 CPU 上運行。這些特性使神經網絡既易于編碼又能快速運行。

2.1.1. 入門

首先，我們導入 PyTorch 庫。請注意，包名稱是 torch.

import torch

To start, we import the np (numpy) and npx (numpy_extension) modules from MXNet. Here, the np module includes functions supported by NumPy, while the npx module contains a set of extensions developed to empower deep learning within a NumPy-like environment. When using tensors, we almost always invoke the set_np function: this is for compatibility of tensor processing by other components of MXNet.

from mxnet import np, npx

npx.set_np()

import jax
from jax import numpy as jnp

To start, we import tensorflow. For brevity, practitioners often assign the alias tf.

import tensorflow as tf

張量表示一個（可能是多維的）數值數組。對于一個軸，張量稱為向量。具有兩個軸的張量稱為矩陣。和k>2軸，我們刪除專門的名稱并僅將對象稱為 kth 階張量。

PyTorch 提供了多種函數來創建預填充值的新張量。例如，通過調用，我們可以創建一個均勻分布值的向量，從 0（包括）開始到（不包括）arange(n)結束。n默認情況下，間隔大小為 1. 除非另有說明，否則新張量存儲在主內存中并指定用于基于 CPU 的計算。

x = torch.arange(12, dtype=torch.float32)
x

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

這些值中的每一個都稱為張量的一個元素。張量 x包含 12 個元素。我們可以通過其方法檢查張量中元素的總數numel。

x.numel()

12

MXNet provides a variety of functions for creating new tensors prepopulated with values. For example, by invoking arange(n), we can create a vector of evenly spaced values, starting at 0 (included) and ending at n (not included). By default, the interval size is 1. Unless otherwise specified, new tensors are stored in main memory and designated for CPU-based computation.

x = np.arange(12)
x

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

Each of these values is called an element of the tensor. The tensor x contains 12 elements. We can inspect the total number of elements in a tensor via its size attribute.

x.size

12

x = jnp.arange(12)
x

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

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

x.size

12

TensorFlow provides a variety of functions for creating new tensors prepopulated with values. For example, by invoking range(n), we can create a vector of evenly spaced values, starting at 0 (included) and ending at n (not included). By default, the interval size is 1. Unless otherwise specified, new tensors are stored in main memory and designated for CPU-based computation.

x = tf.range(12, dtype=tf.float32)
x

Each of these values is called an element of the tensor. The tensor x contains 12 elements. We can inspect the total number of elements in a tensor via the size function.

tf.size(x)

我們可以通過檢查其屬性來訪問張量的形狀（沿每個軸的長度）shape。因為我們在這里處理的是一個向量，所以它只shape包含一個元素并且與大小相同。

x.shape

torch.Size([12])

x.shape

(12,)

x.shape

(12,)

x.shape

TensorShape([12])

我們可以通過調用 來改變張量的形狀而不改變它的大小或值reshape。例如，我們可以將形狀為 (12,) 的向量轉換為形狀為 (3, 4) 的x 矩陣。X這個新張量保留了所有元素，但將它們重新配置為矩陣。請注意，我們向量的元素一次排成一行，因此 .x[3] == X[0, 3]

X = x.reshape(3, 4)
X

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

X = x.reshape(3, 4)
X

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

X = x.reshape(3, 4)
X

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

X = tf.reshape(x, (3, 4))
X

請注意，指定每個形狀組件reshape是多余的。因為我們已經知道張量的大小，所以我們可以在給定其余部分的情況下計算出形狀的一個組成部分。例如，給定大小的張量 n和目標形狀（h,w）， 我們知道 w=n/h. 要自動推斷形狀的一個組件，我們可以-1為應該自動推斷的形狀組件放置一個。在我們的例子中，我們可以等效地調用or 而不是調用。x.reshape(3, 4)x.reshape(-1, 4)x.reshape(3, -1)

從業者通常需要使用初始化為包含全零或全一的張量。我們可以通過函數構造一個所有元素都設置為零且形狀為 (2, 3, 4) 的張量zeros。

torch.zeros((2, 3, 4))

tensor([[[0., 0., 0., 0.],
     [0., 0., 0., 0.],
     [0., 0., 0., 0.]],

    [[0., 0., 0., 0.],
     [0., 0., 0., 0.],
     [0., 0., 0., 0.]]])

np.zeros((2, 3, 4))

array([[[0., 0., 0., 0.],
    [0., 0., 0., 0.],
    [0., 0., 0., 0.]],

    [[0., 0., 0., 0.],
    [0., 0., 0., 0.],
    [0., 0., 0., 0.]]])

jnp.zeros((2, 3, 4))

Array([[[0., 0., 0., 0.],
    [0., 0., 0., 0.],
    [0., 0., 0., 0.]],

    [[0., 0., 0., 0.],
    [0., 0., 0., 0.],
    [0., 0., 0., 0.]]], dtype=float32)

tf.zeros((2, 3, 4))

類似地，我們可以通過調用創建一個全部為 1 的張量ones。

torch.ones((2, 3, 4))

tensor([[[1., 1., 1., 1.],
     [1., 1., 1., 1.],
     [1., 1., 1., 1.]],

    [[1., 1., 1., 1.],
     [1., 1., 1., 1.],
     [1., 1., 1., 1.]]])

np.ones((2, 3, 4))

array([[[1., 1., 1., 1.],
    [1., 1., 1., 1.],
    [1., 1., 1., 1.]],

    [[1., 1., 1., 1.],
    [1., 1., 1., 1.],
    [1., 1., 1., 1.]]])

jnp.ones((2, 3, 4))

Array([[[1., 1., 1., 1.],
    [1., 1., 1., 1.],
    [1., 1., 1., 1.]],

    [[1., 1., 1., 1.],
    [1., 1., 1., 1.],
    [1., 1., 1., 1.]]], dtype=float32)

tf.ones((2, 3, 4))

我們經常希望從給定的概率分布中隨機（且獨立地）采樣每個元素。例如，神經網絡的參數通常是隨機初始化的。以下代碼片段創建了一個張量，其中的元素取自標準高斯（正態）分布，均值為 0，標準差為 1。

torch.randn(3, 4)

tensor([[ 1.4251, -1.4341, 0.2826, -0.4915],
    [ 0.1799, -1.1769, 2.3581, -0.1923],
    [ 0.8576, -0.0719, 1.4172, -1.3151]])

np.random.normal(0, 1, size=(3, 4))

array([[ 2.2122064 , 1.1630787 , 0.7740038 , 0.4838046 ],
    [ 1.0434403 , 0.29956347, 1.1839255 , 0.15302546],
    [ 1.8917114 , -1.1688148 , -1.2347414 , 1.5580711 ]])

# Any call of a random function in JAX requires a key to be
# specified, feeding the same key to a random function will
# always result in the same sample being generated
jax.random.normal(jax.random.PRNGKey(0), (3, 4))

Array([[ 1.1901639 , -1.0996888 , 0.44367844, 0.5984697 ],
    [-0.39189556, 0.69261974, 0.46018356, -2.068578 ],
    [-0.21438177, -0.9898306 , -0.6789304 , 0.27362573]],   dtype=float32)

tf.random.normal(shape=[3, 4])

最后，我們可以通過提供（可能嵌套的）包含數字文字的 Python 列表為每個元素提供精確值來構造張量。在這里，我們構建了一個包含列表列表的矩陣，其中最外層的列表對應于軸 0，內部列表對應于軸 1。

torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

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

np.array([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

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

jnp.array([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

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

tf.constant([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

2.1.2. 索引和切片

與 Python 列表一樣，我們可以通過索引（從 0 開始）訪問張量元素。要根據元素相對于列表末尾的位置訪問元素，我們可以使用負索引。最后，我們可以通過切片（例如，）訪問整個索引范圍X[start:stop]，其中返回值包括第一個索引（start）但不包括最后一個（stop）。最后，當只有一個索引（或切片）被指定為kth階張量，它沿軸 0 應用。因此，在下面的代碼中，[-1]選擇最后一行并 [1:3]選擇第二行和第三行。

X[-1], X[1:3]

(tensor([ 8., 9., 10., 11.]),
 tensor([[ 4., 5., 6., 7.],
     [ 8., 9., 10., 11.]]))

除了讀取之外，我們還可以通過指定索引來寫入矩陣的元素。

X[1, 2] = 17
X

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

X[-1], X[1:3]

(array([ 8., 9., 10., 11.]),
 array([[ 4., 5., 6., 7.],
    [ 8., 9., 10., 11.]]))

Beyond reading, we can also write elements of a matrix by specifying indices.

X[1, 2] = 17
X

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

X[-1], X[1:3]

(Array([ 8, 9, 10, 11], dtype=int32),
 Array([[ 4, 5, 6, 7],
    [ 8, 9, 10, 11]], dtype=int32))

# JAX arrays are immutable. jax.numpy.ndarray.at index
# update operators create a new array with the corresponding
# modifications made
X_new_1 = X.at[1, 2].set(17)
X_new_1

Array([[ 0, 1, 2, 3],
    [ 4, 5, 17, 7],
    [ 8, 9, 10, 11]], dtype=int32)

X[-1], X[1:3]

(,
 )

Tensors in TensorFlow are immutable, and cannot be assigned to. Variables in TensorFlow are mutable containers of state that support assignments. Keep in mind that gradients in TensorFlow do not flow backwards through Variable assignments.

Beyond assigning a value to the entire Variable, we can write elements of a Variable by specifying indices.

X_var = tf.Variable(X)
X_var[1, 2].assign(9)
X_var

如果我們想為多個元素分配相同的值，我們在賦值操作的左側應用索引。例如，訪問第一行和第二行，其中 獲取沿軸 1（列）的所有元素。雖然我們討論了矩陣的索引，但它也適用于向量和二維以上的張量。[:2, :]:

X[:2, :] = 12
X

tensor([[12., 12., 12., 12.],
    [12., 12., 12., 12.],
    [ 8., 9., 10., 11.]])

X[:2, :] = 12
X

array([[12., 12., 12., 12.],
    [12., 12., 12., 12.],
    [ 8., 9., 10., 11.]])

X_new_2 = X_new_1.at[:2, :].set(12)
X_new_2

Array([[12, 12, 12, 12],
    [12, 12, 12, 12],
    [ 8, 9, 10, 11]], dtype=int32)

X_var = tf.Variable(X)
X_var[:2, :].assign(tf.ones(X_var[:2,:].shape, dtype=tf.float32) * 12)
X_var

2.1.3. 操作

現在我們知道如何構建張量以及如何讀取和寫入它們的元素，我們可以開始使用各種數學運算來操縱它們。最有用的工具之一是 逐元素操作。這些將標準標量運算應用于張量的每個元素。對于將兩個張量作為輸入的函數，逐元素運算對每對對應元素應用一些標準二元運算符。我們可以從從標量映射到標量的任何函數創建一個逐元素函數。

在數學符號中，我們用簽名表示這樣的一元標量運算符（接受一個輸入 ）f:R→R. 這只是意味著函數從任何實數映射到其他實數。大多數標準運算符都可以按元素應用，包括一元運算符，如ex.

torch.exp(x)

tensor([162754.7969, 162754.7969, 162754.7969, 162754.7969, 162754.7969,
    162754.7969, 162754.7969, 162754.7969,  2980.9580,  8103.0840,
     22026.4648, 59874.1406])

np.exp(x)

array([1.0000000e+00, 2.7182817e+00, 7.3890562e+00, 2.0085537e+01,
    5.4598148e+01, 1.4841316e+02, 4.0342880e+02, 1.0966332e+03,
    2.9809580e+03, 8.1030840e+03, 2.2026465e+04, 5.9874141e+04])

jnp.exp(x)

Array([1.0000000e+00, 2.7182817e+00, 7.3890562e+00, 2.0085537e+01,
    5.4598152e+01, 1.4841316e+02, 4.0342880e+02, 1.0966332e+03,
    2.9809580e+03, 8.1030840e+03, 2.2026465e+04, 5.9874141e+04],   dtype=float32)

tf.exp(x)

同樣，我們表示二元標量運算符，它通過簽名將成對的實數映射到一個（單個）實數 f:R,R→R. 給定任意兩個向量u和v 形狀相同，和一個二元運算符f，我們可以產生一個向量 c=F(u,v)通過設置 ci←f(ui,vi)對全部i， 在哪里ci,ui， 和vi是ith向量的元素 c,u， 和v. 在這里，我們產生了向量值 F:Rd,Rd→Rd通過 將標量函數提升為元素向量運算。+加法 ( )、減法 ( -)、乘法 ( *)、除法 ( /) 和求冪 ( )的常見標準算術運算符**都已提升為任意形狀的相同形狀張量的元素運算。

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y

(tensor([ 3., 4., 6., 10.]),
 tensor([-1., 0., 2., 6.]),
 tensor([ 2., 4., 8., 16.]),
 tensor([0.5000, 1.0000, 2.0000, 4.0000]),
 tensor([ 1., 4., 16., 64.]))

x = np.array([1, 2, 4, 8])
y = np.array([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y

(array([ 3., 4., 6., 10.]),
 array([-1., 0., 2., 6.]),
 array([ 2., 4., 8., 16.]),
 array([0.5, 1. , 2. , 4. ]),
 array([ 1., 4., 16., 64.]))

x = jnp.array([1.0, 2, 4, 8])
y = jnp.array([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y

(Array([ 3., 4., 6., 10.], dtype=float32),
 Array([-1., 0., 2., 6.], dtype=float32),
 Array([ 2., 4., 8., 16.], dtype=float32),
 Array([0.5, 1. , 2. , 4. ], dtype=float32),
 Array([ 1., 4., 16., 64.], dtype=float32))

x = tf.constant([1.0, 2, 4, 8])
y = tf.constant([2.0, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y

(,
 ,
 ,
 ,
 )

除了按元素計算，我們還可以執行線性代數運算，例如點積和矩陣乘法。我們將在2.3 節中詳細說明這些內容。

我們還可以將多個張量連接在一起，將它們首尾相連形成一個更大的張量。我們只需要提供一個張量列表并告訴系統沿著哪個軸連接。下面的示例顯示了當我們沿行（軸 0）與列（軸 1）連接兩個矩陣時會發生什么。我們可以看到第一個輸出的 axis-0 長度 (6) 是兩個輸入張量的軸 0 長度之和 (3+3); 而第二個輸出的 axis-1 長度 (8) 是兩個輸入張量的 axis-1 長度之和 (4+4).

X = torch.arange(12, dtype=torch.float32).reshape((3,4))
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)

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

X = np.arange(12).reshape(3, 4)
Y = np.array([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
np.concatenate([X, Y], axis=0), np.concatenate([X, Y], axis=1)

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

X = jnp.arange(12, dtype=jnp.float32).reshape((3, 4))
Y = jnp.array([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
jnp.concatenate((X, Y), axis=0), jnp.concatenate((X, Y), axis=1)

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

X = tf.reshape(tf.range(12, dtype=tf.float32), (3, 4))
Y = tf.constant([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
tf.concat([X, Y], axis=0), tf.concat([X, Y], axis=1)

(,
 )

有時，我們想通過邏輯語句構造一個二元張量。舉個例子。對于每一個位置，如果和相等，則結果中相應的條目取值，否則取值。X == Yi, jX[i, j]Y[i, j]10

X == Y

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

X == Y

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

X == Y

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

X == Y

將張量中的所有元素相加得到一個只有一個元素的張量。

X.sum()

tensor(66.)

X.sum()

array(66.)

X.sum()

Array(66., dtype=float32)

tf.reduce_sum(X)

2.1.4. 廣播

到目前為止，您已經知道如何對兩個相同形狀的張量執行逐元素二元運算。在某些條件下，即使形狀不同，我們仍然可以通過調用廣播機制來執行元素二元運算。廣播根據以下兩步過程進行：（i）通過沿長度為 1 的軸復制元素來擴展一個或兩個數組，以便在該轉換之后，兩個張量具有相同的形狀；(ii) 對結果數組執行逐元素操作。

a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b

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

a = np.arange(3).reshape(3, 1)
b = np.arange(2).reshape(1, 2)
a, b

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

a = jnp.arange(3).reshape((3, 1))
b = jnp.arange(2).reshape((1, 2))
a, b

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

a = tf.reshape(tf.range(3), (3, 1))
b = tf.reshape(tf.range(2), (1, 2))
a, b

(,
 )

因為a和b是3×1和1×2 矩陣，它們的形狀不匹配。廣播產生了更大的3×2a 通過在按元素添加之前沿列復制矩陣和b沿行復制矩陣來創建矩陣。

a + b

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

a + b

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

a + b

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

a + b

2.1.5. 節省內存

運行操作可能會導致將新內存分配給主機結果。例如，如果我們寫，我們取消引用曾經指向的張量 ，而是指向新分配的內存。我們可以用 Python 的函數來演示這個問題，它為我們提供了被引用對象在內存中的確切地址。請注意，在我們運行之后，指向不同的位置。這是因為 Python 首先求值，為結果分配新的內存，然后指向內存中的這個新位置。Y = X + YYYid()Y = Y + Xid(Y)Y + XY

before = id(Y)
Y = Y + X
id(Y) == before

False

before = id(Y)
Y = Y + X
id(Y) == before

False

before = id(Y)
Y = Y + X
id(Y) == before

False

before = id(Y)
Y = Y + X
id(Y) == before

False

由于兩個原因，這可能是不受歡迎的。首先，我們不想一直在不必要地分配內存。在機器學習中，我們通常有數百兆字節的參數并且每秒更新所有這些參數多次。只要有可能，我們都希望就地執行這些更新。其次，我們可能會從多個變量中指向相同的參數。如果我們沒有就地更新，我們必須小心更新所有這些引用，以免引發內存泄漏或無意中引用過時的參數。

幸運的是，執行就地操作很容易。Y我們可以使用切片表示法將操作的結果分配給先前分配的數組： 。為了說明這個概念，我們覆蓋張量的值，在初始化它之后，使用 ，使其具有與 相同的形狀。Y[:] = Zzeros_likeY

Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))

id(Z): 139763606871712
id(Z): 139763606871712

X如果在后續計算中不重用的值，我們也可以使用or來減少操作的內存開銷。X[:] = X + YX += Y

before = id(X)
X += Y
id(X) == before

True

Fortunately, performing in-place operations is easy. We can assign the result of an operation to a previously allocated array Y by using slice notation: Y[:] = . To illustrate this concept, we overwrite the values of tensor Z, after initializing it, using zeros_like, to have the same shape as Y.

Z = np.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))

id(Z): 140447312694464
id(Z): 140447312694464

If the value of X is not reused in subsequent computations, we can also use X[:] = X + Y or X += Y to reduce the memory overhead of the operation.

before = id(X)
X += Y
id(X) == before

True

# JAX arrays do not allow in-place operations

Variables are mutable containers of state in TensorFlow. They provide a way to store your model parameters. We can assign the result of an operation to a Variable with assign. To illustrate this concept, we overwrite the values of Variable Z after initializing it, using zeros_like, to have the same shape as Y.

Z = tf.Variable(tf.zeros_like(Y))
print('id(Z):', id(Z))
Z.assign(X + Y)
print('id(Z):', id(Z))

id(Z): 140457113440208
id(Z): 140457113440208

Even once you store state persistently in a Variable, you may want to reduce your memory usage further by avoiding excess allocations for tensors that are not your model parameters. Because TensorFlow Tensors are immutable and gradients do not flow through Variable assignments, TensorFlow does not provide an explicit way to run an individual operation in-place.

However, TensorFlow provides the tf.function decorator to wrap computation inside of a TensorFlow graph that gets compiled and optimized before running. This allows TensorFlow to prune unused values, and to reuse prior allocations that are no longer needed. This minimizes the memory overhead of TensorFlow computations.

@tf.function
def computation(X, Y):
  Z = tf.zeros_like(Y) # This unused value will be pruned out
  A = X + Y # Allocations will be reused when no longer needed
  B = A + Y
  C = B + Y
  return C + Y

computation(X, Y)

2.1.6. 轉換為其他 Python 對象

轉換為 NumPy 張量 ( ndarray)，反之亦然，很容易。torch Tensor 和 numpy array 將共享它們的底層內存，通過就地操作改變一個也會改變另一個。

A = X.numpy()
B = torch.from_numpy(A)
type(A), type(B)

(numpy.ndarray, torch.Tensor)

Converting to a NumPy tensor (ndarray), or vice versa, is easy. The converted result does not share memory. This minor inconvenience is actually quite important: when you perform operations on the CPU or on GPUs, you do not want to halt computation, waiting to see whether the NumPy package of Python might want to be doing something else with the same chunk of memory.

A = X.asnumpy()
B = np.array(A)
type(A), type(B)

(numpy.ndarray, mxnet.numpy.ndarray)

A = jax.device_get(X)
B = jax.device_put(A)
type(A), type(B)

(numpy.ndarray, jaxlib.xla_extension.Array)

Converting to a NumPy tensor (ndarray), or vice versa, is easy. The converted result does not share memory. This minor inconvenience is actually quite important: when you perform operations on the CPU or on GPUs, you do not want to halt computation, waiting to see whether the NumPy package of Python might want to be doing something else with the same chunk of memory.

A = X.numpy()
B = tf.constant(A)
type(A), type(B)

(numpy.ndarray, tensorflow.python.framework.ops.EagerTensor)

要將大小為 1 的張量轉換為 Python 標量，我們可以調用函數 item或 Python 的內置函數。

a = torch.tensor([3.5])
a, a.item(), float(a), int(a)

(tensor([3.5000]), 3.5, 3.5, 3)

a = np.array([3.5])
a, a.item(), float(a), int(a)

(array([3.5]), 3.5, 3.5, 3)

a = jnp.array([3.5])
a, a.item(), float(a), int(a)

(Array([3.5], dtype=float32), 3.5, 3.5, 3)

a = tf.constant([3.5]).numpy()
a, a.item(), float(a), int(a)

(array([3.5], dtype=float32), 3.5, 3.5, 3)

2.1.7. 概括

張量類是深度學習庫中存儲和操作數據的主要接口。張量提供多種功能，包括構造例程；索引和切片；基礎數學運算；廣播; 內存高效分配；以及與其他 Python 對象之間的轉換。

2.1.8. 練習

運行本節中的代碼。把條件語句改成 or ，然后看看你能得到什么樣的張量。X == YX < YX > Y

將廣播機制中按元素操作的兩個張量替換為其他形狀，例如 3 維張量。結果和預期的一樣嗎？